Java必须会的基础知识入门

一、Java程序设计概述

（一）Java的特点

• 一、Java的特点
  • (一) 跨平台性：
    所谓的跨平台性，是指软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。
  • (二) 面向对象：
    面向对象是指以对象为基本粒度，其下包含属性和方法。Java是一种面向对象的语言，也继承了面向对象的诸多好处，如代码扩展、代码复用等。
  • (三) 安全性：
    可以分为四个层面，即语言级安全性、编译时安全性、运行时安全性、可执行代码安全性。语言级安全性指Java的数据结构是完整的对象，这些封装过的数据类型具有安全性。
  • (四) 多线程：
    在操作系统中已得到了最成功的应用。多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理。
  • (五) 简单易用：
    Java源代码的书写不拘泥于特定的环境，可以用记事本、文本编辑器等编辑软件来实现，然后将源文件进行编译，编译通过后可直接运行，通过调试则可得到想要的结果。

（二）Java的发明者

• 二、JAVA的发明者：是 James Gosling 詹姆斯•高斯林
  是印度尼西亚爪哇岛的英文名称，因盛产咖啡而闻名

（三）Java 开发环境

本文以 JDK 1.8 介绍
JDK下载链接：https://pan.baidu.com/s/14WSWrriIlKWL2QTwrIkCKQ 提取码：fwg7
官方链接：https://www.oracle.com/java/technologies/javase-jdk8-downloads.html

• 三、开发环境：
  • 1、java编译运行过程:----------常见面试题
    1.1) 编译期: . java源文件，经过编译，生成 . class字节码文件
    1.2) 运行期:JVM加载 . class并运行 . class
  • 2、开发Java应用程序需要经过哪些主要步骤？
    2.1) 编写源文件:扩展名必须是 . java。
    2.2) 编译Java源程序:用Java编译器（javac.exe）编译源文件，得到字节码文件。
    2.3) 运行Java程序:使用Java解释器（java.exe）来解释执行字节码文件。
    另外可以用文本编辑器编写源文件2.使用javac编译源文件得到字节码文件3.使用解释器运行程序
    特点:跨平台、一次编程到处使用
  • 3、名词解释
    3.1) JVM：Java虚拟机
    加载 .class文件并运行 .class文件
    3.2) JRE：Java运行环境
    除了包含 JVM 以外还包含了运行java程序所必须的环境 JRE = JVM + Java系统类库（小零件）。
    3.2) JDK：Java开发工具包
    除了包含 JRE 以外还包含了开发java程序所必须的命令工具 JDK = JVM + 编译、运行等命令工具。

（四）Java环境变量配置

• 四、Java配置环境变量
  • 可参照该步骤设置：https://blog.csdn.net/qq_41254299/article/details/104144796
    • 了解
      4.1) JAVA_HOME：指向 jdk 的安装路径
      4.2) CLASSPATH：表示类的搜索路径
      4.3) PATH：指向 jdk 下的 bin 目录

（五）编程风格

1. Allmans 独占风格（大括号独占行）。

public static void main(String[] args)
{
	int score = 0；
	for(int i=1; i<=10; i++)
	{
		score = score + i;
	}
	System.out.println(score);
} 

3. Kernighan 行尾风格 （左大括号在上一行行尾，右大括号独占）。

public static void main(String[] args){
	int score = 0；
	for(int i=1; i<=10; i++){
		score = score + i;
	}
	System.out.println(score);
} 

(Java一般都是常用这种行尾风格)

（六）开发工具

开发工具有多种，有企业级的，也有轻量级的，本文主要以 Eclipse
下载下来，先安装 JDK 和配置环境变量，再解压 Eclipse 打开执行文件 . exe 文件即可。
官方链接：https://www.eclipse.org/downloads/
百度网盘：https://pan.baidu.com/s/1kHqUyuBC7ZMbc9uwy8pFeg 提取码：kinb

二、基本程序设计

1.注释

注释：解释性文本

1.1	单行注释用	//
1.2	多行注释用	/* */
1.3	文档注释用	/** */

2.变量的声明

1. 变量：是一个代词，指代它所存储的内存中的数据。
2. 声明：

int num; //声明一个变量，名为 num
int a,b,c; //同时声明多个变量，名分别为 a,b,c

3. 命名：
   • 只能包含字母、数字、_ 下划线和 $ 美元符号，并且不能以数字开头。
   • 不能使用保留字/关键字。
   • Java 严格区分大小写。
   • 可以中文、日文、韩文命名，但不建议，有可能会乱码。
   • 建议：见名知意，驼峰命名法，使用英文，尽量不用拼音。
     • 栗子：

     String uid; // userID用户ID，见名知意
     String myFirstCode;
     

