Day5 深入类和对象

Day5 深入类和对象

封装，继承，多态

• 封装：把客观的事物抽象成类，将类的属性私有化，同时提供外界可以访问该属性的方法。
• 继承：将已经存在的类（父）作为新建立的类（子）的基础，子类可以使用父类的所有功能，可以对子类的功能进行扩展，可以让子类的代码实现复用。
• 多态：允许你使用父类的引用去指向子类的对象，所指向的具体的类型，在编译时不会确定，在运行时动态绑定。

接口，抽象类，内部类

抽象类：被标记为abstract的类

• 抽象类不能被实例化，只能被继承。
• 存在抽象方法的类一定是抽象类，抽象类中不一定有抽象方法。
• 子类继承了抽象类，就必须实现父类的抽象方法，不然子类也也是抽象类。

接口：被标记为interface

• 接口中可以声明属性和方法，不过都被默认标记为public static final。
• 接口支持多继承，间接的解决了java单继承的问题。
• 一个类可以实现多个接口。
• jdk8之后，可以使用default关键字来标记其中的方法，使得该方法可以有具体的实现，子类可以调用该方法。

内部类：在一个类的内部声明的类

• 非静态内部类：可以使用private 或 protected来修饰，可以访问外部类的成员。不能直接被实例化，需要通过先实例化外部类来实例化内部类。
• 静态内部类：不需要创建外部类来访问，可以直接被访问到。但是不能访问外部类的成员。

代码块

• 普通代码块：定义在类的方法中，调用该方法时被执行。
• 构造代码块：定义在类中，一般用于初始化属性。在创建对象时调用，优先级高于构造器。
• 静态代码块：只执行一次，存在多个静态代码块时，会按照声明的顺序合并，再执行。

this，supper

this：表示当前对象，在方法中使用

• 调用属性：构造器/方法中给初始化属性，防止变量名冲突。
• 调用构造方法：当类中存在多个构造方法，可以在其中一个构造器中调用其他构造方法来给属性赋值。
• 调用普通方法：this.方法，在当前类中的方法中调用当前类的方法。
• 返回当前对象：return this

supper：表示父类对象的引用

• 调用父类的构造器：在创建子类对象的同时，会调用父类的构造器，默认时调用的空参构造器
• 调用父类的属性：supper.父类属性
• 调用父类的方法：supper.父类方法

this与supper都必须放在构造方法的第一行

枚举

• Enum实现java.lang.Aeriablizable和java.lang.Comparable两个接口。当定义一个枚举类型时，每一个枚举类型成员都可以看作是Enum类的实例。
• 这些枚举成员默认值都被final、public、static修饰

用法：

• 定义常量
• switch语句中
• 给枚举添加属性
• 给枚举添加方法
• 重写枚举方法

// 枚举
enum Chap1 {
    SPRING(1), SUMMER(2), AUTUMN(3), WINTER(4);

    // 可以声明属性，需要添加到构造函数中
    private int index;
    Chap1(int index){
        this.index = index;
    }

    // 存在get/set方法
    public int getIndex() {
        return index;
    }
    public void setIndex(int index){
        this.index = index;
    }

    // 枚举中定义方法
    public static Chap1 getSeason(int i){
        switch (i){
            case 1:return Chap1.SPRING;
            case 2:return Chap1.SUMMER;
            case 3:return Chap1.AUTUMN;
            case 4:return Chap1.WINTER;
            default:return null;
        }
    }

    // 重写枚举的方法
    @Override
    public String toString() {
        return this.index + "";
    }
}
class Test{
    public static void main(String[] args) {
        System.out.println(Chap1.SUMMER);   // SUMMER
        // 取得对应的常量
        System.out.println(Chap1.valueOf("WINTER"));
        // Chap1.values(), 获得枚举数组
        for (int i = 0; i < Chap1.values().length; i++) {
            // 0: SPRING   1: SUMMER  2: AUTUMN  3: WINTER
            System.out.print(Chap1.values()[i].ordinal() + ": ");
            System.out.print(Chap1.values()[i] + "\t");
        }
        // 3
        System.out.println(Chap1.AUTUMN.getIndex());
        // AUTUMN，  调用自定义的方法
        System.out.println(Chap1.getSeason(3));
    }
}

单例模式

// 饿汉式
public class Chap2 {
    private static final Chap2 chap2 = new Chap2();
    private Chap2(){
        System.out.println("Chap2");
    }
    public static Chap2 getChap2() {
        return chap2;
    }
}

// 懒汉式
class Chap3 {
    private static Chap3 chap3;
    private Chap3(){
        System.out.println("Chap3");
    }
    public static Chap3 getChap3() {
        if (chap3 == null){
            chap3 = new Chap3();
        }
        return chap3;
    }
}

// 加锁的单例模式
class Chap4{
    private static Chap4 chap4;
    private Chap4(){
        System.out.println("Chap4");
    }
    public synchronized static Chap4 getChap4() {
        if (chap4 == null){
            synchronized (Chap4.class){
                if (chap4 == null){
                    chap4 = new Chap4();
                }
            }
        }
        return chap4;
    }
}

// 静态内部类
class Chap5{
    private Chap5(){
        System.out.println("Chap5");
    }
    private static final class setChap5 {
        private static final Chap5 chap5 = new Chap5();
    }
    public synchronized static Chap5 getChap5(){
        return setChap5.chap5;
    }
}

class Test2{
    public static void main(String[] args) {
        Chap2 chap2 = Chap2.getChap2();
        Chap3 chap3 = Chap3.getChap3();
        Chap4 chap4 = Chap4.getChap4();
        Chap5 chap5 = Chap5.getChap5();
    }
}