java学习笔记——面向对象（下）2021.12.3

• static关键字
• • 单例Singleton设计模式
• 理解main方法的语法
• 类的成员之四：代码块
• final关键字
• 抽象类与抽象方法
• 接口interface
• 类的成员之五：内部类

static关键字

• 可以修饰：属性、方法、代码块、内部类
• 修饰属性：静态变量（类变量）
  按是否使用static修饰，将属性分为：静态属性 vs 非静态属性（实例变量）；
  实例变量：创建类的多个对象，每个对象都独立拥有一套类中的非静态属性，当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值改变；
  静态变量：创建类的多个对象，多个对象共享一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象的该静态变量同时修改；
  静态变量随着类的加载而加载，可以通过“类.静态属性”的方式进行调用，加载要早于对象的创建；
  由于类只会加载一次，所以静态变量在内存中也只存在一份，存在方法区的静态域中；
• 修饰方法：静态方法
  静态方法随着类的加载而加载，可以通过“类.静态方法”的方式进行调用；
• 在静态的方法内，不能使用this、super
• 如何确定是否使用static：
  属性是可以被多个对象所共享的，不会随着对象的不同而不同；
  方法：操作静态属性的方法，通常设置为static，工具类中的方法，习惯上声明为static

单例Singleton设计模式

饿汉式：坏处-加载时间过长；好处-线程安全

class SingleBank{
    //私有化类的构造器
    private SingleBank(){
    }
    //内部创建类的对象
    private static SingleBank instance = new SingleBank();
    //提供公共的方法，返回类的对象
    public static SingleBank getInstance(){
        return instance;
    }
}

懒汉式：好处：延迟对象的创建；坏处-线程不安全；

class LazyBank{
    //私有化类的构造器
    private LazyBank(){
    }
    //声明当前类对象，没有初始化
    private  static LazyBank instance = null;
    //声明public、static的返回当前类对象的方法
    public static LazyBank getInstance(){
        if(instance == null){
            instance = new LazyBank();
        }
        return instance;
    }
}

理解main方法的语法

• 作为程序的入口；
• 也是一个普通的静态方法

类的成员之四：代码块

{代码块}
作用：用来初始化类、对象；

• 代码块如果有修饰，只能用static—>静态代码块 vs 非静态代码块；
• 静态代码块：内部有输出语句；随着类的加载而执行，而且只执行一次；
  作用：初始化类的信息；
  静态代码块内只能调用静态的我属性、静态的方法，不能调用非静态的结构；
• 非静态代码块：内部可以有输出语句；随着对象的创建而执行，每创建一个对象，就执行一次非静态代码块；
  作用：可以在创建对象时，对对象的属性进行初始化；

如果定义了多个代码块，同类代码块按照声明顺序进行执行，静态代码块先于非静态代码块执行；
代码块执行先于构造器；

• 对属性可以赋值的位置及其顺序：
  1.默认初始化；
  2.显式初始化/2.在代码块中赋值；这两种方式按声明顺序
  4.构造器中初始化；
  5.有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值；

final关键字

• 可以用来修饰：类、方法、变量；
• 修饰类：不能被继承；
• 修饰方法：不能被重写；
• 修饰变量：变量变为常量
  final修饰属性后，可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化；
  final修饰局部变量：尤其是修饰形参时，表示该形参为常量，给常量形参赋值一个实参，一旦赋值以后，就只能在方法体内使用此形参，但不能重新赋值；
• static final 用来修饰属性（全局常量）、方法

抽象类与抽象方法

• abstract修饰类：抽象类，一旦抽象，就不能实例化了；类中一定有构造器，便于子类对象实例化调用；都会提供抽象类的子类，让子类对象实例化；
• abstract修饰方法：抽象方法，只有方法的声明，没有方法体；权限修饰符 abstract void 方法名（）；包含抽象方法的类，一定是抽象类，反之不成立；若子类重写了父类中的所有抽象方法后，此子类方可实例化；若子类没有重写父类的所有抽象方法，则子类也是抽象类，要使用abstract修饰；
• abstract不能用来修饰：属性、构造器等结构；
• abstr不能用来修饰私有方法、静态方法、final的方法、final的类；
• 创建匿名子类的对象；
• 创建匿名子类的匿名对象；

接口interface

• 接口使用interface来定义；
• 接口和类是并列的两个结构；
• 定义接口：定义接口中的成员：全局常量（public static final，可以省略）、抽象方法（public abstract，可以省略）、静态方法、默认方法；
• 接口中不能定义构造器，意味着接口不能实例化；
• 接口通过让类去实现（implements）的方式来使用；如果实现类覆盖了接口中的所有抽象方法，则可以实例化，否则实现类仍为抽象类；
  class 类名 implements 接口名1，接口名2…{}；
  class 类名 extends 父类名 implements 接口名1，接口名2…{}；
• 类可以实现多个接口，弥补了单继承性的局限性；
• 接口和接口之间可以多继承；
  interface 接口名 extends 接口名1，接口名2，…{}
• 接口实际上可以看作一种规范；
• 面向接口编程；
• 接口内定义静态方法：public static void 方法(){}；
  接口中定义的静态方法，只能通过接口本身去调用；
• 接口内定义默认方法：public default void 方法(){}
  通过实现类的对象，可以调用接口中的默认方法；
  如果实现类重写了接口中的默认方法，调用的是重写后的方法；
  如果子类（或实现类）继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法—>类优先原则；
  如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错—->接口冲突，需要重写此方法；
  在子类（或实现类）的方法中调用父类、接口中被重写的方法；

类的成员之五：内部类

• 声明在类中的类；
• 内部类的分类：成员内部类 vs 局部内部类（方法内、代码块内、构造器内）；
• 成员内部类：类内可以定义：属性、方法、构造器；final修饰，表示不能被继承，不加final可以被继承；可以被abstract修饰；可以调用外部类的结构；可以被static修饰；可以被权限修饰符修饰；
• 局部内部类；
• 如何实例化内部类的对象：
  静态的成员内部类： 外部类.内部类 对象名 = new 外部类.内部类()；
  非静态的成员内部类：先创建外部的类对象p；外部类.内部类 对象名 = p.new 内部类()；
• 如何在成员内部类中区分调用外部类的结构：方法的形参：参数名；内部类的属性：this.name；外部类的属性：外部类名.this.name；
• 开发中局部内部类的使用；