JAVAday1-8笔记

DOS控制台

• 打开
  win+r – cmd
• 常见命令
  
  • A:d: 回车 盘符切换
  • B:dir(directory):列出当前目录下的文件以及文件夹
  • C:cd (change directory)改变指定目录(进入指定目录)
  • D:cd.. : 退回到上一级目录
  • E:cd: 退回到根目录
  • F:cls : (clear screen)清屏
  • G:exit : 退出dos命令行

JAVA基础

• JRE:JVM(Java Virtual Machine)+库类
• JDK:JAVA开发工具
• HelloWorld:
  
  • A:定义类
  • B:写main方法
  • C:写输出语句
  • D:Java程序开发运行与工作原理
  • E:编译和运行程序

        class HelloWorld {
            public static void main(String[] args) {
                System.out.println("HelloWorld");
            }
        }

• JAVA书写格式
  
  • A:包
    最好是域名倒过来,要求所有的字母小写
  • B:类或者接口
    如果是一个单词首字母大写
    如果是多个单词每个单词首字母大写(驼峰标识)
  • C:方法或者变量
    如果是一个单词全部小写
    如果是多个单词,从第二个单词首字母大写
  • D:常量
    如果是一个单词,所有字母大写
    如果是多个单词,所有的单词大写,用下划线区分每个单词
• 常量
  
  • 字符串常量 用双引号括起来的内容
  • 整数常量 所有整数
  • 小数常量 所有小数
  • 字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
  • 布尔常量 较为特殊，只有true和false
  • 空常量 null(数组部分讲解)
• 进制
  
  • 二进制
    
    • 0b开头
  • 八进制
    
    • 0开头
  • 十六进制
    
    • 0x开头
  • 进制快速转换
    
    • 8421码:在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
• 原码反码补码
  
  • 原码
    
    • 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
    • 通过一个字节,也就是8个二进制位表示+7和-7
    • 0(符号位) 0000111
    • 1(符号位) 0000111
  • 反码
    
    • 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
  • 补码
    
    • 正数的补码与其原码相同；负数的补码是在其反码的末位加1。
• 变量
  
  • 定义格式 : 数据类型 变量名 = 变量值;
• 数据类型
  
  • 基本数据类型
    
    • 整数型
      
      • byte 占一个字节 -128到127
      • short 占两个字 -2^15~2^15-1
      • int 占四个字节 -2^31~2^31-1
      • long 占八个字节 -2^63~2^63-1
    • 浮点型
      
      • float 占四个字节 -3.403E38~3.403E38 单精度
      • double 占八个字节-1.798E308~1.798E308 双精度
    • 字符型
      
      • char 占两个字节 0~65535
    • 布尔型
      
      • boolean
        boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小
  • 引用数据类型
    
    • 面向对象部分讲解
• 隐转和强转
  
  • Java中的默认转换规则
    取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
  • 强转格式 : b = (byte)(a + b);
• 字符串运算
  
  • ASCII码表
  • +在有字符串参与中被称为字符串连接符

System.out.println("hello"+'a'+1);

• 运算符

  • 算术运算符
    +,-,*,/,%,++,--
    
    • a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
    • b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
    • c:/获取的是除法操作的商，%获取的是除法操作的余数
    • %运算符
      
      • 当左边的绝对值小于右边绝对值时,结果是左边
      • 当左边的绝对值等于右边或是右边的倍数时,结果是0
      • 当左边的绝对值大于右边绝对值时,结果是余数
      • %运算符结果的符号只和左边有关系,与右边无关
      • 任何一个正整数%2结果不是0就是1可以用来当作切换条件
    • ++ --运算符的作用
      
      • 自加（++）自减（--）运算
      • ++:自加。对原有的数据进行+1
      • --:自减。对原有的数据进行-1
    • 例题
      byte b = 10;
b++;
b = b + 1;
      哪一句会报错?

  b = b+1;
  Error:不兼容的类型: 从int转换到byte可能会有损失

  • 赋值运算符
    
    • =,+=,-=,*=,/=,%=
    • short s=1;s = s+1;
short s=1;s+=1;
      是否有什么问题?

  short s=1;s = s+1;
  Error: 不兼容的类型: 从int转换到short可能会有损失

  • 比较(关系或条件)运算符
    
    • ==,!=,>,>=,<,<=
    • 结果是boolean类型
  • 逻辑运算符
    
    • &,|,^,!
