Java语言基础

（一）Java编译运行过程

 编译期：Java源文件经过编译生成.class字节码文件
 运行期：JVM加载.class并运行.class
 特点：跨平台，一次编译到处使用(跨平台特性如下图)

（二）JVM、JRE、JDK

 JVM：(Java Virtual Machine）,Java虚拟机
 JRE：(Java Runtime Environment）,Java运行环境，除包含JVM外还包含运行Java程序所必须的环境，JRE = JVM + Java系统类库
 JDK：(Java Development Kit）,Java开发工具包，JDK = JRE + 编译运行等命令工具

• 说明:
  • 运行Java程序最小环境为JRE
  • 开发Java程序最小的环境为JDK

（三）变量的命名

 在程序执行过程中，其值能被改变的量称为变量，其值不能改变的量称为常量。变量与常量的命名都必须使用合法的标识符。

    变量的命名应遵循以下规则：
      -只能包含字母、数字、_和$符，并且不能以数字开头
      -严格区分大小写
      -不能使用关键字
      -允许中文命名，但不建议，建议"英文的见名知意"、"小驼峰命名法"

（四）代码注释

  通过在程序代码中添加注释可以提高程序代码的可读性和可维护性，帮助程序员更好的阅读和理解程序。Java语言提供 3 种添加注释的方法，分别为单行注释、多行注释和文档注释。

• 单行注释
  “//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均为注释而被编译器忽略。语法如下：

      //注释内容
  
      例如，以下代码为声明 int 型变量添加注释：
      int age;    //声明 int 变量用于保存年龄信息
  

• 多行注释
  “/* */”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。语法如下：

    /*
    注释内容 1
    注释内容 2
    ...
    */
  
    //多行注释中可以嵌套单行注释，但是多行注释中不可以嵌套多行注释
  

• 文档注释

  “/** */”为文档注释标记，符号“/**”与“*/”之间的所有内容均为注释内容。注释中的内容可以换行。在文档注释出现在声明（如类的声明、类的成员变量的声明、类的成员方法的声明、类的成员方法的声明等）之前时，会被Javadoc文档工具读取作为Javadoc的文档内容。文档注释的格式与多行注释的格式相同。

（五）Java数据类型

1、Java语言提供了四类八种基本数据类型：

  整数类型：byte、short、int、long
  浮点数类型：float、double
  布尔类型：boolean
  字符类型：char

2、简述java的8种基本数据类型：

byte:     字节型，用于存储整数，占用 1 个字节，范围 -128 ~ 127，默认值是 0
short：   短整型，用于存储整数，占用 2 个字节，范围 -32768 ~ 32767，默认值是 0
int：     整型，用于存储整数，占用 4 个字节，范围 -2^31 ~ 2^31-1，默认值是 0
long：    长整型，用于存储较大的整数，占用 8 个字节，范围 -2^63 ~ 2^63-1，默认值是 0L
float:    单精度浮点数，用于存储小数，占用 4 个字节，不能表示精确的值，默认值是 0.0F
double：  双精度浮点数，用于存储小数，占用 8 个字节，不能表示精确的值，默认值是 0.0D
boolean： 布尔型，用于存储 true 和 false，占用 1 个字节，默认值是 false
char：    字符型，采用 Unicode 字符集编码，用于存储单个字符，占用 2 个字节，范围 0 ~ 65535

  举个栗子：
  byte a = 100;byte b = -50;

  short s = 1000;short r = -20000;

  int a = 100000;int b = -200000;  //1)整数直接量默认为int类型，但不能超出范围，若超出范围则发生编译错误 2)两个整数相除，结果还是整数,小数位无条件舍弃 3)运算时若超出范围，则发生溢出，溢出是需要避免的

  long a = 100000L;Long b = -200000L;  //长整型直接量需要在数字后加 L 或者 l,运算时若可能溢出，建议在第一个数字后加L

  //浮点数直接量默认为double类型，若想表示float，需在数字后加F 或 f
  //double 或 float型数据参与运算时，有可能出现舍入误差，精确场合不能使用
  float f = 3.14F;   //3.14F为float型直接量

  double d = 3.14;    //3.14为浮点数直接量，默认为double型

  boolean b1 = true;boolean b2 = false;  //true 和 false 都是布尔类型的直接量

  char letter = "A";  //char类型，字符型直接量必须放到单引号里面，单引号里面必须有字符，只能有一个字符,特殊符号需要通过来转义，例如：char c = "\" 表示字符  ;

3、数据类型间的转换

• 小到大依次为:byte-short/char-int-long-float-double
• 自动/隐式类型转换：由小到大
• 强制类型转换：语法（要转换成为的数据类型）变量，由大到小，强转有可能发生溢出或丢失精度

  int a = 5;
  long b = a; //自动类型转换
  int c = (int) b; //强制类型转换

  long d = 5;
  double e = 5;
  long f = 10000000000L;
  int g = (int) f;
  System.out.println(g);  //1410065408    强转有可能会内存溢出
  double h = 23.34545;
  int i = (int) h;
  System.out.println(i);  //23    强转有可能会丢失精度

  //整数直接量可以直接赋值给byte、short、char，但是不能超出范围
  //byte、short、char型的数据参与运算，系统会将其自动转换为int再运算
  byte b = 3;
  byte b1 = 5;
  byte b2 = (byte) (b + b1);
  System.out.println(b2);

  System.out.println("2" + "2");//100."2"的码50 加上 "2"的码50 ，得100

（六）Java中的运算符

• 算数运算符：+、——、*、/、%、++、–
• 关系运算符：>、<、>=、<=、==、!=
• 逻辑运算符：&&、||、！
• 赋值运算符：=、+=、-=、*=、/=、%=
• 字符串连接符：+
• 条件运算符：boolean ？ 数1 : 数2

  算数运算符自增（++）、自减（--）使用的两种不同情况：
  单独使用时：在前在后都是会使值自增1
  被使用时：a++/a--  ————————先赋值，再运算
            ++a/--a   ————————先运算，再赋值
        
public class OperatorDemo {
    public static void main(String[] args) {
            //自增、自减运算演示

            //单独使用时，都会自增/自减1
            int a = 5, b = 10;
            a++;
            b++;
            System.out.println("a = " + a); //6
            System.out.println("b = " + b); //11

            //被使用时。运算符在前，先运算后赋值；运算符在后，先赋值后运算
            int c = 20, d = 20;
            int e = c++;
            int f = ++d;
            System.out.println("e = " + e); //20
            System.out.println("f = " + f); //21
    }
}

（七）Java中的流程控制

1、程序结构

• 顺序结构：按照书写顺序执行的语句构成的程序段,从上往下执行，每句必走
• 分支结构：有条件的执行不同的语句，并非每句都走
• 循环结构：循环条件满足的情况下，反复执行一段相同或相似的代码

2、if条件语句
 主要用于告诉程序在某个条件成立的情况下执行某段语句。语法结构和执行过程如下：

1)语法:
     if(boolean){
        语句块;
      }
2)执行过程:
      判断boolean的值:
      若为true，则执行语句块(if结束)
      若为false，则if直接结束

3、if…else语句
 如果满足某种条件，就进行某种处理，否则就进行另一种处理。语法结构和执行过程如下：

1)语法:
    if(boolean){
       语句块1
    }else{
       语句块2
    }
