进阶篇day02 --- 包 / 抽象类 / 接口 / 多态

能够定义抽象方法和抽象类

清楚抽象类子类的特点

能够理解接口的思想和好处

清楚接口中的成员特点

能够理解多态的好处

掌握多态中的成员访问特点

包

抽象类

抽象类是一种特殊的父类 , 内部可以编写抽象方法

public class AbstractTest1 {
    /*
        抽象类: 特殊的父类

        问题: 特殊在哪里呢?
        回答: 内部允许编写抽象方法

        问题: 什么是抽象方法?
        回答: 当我们将共性的方法, 抽取到父类之后, 发现这个方法在父类中无法给出具体明确(描述不清了)
                而且这个方法, 还是子类必须要有的方法, 就可以设计为抽象方法.
     */
    public static void main(String[] args) {

    }
}

abstract class Animal {
    public abstract void eat();
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

public class AbstractTest2 {
    /*
        抽象类的注意事项 :

            1. 抽象类不能实例化
                - 如果抽象类允许创建对象, 就可以调用内部没有方法体的, 抽象方法了
            2. 抽象类存在构造方法
                - 交给子类, 通过super进行访问
            3. 抽象类中可以存在普通方法
                - 可以让子类继承到继续使用
            4. 抽象类的子类
                    1). 要么重写抽象类中的所有抽象方法
                    2). 要么是抽象类
     */
    public static void main(String[] args) {
         Zi z = new Zi();
         z.method();

    }
}

abstract class A {
    public  abstract void showA();
}

abstract class B extends A {

    @Override
    public void showA() {

    }

    public abstract void showB();
}

class C extends B {

    @Override
    public void showB() {

    }
}


abstract class Fu {

    public Fu(){

    }

    public abstract void show();

    public void method(){
        System.out.println("method...");
    }

}

class Zi extends Fu {

    public Zi(){
        super();
    }

    @Override
    public void show() {

    }
}

接口

public class InterfaceTest1 {
    /*
        接口: 体现的思想就是声明 [规则]

        思路: 如果发现一个类, 所有的组成, 都是抽象方法
                    - 没有成员变量
                    - 没有普通方法

                    这种类, 我们通常会设计为Java中的接口, 因为现在这个类存在的唯一价值, 就只是声明规则了


        ---------------------------------

        接口的定义格式:

                interface 接口名 {}

        注意: 接口不允许实例化

        接口和类之间是实现关系, 通过implements关键字来完成

                class 类名 implements 接口名 {}

                实现类(接口的子类):

                        1. 重写所有抽象方法
                        2. 将实现类变成抽象类
     */
    public static void main(String[] args) {
        // 创建实现类对象
        InterImpl ii = new InterImpl();
        ii.method();
        ii.show();
    }
}

interface Inter {
    public abstract void show();
    public abstract void method();
}

class InterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("show...");
    }

    @Override
    public void method() {
        System.out.println("method...");
    }
}

 

public class InterfaceTest2 {
    /*
        接口的成员特点 :

            1. 成员变量 : 只能定义常量, 因为系统会默认加入三个关键字
                                public static final
                                - 这三个关键字没有顺序关系

            2. 成员方法 : 只能是抽象方法, 因为系统会默认加入两个关键字
                                public abstract

            3. 构造方法 : 没有
     */
    public static void main(String[] args) {
        System.out.println(Inter.num);
    }
}

interface MyInter {
    public static final int NUM = 10;

    public abstract void show();

    void method();
}

 

interface InterA {
    void show();
}

interface InterB {
    void show();
}

interface InterC extends InterA, InterB {
    void show();
}

class InterCImpl implements InterC {

    @Override
    public void show() {

    }
}

public class InterfaceTest3 {
    /*
        接口和类之间的各种关系 :

            1. 类和类之间 : 继承关系, 只支持单继承, 不支持多继承, 但是可以多层继承

            2. 类和接口之间 : 实现关系, 可以单实现, 也可以多实现, 甚至可以在继承一个类的同时, 实现多个接口

            3. 接口和接口之间 : 继承关系, 可以单继承, 也可以多继承
     */
    public static void main(String[] args) {

    }
}

class Fu {
    public void show() {
        System.out.println("Fu..show");
    }
}

interface A {
    void show();
}

interface B {
    void show();
}

class Zi extends Fu implements A, B {

}

 

 

多态

 

 

 

public class Test {
    /*
        ClassCastException : 类型转换异常

                在引用数据类型的强转中, [实际类型]和[目标类型]不匹配, 就会出现此异常
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:  1. 国内订单   2. 国外订单");

        OrderService orderService = null;

        int choice = sc.nextInt();
        switch (choice) {
            case 1:
                // 创建国内订单的业务类
                orderService = new OrderServiceImpl();
                break;
            case 2:
                // 创建国外订单的业务类
                orderService = new OverseasServiceImpl();
                break;
        }

        // instanceof : 判断左边的引用, 是否是右边的数据类型
        if(orderService instanceof OverseasServiceImpl){
            OverseasServiceImpl osi = (OverseasServiceImpl) orderService;
            osi.check();
        }

        orderService.create();
        orderService.findOne();
        orderService.findList();
        orderService.cancel();
        orderService.finish();
        orderService.paid();
    }
}

public class PolymorphismTest1 {
    /*
        多态的前提 :
                    有继承 / 实现关系
                    有方法重写
                    有父类引用指向子类对象

        1. 对象多态
                    Animal a1 = new Dog();
                    Animal a2 = new Cat();

                    好处: 方法的形参定义为父类类型, 这个方法就可以接收到该父类的任意子类对象了

        2. 行为多态
                    好处: 同一个方法, 具有多种不同表现形式, 或形态的能力
     */
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());

    }

    public static void useAnimal(Animal a) {        // Animal a = new Dog();
          a.eat();                                  // Animal a = new Cat();
    }

}

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class PolymorphismTest2 {
    /*
        多态的成员访问特点:

              1. 成员变量 : 编译看左边(父类), 运行看左边(父类)

              2. 成员方法 : 编译看左边(父类), 运行看右边(子类)

                                在编译的时候, 会检查父类中有没有这个方法
                                        没有 : 编译出错
                                        有 : 编译通过, 但是运行的时候, 一定会执行子类的方法逻辑

                                原因: 担心你调用的方法, 在父类中是一个抽象方法

        --------------------------------------------------------------------------

            多态创建对象, 调用静态成员 :

                    静态的成员, 推荐类名进行调用
                    细节: 静态的成员, 可以使用对象名调用, 但这是一种假象
                                    - 生成字节码文件后, 会自动将对象名调用, 改成类名调用
     */
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num); //10
        f.show();  //Zi...show
        f.print();          // Fu.print();     打印:Fu...print

        System.out.println("-----------------");

        Inter i = new InterImpl();
        i.method();
    }

}

interface Inter {
    void method();
}

class InterImpl implements Inter {

    @Override
    public void method() {
        System.out.println("method...");
    }
}

class Fu {
    int num = 10;

    public void show() {
        System.out.println("Fu...show");
    }

    public static void print(){
        System.out.println("Fu...print");
    }
}

class Zi extends Fu {
    int num = 20;

    @Override
    public void show() {
        System.out.println("Zi...show");
    }

    public static void print(){
        System.out.println("Zi...print");
    }
}