4. 初始化（第一次赋值）

   • //声明同时初始化
     int num = 1; //声明变量num并初始化为2
     //-----------------------
     //先声明再初始化
     int a; //声明变量a
     a = 3; //给变量a初始化为3
     

   • 访问：
     • 变量在使用之前必须先声明并初始化。
     • 变量的操作必须与类型匹配。

3.基本数据类型

• 数据类型从小到大：
  byte — boolean — short — char — int — float — long — double
  字节型—布尔型—短整型—字符型—整型—长整型—浮点型—双精度型

• byte字节型：1个字节，8位，数据范围 -128~127。

• boolean布尔型：1个字节，只有 true 和 false。

• short短整型：2个字节，32位，数据范围 -32768~32767。

• char字符型：2个字节，16位，0~65535。

  • char型直接量，须放在 ‘’ 中，有且仅有一个，栗(例)子：char c = ‘博客’;
  • Unicode 编码格式，实质是整数，即char对应的码 。

  char a = 5254; //直接使用（0-65535）常量赋值.
  char a = 'A'; //直接使用字符赋值
  char a = '\u0041' //使用Unicode中16进制的格式
  //由于java中某些字符有独特的意义，因此要使用这些字符时，需要用转义字符 '\'
  

  char类型在ASCII字符编码中，有对应的数值，例如下图
  ASCII码表对照：https://tool.oschina.net/commons?type=4
  

• int整型：4个字节，32位，数据范围 -2³¹ （-2,147,483,648）到 2³¹-1（2,147,483,647）

  • 整数默认为int型
  • 两个int操作，结果还是int型，小数位无条件舍弃
  • 超范围时可能会发生溢出，需避免

• float浮点型，4个字节，32位，-2³¹~2³¹-1

  • float 的直接量，在小数后加 f 或 F

• long长整型：8个字节，64位，数据范围 -2⁶³ （-9,223,372,036,854,775,808‬）到 2⁶³-1（9,223,372,036,854,775,8087）

  • long型直接量，在整数后加 l 或 L

    long a = 100000000000L;
    

  • System.currentTimeMillis(); 用于获取字1970.1.1零时到现在的时间毫秒数

• double双精度型：8个字节，64位，-2^63~263-1

  • 小数默认为double型
  • 有舍入误差，精确运算时慎用，(因为10进制与2进制之间转换时损失了精度)

自动类型转换：从小类型到大类型 （隐式转换）
强制类型转换：从大类型到小类型强转有可能会发生精度丢失、溢出

4.运算符

• && 和 & 的区别？

  • 答：
  1. && 是逻辑与运算符，会发生短路现象;
  2. & 是位与运算符，不会发生短路现象。

• 1)算术运算: + - * / % ++ –

  • 1.1)%:求余、求模、取模
  • 1.2)++/–:自增1/自减1运算
  • 1.2.1)单独使用时，++/–在前在后无差别
  • 1.2.2)若被使用时，++/–在前在后有差别

// ++/--在前:先运算(自增/减)，后使用
int number = 10;
++number; //先将number变量自身+1, 再将number的值给++number表达式, 此时number=11, ++number=11
--number; //先将number变量自身-1, 再将number的值给--number表达式, 此时number=10, --number=10++/--在后:先使用，后运算(自增/减)
int number = 10;
number++; //先将number的值给number++表达式, 再将number变量自身+1, 此时number=11, number++=10
number--; //先将number的值给number--表达式, 再将number变量自身-1, 此时number=10, number--=11

• 2)关系运算: > < >= <= == !=
  关系运算的结果为boolean型
• 3)逻辑运算: && || !
  建立在关系运算基础之上，运算的结果也是boolean型
  • 3.1)&&:短路与，两边都为真，则为真
    当左边为false时发生短路(不再计算右边)
  • 3.2)||:短路或，有一边为真，则为真
    当左边为true时发生短路(不再计算右边)
  • 3.3)!:非真则假，非假则真
• 4)赋值运算: =
  扩展赋值运算: += -= *= /= %= ----在本身基础之上做操作
  建议使用扩展赋值运算，运算效率高
• 5)+:若两边都为数字，做加法运算
  若有一边为字符串，做字符串连接
• 6)三目(元)运算: boolean表达式 ? 值1 : 值2
  运算过程:
  计算boolean表达式的值：
  若为true则整个表达式的结果为值1
  若为false则整个表达式的结果为值2

5.分支结构

