Java笔记017-类变量和类方法、理解main方法语法、代码块、单例设计模式、final关键字_编写一个类a,它有静态变量count,实现用count记录类a对象的个数,再用静态方法-CSDN博客

本文链接：https://blog.csdn.net/qq_59621600/article/details/128485750

本文详细讲解了面向对象编程中的类变量和类方法，包括它们的定义、访问方式、内存布局以及使用注意事项。通过案例展示了如何使用类变量来统计小孩玩游戏的数量，并探讨了静态方法的应用场景。此外，还介绍了代码块的使用，包括静态代码块和普通代码块的执行顺序以及它们在初始化对象时的作用。最后，文章提到了单例设计模式，阐述了饿汉式和懒汉式的区别，并讨论了final关键字的用途。

摘要由CSDN通过智能技术生成

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

2、下面代码正确么，为什么

面向对象编程(高级部分)

类变量和类方法

类变量-提出问题

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

传统方法解决

思路

1、在main方法中定义一个变量count

2、当一个小孩加入游戏后count++，最后个count 就记录有多少小孩玩游戏

package com10.static_;

public class ChildGame {
    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;

    public Child(String name) {
        this.name = name;
    }

    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

问题分析：

1、count是一个独立于对象，很尴尬

2、以后我们访问count很麻烦，没有使用到OOP

3、因此，我们引出类变量/静态变量

类变量快速入门

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

package com10.static_;

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 {//类
    //定义一个变量 count,是一个类变量(静态变量)static静态
    //该变量最大的特点就是会被Child 类的所有的对象实例共享
    public static int count = 0;
    private String name;

    public Child(String name) {
        this.name = name;
    }

    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

类变量内存布局

画一个小图理解。=> 画出一个示意图帮助理解，静态变量放在哪里?

1.静态变量被对象共享

2.因此不影响对静态变量的使用

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

什么是类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，

如何定义类变量定义语法：

访问修饰符static 数据类型变量名;[推荐]
static 访问修饰符数据类型变量名;

如何访问类变量

定义语法：

类名.类变量名
或者对象名.类变量名

【静态变量的访问修饰符的访问权限和范围和普通属性是一样的】

推荐使用类名.类变量名

package com10.static_;

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 = "甲柒";
}

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

1、什么时候需要用类变量
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)：
比如：定义学生类，统计所有学生共交多少钱。Student (name, fee)

2、类变量与实例变量(普通属性)区别
类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3、加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量

4、类变量可以通过类名.类变量名或者 对象名.类变量名 来访问，但java设计者推荐我们使用 类名.类变量名 方式访问。【前提是满足访问修饰符的访问权限和范围】

5、实例变量不能通过 类名.类变量 名方式访问。

6、类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。[案例演示]

7、类变量的生命周期是随类的加载开始，随着类消亡而销毁。[举例，Monster.name][案例演示]

package com10.static_;

