java学习笔记(10) 第10 章（上） - 面向对象编程(高级部分)

java学习笔记(10) 第10 章（上） - 面向对象编程(高级部分)

第10 章 - 面向对象编程-高级部分-上

• 10.1 类变量和类方法
• • 10.1.1 类变量-提出问题-传统方法解决
  • 10.1.2 类变量快速入门
  • 10.1.3 类变量内存布局
  • 10.1.4 类变量的概念、定义语法、如何访问
  • 10.1.5 类变量使用注意事项和细节讨论
  • 10.1.6 类方法基本介绍、类方法的调用、案例演示、经典使用场景
  • 10.1.7 类方法使用注意事项和细节讨论
  • 10.1.8 课堂练习 StaticExercise01.java
• 10.2 理解main 方法语法
• • 10.2.1 深入理解main 方法
  • 10.2.2 特别提示：
  • 10.2.3 案例演示-main传参
• 10.3 代码块
• • 10.3.1 基本介绍、基本语法
  • 10.3.2 代码块的好处和案例演示
  • 10.3.3 代码块使用注意事项和细节讨论
  • 10.3.4 课堂练习题
• 10.4 单例设计模式
• • 10.4.1 什么是设计模式
  • 10.4.2 什么是单例模式
  • 10.4.3 单例模式应用实例
  • 10.4.4 饿汉式VS 懒汉式
• 10.5 final 关键字
• • 10.5.1 基本介绍
  • 10.5.2 final 使用注意事项和细节讨论
  • 10.5.3 final 应用实例

10.1 类变量和类方法 10.1.1 类变量-提出问题-传统方法解决

• 提出问题
  说：有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?，编写程序解决。

• 传统的方法来解决

  使用我们现有的技术来解决这个问题,大家看看如何?com.hspedu.static_.ChildGame.java
  思路：
  1.在main方法中定义一个变量 count
  2.当一个小孩加入游戏后count++,最后个count 就记录有多少小孩玩游戏
  问题分析:
  1.count是一个独立于对象,很尴尬
  2.以后我们访问count很麻烦,没有使用到OOP
  3.因此,我们引出类变量/静态变量

传统方法代码：

public class LianXi {
  public static void main(String[] args) {
       
              //定义一个变量 count, 统计有多少小孩加入了游戏
              int count = 0;

                Child child1 = new Child("白骨精");
                child1.join();
                count++;

                Child child2 = new Child("狐狸精");
                child2.join();
                count++;

                Child child3 = new Child("老鼠精");
                child3.join();
                count++;
                
                System.out.println("共有" + count  + " 个小孩加入了游戏...");
            }
        }

        class Child { //类
            private String name;
            //定义一个变量 count ,是一个类变量(静态变量) static 静态
            //该变量最大的特点就是会被Child 类的所有的对象实例共享
            // public static int count = 0;
            public Child(String name) {
                this.name = name;
            }
            public void join() {
                System.out.println(name + " 加入了游戏.."); 
            }
        }

10.1.2 类变量快速入门

思考: 如果,设计一个int count 表示总人数,我们在创建一个小孩时，就把count 加1,并且count 是所有对象共享的就ok 了!，我们使用类变量来解决

改进代码：

public class ChildGame {
    public static void main(String[] args) {

        //定义一个变量 count, 统计有多少小孩加入了游戏
        int count = 0;

        Child child1 = new Child("白骨精");
        child1.join();
        //count++;
        child1.count++;

        Child child2 = new Child("狐狸精");
        child2.join();
        //count++;
        child2.count++;

        Child child3 = new Child("老鼠精");
        child3.join();
        //count++;
        child3.count++;

        //===========
        //类变量，可以通过类名来访问
        System.out.println("共有" + Child.count  + " 小孩加入了游戏...");
        //下面的代码输出什么?
        System.out.println("child1.count=" + child1.count);//3
        System.out.println("child2.count=" + child2.count);//3
        System.out.println("child3.count=" + child3.count);//3
    }
}