• 5.分支结构:

  • 1)if:1条路
    语法结构:

     if(boolean表达式){
          //boolean表达式为true时执行的语句块
     }
    

  • 2)if…else:2条路
    语法结构:

     if(boolean表达式){
          //boolean表达式为true时执行的语句块
     }else{
          //boolean表达式为false时执行的语句块
     }
    

  • 3)if…else if:多条路
    语法结构:

       if(boolean表达式1){
          //boolean表达式1为true时执行的语句块
       }else if(boolean表达式2){
          //boolean表达式2为true时执行的语句块
       }else {
          //boolean表达式1和2都为false时执行的语句块
       }
    

  • 4)switch…case:多条路
    语法结构:

      switch(表达式){
        case 值1:
        case 值2:
        ...
        default:
      }
    

    注意:表达式默认支持int类型（byte、short、int、char），JDK1.7之后开始支持String字符串类型
    case后面的值必须是直接量(字面量)或者常量，不能是变量
    缺点:只能是整数或字符串(JDK1.7以上)表达式，只能判断是否相等
    优点:程序结构清晰、可读性好，执行效率高
    break:用在switch中，跳出switch

6.循环结构

• 6.循环结构:

  • 1)循环:反复的执行相同或相似的代码

  • 2)循环三要素:

    • 1)循环变量的初始化
    • 2)循环条件(以循环变量为基础)
    • 3)循环变量的改变(向着循环结束变)
      循环变量:在循环过程中所改变的那个量

  • 3).关键字:
    break:跳出循环，应用率比较高
    continue:跳过循环体中剩余语句而进入下一次循环，应用率比较低

  • 4)while:先判断后执行
    语法结构:

     while(boolean表达式){
          //循环体
     }
    

    执行过程:
    只要boolean表达式为true，就执行循环体，否则结束循环

  • 5)do…while:先执行一次再判断
    语法结构:

     do{
    	//循环体
    }while(boolean表达式);
    

    执行过程:
      先执行一次循环体
      只要boolean表达式为true，就执行循环体，否则结束循环
    窍门:当第1要素和第3要素一样时，首选do...while
    

  • 6)for:
    语法结构:

     for(表达式1; 表达式2; 表达式3){
          //循环体
        }
    

    表达式1: 循环变量的初始化
    表达式2: 循环条件的判断
    表达式3: 循环变量的改变
    执行过程:
    a)执行一次表达式1
    b)执行表达式2
    c)若表达式2结果为true，执行循环体，否则结束循环
    d)执行表达式3
    e)重复执行b/c/d

  • 7).循环结构如何选择:
    1)“当…”------while
    2)“直到…”----do…while(要素1和3一样时)
    3)固定次数------for

7.数组

• 7.数组:

  • 1)是一种数据类型—是引用类型，而非基本数据类型

  • 2)数组中的元素数据类型必须相同

  • 3)数组的定义:
    语法结构:
    数据类型[ ] 引用变量名; //推荐
    数据类型 引用变量名[ ]; //不推荐

    数据类型[ ] 引用变量名[ ]; //数组中的数组
    数据类型[ ][ ] 引用变量名;
    数据类型 引用变量名[ ][ ];
    例如:

      //声明整型数组arr，包含3个元素，每个元素都是int型
      //arr中的每一个元素都默认为0
      int[ ] arr = new int[3];
    

  • 4)数组的初始化:

    int[] arr = new int[3]; //每个元素都是0
    int[] arr = {1,4,7}; //3个元素，分别是1,4,7
    int[] arr = new int[]{1,4,7}; //3个元素，分别是1,4,7
    int[] arr; //声明整型数组arr
    arr = {1,4,7}; //编译错误，直接{}赋值只适用于声明同时初始化
    arr = new int[]{1,4,7}; //正确
    

  • 5)数组的访问:
    通过下标/索引来访问元素
    索引从0开始，到数组的长度(length)-1

    int[] arr = {1,4,7,8};
    System.out.println(arr.length); //4
    arr[0] = 100; //给arr中的第1个数赋值为100
    System.out.println(arr[3]); //输出arr中的最后一个数
    arr[4] = 88; //错误的，下标越界/超范围
      
    int[] arr = new int[4];
    for(int i=0; i<arr.length; i++){
      arr[i] = 100; //给arr中每一个元素赋值为100
    }
    for(int i=0; i<arr.length; i++){
      System.out.println(arr[i]);
    }
    for(int i=arr.length-1; i>=0; i--){
      System.out.println(arr[i]);
    }
    

第一个阶段先到这。分别复习了
一、Java程序设计概述
（一）Java的特点
（二）Java的发明者
（三）Java 开发环境
（四）Java环境变量配置
（五）编程风格
（六）开发工具
二、基本程序设计
1.注释
2.变量的声明
3.基本数据类型
4.运算符
5.分支结构
6,循环结构
7.数组

觉得不错的小伙伴点个赞，谢谢！

章节目录在此处：https://blog.csdn.net/qq_41254299/article/details/106638651
转载请注明出处：https://blog.csdn.net/qq_41254299
本文出自 [Superclover_的博客]