JAVA - 类 class （3）

类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。

多态

多态的概念

• 多态主要指同一种事物表现出来的多种形态。

• 饮料：可乐、雪碧、红牛、脉动、...

• 宠物：猫、狗、鸟、小强、鱼、...

• 人：学生、教师、工人、保安、...

• 图形：矩形、圆形、梯形、三角形、…

多态的语法格式

• 父类类型 引用变量名 = new 子类类型();
• 如：
  • Shape sr = new Rect();
  • sr.show();

多态的特点

• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。

• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。

• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。

• 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

引用数据类型之间的转换

• 引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。

• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫做向上转型。

• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显式类型转换。

• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。

• 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。

• 为了避免上述错误的发生，应该在强转之前进行判断，格式如下：

  • if(引用变量 instanceof 数据类型)

  • 判断引用变量指向的对象是否为后面的数据类型

多态的实际意义

• 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。

抽象类

抽象方法的概念

• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。

• 具体格式如下：

  • 访问权限 abstract 返回值类型 方法名(形参列表);

  • public abstract void cry();

抽象类的概念

• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。

抽象类和抽象方法的关系

• 抽象类中可以有成员变量、构造方法、成员方法；

• 抽象类中可以没有抽象方法，也可以有抽象方法；

• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类。

抽象类的实际意义

• 抽象类的实际意义不在于创建对象而在于被继承。

• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

接口

接口的基本概念

• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法。
• 定义类的关键字是class，而定义接口的关键字是interface。

类和接口之间的关系

名称	关键字	关系
类和类之间的关系	使用extends关键字表达继承关系	支持单继承
类和接口之间的关系	使用implements关键字表达实现关系	支持多实现
接口和接口之间的关系	使用extends关键字表达继承关系	支持多继承

抽象类和接口的主要区别（笔试题）

• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface。

• 继承抽象类的关键字是extends，而实现接口的关键字是implements。

• 继承抽象类支持单继承，而实现接口支持多实现。

• 抽象类中可以有构造方法，而接口中不可以有构造方法。

• 抽象类中可以有成员变量，而接口中只可以有常量。

抽象类和接口的主要区别

• 抽象类中可以有成员方法，而接口中只可以有抽象方法。

• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写（Java8以前的版本）。

• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰。

• 从Java9开始增加新特性，接口中允许出现私有方法。

内部类

内部类的基本概念

• 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）。

实际作用

• 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

内部类的分类

• 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。

• 静态内部类 - 使用static关键字修饰的内部类，隶属于类层级。

• 局部内部类 - 直接将一个类的定义放在方法体的内部时。

• 普通内部类 - 直接将一个类的定义放在另外一个类的类体中。

普通（成员）内部类的格式

访问修饰符 class 外部类的类名 {
    访问修饰符 class 内部类的类名 {
    内部类的类体;
    } 
} 

public class demo {
    public class demo1 {
        内部类的类体;
    }
}

public class NormalOuter {
    private int cnt = 1;

    // 定义普通内部类，隶属于外部类的成员，并且是对象层级
    /*private*/public /*final*/ class NormalInner {
        private int ia = 2;
        private int cnt = 3;
        public NormalInner() {
            System.out.println("普通内部类的构造方法体执行到了！");
        }

        public void show() {
            System.out.println("外部类中变量cnt的数值为：" + cnt); // 1
            System.out.println("ia = " + ia); // 2
        }

        public void show2(int cnt) {
            System.out.println("形参变量cnt = " + cnt);  // 局部优先原则  4
            System.out.println("内部类中cnt = " + this.cnt); // 3
            System.out.println("外部类中cnt = " + NormalOuter.this.cnt); // 1
        }
    }
}

普通内部类的使用方式

• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。

• 普通内部类和普通类一样可以使用final或者abstract关键字修饰。

• 普通内部类还可以使用private或protected关键字进行修饰。

• 普通内部类需要使用外部类对象来创建对象。

• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字。

静态内部类的格式

访问修饰符 class 外部类的类名 {
    访问修饰符 static class 内部类的类名 {
        内部类的类体;
    } 
}

public class demo {
    public static class demo1 {
        内部类的类体;
    }
}

public class StaticOuter {
    private int cnt = 1;        // 隶属于对象层级
    private static int snt = 2; // 隶属于类层级

