1 类变量和类方法

1.1 类变量-提出问题

提出问题的主要目的就是让大家思考解决之道，从而引出我要讲的知识点.
说：有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?，编写程序解决。
在这里插入图片描述

1.2 传统的方法来解决

在这里插入图片描述

1.3 类变量快速入门

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

package com.hspedu.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 {
    
     //类
    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 + " 加入了游戏..");
    }
}

1.4 类变量内存布局

在这里插入图片描述
（1）static 变量是同一个类所有对象共享
（2）static 类变量，在类加载的时候就生成了

1.5 什么是类变量

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

1.6 如何定义类变量

定义语法：
访问修饰符 static 数据类型 变量名；【推荐】
static 访问修饰符 数据结构 变量名；

1.7 如何访问类变量

在这里插入图片描述

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

（1）什么时候需要用类变量：
当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）
（2）类变量与实例变量（普通属性）区别：
类变量是该类所有对象共享的，而实例变量是每个对象独享的
（3）加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
（4）类变量可以通过类名.类变量名或者对象名.类变量名来访问。【前提要满足修饰符访问权限和范围】
（5）实例变量不能通过类名.类变量名的方式访问。
（6）类变量在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。
（7）类变量的生命周期是随着类的加载开始，随着类消亡而销毁。

1.9 类方法基本介绍

在这里插入图片描述

1.10 类方法的调用

使用方式：
（1）类名.类方法名
（2）对象名.类方法名
前提是要满足访问修饰符的访问权限和范围

1.12 类方法经典的使用场景

（1）当方法不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率。
比如：工具类中的方法 utils
Math类、Arrays类、Collections 集合类看下源码：
（2）小结：
在程序实际开发，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序，完成某个计算任务等…

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

（1）类方法和普通方法都是随着类的加载加载，将结构信息存储在方法区：
类方法中无this的参数
普通方法中隐含着this的参数
（2）类方法可以通过类名调用，也可以通过对象调用
（3）普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用
（4）类方法中不允许使用和对象有关的关键字，比如this和super。普通方法可以。
（5）类方法（静态方法）中，只能访问静态属性或静态方法
（6）普通成员方法，既可以访问非静态成员，也可以访问静态成员。
小结：静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员【必须要遵守访问权限】

扫描二维码关注公众号，回复： 14237398 查看本文章

package com.hspedu.static_;

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();//错误
    }
    //普通成员方法，既可以访问  非静态成员，也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() {
    
    
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();

    }
}

1.14 练习

package com.hspedu.static_;

public class StaticExercise01 {
    
    
}

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

1.15 看看下面代码有没有错误,如果有错误，就修改，看看输出什么?

package com.hspedu.static_;

public class StaticExercise02 {
    
    
}
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
    }
}
class TestPerson {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("Number of total is " +Person.getTotalPerson()); //0
        Person p1 = new Person();
        System.out.println( "Number of total is "+ Person.getTotalPerson()); //1
    }
}

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

package com.hspedu.static_;

public class StaticExercise03 {
    
    
}

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++;
        id = total;
    }
    //编写一个方法，输出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
    }
}

2 理解 main 方法语法

2.1 深入理解 main 方法

在这里插入图片描述

解释main方法的形式：public static void main(String[] args){
    
    }
1.main方法是虚拟机调用
2.Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
3.Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
4.该方法接受String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数

2.2 特别提示：

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

3 代码块

3.1 基本介绍

代码块又称初始化块，属于类中的成员【即：是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但是，和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类的时候，或创建对象时隐式调用。

3.2 基本语法

[修饰符]{
    
    
	代码
};

说明：
（1）修饰符可选，要写的话，也只能写 static
（2）代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
（3）逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
（4）; 号可以写上，也可以省略。

3.3 代码块的好处

（1）相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
（2）场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

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

链接: https://www.bilibili.com/video/BV1fh411y7R8?p=387.

（1）static代码块也叫做静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
（2）类什么时候被加载【很重要，需要背下来！】

①. 创建对象实例时（new）
②. 创建子类对象实例，父类也会被加载
③. 使用类的静态代码块时（静态属性，静态方法）

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

小结：

static代码块是类加载时执行，并且只会执行一次。
普通代码块是在创建对象时调用的，创建一次，调用一次
类加载的 3 种情况，需要牢记！！！

package com.hspedu.codeblock_;

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

        //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）创建一个对象时，在一个类调用顺序是：（重点，难点）一定要记住！！！
① 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
② 调用普通代码块和普通属性初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用）
③ 调用构造方法。

package com.hspedu.codeblock_;

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）构造器的最前面其实隐含了 super() 和调用普通代码块和普通属性初始化

class A{
    
    
	public A() {
    
    //构造器
		//这里隐藏了执行要求
		//（1）super();
		//（2）调用普通代码块和普通属性初始化
		System.out.println("构造器前隐藏的两个东东很关键！")
	}

}

在这里插入图片描述

package com.hspedu.codeblock_;

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）创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

① 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
② 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
③ 父类的普通方法和普通属性初始化（优先级一样，按定义顺序执行）
④ 父类的构造方法
⑤ 子类的普通方法和普通属性初始化（优先级一样，按定义顺序执行）
⑥ 子类的构造方法 //面试题
当创建对象时：
(1) 先进行类的加载：
1.1 先加载父类 A02
1.2 再加载 B02
(2) 创建对象
2.1 从子类的构造器开始

package com.hspedu.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）静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

3.5 练习题

题 1：下面的代码输出什么？1min

package com.hspedu.codeblock_;

public class CodeBlockExercise01 {
    
    
}
class Person {
    
    
   public static int total;//静态变量
   static {
    
    //静态代码块
       total = 100;
       System.out.println("in static block!");//(1)
   }
}

class Test {
    
    
   public static void main(String[] args) {
    
    
       System.out.println("total = "+ Person.total); //100
       System.out.println("total = "+ Person.total); //100
       //（1）调用静态属性时会先进行类的加载
   }
}

题 2：下面的代码输出什么？

package com.hspedu.codeblock_;

public class CodeBlockExercise02 {
    
    
}