&&,||
    • 用于连接boolean类型的表达式或值
    • &逻辑与:有false则false。
    • |逻辑或:有true则true。
    • ^逻辑异或:相同为false，不同为true。
    • !逻辑非:非false则true，非true则false。
    • &&和&的区别?
      
      • a:最终结果一样。
      • b:&&具有短路效果。左边是false，右边不执行。
        &是无论左边是false还是true,右边都会执行
    • ||和|同上
  • 位运算符
    
    • &,|,^,~ ,>>,>>>,<<
    • &:有0则0
    • |:有1则1
    • ^:相同则0，不同则1
      
      • ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
    • ~:按位取反
    • <<:左移 左边最高位丢弃，右边补齐0
    • >>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1
    • >>>:无符号右移 无论最高位是0还是1，左边补齐0
  • 三目(元)运算符
    
    • 格式 : (关系表达式) ? 表达式1 : 表达式2;
• 键盘录入
  
  • 导包 : import java.util.Scanner;
  • 创建 : Scanner sc = new Scanner(System.in);
  • 录入 : int x = sc.nextInt();

• 流程控制结构

  • 顺序结构

  • 选择结构

    • if语句

      • if语句和三元运算符的区别
        三元运算符实现的，都可以采用if语句实现。反之不成立。
      • 格式
        if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}

    • switch语句

      • 格式
        switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}

      • 注意

        1. switch表达式中能接受的基本数据类型为 byte，short，char，int（能自动提升为int的数据类型）
        2. 引用数据类型中可以接受枚举（JDK1.5）和String(JDK1.7）
        3. case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
        4. break省略可能回出现穿透现象

• 循环结构

  • for
    
    • 格式
      for(初始化表达式;条件表达式;循环后的操作表达式) {
循环体;
}
  • while
    
    • 格式
      while(判断条件语句) {
循环体语句;
控制条件语句;
}
  • do…while
    
    • 格式
      do {
循环体语句;
控制条件语句;
}while(判断条件语句);
  • 三种循环格式的区别
    
    • do…while循环至少执行一次循环体。
    • 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
• 控制跳转语句
  
  • break；
    跳出循环
  • continue；
    终止本次循环继续下次循环
  • return；
    跳出方法
  • 自定义标记
• 方法
  
  • 完成特定功能的代码块，提高代码的复用性
  • 格式
    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
  • 写一个方法要知道
    
    1. 明确返回值类型
    2. 明确参数列表
  • 方法调用图解
• 数组
  
  • 格式
    数据类型[] 数组名 = new 数据类型[数组的长度];
  • 数组的初始化
    
    • 静态初始化
      给定初始化值，由系统决定长度
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
数据类型[] 数组名 = {元素1,元素2,…};
    • 动态初始化
      数据类型[] 数组名 = new 数据类型[数组长度];
EX : int[] arr = new int[5];
    • 数组中常见的错误
      
      • ArrayIndexOutOfBoundsException:数组索引越界异常
        
        • 原因：你访问了不存在的索引。
      • NullPointerException:空指针异常
        
        • 原因：数组名指向的堆内存不存在。
• 数组的基本操作
  1. 数组的遍历
  
  • arr.length 数组的长度
  • 数组的最大索引:arr.length - 1;

public static void print(int[] arr) {
                for (int i = 0;i < arr.length ;i++ ) {
                    System.out.print(arr[i] + " ");
                }
            }

  2. 数组的反转

public static void reverseArray(int[] arr) {
                for (int i = 0;i < arr.length / 2 ; i++) {
                    //arr[0]和arr[arr.length-1-0]交换
                    //arr[1]和arr[arr.length-1-1]交换
                    //arr[2]和arr[arr.lentth-1-2]
                    //...

                    int temp = arr[i];
                    arr[i] = arr[arr.length-1-i];
                    arr[arr.length-1-i] = temp;
                }
            }

• 二维数组
  
  • 格式
    
    1. 数据类型 数组名[][] = new 数据类型[m][n];
    2. 数据类型[] 数组名[] = new 数据类型[m][n];
    3. int[][] arr = new int[3][2];
    4. int[][] arr = new int[3][];
    5. int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
  • 遍历
    嵌套循环

int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

            for (int i = 0;i < arr.length ;i++ ) {      
                for (int j = 0;j < arr[i].length ;j++ ) {   
                    System.out.print(arr[i][j] + " ");
                }

                System.out.println();
            }

• JAVA中的内存分配以及栈和堆的区别（掌握图解）
  
  • A:栈
    
    • 存储局部变量
  • B:堆
    
    • 存储new出来的数组或对象
  • C:方法区
    
    • 面向对象部分讲解
  • D:本地方法区
    
    • 和系统相关
  • E:寄存器
    
    • 给CPU使用

面向对象

• 开发
  
  • 不断的创建对象，使用对象，指挥对象做事情。
• 特征
  
  • 封装(encapsulation)
  • 继承(inheritance)
  • 多态(polymorphism)

• CLASS

  • JAVA中最基本的单位
    
    • 成员变量
      
      • 在类中，方法外
    • 成员方法
  • 类和对象
    
    • 类：是一组相关的属性和行为的集合
    • 对象：是该类事物的具体体现
  • 举例 ：
    
    • 学生 ：
      
      • 属性: 姓名,年龄,性别
      • 行为: 学习,睡觉
  • 创建格式：
    类名 对象名 = new 类名();
  • 使用：
    对象名.变量名
对象名.方法名()
  • 如果一个方法的形式参数是一个类类型(引用类型)，其实需要的是该类的对象。

• 成员变量和局部变量的区别

  • A:在类中的位置不同
    
    • 成员变量：在类中方法外
    • 局部变量：在方法定义中或者方法声明上
  • B:在内存中的位置不同
    
    • 成员变量：在堆内存(成员变量属于对象,对象进堆内存)
    • 局部变量：在栈内存(局部变量属于方法,方法进栈内存)
  • C:生命周期不同
    
    • 成员变量：随着对象的创建而存在，随着对象的消失而消失
    • 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
  • D:初始化值不同
    
    • 成员变量：有默认初始化值
    • 局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
  • 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
• 匿名对象的概述和应用
  
  • 什么是匿名对象
    
    • 没有名字的对象
  • 匿名对象应用场景
    
    • 调用方法，仅仅只调用一次的时候。
      
      • 好处
        
        • 节省代码
      • 注意：调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
    • 匿名对象可以作为实际参数传递
• 封装
  
  • 隐藏对象的属性和实现细节，仅对外提供公共访问方式。
  • 封装好处
    
    • 隐藏实现细节，提供公共的访问方式
    • 提高了代码的复用性
    • 提高安全性
  • 封装原则
    
    • 将不需要对外提供的内容都隐藏起来
    • 把属性隐藏，提供公共方法对其访问
  • Private
    
    • private关键字特点
      
      • 是一个权限修饰符
      • 可以修饰成员变量和成员方法
      • 被其修饰的成员只能在本类中被访问
    • 把成员变量用private修饰
    • 提供对应的getXxx()和setXxx()方法
    • private仅仅是封装的一种体现形式,不能说封装就是私有
  • This
    
    • 代表当前对象的引用
    • this的应用场景
    • 用来区分成员变量和局部变量重名

public class example_Phone {
    public static void main(String[] args){
        Phone p = new Phone();
        p.setBrand("小米");
        p.setPrice(2000);
        p.call();
    }
}
class Phone{
    private int price;
    private String brand;

    public void setPrice(int price){
        this.price = price;
    }

    public int getPrice(){
        return price;
    }

    public void setBrand(String brand){
        this.brand = brand;
    }

    public String getBrand(){
        return brand;
    }

    public void call(){
        System.out.println("打电话");
    }

}

• 构造方法Constructor概述和格式
  
  • 作用
    
    • 给对象的数据(属性)进行初始化
  • 特点
    
    • 方法名与类名相同(大小也要与类名一致)
    • 没有返回值类型，连void都没有
    • 没有具体的返回值return;
  • 重载
    
    • 方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表
  • 注意
    
    • 如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
    • 如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
• 给成员赋值的两种方法

class Demo3_Person {
    public static void main(String[] args) {
        Person p1 = new Person("张三",23);
        //p1 = new Person("张天一",23);    //这种方式看运行结果貌似是改名了,其实是将原对象变成垃圾
        System.out.println(p1.getName() + "..." + p1.getAge());

        System.out.println("--------------------");
        Person p2 = new Person();       //空参构造创建对象
        p2.setName("李四");
        p2.setAge(24);

        p2.setName("李鬼");
        System.out.println(p2.getName() + "..." + p2.getAge());
    }
}
/*
构造方法
    给属性进行初始化
setXxx方法
    修改属性值
    这两种方式,在开发中用setXxx更多一些,因为比较灵活
*/
class Person {
    private String name;                //姓名
    private int age;                    //年龄

    public Person() {                   //空参构造
    }

    public Person(String name,int age) {//有参构造
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {  //设置姓名
        this.name = name;
    }

    public String getName() {           //获取姓名
        return name;
    }

    public void setAge(int age) {       //设置年龄
        this.age = age;
    }

    public int getAge() {               //获取年龄
        return age;
    }
}

• 创建一个对象

class Demo1_Student {
    public static void main(String[] args) {
        Student s = new Student();  
        s.show();
    }
}

class Student {
    private String name = "张三";
    private int age = 23;

    public Student() {
        name = "李四";
        age = 24;                   
    }

    public void show() {
        System.out.println(name + "..." + age);
    }
}![步骤演示](https://img-blog.csdn.net/20180327101255713?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VjaGloYTcxMQ==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)

• static关键字
  
  • 随着类的加载而加载
  • 优先于对象存在
  • 被类的所有对象共享
    
    • 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
  • 可以通过类名调用
    
    • 其实它本身也可以通过对象名调用。
    • 推荐使用类名调用。
    • 静态修饰的内容一般我们称其为：与类相关的，类成员
  • 在静态方法中是没有this关键字的
    * 静态是随着类的加载而加载，this是随着对象的创建而存在。
    * 静态比对象先存在。
  • 静态方法只能访问静态的成员变量和静态的成员方法
    
    • 静态方法：
      
      • 成员变量：只能访问静态变量
      • 成员方法：只能访问静态成员方法
    • 非静态方法：
      
      • 成员变量：可以是静态的，也可以是非静态的
      • 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
• main方法
  
  • public static void main(String[] args) {}
  • public 被jvm调用，访问权限足够大。
  • static 被jvm调用，不用创建对象，直接类名访问
  • void被jvm调用，不需要给jvm返回值
  • main 一个通用的名称，虽然不是关键字，但是被jvm识别
  • String[] args 以前用于接收键盘录入的 （习惯）
• 制作一个工具类以及说明书

/**
这是一个数组工具类,里面封装了查找数组最大值,打印数组,数组反转的方法
@author fengjia
@version v1.0
*/
public class ArrayTool {
    //如果一个类中所有的方法都是静态的,需要再多做一步,私有构造方法,目的是不让其他类创建本类对象
    //直接用类名.调用即可
    /**
    私有构造方法
    */
    private ArrayTool(){}

    //1,获取最大值

    /**
    这是获取数组中最大值的方法
    @param arr 接收一个int类型数组
    @return 返回数组中最大值
    */
    public static int getMax(int[] arr) {
        int max = arr[0];                       //记录第一个元素
        for (int i = 1;i < arr.length ;i++ ) {  //从第二个元素开始遍历
            if (max < arr[i]) {                 //max与数组中其他的元素比较
                max = arr[i];                   //记录住较大的
            }
        }

        return max;                             //将最大值返回
    }
    //2,数组的遍历
    /**
    这是遍历数组的方法
    @param arr 接收一个int类型数组
    */
    public static void print(int[] arr) {
        for (int i = 0;i < arr.length ;i++ ) {  //遍历数组
            System.out.print(arr[i] + " ");
        }
    }
    //3,数组的反转
    /**
    这是数组反转的方法
    @param arr 接收一个int类型数组
    */
    public static void revArray(int[] arr) {
        for (int i = 0;i < arr.length / 2 ;i++ ) {  //循环次数是元素个数的一半
            /*
            arr[0]与arr[arr.length-1-0]  交换
            arr[1]与arr[arr.length-1-1]  交换
            arr[2]与arr[arr.length-1-2] 交换
            */
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
}

• 代码块
  
  • 代码块概述
    
    • 在Java中，使用{}括起来的代码被称为代码块。
  • 代码块分类
    
    • 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
  • 常见代码块的应用
    
    • 局部代码块
      
      • 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
    • 构造代码块 (初始化块)
      
      • 在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
    • 静态代码块
      
      • 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。
      • 一般用于加载驱动

class Student {
            static {
                System.out.println("Student 静态代码块");
            }

            {
                System.out.println("Student 构造代码块");
            }

            public Student() {
                System.out.println("Student 构造方法");
            }
        }

        class Demo2_Student {
            static {
                System.out.println("Demo2_Student静态代码块");
            }

            public static void main(String[] args) {
                System.out.println("我是main方法");

                Student s1 = new Student();
                Student s2 = new Student();
            }
        }

输出：
Demo2_Student静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

• 继承
  
  • 让类与类之间产生关系,子父类关系
  • 继承的好处
    
    • 提高了代码的复用性
    • 提高了代码的维护性
    • 让类与类之间产生了关系，是多态的前提
  • 继承的弊端
    
    • 类的耦合性增强了。
    • 开发的原则：高内聚，低耦合。
    • 耦合：类与类的关系
    • 内聚：就是自己完成某件事情的能力
• 类的继承特点
  
  • Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)
    
    • 有些语言是支持多继承，格式：extends 类1,类2,…
  • Java支持多层继承(继承体系)
  • 如果想用这个体系的所有功能用最底层的类创建对象
  • 如果想看这个体系的共性功能,看最顶层的类
  • 注意
    
    • 子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • 子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
    • 不要为了部分功能而去继承
• this和super都代表什么
  
  • this:代表当前对象的引用,谁来调用我,我就代表谁
  • super:代表当前对象父类的引用
  • this和super的使用区别
    
    • 调用成员变量
      
      • this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
      • super.成员变量 调用父类的成员变量
    • 调用构造方法
      
      • this(…) 调用本类的构造方法
      • super(…) 调用父类的构造方法
    • 调用成员方法
      
      • this.成员方法 调用本类的成员方法,也可以调用父类的方法
      • super.成员方法 调用父类的成员方法
  • 子类中所有的构造方法默认都会访问父类中空参数的构造方法
  • 父类没有无参构造方法,子类怎么办?
    
    • super解决
    • this解决
  • 注意事项
    
    • super（)或者this（)必须出现在构造方法的第一条语句上
• 重写
  
  • 子父类出现了一模一样的方法(注意:返回值类型可以是子父类,这个我们学完面向对象讲)
  • 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。
  • 父类中私有方法不能被重写
    
    • 因为父类私有方法子类根本就无法继承
  • 子类重写父类方法时，访问权限不能更低
    
    • 最好就一致
  • 父类静态方法，子类也必须通过静态方法进行重写
    
    • 其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)
• overload和override
  
  • 方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的
  • 方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值类型无关。

class Test4_Person {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(23);
        System.out.println(s1.getName() + "..." + s1.getAge());
        s1.eat();
        s1.study();

        System.out.println("------------------");
        Student s2 = new Student("李四",24);
        System.out.println(s2.getName() + "..." + s2.getAge());
        s2.eat();
        s2.study();
    }
}
/*
* 使用继承后的学生和老师案例
*/