    public void show() {
        System.out.println("外部类的show方法就是这里！");
    }
    
    public static void show1() {
        System.out.println("外部类的show方法就是这里！");
    }

    /**
     * 定义静态内部类   有static关键字修饰隶属于类层级
     */
    public static class StaticInner {
        private int ia = 3;
        private static int snt = 4;

        public StaticInner() {
            System.out.println("静态内部类的构造方法哦！");
        }

        public void show() {
            System.out.println("ia = " + ia); // 3
            System.out.println("外部类中的snt = " + snt); // 2
            //System.out.println("外部类的cnt = " + cnt); // Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象
        }

        public void show2(int snt) {  // 就近原则
            System.out.println("snt = " + snt); // 5
            System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4
            System.out.println("外部类中的成员snt = " + StaticOuter.snt); // 2
            // 使用外部静态类
            StaticOuter.show1();
            // 使用外部普通类
            new StaticOuter().show();
        }
    }
}

静态内部类的使用方式

• 静态内部类不能直接访问外部类的非静态成员。

• 静态内部类可以直接创建对象。

• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。

局部（方法）内部类的格式

访问修饰符 class 外部类的类名 {
    访问修饰符 返回值类型 成员方法名（形参列表） {
        class 内部类的类名 {
            内部类的类体;
        }
    } 
} 

public class demo {
    public void  demo1(String[] args) {
           class demo2 {
                内部类的类体;
            }
    }
}

public class AreaOuter {
    private int cnt = 1;

    public void show() {

        // 定义一个局部变量进行测试，从Java8开始默认理解为final关键字修饰的变量
        // 虽然可以省略final关键字，但建议还是加上
        final int ic = 4;

        // 定义局部内部类，只在当前方法体的内部好使    拷贝一份
        class AreaInner {
            private int ia = 2;

            public AreaInner() {
                System.out.println("局部内部类的构造方法！");
            }

            public void test() {
                int ib = 3;
                System.out.println("ia = " + ia); // 2
                System.out.println("cnt = " + cnt); // 1
                //ic = 5;  Error 不能修改值
                System.out.println("ic = " + ic); // 4
            }
        }

        // 声明局部内部类的引用指向局部内部类的对象
        AreaInner ai = new AreaInner();
        ai.test();
    }

}

局部内部类的使用方式

• 局部内部类只能在该方法的内部可以使用。

• 局部内部类可以在方法体内部直接创建对象。

• 局部内部类不能使用访问控制符和static关键字修饰符。

• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。

匿名内部类的语法格式

// 使用匿名内部类的语法格式来得到接口类型的引用，
// 格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };

// AnonymousInterface 接口文件
public interface AnonymousInterface {
    // 自定义抽象方法
    public abstract void show();
}

// AnonymousInterface 类文件
public class AnonymousInterfaceImpl implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("这里是接口的实现类！");
    }
}

// AnonymousInterface 类的测试文件
public class AnonymousInterfaceTest {

    // 假设已有下面的方法，请问如何调用下面的方法？
    // AnonymousInterface ai = new AnonymousInterfaceImpl();
    
    // 接口类型的引用指向实现类型的对象，形成了多态
    public static void test(AnonymousInterface ai) {
        // 编译阶段调用父类版本，运行调用实现类重写的版本
        ai.show();
    }

    public static void main(String[] args) {

        //AnonymousInterfaceTest.test(new AnonymousInterface()); // Error:接口不能实例化
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl()); // 没有使用匿名内部类的语法格式

        System.out.println("---------------------------------------------------------------");
        // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 }; 
        // 使用回调模式
        AnonymousInterface ait = new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");
            }
        };

        // 从Java8开始提出新特性lamda表达式可以简化上述代码，格式为：(参数列表) -> {方法体}
        AnonymousInterface ait2 = () -> System.out.println("lamda表达式原来是如此简单！");
        AnonymousInterfaceTest.test(ait2);
    }
}

/**
* 回调模式
* 回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，
* 需要创建并传递一个实现此接口类型的对象；
* 而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。
*/ 

匿名内部类的使用方式

• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：

• 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；

• 使用上述匿名内部类的语法格式得到接口/类类型的引用即可；