public class StaticDetail {
    public static void main(String[] args) {
        B b = new B();
//        System.out.println(B.n1);
        System.out.println(B.n2);

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

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

class C {
    public static String address = "郑州";
}

类方法基本介绍

类方法也叫静态方法

形式如下：

访问修饰符 static 数据返回类型方法名(){}【推荐】
static 访问修饰符数据返回类型方法名(){}

类方法的调用：

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

类方法应用案例

统计学费总和

package com10.static_;

public class StaticMethod {
    public static void main(String[] args) {
        //创建两个学生对象，来累计学生的学费
        Stu tom = new Stu("tom");
        tom.payFee(100);
        Stu.payFee(100);
        Stu mary = new Stu("mary");
        mary.payFee(200);
        Stu.payFee(200);

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

class Stu {
    //定义一个静态变量，来累计学生的学费
    private static double fee = 0;
    private String name;//普通成员

    public Stu(String name) {
        this.name = name;
    }

    //说明
    //1.当方法使用了static修饰后，该方法就是静态方法
    //2.静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//累积到
    }

    public static void showFee() {
        System.out.println("总学费有：" + Stu.fee);
    }
}

运行结果

类方法经典的使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。

比如：工具类中的方法utils
Math类、Arrays类、Collections集合类看下源码

小结

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

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

1、类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区
类方法中无this的参数
普通方法中隐含着this的参数

2、类方法可以通过类名调用，也可以通过对象名调用。[举例]

3、普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。[举例]

4、类方法中不允许使用和对象有关的关建字，比如this和super。晋迪万法(永员万法)可以。[举例]

5、类方法(静态方法)中只能访问静态变量或静态方法。【如何理解】

6、普通成员方法，既可以访问普通变量(方法)，也可以访问静态变量(方法)。

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

package com10.static_;

public class StaticMethodDetail {
    public static void main(String[] args) {
        D.hi();//ok
        //非静态方法，不能通过类名调用
//        D.say();//错误，需要先创建对象，再调用
        new D().say();//ok
    }
}

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

    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();//错误
    }

    public void say() {//非静态类

    }

    //普通成员方法，既可以访问普通变量(方法)，也可以访问静态变量(方法)
    //小结：非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

练习题

1、以下代码输出什么

package com10.static_;

public class StaticExercise01 {
    public static void main(String[] args) {
        new Test().count();//9
        new Test().count();//10
        System.out.println(Test.count);//11
    }
}

class Test {
    static int count = 9;

    public void count() {
        System.out.println("count=" + (count++));
    }
}

运行结果

2、看下面代码有没有错误，如果有错误，就修改，看看输出什么？

package com10.static_;

public class StaticExercise02 {
    public static void main(String[] args) {
        System.out.println("Number of total is" + Person.getTotalPerson());
        Person p1 = new Person();
        System.out.println("Number of total is" + Person.getTotalPerson());
    }
}

class Person {
    private static int total = 0;
    private int id;

    public Person() {
        total++;
        id = total;
    }

    public static int getTotalPerson() {
        id++;//错误
        return total;
    }
}

修改后的代码

package com10.static_;

public class StaticExercise02 {
    public static void main(String[] args) {
        System.out.println("Number of total is" + Person.getTotalPerson());
        Person p1 = new Person();
        System.out.println("Number of total is" + Person.getTotalPerson());
    }
}

class Person {
    private static int total = 0;
    private int id;

    public Person() {
        total++;
        id = total;
    }

    public static int getTotalPerson() {
//        id++;//错误
        return total;
    }
}

运行结果

3、看看下面代码有没有错误，如果有错误，就修改，看看total等于多少

package com10.static_;

public class StaticExercise03 {
    public static void main(String[] args) {
        Person03.setTotalPerson(3);
        new Person03();
    }
}

class Person03 {
    private static int total = 0;
    private int id;

    public Person03() {
        total++;
        id = total;
    }

    public static void setTotalPerson(int total) {
        this.total;
        Person03.total = total;
    }
}

修改后的代码

package com10.static_;

public class StaticExercise03 {
    public static void main(String[] args) {
        Person03.setTotalPerson(3);
        new Person03().m();
    }
}

class Person03 {
    private static int total = 0;
    private int id;

    public Person03() {//构造器
        total++;
        id = total;
    }

    public static void setTotalPerson(int total) {
//        this.total;//错误，因为在static方法中，不可以使用this关键字
        Person03.total = total;
    }

    //编写一个方法，输出total的值
    public void m() {
        System.out.println("total=" + total);
    }
}

运行结果

理解main方法语法

深入理解main方法

解释main方法的形式：public static void main(String[] args){ }

1、main方法是虚拟机调用

2、java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

3、java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4、该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数，案例演示，接收参数

5、java 执行的程序参数1参数2参数3

package com10.static_;

public class Hello {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("第" + (i + 1) + "个参数=" + args[i]);
        }
    }
}

特别提示

1、在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

2、但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员,

package com10.static_;

public class Main01 {
    //静态的变量/属性
    private static String name = "甲柒";
    //非静态的变量/属性
    private int n1 = 3600;

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

    public static void main(String[] args) {
        //可以直接使用name
        //1.静态方法可以访问本类的静态成员
        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);
        main01.cry();
    }

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

main方法使用案例演示

package com10.static_;

public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]=" + args[i]);
        }
    }
}

代码块

基本介绍

代码化块又称为初始化块，属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符]{
代码
};

注意：

1、修饰符可选，要写的话，也只能写static

2、代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。

3、逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)

4、;号可以写上，也可以省略。

代码块的好处和案例演示

1、相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作

2、场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

3、代码块的快速入门

package com10.static_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好，李焕英");
        System.out.println("=================================");
        Movie movie1 = new Movie("十二生肖", 46, "成龙");
    }
}

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;
    }
}

运行结果

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

1、static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。

2、类什么时候被加载【重要】

创建对象实例时(new)
创建子类对象实例，父类也会被加载
使用类的静态成员时(静态属性,静态方法)
案例演示：A类extends B类的静态块

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

package com10.codeblock;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1.创建对象实例时(new)
//        AA aa = new AA();
        //2.创建子类对象实例，父类也会被加载,而且，父类先被加载，子类后被加载
//        AA aa1 = new AA();
        //3.使用类的静态成员时(静态属性,静态方法)
//        System.out.println(Cat.n1);

        //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 AA extends BB {
    //静态代码块
    static {
        System.out.println("AA 的静态代码1被执行...");
    }
}

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

小结：
1.static代码块是类加载时，执行，只会执行一次
2.普通代码块时在创建对象时调用的，创建一次，调用一次

4、创建一个对象时，在一个类调用顺序是：(重点，难点)

调用静态代码块和静态属性初始化
(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
调用普通代码块和普通属性的初始化
(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
调用构造方法。

新写一个类演示

package com10.codeblock;

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

    }
}

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

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

    //普通属性的初始化
    private int n2 = getN2();

    {//普通代码块
        System.out.println("A 普通代码块01");
    }

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

    public static int getN1() {
        System.out.println("getN1被调用...");
        return 100;
    }

    public static int getN2() {
        System.out.println("getN2被调用...");
        return 200;
    }
}