class Person {
    private String name;                    //姓名
    private int age;                        //年龄

    public Person() {}                      //空参构造

    public Person(String name,int age) {    //有参构造
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {      //设置姓名
        this.name = name;
    }

    public String getName() {               //获取姓名
        return name;
    }

    public void setAge(int age) {           //设置年龄
        this.age = age;
    }

    public int getAge() {                   //获取年龄
        return age;
    }

    public void eat() {                     //吃饭
        System.out.println(name  + "吃饭");
    }
}

class Student extends Person {
    public Student() {}                     //空参构造

    public Student(String name,int age) {
        super(name,age);
    }

    public void study() {
        System.out.println(this.getName() + "学习");
    }
}

class Teacher extends Person {
    public Teacher() {}                     //空参构造

    public Teacher(String name,int age) {
        super(name,age);
    }

    public void teach() {
        System.out.println(this.getName() + "讲课");
    }
}

• final
  
  • 特点
    
    • 修饰类，类不能被继承
    • 修饰变量，变量就变成了常量，只能被赋值一次
    • 修饰方法，方法不能被重写
  • final关键字修饰局部变量
    
    • 基本类型，是值不能被改变
    • 引用类型，是地址值不能被改变,对象中的属性可以改变
  • final修饰变量的初始化时机
    
    • 显示初始化
    • 在对象构造完毕前即可