枚举

枚举的基本概念

• 一年中的所有季节：春季、夏季、秋季、冬季。

• 所有的性别：男、女。

• 键盘上的所有方向按键：向上、向下、向左、向右。

• 在日常生活中这些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型。

枚举的定义

• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。

• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用。

• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。

Enum类的概念和方法

所有的枚举类都继承自java.lang.Enum类，常用方法如下：

方法	说明
static T[] values()	返回当前枚举类中的所有对象
String toString()	返回当前枚举类对象的名称
int ordinal()	获取枚举对象在枚举类中的索引位置
static T valueOf(String str)	将参数指定的字符串名转为当前枚举类的对象
int compareTo(E o)	比较两个枚举对象在定义时的顺序

枚举类实现接口的方式

• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写。

// DirectionInterface 接口文件
public interface DirectionInterface {
    // 自定义抽象方法
    public abstract void show();
}

// DirectionEnum 枚举文件
public enum DirectionEnum implements DirectionInterface {
    // 2.声明本类类型的引用指向本类类型的对象
    // 匿名内部类的语法格式：接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
    // public static final Direction UP = new Direction("向上") { 方法的重写 };
    UP("向上") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向上移动了一下！");
        }
    }, DOWN("向下") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向下移动了一下！");
        }
    }, LEFT("向左") {
        @Override
        public void show() {
            System.out.println("左移了一下！");
        }
    }, RIGHT("向右") {
        @Override
        public void show() {
            System.out.println("右移了一下！");
        }
    };

    private final String desc; // 用于描述方向字符串的成员变量

    // 通过构造方法实现成员变量的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
    private DirectionEnum(String desc) { this.desc = desc; }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }

    // 整个枚举类型只重写一次，所有对象调用同一个
    /*@Override
    public void show() {
        System.out.println("现在可以实现接口中抽象方法的重写了！");
    }*/
}

public class DirectionEnumTest {

    public static void main(String[] args) {

        // 1.获取DirectionEnum类型中所有的枚举对象
        DirectionEnum[] arr = DirectionEnum.values();
        // 2.打印每个枚举对象在枚举类型中的名称和索引位置
        for (int i = 0; i < arr.length; i++) {
            System.out.println("获取到的枚举对象名称是：" + arr[i].toString());
            System.out.println("获取到的枚举对象对应的索引位置是：" + arr[i].ordinal()); // 和数组一样下标从0开始
        }

        System.out.println("---------------------------------------------------------------");
        // 3.根据参数指定的字符串得到枚举类型的对象，也就是将字符串转换为对象
        // DirectionEnum de = DirectionEnum.valueOf("向下"); // 编译ok，运行发生IllegalArgumentException非法参数异常
        DirectionEnum de = DirectionEnum.valueOf("DOWN");
        // DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); // 要求字符串名称必须在枚举对象中存在
        // System.out.println("转换出来的枚举对象名称是：" + de.toString());
        System.out.println("转换出来的枚举对象名称是：" + de); // 当打印引用变量时，会自动调用toString方法

        System.out.println("---------------------------------------------------------------");
        // 4.使用获取到的枚举对象与枚举类中已有的对象比较先后顺序
        for(int i = 0; i < arr.length; i++) {
            // 当调用对象在参数对象之后时，获取到的比较结果为 正数
            // 当调用对象在参数对象相同位置时，则获取到的比较结果为 零
            // 当调用对象在参数对象之前时，则获取到的比较结果为 负数
            System.out.println("调用对象与数组中对象比较的先后顺序结果是：" + de.compareTo(arr[i]));
        }
        
       // 调用对象与数组中对象比较的先后顺序结果是：1
       // 调用对象与数组中对象比较的先后顺序结果是：0
       // 调用对象与数组中对象比较的先后顺序结果是：-1
       // 调用对象与数组中对象比较的先后顺序结果是：-2

        System.out.println("---------------------------------------------------------------");
        // 5.使用数组中每个DirectionEnum对象都去调用show方法测试
        for (int i = 0; i < arr.length; i++) {
            arr[i].show();
        }
        
        // 贪吃蛇向上移动了一下！
        // 贪吃蛇向下移动了一下！
        // 左移了一下！
        // 右移了一下！
    }
}