class Child { //类
    private String name;
    //定义一个变量 count ,是一个类变量(静态变量) static 静态
    //该变量最大的特点就是会被Child 类的所有的对象实例共享
    public static int count = 0;
    public Child(String name) {
        this.name = name;
    }
    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

10.1.3 类变量内存布局

• 类变量在哪里？

参考文章1：https://blog.csdn.net/x iya/article/details/81260154/可以看到 static 变量保存在 Class 实例的尾部。Class 对象确实在堆中。

参考文章2：https://www.zhihu.com/question/59174759/answer/163207831结论:JDK7以上版本，静态域存储于定义类型的Class对象中，Class对象如同堆中其他对象一样，存在于GC堆中。

有些书说在方法区…, 与jdk 版本有关系,记住一点:static变量是对象共享

不管static变量在哪里，共识
(1) static变量是同一个类所有对象共享(2) static类变量，在类加载的时候就生成了.

10.1.4 类变量的概念、定义语法、如何访问

• 1.类变量的概念

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。这个从前面的图也可看出来。

• 2.如何定义类变量

  定义语法:
  访问修饰符 static 数据类型 变量名;[推荐用这个定义]
  static 访问修饰符 数据类型 变量名;

• 3.如何访问类变量VisitStatic.java

  类名.类变量名
  或者 对象名.类变量名【静态变量的访问修饰符的访问权限和范围和普通属性是一样的。】
  推荐使用:类名.类变量名;

代码演示

public class VisitStatic {
    public static void main(String[] args) {
        //类名.类变量名
        //说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名
        System.out.println("a.name=" + a.name);
    }
}

class A {
    //类变量
    //类变量的访问，必须遵守 相关的访问权限.
    public static  String name = "Java教育"; //public改成private上边就报错了，private只能在本类使用
    //普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
    private int num = 10;
}

注意：如果A类public改成private上边就报错了，private只能在本类使用

10.1.5 类变量使用注意事项和细节讨论

StaticDetail.java

1. 什么时候需要用类变量？
   当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量):比如:定义学生类，统计所有学生共交多少钱。Student (name,staticfee)
2. 类变量与实例变量（普通属性)区别
   类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
3. 加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
4. 类变量可以通过 类名.类变量名 或 对象名.类变量名 来访问，但java设计者推荐我们使用 类名.类变量名 方式访问。【前提是满足访问修饰符的访问权限和范围】
5. 实例变量不能通过 类名.类变量名 方式访问。
6. 类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了,就可以使用类变量了。[案例演示]
7. 类变量的生命周期是随类的加载开始,随着类消亡而销毁。

代码：

public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
        //System.out.println(B.n1); //n1是实例变量，不是静态变量
        System.out.println(B.n2); //n2是静态的，可以访问

        //静态变量是类加载的时候，就创建了,所以我们没有创建对象实例
        //也可以通过类名.类变量名来访问
        System.out.println(C.address);
    }
}

class B {
    public  int n1 = 100;
    public static int n2 = 200;
}

class C {
    public static String address = "北京";
}

10.1.6 类方法基本介绍、类方法的调用、案例演示、经典使用场景

1. 基本介绍

   类方法也叫静态方法。形式如下:
   访问修饰符 static 数据返回类型 方法名 ( )【推荐】
   static 访问修饰符 数据返回类型 方法名 ( )

2. 类方法的调用
   使用方式: 类名.类方法名 或者 对象名.类方法名【前提是满足访问修饰符的访问权限和范围】

3. 方法应用案例 StaticMethod.java
   学生交学费的应用案例

4. 类方法经典的使用场景

   当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法,提高开发效率
   比如:工具类中的方法utils
   Math类、Arrays类、Collections集合类看下源码:

   小结
   在程序员实际开发，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序,完成某个计算任务等…