class Sample
{
    
    
    Sample(String s)
    {
    
    
        System.out.println(s);
    }
    Sample()
    {
    
    
        System.out.println("Sample默认构造函数被调用");
    }
}
class Test{
    
    
    Sample sam1=new Sample("sam1成员初始化");//3
    static Sample sam=new Sample("静态成员sam初始化 ");//1
    static{
    
    
        System.out.println("static块执行");//2
        if(sam==null)System.out.println("sam is null");
    }
    Test()//构造器
    {
    
    
        System.out.println("Test默认构造函数被调用");//4
    }
    //主方法
    public static void  main(String  str[])
    {
    
    
    	//（1）先进行类的加载，完成静态代码块和静态属性初始化
    	//（2）走无参构造器，先隐式执行普通代码块和普通属性初始化
        Test a=new Test();//无参构造器
    }

}

4 单例设计模式

4.1 什么是设计模式

（1）静态方法和属性的经典使用
（2）设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思维方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们再一步一步从头思考和摸索的过程
在这里插入图片描述

4.2 什么是单例模式

单例（单个的实例）

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

4.3 单例模式应用实例

演示饿汉式和懒汉式单例模式的实现。
步骤如下：
（1）构造器私有化 —> 防止直接 new
（2）类的内部创建对象
（3）向外暴露一个静态的公共方法。setInstance
（4）代码实现

package com.hspedu.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 {
    
    
    private String name;
    //public static  int n1 = 100;
    //为了能够在静态方法中，返回 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 + '\'' +
                '}';
    }
}

package com.hspedu.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 {
    
    
    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 + '\'' +
                '}';
    }
}

4.4 饿汉式 VS 懒汉式

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

5 final 关键字

5.1 基本介绍

final 中文意思：最后的，最终的
final 可以修饰类、属性、方法和局部变量
在某些情况下，程序员可能有以下需求，就会使用到final：
（1）当不希望类被继承时，可以用final修饰。
（2）当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字修饰。
（3）当不希望类的某个属性的值被修改，可以用final修饰。
（4）当不希望某个局部变量被修改，可以使用final修饰。

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

（1）final修饰的属性又叫常量，一般用 XX_XX_XX来命名
（2）final修饰的属性在定义时，必须赋初始值，并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初始值即可】：
① 定义时：如 public final double TAX_RATE = 0.08;
② 在构造器中
③ 在代码块中
（3）如果final修饰的属性是静态的，则初始化的位置只能是：① 定义时， ② 在静态代码块。不能在构造器赋值
（4）final类不能继承，但是可以实例化对象
（5）如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。

package com.hspedu.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 ;

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

（5）一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。
（6）final不能修饰构造方法（即构造器）
（7）final 和 static 往往搭配使用，效率更高，不会导致类加载。底层编译器做了优化处理。

public Demo{
    
    
	public static final int i = 16;
	static{
    
    
		System.out.println("自律即自由~");
	}
}

（8）包装类（Integer，Double，Float，Boolean等）都是final，String也是final

6 抽象类

6.1 先看一个问题

在这里插入图片描述

package com.hspedu.abstract_;

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

    }
}

abstract class Animal {
    
    
    private String name;

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

    //思考：这里eat 这里你实现了，其实没有什么意义
    //即： 父类方法不确定性的问题
    //===> 考虑将该方法设计为抽象(abstract)方法
    //===> 所谓抽象方法就是没有实现的方法
    //===> 所谓没有实现就是指，没有方法体
    //===> 当一个类中存在抽象方法时，需要将该类声明为abstract类
    //===> 一般来说，抽象类会被继承，有其子类来实现抽象方法.
//    public void eat() {
    
    
//        System.out.println("这是一个动物，但是不知道吃什么..");
//    }
    public abstract void eat()  ;
}

6.2 解决之道-抽象类快速入门

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。
在这里插入图片描述

6.3 抽象类的介绍

（1）用abstract关键字修饰一个类时，这个类就叫作抽象类

访问修饰符 abstract 类名{
    
    
}

（2）用abstract 关键字来修饰一个方法时，这个方法就是抽象方法。

访问修饰符 abstract 返回类型 方法名(形参列表);//没有方法体

（3）抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类。
（4）抽象类，是面试官爱问的知识点，在框架和设计模式使用较多！！！

6.4 抽象类使用的注意事项和细节讨论

（1）抽象类不能被实例化
（2）抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法。
（3）一旦包含了abstract方法，则这个类必须声明为abstract。
（4）abstract 只能修饰类和方法，不能修饰属性和其他的。

package com.hspedu.abstract_;

public class AbstractDetail01 {
    
    
    public static void main(String[] args) {
    
    
        //抽象类，不能被实例化
        //new A();
    }
}
//抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
//，还可以有实现的方法。
abstract class A {
    
    
    public void hi() {
    
    
        System.out.println("hi");
    }
}
//一旦类包含了abstract方法,则这个类必须声明为abstract
abstract class B {
    
    
    public abstract void hi();
}
//abstract 只能修饰类和方法，不能修饰属性和其它的
class C {
    
    
   // public abstract int n1 = 1;
}

（5）抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法，构造器，静态属性等等
（6）抽象方法不能有主体，即不能实现。
在这里插入图片描述
（7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。
（8）抽象方法不能使用private、final 和 static 来修饰，因为这些关键字都是和重写相违背的。

package com.hspedu.abstract_;

public class AbstractDetail02 {
    
    
    public static void main(String[] args) {
    
    
        System.out.println("hello");
    }
}
//抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
abstract class H {
    
    
    public   abstract void hi();//抽象方法
}

//如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
abstract class E {
    
    
    public abstract void hi();
}
abstract class F extends E {
    
    

}
class G extends E {
    
    
    @Override
    public void hi() {
    
     //这里相等于G子类实现了父类E的抽象方法，所谓实现方法，就是有方法体

    }
}

//抽象类的本质还是类，所以可以有类的各种成员
abstract class D {
    
    
    public int n1 = 10;
    public static  String name = "我亦无他，惟手熟尔";
    public void hi() {
    
    
        System.out.println("hi");
    }
    public abstract void hello();
    public static void ok() {
    
    
        System.out.println("ok");
    }
}

6.6 练习题

在这里插入图片描述

package com.hspedu.abstract_;

