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

10.1 类变量和类方法
10.2 理解main 方法语法
10.3 代码块
10.4 单例设计模式
10.5 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

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

代码：

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 类方法基本介绍、类方法的调用、案例演示、经典使用场景

基本介绍

类方法也叫静态方法。形式如下:
访问修饰符 static 数据返回类型方法名 ( )【推荐】
static 访问修饰符数据返回类型方法名 ( )
类方法的调用
使用方式: 类名.类方法名或者对象名.类方法名【前提是满足访问修饰符的访问权限和范围】
方法应用案例 StaticMethod.java
学生交学费的应用案例
类方法经典的使用场景

当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法,提高开发效率
比如:工具类中的方法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 类方法使用注意事项和细节讨论

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

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

代码：

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，写出下面代码输出结果
题目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，看看下面代码有没有错误,如果有错误，就修改，看看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 特别提示：

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

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 代码块的好处和案例演示

好处：

相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
场景:如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用
性
代码块的快速入门 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 什么是设计模式

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

10.4.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 懒汉式

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

10.5 final 关键字

10.5.1 基本介绍

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

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

当不希望类被继承时,可以用final修饰.【案例演示】
当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字
修饰。【案例演示:访问修饰符 final返回类型方法名】
当不希望类的的某个属性的值被修改,可以用final修饰.【案例演示: public final double TAX RATE=0.08】
当不希望某个局部变量被修改，可以使用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 使用注意事项和细节讨论

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

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

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

细节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的值没有变化
    }
}

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 应用实例

相关推荐