public class StaticMethod {
    public static void main(String[] args) {
        //创建2个学生对象，交学费
        Stu tom = new Stu("tom");
        //tom.payFee(100); //对象名.类方法名 调用
        Stu.payFee(100);//类名.类方法名 调用，对不对?对

        Stu mary = new Stu("mary");
        //mary.payFee(200);
        Stu.payFee(200);//对

        //输出当前收到的总学费
        Stu.showFee();//300

        //如果我们希望不创建实例，也可以调用某个方法(即当做工具来使用)
        //这时，把方法做成静态方法时非常合适
        System.out.println("9开平方的结果是=" + Math.sqrt(9));

        System.out.println(MyTools.calSum(10, 30));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools  {
    //求出两个数的和
    public static double calSum(double n1, double n2) {
        return  n1 + n2;
    }
    //可以写出很多这样的工具方法...
}
class Stu {
    private String name;//普通成员
    //定义一个静态变量，来累积学生的学费
    private static double fee = 0;

    public Stu(String name) {
        this.name = name;
    }
    //说明
    //1. 当方法使用了static修饰后，该方法就是静态方法
    //2. 静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//传进来的fee，累积到静态fee
    }
    public static void showFee() {
        System.out.println("总学费有:" + Stu.fee);
    }
}

10.1.7 类方法使用注意事项和细节讨论

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区:类方法中无this的参数,
   普通方法中隐含着this的参数
2. 类方法可以通过类名调用，也可以通过对象名调用。[举例]
3. 普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。[举例]
4. 类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。[举例]
5. 类方法(静态方法)中只能访问静态变量或静态方法。【如何理解】
6. 普通成员方法，既可以访问非静态成员，也可以访问静态成员。

• 小结:静态方法，只能访问静态的成员。非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)

代码：

public class StaticMethodDetail {
    public static void main(String[] args) {

        D.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new D().say();//可以,创建对象也可以是匿名对象
    }
}
class D {
    private int n1 = 100;
    private static  int n2 = 200;
    public void say() {//非静态方法,普通方法
    }

    public static  void hi() {//静态方法,类方法
        // 类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以。
        //System.out.println(this.n1);
    }

    //类方法(静态方法)中 只能访问 静态变量 或静态方法
    //口诀:静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误，say()是非静态方法。
    }
    //普通成员方法，既可以访问  非静态成员，也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() { //非静态方法
        //非静态成员
        System.out.println(n1);
        say(); //say()是非静态方法。

        //静态成员
        System.out.println(n2);
        hello();
    }
}

10.1.8 课堂练习 StaticExercise01.java

1. 题目1，写出下面代码输出结果
   
2. 题目2，看看下面代码有没有错误,如果有错误，就修改，看看输出什么?
   
   代码：
   注意：new Person（）才会进入无参构造器

public class LianXi {
    public static void main(String[] args) {

       System.out.println("Number of total is " +Person.getTotalPerson()); //0  Person类直接调用类方法
        Person p1 = new Person();
        System.out.println( "Number of total is "+ Person.getTotalPerson()); //1

    }
}
class Person {  //StaticExercise02.java 2min 时间
    private int id;
    private static int total = 0;
    public static int getTotalPerson() {
        //id++;//错误, 注销

        return total;
    }
    public Person() {//构造器
        total++;  //total = 1
        id = total;//id = 1
    }
}

3. 题目3，看看下面代码有没有错误,如果有错误，就修改，看看total 等于多少4?
   

public class LianXi {
    }
class Person { //StaticExercise03.java 2min 看
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
        // this.total = total;//错误，因为在static方法中，不可以使用this 关键字

        Person.total = total;
    }
    public Person() {//构造器
        total++; //4
        id = total;  //4
    }
    //编写一个方法，输出total的值
    public static void m() {
        System.out.println("total的值=" + total);
    }
    
}
class TestPerson {
    public static void main(String[] args) {

        Person.setTotalPerson(3);
        new Person(); //最后 total的值就是4
        Person.m();//看看输出的是不是4
    }
}

10.2 理解main 方法语法 10.2.1 深入理解main 方法

所以，传参给args是java执行程序的时候传进去的。

10.2.2 特别提示：

1. 在main()方法中，我们可以直接调用main 方法所在类的静态方法或静态属性。
2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，[举例说明] Main01.java
3. 代码

public class Main01 {

    //静态的变量/属性
    private static  String name = "java教育";
    //非静态的变量/属性
    private int n1 = 10000;

    //静态方法
    public static  void hi() {
        System.out.println("Main01的 hi方法");
    }
    //非静态方法
    public void cry() {
        System.out.println("Main01的 cry方法");
    }

    public static void main(String[] args) {

        //可以直接使用 name
        //1. 静态方法main 可以访问本类的静态成员
        System.out.println("name=" + name);
        hi();
        //2. 静态方法main 不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();
        //3. 静态方法main 要访问本类的非静态成员，需要先创建对象 , 再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);//ok
        main01.cry();
    }
}

10.2.3 案例演示-main传参