public class AbstractExercise01 {
    
    
    public static void main(String[] args) {
    
    
        //测试
        Manager jack = new Manager("jack", 999, 50000);
        jack.setBonus(8000);
        jack.work();

        CommonEmployee tom = new CommonEmployee("tom", 888, 20000);
        tom.work();
    }
}

package com.hspedu.abstract_;

abstract public class Employee {
    
    
    private String name;
    private int id;
    private double salary;

    public Employee(String name, int id, double salary) {
    
    
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    //将work做成一个抽象方法
    public abstract void work();
    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getId() {
    
    
        return id;
    }

    public void setId(int id) {
    
    
        this.id = id;
    }

    public double getSalary() {
    
    
        return salary;
    }

    public void setSalary(double salary) {
    
    
        this.salary = salary;
    }
}

package com.hspedu.abstract_;

public class Manager extends Employee {
    
    

    private double bonus;
    public Manager(String name, int id, double salary) {
    
    
        super(name, id, salary);
    }

    public double getBonus() {
    
    
        return bonus;
    }

    public void setBonus(double bonus) {
    
    
        this.bonus = bonus;
    }

    @Override
    public void work() {
    
    
        System.out.println("经理 " + getName() + " 工作中...");
    }
}

package com.hspedu.abstract_;

public class CommonEmployee extends Employee{
    
    
    public CommonEmployee(String name, int id, double salary) {
    
    
        super(name, id, salary);
    }

    @Override
    public void work() {
    
    
        System.out.println("普通员工 " + getName() + " 工作中...");
    }
}

7 抽象类最佳实践-模板设计模式

7.1 基本介绍

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

7.2 模板设计模式能解决的问题

（1）当功能内部一部分是确定，一部分是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
（2）编写一个抽象父类，父类提供了多个子类的同用方法，并把一个或多个方法留给其子类实现，就是一种模板模式。

7.3 最佳实践

需求：
（1）有多个类，完成不同的任务 job
（2）要求统计得到各自完成任务的时间
（3）请编程实现

写代码应该做的感情的自然流露

先用最容易想到的方法 —> 代码实现
分析问题，提出使用模式设计模式

package com.hspedu.abstract_;

abstract public class Template {
    
     //抽象类-模板设计模式

    public abstract void job();//抽象方法

    public void calculateTime() {
    
    //实现方法，调用job方法
        //得到开始的时间
        long start = System.currentTimeMillis();
        job(); //动态绑定机制
        //得的结束的时间
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间 " + (end - start));
    }
}

package com.hspedu.abstract_;

public class AA extends Template {
    
    

    //计算任务
    //1+....+ 800000
    @Override
    public void job() {
    
     //实现Template的抽象方法job

        long num = 0;
        for (long i = 1; i <= 800000; i++) {
    
    
            num += i;
        }
    }

//    public void job2() {
    
    
//        //得到开始的时间
//        long start = System.currentTimeMillis();
//        long num = 0;
//        for (long i = 1; i <= 200000; i++) {
    
    
//            num += i;
//        }
//        //得的结束的时间
//        long end = System.currentTimeMillis();
//        System.out.println("AA 执行时间 " + (end - start));
//    }
}

package com.hspedu.abstract_;

public class BB extends Template{
    
    

    public void job() {
    
    //这里也去，重写了Template的job方法

        long num = 0;
        for (long i = 1; i <= 80000; i++) {
    
    
            num *= i;
        }

    }
}

package com.hspedu.abstract_;

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

        AA aa = new AA();
        aa.calculateTime(); //这里还是需要有良好的OOP基础，对多态

        BB bb = new BB();
        bb.calculateTime();
    }
}

8 接口

8.1 为什么有接口

在这里插入图片描述

8.2 接口快速入门

这样的设计需求在Java编程/PHP/.net/go 中也是会大量存在的，一个程序就是一个世界，在现实世界存在的情况，在程序中也会出现。我们用程序来模拟一下。

package com.hspedu.interface_;

public interface UsbInterface {
    
     //接口
    //规定接口的相关方法,即规范...
    public void start();
    public void stop();
}

package com.hspedu.interface_;

public class Camera implements UsbInterface{
    
    //实现接口,就是把接口方法实现

    @Override
    public void start() {
    
    
        System.out.println("相机开始工作...");
    }

    @Override
    public void stop() {
    
    
        System.out.println("相机停止工作....");
    }
}

package com.hspedu.interface_;

//Phone 类 实现 UsbInterface
//解读1. 即 Phone类需要实现 UsbInterface接口 规定/声明的方法
public class Phone implements UsbInterface {
    
    

    @Override
    public void start() {
    
    
        System.out.println("手机开始工作...");
    }

    @Override
    public void stop() {
    
    
        System.out.println("手机停止工作.....");
    }
}

package com.hspedu.interface_;

public class Computer {
    
    
    //编写一个方法, 计算机工作
    //解读:
    //1. UsbInterface usbInterface 形参是接口类型 UsbInterface
    //2. 看到 接收 实现了 UsbInterface接口的类的对象实例
    public void work(UsbInterface usbInterface) {
    
    
        //通过接口，来调用方法
        usbInterface.start();
        usbInterface.stop();
    }
}

package com.hspedu.interface_;

public class Interface01 {
    
    
    public static void main(String[] args) {
    
    
        //创建手机，相机对象
        //Camera 实现了 UsbInterface
        Camera camera = new Camera();
        //Phone 实现了 UsbInterface
        Phone phone = new Phone();
        //创建计算机
        Computer computer = new Computer();
        computer.work(phone);//把手机接入到计算机
        System.out.println("===============");
        computer.work(camera);//把相机接入到计算机

    }
}

8.3 基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。语法：

interface 接口名{
    
    
	//属性
	//抽象方法
}
class 类名 implements 接口{
    
    
	自己的属性;
	自己的方法;
	必须实现的接口的抽象方法
}

小结：接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体【jdk 7.0】。接口体现程序设计的多态和高内聚低耦合的设计思想。
特别说明：jdk8.0后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

8.4 深入讨论

在这里插入图片描述

package com.hspedu.interface_;

public interface DBInterface {
    
     //项目经理

    public void connect();//连接方法
    public void close();//关闭连接
}

