第六章：面向对象编程（下）
2021年3月20日
11:53
* static关键字的使用
* 2. static可以用来修饰：属性、方法、代码块、内部类 不可以修饰构造器
* 3. 使用static修饰属性：静态变量（或类变量）
* 3.2 static修饰属性的其他说明：
* ① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
* ② 静态变量的加载要早于对象的创建
* ③ 由于类只会加载一次，所以静态变量在内存中也只会存在一份：存在方法区的静态域中
* 3.3 静态属性举例：System.out; Math.PI;
* 4. 使用static修饰方法：静态方法
* ① 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
* ② 静态方法中，只能调用静态的方法或属性
* 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性（虽然用类和对象都可以调用，但是如果直接调用的话，省略了"类."，而不是省略了"对象."。应该以静态的方式调用）
*
* 5. static注意点
* 5.1 在静态的方法内，不能使用this关键字、super关键字
* 5.2 关于静态属性和静态方法的使用，都可以从生命周期的角度去理解
* 6. 开发中，如何确定一个属性是否要声明为static的？
* > 属性是可以被多个对象所共享的，不会随着对象的不同而不同的
* > 类中的常量也常常声明为static
* 开发中，如何确定一个方法是否要声明为static的？
* > 操作静态属性的方法，通常设置为static的
* > 工具类中的方法，习惯上声明为static的。比如Math、Arrays、Collections
23种设计模式
单例 (Singleton)设计模式
如何实现？
饿汉式 vs 懒汉式
饿汉式：提前把对象造好
坏处：对象加载时间过长。
好处：饿汉式是线程安全的
懒汉式：什么时候用，什么时候造对象
好处：延迟对象的创建。
目前写法的坏处：线程不安全。 ---> 到多线程内容时，再修改
* 1. 私有化类的构造器
* 2. 内部创建类的对象（饿汉式声明当前类的对象，没有初始化）
* 3. 提供公共的（静态的）方法，返回类的对象（注意饿汉式要直接在定义static变量的时候生成实例，而不是在静态方法中生成实例，要不然每次调用方法，都会生成一个新的实例！！懒汉式需要判断一下静态变量是否为null，为null时候声明对象）
* 4. 要求此对象也必须声明为静态的
应用场景：
* 网站的计数器，一般也是单例模式实现，否则难以同步。
* 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
* 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
* 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
* Application 也是单例的典型应用
* Windows的Task Manager (任务管理器)就是很典型的单例模式
* Windows的Recycle Bin (回收站)也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
main()方法的使用说明
- main()方法作为程序的入口
- main()方法也是一个普通的静态方法
- main()方法可以作为我们与控制台交互的方式（之前：使用Scanner）
在Eclipse中，在Run Configurations中添加参数（需要先编译。参数加不加双引号都可以）
在命令行中，运行的时候，在类名后面追加参数（参数加不加双引号都可以。eg: java MainDemo "刘德华" 张学友 "沈腾"）
* 类的成员之四：代码块（或初始化块）
* 1. 代码块的作用：用来初始化类、对象
* 2. 代码块如果有修饰的话，只能使用static
* 3. 分类：静态代码块 vs 非静态代码块
* 4. 静态代码块
* > 内部可以有输出语句
* > 随着类的加载而执行，而且只执行一次（静态方法和静态属性是随着类的加载而加载）
* > 作用：初始化类的信息
* > 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
* > 静态代码块的执行要优先于非静态代码块的执行
* > 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
* 5. 非静态代码块
* > 内部可以有输出语句
* > 随着对象的创建而执行
* > 每创建一个对象，就执行一次非静态代码块
* > 作用：可以在创建对象时，对对象的属性等进行初始化
* > 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
* > 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
代码块的执行顺序：由父及子，静态先行
new一个子类对象：
①先加载类的静态代码块，从父到子
②再加载父类的非静态代码块、父类的构造器
③然后加载子类的非静态代码块，子类的构造器
另：main方法也是类的方法，所以main方法运行时，会先加载类，执行类的静态代码块
先执行非静态代码块，后执行构造器
* 对属性可以赋值的位置：
* ①默认初始化
* ②显式初始化/⑤在代码块中赋值 ②和⑤按照代码从上到下的顺序赋值，但是一般会先写属性，后写代码块。
* ③构造器中初始化
* ④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值
*
* 执行的先后顺序：① - ②/⑤ - ③ - ④
native关键字表明方法调用的是底层c或c++的内容
* final：最终的
* 1.final可以用来修饰的结构：类、方法、变量
*
* 2.final 用来修饰一个类：此类不能被其他类所继承
* 比如：String类、System类、StringBuffer类
* 3.final 用来修饰方法：表明此方法不可以被重写
* 比如：Object类中getClass();
* 4.final 用来修饰变量：此时的"变量"就称为是一个常量
* 4.1 final修饰属性：可以考虑赋值的位置有：显式初始化、代码块中初始化、构造器中初始化
* 不支持默认初始化，必须赋值
* 不支持在方法中赋值，因为构造器已经是创建对象的最后一步了，构造器执行完毕内存中就已经有了对象，这时候的常量必须有一个值
* 如果每个对象的值不一样，就用构造器赋值；如果每个对象的值都一样，就用显式初始化；如果每个对象的值都一样，并且赋值前需要执行一个方法，或者需要抛异常，就用代码块初始化
* 4.2 final修饰局部变量：
* 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，不能进行重新赋值
*
* static final 用来修饰属性：全局常量
* static final 用来修饰方法：这种情况不常见，用的比较少
final可以修饰的变量，包括对象（引用数据类型）
final修饰的对象，可以更改里面的属性，但是不可以重新赋值（new一个其他对象）
|
Other o = new Other(); new Something().addOne(o); public void addOne(final Other o) { // 没问题 // o = new Other(); // 报错！！！ o.i++; // 没问题 } class Other { public int i; } |
* abstract关键字的使用
* 1. abstract：抽象的
* 2. abstract可以用来修饰的结构：类、方法
*
* 3. abstract修饰类：抽象类
* > 此类不能实例化
* > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
* > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
*
* 4. abstract修饰方法：抽象方法
* > 抽象方法只有方法的声明，没有方法体
* > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法。
* > 若子类重写了（implements实现）父类中的所有的抽象方法后，此子类方可实例化
* 若子类没有重写（implements实现）父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
* abstract使用上的注意点：
* 1. abstract不能用来修饰：属性、构造器、代码块
* 2. abstract不能用来修饰私有方法、静态方法、final的方法、final的类
匿名子类&匿名对象
|
method1(worker); //非匿名的类，非匿名的对象 method1(new Worker());//非匿名的类，匿名的对象 //创建了一个匿名子类的对象：p Person p = new Person() { public void swim() { System.out.println("匿名子类会游泳"); } public void breath() { System.out.println("匿名子类会呼吸"); } }; method1(p); //创建匿名子类的匿名对象 method1(new Person() { public void swim() { System.out.println("匿名子类的匿名对象也一样会游泳"); } public void breath() { System.out.println("匿名子类的匿名对象也能呼吸"); } }); |
多态的应用：模板方法设计模式(TemplateMethod)
当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式
* 1. 抽象类的非抽象方法一般要在子类对象中使用，要不然就没有存在的意义了
* 2. 连接String的过程中，会自动调用对象的toString()方法，不用.toString()调用。如果想连接对象其他方法的返回值，可以"."调用一下
* 3. System.out.print(对象)会自动调用对象的toString()方法，不用.toString()调用
|
Calendar calendar = Calendar.getInstance(); int month = calendar.get(Calendar.MONTH);//获取当前月份，从0开始 System.out.println(month); |
* 接口的使用：接口(interface)是抽象方法和常量值定义的集合。
* 1. 接口使用interface关键字来定义
* 2. Java中，接口和类是并列的两个结构
* 3. 如何定义接口：定义接口就是定义接口中的成员
* 3.1 JDK7及以前：只能定义全局常量和抽象方法
* > 全局常量：public static final的。但是书写时，可以省略不写
* > 抽象方法：public abstract的
*
* 3.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
*
* 4. 接口中不能定义构造器！意味着接口不可以实例化
*
* 5. Java开发中，接口通过让类去实现（implements）的方式来使用
* 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
* 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
*
* 6. Java类可以实现多个接口 --> 弥补了Java单继承性的局限性
* 格式： class AA extends BB implements CC,DD,EE {}
* 先写继承，后写实现
*
* 7. 接口与接口之间可以继承，而且可以多继承
* 继承多个接口之后，重名的抽象方法需要有相同的返回值类型，不然会报错。重写之后认为对多个接口都实现了重写。
*
* ******************************
* 8. 接口的具体使用，体现多态性
* 接口可以作为形参，传入实现类的对象作为实参
* 9. 接口，实际上可以看做是一种规范
* 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
* 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
开发中，体会面向接口编程
接口作为形参的时候，也可以使用匿名实现类的方式传参数，跟类的匿名子类一样
接口的应用：代理模式
接口的应用：工厂模式
把调用者与创建者分离。
|
没有 "super.super.属性/方法" 这样的写法 A的父类B重写了B的父类C的方法，或B和C有同名的属性，那么子类A里没办法直接调用父类的父类C里的被B覆盖的内容了。 实在要调用的话，只能在父类B里用super调用C的内容，再在A里用super调用B的内容 |
C继承B实现A，B和A里有相同的属性x，那么不能直接在C里调用x，编译不通过，x是不明确的
如果要调用父类B里的x，用super.x
如果要调用接口A里的x，用A.x 因为x是一个全局常量，public static final的
|
interface A { int x = 0; } class B { int x = 1; } class C extends B implements A { public void pX() { // System.out.println(x); // 编译不通过，x是不明确的 System.out.println(super.x); //1 System.out.println(A.x); //0 } public static void main(String[] args) { new C().pX(); } } |
包装类有compareTo()方法，用来比较大小
JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法
|
// 静态方法 public static void method1() { System.out.println("CompareA: 北京"); } // 默认方法 public default void method2() { System.out.println("CompareA: 上海"); } // 可以省略public default void method3() { System.out.println("CompareA: 广州"); } |
知识点1：接口中定义的静态方法，只能通过接口来调用
知识点2：通过实现类的对象，可以调用接口中的默认方法
如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点3：如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的默认方法，
那么子类在没有重写此方法的情况下，默认调用的是父类中的同名同参数的方法。 --> 类优先原则
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，
那么在实现类没有重写此方法的情况下，会报错 --> 接口冲突
这就需要我们必须在实现类中重写此方法
知识点5：如何在子类（或实现类）的方法中调用父类、接口中被重写的方法
method3(); //调用自己定义的重写的方法
super.method3(); //调用的是父类中声明的
//调用接口中的默认方法
CompareA.super.method3();
CompareB.super.method3();
* 类的内部成员之五：内部类
* 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
* 2. 内部类的分类：成员内部类（静态、非静态） vs 局部内部类（方法内、代码块内、构造器内）
*
* 3. 成员内部类：
* 一方面，作为外部类的成员：
* >调用外部类的结构比如eat()省略的是Person.this.eat(); //调用外部类的非静态属性
* >可以被static修饰
* >可以被4种不同的权限修饰
* 另一方面，作为一个类：
* >类内可以定义属性、方法、构造器等
* >可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
* >可以被abstract修饰
*
* 4. 关注如下的3个问题
* 4.1 如何实例化成员内部类的对象
* //创建Dog实例（静态的成员内部类）
Person.Dog dog = new Person.Dog();
//创建Bird实例（非静态的成员内部类）
Person p = new Person();
Person.Bird bird = p.new Bird(); //对象.xx来调用类的非静态结构
* 4.2 如何在成员内部类中区分调用外部类的结构
* System.out.println(this.name);//内部类的属性
System.out.println(Person.this.name);//外部类的属性
* 4.3 开发中局部内部类的使用
|
//返回一个实现了Comparable接口的类的对象 public Comparable getComparable() { //创建一个实现了Comparable接口的类：局部内部类 //方式一： // class MyComparable implements Comparable{ // // public int compareTo(Object o) { // return 0; // } // } // return new MyComparable(); //方式二： return new Comparable() { public int compareTo(Object o) { return 0; } }; } |
成员内部类和局部内部类，在编译以后，都会生成字节码文件
格式：成员内部类：外部类$内部类名.class
局部内部类：外部类$1内部类名.class 有数字序号可以区分同名的局部内部类
* 在局部内部类的方法中（比如：show）如果调用局部内部类所声明的方法（比如：method）中的局部变量（比如：num）的话，要求此局部变量声明为final的
*
* jdk 7及之前版本：要求此局部变量显式地声明为final的
* jdk 8及之后的版本：可以省略final的声明
|
public void method() { // 局部变量 int num = 10; //默认声明为final了 final Object o = new Object();
class AA{ public void show() { System.out.println(num); System.out.println(o); } } new AA().show(); // o = new Object(); //无法修改 // num = 20; //无法修改 System.out.println(num); System.out.println(o); //跟show里面的o是同一个引用 } |
匿名子类算是一种内部类，适用上面的规则
抽象类和接口的区别
结尾