5、构造方法(构造器)的最前面其实隐含了super()和调用普通代码块，新写一个类演示【截图+说明】，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

package com10.codeblock;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        BBB bbb = 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、我们看一下创建一个子类时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)4父类的构造方法
子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
子类的构造方法面试题

A extends B类演示

package com10.codeblock;

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 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();
    }
}

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)
        // TODO Auto-generated constructor stub
    }
}

7、静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。

代码块练习题

1、下面的代码输出什么？

package com10.codeblock;

public class CodeBlockExercise01 {
    public static void main(String[] args) {
        System.out.println("total = " + Person.total); //100
        System.out.println("total = " + Person.total); //100
    }
}

class Person {
    public static int total;//静态变量

    static {//静态代码块
        total = 100;
        System.out.println("in static block!");//(1)
    }
}

运行结果

2、下面的代码输出什么？

package com10.codeblock;

public class CodeBlockExercise02 {
    //主方法
    public static void main(String str[]) {
        Test a = new Test();//无参构造器
    }

}

class Sample {
    Sample(String s) {
        System.out.println(s);
    }

    Sample() {
        System.out.println("Sample默认构造函数被调用");
    }
}

class Test {
    static Sample sam = new Sample("静态成员sam初始化 ");//1

    static {
        System.out.println("static块执行");//2
        if (sam == null) System.out.println("sam is null");
    }

    Sample sam1 = new Sample("sam1成员初始化");//3

    Test()//构造器
    {
        System.out.println("Test默认构造函数被调用");//4
    }

}

运行结果

单例设计模式

什么是设计模式

1、静态方法和属性的经典使用

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

什么是单例模式单例(单个的实例)

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

2、单例模式有两种方式：

饿汉式
懒汉式

单例模式应用实例

演示饿汉式和懒汉式单例模式的实现。

步骤如下：

1、构造器私有化 => 防止直接new

2、类的内部创建对象

3、向外暴露一个静态的公共方法。getInstance

4、代码实现

[单例模式]饿汉式

package com10.single_;

public class SingleTon01 {

    public static void main(String[] args) {
//        GirlFriend xh = new GirlFriend("小红");
//        GirlFriend xb = new GirlFriend("小白");

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

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

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

        //...

    }

}

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

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

    //如何保障我们只能创建一个 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 + '\'' +
                '}';
    }
}

[单例模式]懒汉式

package com10.single_;

/**
 * 演示懒汉式的单例模式
 */
public class SingleTon02 {
    public static void main(String[] args) {
        //new Cat("大黄");
        //System.out.println(Cat.n1);
        Cat instance = Cat.getInstance();
        System.out.println(instance);

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

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

    }
}


//希望在程序运行过程中，只能创建一个Cat对象
//使用单例模式
class Cat {
    public static int n1 = 999;
    private static Cat cat; //默认是null
    private String name;

    //步骤
    //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 + '\'' +
                '}';
    }
}

饿汉式 VS 懒汉式

1、二者最主要的区别在于创建对象的时机不同：
饿汉式是在类加载就创建了对象实例 而 懒汉式是在使用时才创建。

2、饿汉式不存在线程安全问题，懒汉式存在线程安全问题。(后面学习线程后，会完善一把)

3、饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。

4、在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式。

final关键字

基本介绍

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】

package com10.final_;

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);
    }
}

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

1、final修饰的属性又叫常量，一般用XX XX XX来命名

2、final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一
【选择一个位置赋初值即可】

定义时：如public final double TAX_RATE=0.08;
在构造器中
在代码块中

3、如果final修饰的属性是静态的，则初始化的位置只能是

定义时
在静态代码块不能在构造器中赋值。

4、final类不能继承，但是可以实例化对象。[A2类]

5、如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。[A3类]

package com10.final_;

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

        new EE().cal();
    }
}

class AA {
    /*
    1. 定义时：如 public final double TAX_RATE=0.08;
    2. 在构造器中
    3. 在代码块中
     */
    public final double TAX_RATE = 0.08;//1.定义时赋值
    public final double TAX_RATE2;
    public final double TAX_RATE3;

    {//在代码块赋值
        TAX_RATE3 = 8.8;
    }

    public AA() {//构造器中赋值
        TAX_RATE2 = 1.1;
    }
}

class BB {
    /*
    如果final修饰的属性是静态的，则初始化的位置只能是
    1 定义时  2 在静态代码块 不能在构造器中赋值。
     */
    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 {
}

5、一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

6、final不能修饰构造方法(即构造器)

7、final和static往往搭配使用，效率更高，底层编译器做了优化处理。

8、包装类(Integer,Double,Float, Boolean等都是final)，String也是final类。

package com10.final_;

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;

    static {
        System.out.println("BBB 静态代码块被执行");
    }
}

final class AAA {
    //一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
    //public final void cry() {}
}

final应用实例

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

package com10.final_;

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

class Circle {
    private final double PI;// = 3.14;
    private double radius;

    {
        PI = 3.14;
    }

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

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

2、下面代码正确么，为什么

package com10.final_;

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

    }
}

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