package com.hspedu.interface_;
//A程序
public class MysqlDB implements DBInterface {
    
    
    @Override
    public void connect() {
    
    
        System.out.println("连接mysql");
    }

    @Override
    public void close() {
    
    
        System.out.println("关闭mysql");
    }
}

package com.hspedu.interface_;

//B程序员连接Oracle
public class OracleDB implements DBInterface{
    
    

    @Override
    public void connect() {
    
    
        System.out.println("连接oracle");
    }

    @Override
    public void close() {
    
    
        System.out.println("关闭oracle");
    }
}

package com.hspedu.interface_;

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

        MysqlDB mysqlDB = new MysqlDB();
        t(mysqlDB);
        OracleDB oracleDB = new OracleDB();
        t(oracleDB);
    }

    public static void t(DBInterface db) {
    
    
        db.connect();
        db.close();
    }
}

8.5 注意事项和细节

（1）接口不能被实例化
（2）接口中所有的方法是 public方法，接口中抽象方法，可以不用 abstract 修饰。
在这里插入图片描述
（3）一个普通类实现接口，就必须将该接口的所有方法都实现。
（4）抽象类实现接口，可以不用实现接口的方法。
（5）一个类同时可以实现多个接口
（6）接口中的属性，只能是final的，而且是 public static final 修饰符。

int a = 1；实际上是 public static final int a = 1；（必须初始化）

（7）接口中属性的访问形式：接口名.属性名
（8）接口不能继承其他的类，但是可以继承多个别的接口

interface A extends B,C{
    
    }

（9）接口的修饰符只能是 public 和默认，这一点和类的修饰符是一样的。

package com.hspedu.interface_;

public class InterfaceDetail02 {
    
    
    public static void main(String[] args) {
    
    
        //接口中的属性,是 public static final
        System.out.println(IB.n1);//说明n1 就是static
        //IB.n1 = 30; 说明n1 是 final
    }
}
interface IB {
    
    
    //接口中的属性,只能是final的，而且是 public static final 修饰符
    int n1 = 10; //等价 public static final int n1 = 10;
    void hi();
}
interface IC {
    
    
    void say();
}
//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
    
    
}
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{
    
    }

//一个类同时可以实现多个接口
class Pig implements IB,IC {
    
    
    @Override
    public void hi() {
    
    
    }
    @Override
    public void say() {
    
    
    }
}

8.6 练习

在这里插入图片描述

8.7 实现接口 vs 继承类

8.7.1 接口和继承解决的问题不同：

继承的价值主要在于：解决代码的复用性和可维护性。
接口的价值主要在于：设计，设计好各种规范（方法），让其他类去实现这些方法。即，更加的灵活

8.7.2 接口比继承更加灵活

接口比继承更加灵活，继承是满足 is - a 的关系，而接口只需满足 like - a 的关系。

8.7.3 接口在一定程度上实现代码解耦

【即：接口规范性 + 动态绑定机制】

8.8 接口的多态特性

8.8.1 多态参数

在前面的Usb接口案例，既可以接受手机对象，又可以接受相机对象，就体现了接口多态（接口引用可以指向实现了接口的类的对象）

8.8.2 多态数组

演示一个案例：在Usb数组中，存放 Phone 和相机对象，Phone类还有一个特有的方法call()，请遍历Usb数组，如果Phone对象，除了调用Usb 接口定义的方法外，还需要调用 Phone 特有方法 call

package com.hspedu.interface_;

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

        //多态数组 -> 接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        /*
        给Usb数组中，存放 Phone  和  相机对象，Phone类还有一个特有的方法call（），
        请遍历Usb数组，如果是Phone对象，除了调用Usb 接口定义的方法外，
        还需要调用Phone 特有方法 call
         */
        for(int i = 0; i < usbs.length; i++) {
    
    
            usbs[i].work();//动态绑定..
            //和前面一样，我们仍然需要进行类型的向下转型
            if(usbs[i] instanceof Phone_) {
    
    //判断他的运行类型是 Phone_
                ((Phone_) usbs[i]).call();
            }
        }

    }
}

interface Usb{
    
    
    void work();
}
class Phone_ implements Usb {
    
    
    public void call() {
    
    
        System.out.println("手机可以打电话...");
    }

    @Override
    public void work() {
    
    
        System.out.println("手机工作中...");
    }
}
class Camera_ implements Usb {
    
    

    @Override
    public void work() {
    
    
        System.out.println("相机工作中...");
    }
}

8.8.3 多态传递

接口存在多态传递现象
如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
那么，实际上就相当于 Teacher 类也实现了 IH接口.
这就是所谓的 接口多态传递现象.

package com.hspedu.interface_;

/**
 * 演示多态传递现象
 */
public class InterfacePolyPass {
    
    
    public static void main(String[] args) {
    
    
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果IG 继承了 IH 接口，而Teacher 类实现了 IG接口
        //那么，实际上就相当于 Teacher 类也实现了 IH接口.
        //这就是所谓的 接口多态传递现象.
        IH ih = new Teacher();
    }
}

interface IH {
    
    
    void hi();
}
interface IG extends IH{
    
     }
class Teacher implements IG {
    
    
    @Override
    public void hi() {
    
    
    }
}

9 内部类

如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类
定义在成员位置 (1) 成员内部类 (2) 静态内部类

9.1 基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是我们类的第五大成员【思考：类的五大成员是哪些？属性、方法、构造器、代码块、内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系，注意：内部类是学习的难点，同时也是重点，后面看底层源码时，有大量的内部类。

9.2 基本语法

在这里插入图片描述

9.3 快速入门案例

package com.hspedu.innerclass;

public class InnerClass01 {
    
     //外部其他类
    public static void main(String[] args) {
    
    

    }
}
class Outer {
    
     //外部类
    private int n1 = 100;//属性
    public Outer(int n1) {
    
    //构造器
        this.n1 = n1;
    }
    public void m1() {
    
    //方法
        System.out.println("m1()");
    }
    {
    
    //代码块
        System.out.println("代码块...");
    }
    class Inner {
    
     //内部类, 在Outer类的内部

    }
}

9.4 内部类的分类

定义在外部类局部位置上（比如方法内）：
① 局部内部类（有类名）
② 匿名内部类（没有类名，重点！！！）
定义在外部类的成员位置上：
① 成员内部类（没用static修饰）
② 静态内部类（使用static修饰）