一般在submit软件运行时 直接传参方便，以下是演示IDEA如何传参。

现在，不传参直接运行代码 ，没有输出值

10.3 代码块 10.3.1 基本介绍、基本语法

10.3.2 代码块的好处和案例演示

好处：

1. 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的 *** 作
2. 场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用
   性
3. 代码块的快速入门 CodeBlock01.java

public class CodeBlock01 {
    public static void main(String[] args) {

        Movie movie = new Movie("你好，李焕英");
        System.out.println("===============");
        Movie movie2 = new Movie("唐探3", 100, "陈思诚");
    }
}

class Movie {
    private String name;
    private double price;
    private String director;

    //3个构造器-》重载
    //解读
    //(1) 下面的三个构造器都有相同的语句
    //(2) 这样代码看起来比较冗余
    //(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
    //(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //(5) 代码块调用的顺序优先于构造器..
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    };

    public Movie(String name) {
        System.out.println("Movie(String name) 被调用...");
        this.name = name;
    }

    public Movie(String name, double price) {

        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {

        System.out.println("Movie(String name, double price, String director) 被调用...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

10.3.3 代码块使用注意事项和细节讨论

• 细节第1-3点
  CodeBlockDetail01.java
  

第1-3点对应的代码： 从下往上看，从AA类开始看到DD类

public class CodeBlockDetail01 {
    public static void main(String[] args) {

        //类被加载的情况举例
        //1. 创建对象实例时(new)
        // AA aa = new AA();
        //2. 创建子类对象实例，父类也会被加载, 而且，父类先被加载，子类后被加载
        // AA aa2 = new AA();
        //3. 使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.n1); //父类先被加载，子类后被加载
                                       //所以animal的也会被加载

        //static代码块，是在类加载时，执行的，而且只会执行一次.
       // DD dd = new DD();
       // DD dd1 = new DD();

        //普通的代码块，在创建对象实例时，会被隐式的调用。
        // 被创建一次，就会调用一次。
        // 如果只是使用类的静态成员时，普通代码块并不会执行

        System.out.println(DD.n1);//8888, 静态模块块一定会执行

    }
}

class DD {
    public static int n1 = 8888;//静态属性
    //静态代码块
    static {
        System.out.println("DD 的静态代码1被执行...");//
    }
    //普通代码块, 在new 对象时，被调用，而且是每创建一个对象，就调用一次
    //可以这样简单的，理解 普通代码块是构造器的补充
    {
        System.out.println("DD 的普通代码块...");
    }
}

class Animal {
    //静态代码块
    static {
        System.out.println("Animal 的静态代码1被执行...");//
    }
}

class Cat extends Animal {

    public static  int n1 = 999;//静态属性

    //静态代码块
    static {
        System.out.println("Cat 的静态代码1被执行...");//
    }
}

class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行...");//1
    }
}

class AA extends BB {
    //静态代码块
    static {
        System.out.println("AA 的静态代码1被执行...");//2
    }
}

• 细节第4点
  
  第4点对应代码：

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();// (1) A 静态代码块01 (2) getN1被调用...(3)A 普通代码块01(4)getN2被调用...(5)A() 构造器被调用
    }
}

class A {
    { //普通代码块
        System.out.println("A 普通代码块01");
    }
    private int n2 = getN2();//普通属性的初始化

    static { //静态代码块
        System.out.println("A 静态代码块01");
    }

    //静态属性的初始化
    private static  int n1 = getN1();

    public static int getN1() {
        System.out.println("getN1被调用...");
        return 100;
    }
    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2被调用...");
        return 200;
    }

    //无参构造器
    public A() {
        System.out.println("A() 构造器被调用");
    }
}

• 细节第5点
  

第5点对应代码：

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();//(1)AAA的普通代码块(2)AAA() 构造器被调用(3)BBB的普通代码块(4)BBB() 构造器被调用
    }
}

class AAA { //父类Object没什么输出
    {
        System.out.println("AAA的普通代码块");
    }
    public AAA() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}

class BBB extends AAA  {
    {
        System.out.println("BBB的普通代码块...");
    }
    public BBB() {
        //(1)super()
        //(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用....");
    }
}

• 细节第6-7点：
  

第6-7点对应代码：

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //说明
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        new B02();//对象

        new C02();
    }
}