2)执行过程:
    判断boolean的值:
    若为true，则执行语句块1(整个结束)
    若为false，则执行语句块2(整个结束)
3)说明:
    语句块1和语句块2，必走其中之一-----------2选1

4、if…else…if语句
 针对某一事物的多种情况进行处理，通常表现为“如果满足某种条件就进行某种处理，如果满足另一种条件就进行另一种处理”。语法结构和执行过程如下：

1)语法:
    if(boolean-1){
       语句块1
    }else if(boolean-2){
       语句块2
    }else if(boolean-3){
       语句块3
    }else{
       语句块4
    }
2)执行过程:
     判断boolean-1，若为true则执行语句块1(结束)，若为false则
     再判断boolean-2，若为true则执行语句块2(结束)，若为false则
     再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
     语句块1/2/3/4，只能执行其中之一---------多选1

5、switch…case语句
 根据不同的值给出输出语句，实现多选一的效果。相比较而言，效率高，结构清晰，但是只能对整数判断相等。swich…case能作用在byte、short、int、char、String、枚举等类型的变量上。语法如下：

switch(用于判断的参数){
case 常量表达式1:	语句1;	break;
case 常量表达式2:	语句2;	break;
...
case 常量表达式n:	语句n;	break;
default:    语句n+1;	break;
}