9.5 局部内部类的使用

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。
（1）可以直接访问外部类的所有成员，包括私有的
（2）不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final 修饰，因为局部变量也可以使用final
（3）作用域：仅仅在定义它的方法或代码块中。
（4）局部内部类 — 访问—>外部类的成员【访问方式：直接访问】
（5）外部类 — 访问 —> 局部内部类的成员
访问方式：创建对象，再访问（注意：必须在作用域内）

记住：
①局部内部类定义在方法中/代码块
②作用域在方法体或者代码块中
③本质仍然是一个类

（6）外部其他类 — 不能访问 —> 局部内部类（因为局部内部类地位是一个局部变量）
（7）如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）去访问

package com.hspedu.innerclass;
/**
 * 演示局部内部类的使用
 */
public class LocalInnerClass {
    
    //
    public static void main(String[] args) {
    
    
        //演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02的hashcode=" + outer02);
    }
}


class Outer02 {
    
    //外部类
    private int n1 = 100;
    private void m2() {
    
    
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {
    
    //方法
        //1.局部内部类是定义在外部类的局部位置,通常在方法
        //3.不能添加访问修饰符,但是可以使用final 修饰
        //4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {
    
    //局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1() {
    
    
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                //   使用 外部类名.this.成员）去访问
                //   解读 
                //Outer02.this 本质就是外部类的对象, 即哪个对象调用了m1, Outer02.this就是哪个对象，此处指的就是outer02对象
                System.out.println("n1=" + n1 + " 外部类的n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建Inner02对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }

}

9.6 匿名内部类的使用(重要!!!)

9.6.1 基本介绍

（1）本质是类
（2）内部类
（3）该类没有名字
（4）同时还是一个对象
说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名。

9.6.2 细节说明！！！

匿名内部类的基本语法：

new 类或接口(参数列表){
    
    
	类体
}

案例：

package com.hspedu.innerclass;


/**
 * 演示匿名内部类的使用
 */
public class AnonymousInnerClass {
    
    
    public static void main(String[] args) {
    
    
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}

class Outer04 {
    
     //外部类
    private int n1 = 10;//属性
    public void method() {
    
    //方法
        //基于接口的匿名内部类
        //解读
        //1.需求： 想使用IA接口,并创建对象
        //2.传统方式，是写一个类，实现该接口，并创建对象
        //3.老韩需求是 Tiger/Dog 类只是使用一次，后面再不使用
        //4. 每次都要创建对象，并且只使用一次，太过繁琐！可以使用匿名内部类来简化开发
        //5. tiger的编译类型 ? IA
        //6. tiger的运行类型 ? 就是匿名内部类  Outer04$1
        /*
            我们看底层 会分配 类名 Outer04$1
            class Outer04$1 implements IA {
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
            }
         */
        //7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1实例，并且把地址
        //   返回给 tiger
        //8. 匿名内部类使用一次，就不能再使用
        IA tiger = new IA() {
    
    
            @Override
            public void cry() {
    
    
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();
        tiger.cry();
        tiger.cry();

//        IA tiger = new Tiger();
//        tiger.cry();

        //演示基于类的匿名内部类
        //分析
        //1. father编译类型 Father
        //2. father运行类型 Outer04$2
        //3. 底层会创建匿名内部类
        /*
            class Outer04$2 extends Father{
                @Override
                public void test() {
                    System.out.println("匿名内部类重写了test方法");
                }
            }
         */
        //4. 同时也直接返回了 匿名内部类 Outer04$2的对象
        //5. 注意("jack") 参数列表会传递给 构造器
        Father father = new Father("jack"){
    
    

            @Override
            public void test() {
    
    
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型=" + father.getClass());//Outer04$2
        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal(){
    
    
            @Override
            void eat() {
    
    
                System.out.println("小狗吃骨头...");
            }
        };
        animal.eat();
    }
}

interface IA {
    
    //接口
    public void cry();
}
//class Tiger implements IA {
    
    
//
//    @Override
//    public void cry() {
    
    
//        System.out.println("老虎叫唤...");
//    }
//}
//class Dog implements  IA{
    
    
//    @Override
//    public void cry() {
    
    
//        System.out.println("小狗汪汪...");
//    }
//}

class Father {
    
    //类
    public Father(String name) {
    
    //构造器
        System.out.println("接收到name=" + name);
    }
    public void test() {
    
    //方法
    }
}

abstract class Animal {
    
     //抽象类
    abstract void eat();
}

匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
可以直接访问外部类的所有成员，包含私有的
不能添加访问修饰符，因为它的地位就是一个局部变量。
作用域：仅仅在定义它的方法或代码块中。
匿名内部类 — 访问 — > 外部类成员【访问方式：直接访问】
外部其他类 — 不能访问 —> 匿名内部类【因为匿名内部类地位是一个局部变量】
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员名）

package com.hspedu.innerclass;

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

        Outer05 outer05 = new Outer05();
        outer05.f1();
        //外部其他类---不能访问----->匿名内部类
        System.out.println("main outer05 hashcode=" + outer05);
    }
}

class Outer05 {
    
    
    private int n1 = 99;
    public void f1() {
    
    
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person(){
    
    
            private int n1 = 88;
            @Override
            public void hi() {
    
    
                //可以直接访问外部类的所有成员，包含私有的
                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +
                        " 外部内的n1=" + Outer05.this.n1 );
                //Outer05.this 就是调用 f1的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        p.hi();//动态绑定, 运行类型是 Outer05$1

        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
//        new Person(){
    
    
//            @Override
//            public void hi() {
    
    
//                System.out.println("匿名内部类重写了 hi方法,哈哈...");
//            }
//            @Override
//            public void ok(String str) {
    
    
//                super.ok(str);
//            }
//        }.ok("jack");


    }
}

class Person {
    
    //类
    public void hi() {
    
    
        System.out.println("Person hi()");
    }
    public void ok(String str) {
    
    
        System.out.println("Person ok() " + str);
    }
}
//抽象类/接口...

9.7 匿名内部类的最佳实践

当做实参直接传递，简洁高效。

package com.hspedu.innerclass;

import com.hspedu.abstract_.AA;

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

        //当做实参直接传递，简洁高效
        f1(new IL() {
    
    
            @Override
            public void show() {
    
    
                System.out.println("这是一副名画~~...");
            }
        });
        //传统方法
        f1(new Picture());

    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
    
    
        il.show();
    }
}
//接口
interface IL {
    
    
    void show();
}
//类->实现IL => 编程领域 (硬编码)
class Picture implements IL {
    
    

    @Override
    public void show() {
    
    
        System.out.println("这是一副名画XX...");
    }
}

9.8 匿名内部类练习

在这里插入图片描述

package com.hspedu.innerclass;

public class InnerClassExercise02 {
    
    
    public static void main(String[] args) {
    
    
        /*
        1.有一个铃声接口Bell，里面有个ring方法。(右图)
        2.有一个手机类Cellphone，具有闹钟功能alarmClock，参数是Bell类型(右图)
        3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
        4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了
         */
        CellPhone cellPhone = new CellPhone();
        //解读
        //1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
        //2. 重写了 ring
        //3. Bell bell = new Bell() {
    
    
        //            @Override
        //            public void ring() {
    
    
        //                System.out.println("懒猪起床了");
        //            }
        //        }
        cellPhone.alarmClock(new Bell() {
    
    
            @Override
            public void ring() {
    
    
                System.out.println("懒猪起床了");
            }
        });

        cellPhone.alarmClock(new Bell() {
    
    
            @Override
            public void ring() {
    
    
                System.out.println("小伙伴上课了");
            }
        });
    }
}
interface Bell{
    
     //接口
    void ring();//方法
}
class CellPhone{
    
    //类
    public void alarmClock(Bell bell){
    
    //形参是Bell接口类型
        System.out.println(bell.getClass());
        bell.ring();//动态绑定
    }
}

9.9 成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

可以直接访问外部类的所有成员，包含私有的
可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
作用域：和外部类的其他成员一样，为整个类体。
成员内部类 — 访问 —> 外部类成员（比如：属性）【访问方式：直接访问】
外部类 — 访问 —> 成员内部类【访问方式：创建对象，再访问】
外部其他类 — 访问 —> 成员内部类
如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

package com.hspedu.innerclass;

public class MemberInnerClass01 {
    
    
    public static void main(String[] args) {
    
    
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类，使用成员内部类的两种方式
        //解读
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是outer08成员
        // 这就是一个语法，不要特别的纠结.
        Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二方式 在外部类中，编写一个方法，可以返回 Inner08对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();


    }
}

class Outer08 {
    
     //外部类
    private int n1 = 10;
    public String name = "张三";

    private void hi() {
    
    
        System.out.println("hi()方法...");
    }

    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {
    
    //成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
    
    
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
            //，可以通过  外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的n1=" + Outer08.this.n1);
            hi();
        }
    }
    //方法，返回一个Inner08实例
    public Inner08 getInner08Instance(){
    
    
        return new Inner08();
    }


    //写方法
    public void t1() {
    
    
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

9.10 静态内部类的使用

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
可以添加任意访问修饰符（public、protected、默认、private），因为他的地位就是一个成员
作用域：同其他成员一样，为整个类体
静态内部类 — 访问 —> 外部类（比如：静态属性）【访问方式：直接访问】
外部类 – 访问 —>静态内部类【访问方式：创建对象，再访问】
外部其他类— 访问 —> 静态内部类
如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

package com.hspedu.innerclass;

public class StaticInnerClass01 {
    
    
    public static void main(String[] args) {
    
    
        Outer10 outer10 = new Outer10();
        outer10.m1();

        //外部其他类 使用静态内部类
        //方式1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式2
        //编写一个方法，可以返回静态内部类的对象实例.
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();

        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 {
    
     //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {
    
    }
    //Inner10就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
    
    
        private static String name = "韩顺平教育";
        public void say() {
    
    
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类name= " + Outer10.name);
            cry();
        }
    }

    public void m1() {
    
     //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
    
    
        return new Inner10();
    }

    public static Inner10 getInner10_() {
    
    
        return new Inner10();
    }
}

9.11 测试题

public class Test {
    
    //外部类
public Test() {
    
    //构造器
Inner s1 = new Inner();
s1.a = 10;
Inner s2 = new Inner();
System.out.println(s2.a);
}
class Inner {
    
     //内部类，成员内部类
public int a = 5;
}
public static void main(String[] args) {
    
    
Test t = new Test();
Inner r = t.new Inner();//5
System.out.println(r.a);//5
}
}

10 本章作业

1 下列代码的执行结果是多少？

public class Homework01 {
    
    
    public static void main(String[] args) {
    
    
        Car c =new Car();
        Car c1=new Car(100);
        System.out.println(c);//9.0,red
        System.out.println(c1);//100.0,red

    }
}
class Car{
    
    
    double price=10;
    static String color="white";
    public String toString(){
    
    
        return price+"\t"+color;
    }
    public Car(){
    
    
        this.price=9;
        this.color="red";
    }
    public Car(double price){
    
    
        this.price=price;
    }
}

2 编程题

1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
2.声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次，将currentNum增加100，并作为返回值。
3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
4.在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法；
5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
6.在TestFrock类的main方法中，分别创建三个Frock 对象，并打印三个对象的序列号，验证是否为按100递增

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

    }
}
/*
1.在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号起始值。
2.声明公有的静态方法getNextNum，作为生成上衣唯一序列号的方法。每调用一次，将currentNum增加100，并作为返回值。
3.在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
4.在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法；
5.在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯一序列号，赋给serialNumber属性。
6.在TestFrock类的main方法中，分别创建三个Frock 对象，并打印三个对象的序列号，验证是否为按100递增
 */
class Frock {
    
    
    private static  int currentNum = 100000;
    private int serialNumber;

    public Frock() {
    
    
        serialNumber = getNextNum();
    }

    public static int getNextNum() {
    
    
        currentNum += 100; //将currentNum增加100
        return currentNum;
    }

    public int getSerialNumber() {
    
    
        return serialNumber;
    }
}
class TestFrock {
    
    
    public static void main(String[] args) {
    
    
        System.out.println(Frock.getNextNum());//100100
        System.out.println(Frock.getNextNum());//100200
        Frock frock = new Frock();//序列号就是 100300
        Frock frock1 = new Frock();//序列号就是 100400
        Frock frock2 = new Frock();//序列号就是 100500
        System.out.println(frock.getSerialNumber());//100300
        System.out.println(frock1.getSerialNumber());//100400
        System.out.println(frock2.getSerialNumber());//100500
    }
}

3 按要求实现下列问题： 1min完成 -> 抽象类的使用

动物类Animal包含了抽象方法 shout()；
Cat类继承了Animal，并实现方法shout，打印“猫会喵喵叫”
Dog类继承了Animal，并实现方法shout，打印“狗会汪汪叫”
在测试类中实例化对象Animal cat =new Cat(),并调用cat的shout方法
在测试类中实例化对象Animal dog=new Dog(),并调用dog的shout方法

public class Homework03 {
    
    
    public static void main(String[] args) {
    
    
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.shout();
        dog.shout();
    }
}
/*
按要求实现下列问题： 1min完成 -> 抽象类的使用
动物类Animal包含了抽象方法  shout()；
Cat类继承了Animal，并实现方法shout，打印“猫会喵喵叫”
Dog类继承了Animal，并实现方法shout，打印“狗会汪汪叫”
在测试类中实例化对象Animal cat =new  Cat(),并调用cat的shout方法
在测试类中实例化对象Animal dog=new  Dog(),并调用dog的shout方法

 */
abstract class Animal {
    
    //抽象类
    public abstract void shout();
}
class Cat extends Animal {
    
    

    @Override
    public void shout() {
    
    
        System.out.println("猫会喵喵叫");
    }
}
class Dog extends Animal {
    
    

    @Override
    public void shout() {
    
    
        System.out.println("狗会汪汪叫");
    }
}

4 编程题（匿名内部类）

1.计算器接口具有work方法，功能是运算，有一个手机类Cellphone，定义方法testWork测试计算功能，调用计算接口的work方法。
2.要求调用CellPhone对象的testWork方法，使用上匿名内部类

public class Homework04 {
    
    
    public static void main(String[] args) {
    
    
        Cellphone cellphone = new Cellphone();
        //思路分析：
        //1. 匿名内部类是
        /*
            new ICalculate() {
                @Override
                public double work(double n1, double n2) {
                    return n1 + n2;
                }
            }, 同时也是一个对象
            他的编译类型 ICalculate, 他的运行类型就是 匿名内部类
         */
        cellphone.testWork(new ICalculate() {
    
    
            @Override
            public double work(double n1, double n2) {
    
    
                return n1 + n2;
            }
        }, 10, 8);//18.0

        cellphone.testWork(new ICalculate() {
    
    
            @Override
            public double work(double n1, double n2) {
    
    
                return n1 * n2;
            }
        }, 10, 8);

    }
}
/*
1.计算器接口具有work方法，功能是运算，有一个手机类Cellphone，
   定义方法testWork测试计算功能，调用计算接口的work方法，
2.要求调用CellPhone对象 的testWork方法，使用上 匿名内部类

 */
//编写接口
interface ICalculate {
    
    
    //work方法 是完成计算，但是题没有具体要求，所以自己设计
    //至于该方法完成怎样的计算，我们交给匿名内部类完成
    public double work(double n1, double n2) ;
}
class Cellphone {
    
    
    //当我们调用testWork方法时，直接传入一个实现了ICalculate接口的匿名内部类即可
    //该匿名内部类，可以灵活的实现work,完成不同的计算任务
    public void testWork(ICalculate iCalculate, double n1, double n2) {
    
    
        double result = iCalculate.work(n1, n2);//动态绑定
        System.out.println("计算后的结果是=" + result);
    }
}

5 编程题

1.编一个类A，在类中定义局部内部类B，B中有一个私有final常量name，有一个方法show()打印常量name。进行测试
2.进阶：A中也定义一个私有的变量name，在show方法中打印测试

public class Homework05 {
    
    
    public static void main(String[] args) {
    
    
        new A().f1();
    }
}
/*
编一个类A，在类中定义局部内部类B，B中有一个私有final常量name，有一个方法show()打印常量name。进行测试
进阶：A中也定义一个私有的变量name，在show方法中打印测试

 */
class A {
    
    
    private String NAME = "hello";
    public void f1() {
    
    

        class B {
    
     //局部内部类
            private final String NAME = "韩顺平教育";
            public void show() {
    
    
                //如果内部类和外部类的属性重名，可以同 外部类.this.属性名来指定
                System.out.println("NAME=" + NAME + " 外部类的name=" + A.this.NAME);
            }
        }

        B b = new B();
        b.show();
    }
}

6 编程题

1.有一个交通工具接口类Vehicles，有work接口
2.有Horse类和Boat类分别实现Vehicles
3.创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
4.有Person类，有name和Vehicles属性，在构造器中为两个属性赋值
5.实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具
6.增加一个情况，如果唐僧过火焰山, 使用飞机 ==> 程序扩展性, 我们前面的程序结构就非常好扩展 10min
使用代码实现上面的要求
编程需求---->理解---->代码–>优化

public interface Vehicles {
    
    
    //有一个交通工具接口类Vehicles，有work接口
    public void work();
}

public class Horse implements Vehicles {
    
    
    @Override
    public void work() {
    
    
        System.out.println(" 一般情况下，使用马儿前进...");
    }
}

public class Boat implements Vehicles {
    
    
    @Override
    public void work() {
    
    
        System.out.println(" 过河的时候，使用小船.. ");
    }
}

public class VehiclesFactory {
    
    
    //马儿始终是同一匹
    private static Horse horse = new Horse(); //饿汉式

    private VehiclesFactory(){
    
    }
    //创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
    //这里，我们将方法做成static
    public static Horse getHorse() {
    
    
//        return new Horse();
        return horse;
    }
    public static Boat getBoat() {
    
    
        return new Boat();
    }
    public static Plane getPlane() {
    
    
        return new Plane();
    }
}

public class Person {
    
    
    private String name;
    private Vehicles vehicles;

    //在创建人对象时，事先给他分配一个交通工具
    public Person(String name, Vehicles vehicles) {
    
    
        this.name = name;
        this.vehicles = vehicles;
    }

    //实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具
    //这里涉及到一个编程思路，就是可以把具体的要求，封装成方法-> 这里就是编程思想
    //思考一个问题，如何不浪费，在构建对象时，传入的交通工具对象->动脑筋
    public void passRiver() {
    
    
        //先得到船
        //判断一下，当前的 vehicles 属性是null, 就获取一艘船
//        Boat boat = VehiclesFactory.getBoat();
//        boat.work();
        //如何防止始终使用的是传入的马 instanceOf
        //if (vehicles == null) {
    
    
        //vehicles instanceof Boat 是判断 当前的 vehicles是不是Boat
        //(1) vehicles = null  : vehicles instanceof Boat  => false
        //(2) vehicles = 马对象 ：vehicles instanceof Boat  => false
        //(3) vehicles = 船对象 ：vehicles instanceof Boat  => true
        if (!(vehicles instanceof Boat)) {
    
    
            vehicles = VehiclesFactory.getBoat();
        }
        vehicles.work();
    }

    public void common() {
    
    
        //得到马儿
        //判断一下，当前的 vehicles 属性是null, 就获取一匹马
        //if (vehicles == null) {
    
    
        if (!(vehicles instanceof Horse)) {
    
    
            //这里使用的是多态
            vehicles = VehiclesFactory.getHorse();
        }
        //这里体现使用接口调用
        vehicles.work();
    }
    //过火焰山
    public void passFireHill() {
    
    
        if (!(vehicles instanceof Plane)) {
    
    
            //这里使用的是多态
            vehicles = VehiclesFactory.getPlane();
        }
        //这里体现使用接口调用
        vehicles.work();

    }
}

//有Person类，有name和Vehicles属性，在构造器中为两个属性赋值

public class Plane implements Vehicles {
    
    
    @Override
    public void work() {
    
    
        System.out.println("过火焰山，使用飞机...");
    }
}

public class Homework06 {
    
    
    public static void main(String[] args) {
    
    
        Person tang = new Person("唐僧", new Horse());
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.common();//一般情况下
        tang.passRiver();//过河
        tang.passRiver();//过河
        tang.passRiver();//过河
        //过火焰山
        tang.passFireHill();

    }
}

7 编程题

有一个Car2类，有属性temperature（温度），车内有Air（空调）类，有吹风的功能flow，
Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，
如果在这之间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，
测试空调吹的风是否正确 . //体现类与类的包含关系的案例类(内部类【成员内部类】)

public class Homework07 {
    
    
    public static void main(String[] args) {
    
    
        //实例化不同的car对象
        Car2 car2 = new Car2(60);
        car2.getAir().flow();
        Car2 car21 = new Car2(-1);
        car21.getAir().flow();
        Car2 car22 = new Car2(20);
        car22.getAir().flow();
    }
}
/*
有一个Car2类，有属性temperature（温度），车内有Air（空调）类，有吹风的功能flow，
Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，
如果在这之间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，
测试空调吹的风是否正确 . //体现 类与类的包含关系的案例 类(内部类【成员内部类】)

 */
class Car2 {
    
    

   private double temperature;

    public Car2(double temperature) {
    
    
        this.temperature = temperature;
    }

    //Air 成员内部类
   class Air {
    
    
       public void flow() {
    
    
           if(temperature > 40) {
    
    
               System.out.println("温度大于40 空调吹冷气..");
           } else if(temperature < 0) {
    
    
               System.out.println("温度小于0 空调吹暖气..");
           } else {
    
    
               System.out.println("温度正常，关闭空调..");
           }
       }
   }
   //返回一个Air对象
    public Air getAir() {
    
    
       return new Air();
    }
}

11 坚持就是胜利~

我亦无他，惟手熟尔。
纸上得来终觉浅，绝知此事要躬行。
好好向韩老师学习，向大师看齐，小谢，加油加油加油！！！
<(￣︶￣)↗[GO!]

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

1 类变量和类方法

1.1 类变量-提出问题

1.2 传统的方法来解决

1.3 类变量快速入门

1.4 类变量内存布局

1.5 什么是类变量

1.6 如何定义类变量

1.7 如何访问类变量

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

1.9 类方法基本介绍

1.10 类方法的调用

1.12 类方法经典的使用场景

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

1.14 练习

1.15 看看下面代码有没有错误,如果有错误，就修改，看看输出什么?

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

2 理解 main 方法语法

2.1 深入理解 main 方法

2.2 特别提示：

3 代码块

3.1 基本介绍

3.2 基本语法

3.3 代码块的好处

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

3.5 练习题

题 1：下面的代码输出什么？1min

题 2：下面的代码输出什么？

4 单例设计模式

4.1 什么是设计模式

4.2 什么是单例模式

4.3 单例模式应用实例

4.4 饿汉式 VS 懒汉式

5 final 关键字

5.1 基本介绍

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

6 抽象类

6.1 先看一个问题

6.2 解决之道-抽象类快速入门

6.3 抽象类的介绍

6.4 抽象类使用的注意事项和细节讨论

6.6 练习题

7 抽象类最佳实践-模板设计模式

7.1 基本介绍

7.2 模板设计模式能解决的问题

7.3 最佳实践

8 接口

8.1 为什么有接口

8.2 接口快速入门

8.3 基本介绍

8.4 深入讨论

8.5 注意事项和细节

8.6 练习

8.7 实现接口 vs 继承类

8.7.1 接口和继承解决的问题不同：

8.7.2 接口比继承更加灵活

8.7.3 接口在一定程度上实现代码解耦

8.8 接口的多态特性

8.8.1 多态参数

8.8.2 多态数组

8.8.3 多态传递

9 内部类

9.1 基本介绍

9.2 基本语法

9.3 快速入门案例

9.4 内部类的分类

9.5 局部内部类的使用

9.6 匿名内部类的使用(重要!!!)

9.6.1 基本介绍

9.6.2 细节说明！！！

9.7 匿名内部类的最佳实践

9.8 匿名内部类练习

9.9 成员内部类的使用

9.10 静态内部类的使用

9.11 测试题

10 本章作业

1 下列代码的执行结果是多少？

2 编程题

3 按要求实现下列问题： 1min完成 -> 抽象类的使用

4 编程题（匿名内部类）