class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }

}

class B02 extends A02 { //

    private static int n3 = getVal03();

    static {
        System.out.println("B02的一个静态代码块..");//(4)
    }
    public int n5 = getVal04();
    {
        System.out.println("B02的第一个普通代码块..");//(9)
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)
    }
}

class C02 {
    private int n1 = 100;
    private static  int n2 = 200;

    private void m1() {

    }
    private static void m2() {

    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

10.3.4 课堂练习题

CodeBlockExercise01.java

• 题1：下面的代码输出什么？
  
  输出为：
  in static block!
  100
  100

• 题2：下面的代码输出什么？
  
  解析：new Test（）会导致类加载，然后会导致静态代码块和静态属性初始化。new Sample（“静态成员sam初始化”）这里把参数传给Sample的有参构造器。静态代码块执行完进行普通代码块或普通属性的初始化。

  输出结果：
  静态成员sam初始化
  static块执行
  sam1成员初始化
  Test默认构造函数被调用

10.4 单例设计模式 10.4.1 什么是设计模式

1. 是静态方法和属性的经典使用
2. 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱,不同的棋局,我们用不同的棋谱,免去我们自己再思考和摸索。

10.4.2 什么是单例模式

单例(单个的实例)

1. 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某
   个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
2. 单例模式有两种方式: 1) 饿汉式 2) 懒汉式

10.4.3 单例模式应用实例

（1）饿汉式代码：

public class SingleTon01 {

    public static void main(String[] args) {
//        GirlFriend xh = new GirlFriend("小红");
//        GirlFriend xb = new GirlFriend("小白");//创建了2个对象 就不是单例

        //通过方法可以获取对象
        GirlFriend instance = GirlFriend.getInstance();
        System.out.println(instance);

        GirlFriend instance2 = GirlFriend.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2);//T  
    }
}

//有一个类， GirlFriend
//只能有一个女朋友
class GirlFriend {

    private String name;
    
    //为了能够在静态方法中，返回 gf对象，需要将其修饰为static
    //對象，通常是重量級的對象, 饿汉式可能造成创建了对象，但是沒有使用.
    private static GirlFriend gf = new GirlFriend("小红红");

    //如何保障我们只能创建一个 GirlFriend 对象
    //步骤[单例模式-饿汉式]
    //1. 将构造器私有化
    //2. 在类的内部直接创建对象(该对象是static)
    //3. 提供一个公共的static方法，返回 gf对象
    private GirlFriend(String name) {
        System.out.println("構造器被調用.");
        this.name = name;
    }

    public static GirlFriend getInstance() {
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + ''' +
                '}';
    }
}

（2）懒汉式代码：

public class SingleTon02 {
    public static void main(String[] args) {
        //new Cat("大黃"); //不行，因为构造器私有化了
        //System.out.println(Cat.n1); //类虽然加载了，但是没创建Cat对象
        
        Cat instance = Cat.getInstance();//创建Cat对象
        System.out.println(instance);

        //再次调用getInstance
        Cat instance2 = Cat.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2);//T
    }
}

//希望在程序運行過程中，只能創建一個Cat對象
//使用單例模式
class Cat {
    private String name;
    public static  int n1 = 999;
    private static Cat cat ; //默认是null

    //步骤
    //1.仍然构造器私有化
    //2.定义一个static静态属性
    //3.提供一个public的static方法，可以返回一个Cat对象
    //4.懒汉式，只有档用户使用getInstance时，才返回cat对象, 后面再次调用时，会返回上次创建的cat对象，
      //从而保证了单例
    
    private Cat(String name) {
        System.out.println("構造器調用...");
        this.name = name;
    }
    public static Cat getInstance() {

        if(cat == null) {//如果还沒有创建cat對象
            cat = new Cat("小可愛");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + ''' +
                '}';
    }
}

10.4.4 饿汉式VS 懒汉式

1. 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例。
   而懒汉式是在使用时才创建。
2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。(后面学习线程后，会完善一把)
3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉
   式创建的对象就浪费了，懒汉式是使用时才创建,就不存在这个问题。
4. 在我们javaSE标准类中， java.lang.Runtime就是经典的单例模式。

10.5 final 关键字 10.5.1 基本介绍