6、while循环语句
 利用一个条件来控制是否要继续反复执行一个语句。先判断后执行，有可能一次也不执行。语法如下：

1)语法:
    while(boolean){
      语句块-------------反复执行的代码
    }
2)执行过程:
     先判断boolean的值，若为true则执行语句块，
     再判断boolean的值，若为true则再执行语句块，
     再判断boolean的值，若为true则再执行语句块，
     如此反复，直到boolean的值为false时，while循环结束

7、do…while循环语句
 类似于while语句。但是do…while语句是先执行再判断，语句块至少执行一次。语法如下：

语法:
    do{
       语句块-------------反复执行的代码
    }while(boolean)；

8、for循环语句
 用来重复执行某条语句，知道条件得到满足(应用率最高)。语法如下：

1)语法:
  //   1     2    3
  for(要素1;要素2;要素3){
     语句块/循环体--------------反复执行的代码  4
  }
2)执行过程:
  1243243243243243...2

说明：break 和 continue 关键字的区别：
    break：跳出循环，结束整个循环，开始执行循环之后的语句。可应用在Switch和循环语句中。
    continue：跳过循环体中剩余语句，进入下一次循环，只能应用在循环中。

（八）数组

• 数组是一种引用类型，是相同数据类型元素的集合

   //声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
   int[] arr = new int[10];

• 初始化：—-初始化数组中的数据

   int[] arr = new int[3]; 
   int[] arr = {1,4,7}; 
   int[] arr = new int[]{1,4,7}; 
   int[] arr;
   //arr = {1,4,7}; //编译错误，此方式只能声明同时初始化
   arr = new int[]{1,4,7}; //正确

• 访问：—-访问的是数组中的元素
  通过(数组名.length)可以获取数组的长度(元素个数)

   int[] arr = new int[3];
   System.out.println(arr.length); //3

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

   int[] arr = new int[3];
   System.out.println(arr[0]); //0，输出第1个元素的值
   arr[0] = 100; //给第1个元素赋值为100
   arr[1] = 200; //给第2个元素赋值为200
   arr[2] = 300; //给第3个元素赋值为300
   //arr[3] = 400; //运行时会发生数组下标越界异常
   System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值

• 数组的遍历/迭代：从头到尾挨个走一遍

    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){ //遍历arr数组
      arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
      System.out.println(arr[i]); //输出每个元素的值
      //arr[i]:代表的是arr中的每一个元素
    }

• 数组的复制
  System.arraycopy(a,1,b,0,4);

    int[] a = {10,20,30,40,50};
    int[] b = new int[6]; //0,0,0,0,0,0
    //a:源数组
    //1:源数组的起始下标
    //b:目标数组
    //0:目标数组的起始下标
    //4:要复制的元素个数
    System.arraycopy(a,1,b,0,4); //灵活性好
    for(int i=0;i<b.length;i++){
        System.out.println(b[i]);
    }

• 数组的扩容
  int[] b = Arrays.copyOf(a,6);
  a = Arrays.copyOf(a,a.length+1);

    //数组的扩容
    int[] a = {10,20,30,40,50};
    //数组的扩容(创建了一个更大的新的数组，并将数据复制进去了)
    a = Arrays.copyOf(a,a.length+1);
    for(int i=0;i<a.length;i++){
        System.out.println(a[i]);
    }

• 数组的排序: Arrays.sort(arr);

    int[] arr = new int[10];
    for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
        System.out.println(arr[i]);
    }
    Arrays.sort(arr); //对arr进行升序排列
    System.out.println("排序后:");
    for(int i=0;i<arr.length;i++){  
        System.out.println(arr[i]);
    }