Final01.java
final中文意思:最后的,最终的.
final可以修饰类、属性、方法和局部变量.

在某些情况下,程序员可能有以下需求，就会使用到final:

1. 当不希望类被继承时,可以用final修饰.【案例演示】
2. 当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字
   修饰。【案例演示:访问修饰符 final返回类型方法名】
3. 当不希望类的的某个属性的值被修改,可以用final修饰.【案例演示: public final double TAX RATE=0.08】
4. 当不希望某个局部变量被修改，可以使用final修饰【案例演示: final double TAX RATE=0.08 】

代码：

public class Final01 {
    public static void main(String[] args) {
        E e = new E();
        //e.TAX_RATE = 0.09;
    }
}

//如果我们要求A类不能被其他类继承
//可以使用final修饰 A类
final class A { }

//class B extends A {} //报错

class C {
    //如果我们要求hi不能被子类重写
    //可以使用final修饰 hi方法
    public final void hi() {}
}
class D extends C {
//    @Override
//    public void hi() {
//        System.out.println("重写了C类的hi方法..");
//    }
}

//当不希望类的的某个属性的值被修改,可以用final修饰
class E {
    public final double TAX_RATE = 0.08;
}

//当不希望某个局部变量被修改，可以使用final修饰
class F {
    public void cry() {
        //这时，NUM 也称为 局部常量
        final double NUM = 0.01;
        //NUM = 0.9;
        System.out.println("NUM=" + NUM);
    }
}

10.5.2 final 使用注意事项和细节讨论

1. final修饰的属性又叫常量,一般用XX XX XX来命名
2. final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如
   下位置之一【选择一个位置赋初值即可】:
   ①定义时:如public final double TAX_RATE=0.08; ②在构造器中 ③在代码块中。
3. 如果final修饰的属性是静态的，则初始化的位置只能是
   ① 定义时 ② 在静态代码块，不能在构造器中赋值。
4. final类不能继承,但是可以实例化对象。
5. 如果类不是final类,但是含有final方法，则该方法虽然不能重写，但是可以被继承。
6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
7. final不能修饰构造方法(即构造器)
8. final和static往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。
   class Demo{
   public static final int i=16; //不写final下边语句就输出了。
   static{ System.out.println(“Java教育~”);}
9. 包装类(Integer,Double,Float,Boolean等都是final),String也是final类.

细节1-5点对应代码：

public class FinalDetail01 {
    public static void main(String[] args) {
        CC cc = new CC();
        
        new EE().cal();
    }
}

class AA {
    
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2 ;
    public final double TAX_RATE3 ;

    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }
}

class BB {
    
    public static final double TAX_RATE = 99.9;
    public static final double TAX_RATE2 ;

    static {
        TAX_RATE2 = 3.3;
    }
}

//final类不能继承，但是可以实例化对象
final class CC { }


//如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
//即，仍然遵守继承的机制.
class DD {
    public final void cal() {
        System.out.println("cal()方法");
    }
}
class EE extends DD { }

细节6-9点对应代码：

public class FinalDetail02 {
    public static void main(String[] args) {
    
        System.out.println(BBB.num);
        //包装类,String 是final类，不能被继承
    }
}

//final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理
class BBB {
    public final static  int num = 10000;//不写final，下边的静态代码块就要被执行了。写了就不执行
    static {
        System.out.println("BBB 静态代码块被执行");
    }
}
final class AAA{
    //一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
    //public final void cry() {}
}

10.5.3 final 应用实例

• 题1 ：请编写一个程序,能够计算圆形的面积。要求圆周率为3.14。赋值的位置3个方式都写一下.

public class FinalExercise01 {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println("面积=" + circle.calArea());
    }
}

class Circle {
    private double radius;
    private final double PI;// = 3.14;
    //构造器
    public Circle(double radius) {
        this.radius = radius;
        //PI = 3.14;
    }
    {
        PI = 3.14;
    }

    public double calArea() {
        return PI * radius * radius;
    }
}

• 题目2：看看下面的代码有没有错误

class Something {  //FinalExercise02.java
    public int addOne(final int x) { //下面的代码是否有误，为什么? 1min
        //++x;  //错误,原因是不能修改 final x的值
        return x + 1; //这里是可以.x的值没有变化
    }
}