Java 面向对象 04

面向对象·四级

多态的概述及其代码实现

* A：多态（polymorphic）概述
　　* 事物存在的多种形态

* B：多态前提
　　* a：要有继承关系
　　* b：要有方法重写
　　* c： 要有父类引用指向子类对象

class Demo1_Polymorphic {
    public static void main(String[] args) {
        Cat c  = new Cat();
        c.eat();

        Animal a = new Cat(); // 父类引用指向子类对象
        a.eat();
    }
}

class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

多态中的成员访问特点之成员变量

* 成员变量

　　* 编译看左边（父类） ，运行看右边（子类）。实际用父类

class Demo2_Polymorphic {
    public static void main(String[] args) {
        Father f = new Son();
        System.out.println(f.num)

        Son s = new Son();
        System.out.println(s.num)
    }
}

class Father {
    int num = 10;
}

class Son extends Father {
    int num = 20;
}

多态中的成员访问特点之成员方法

* 成员方法

　　* 编译看左边（父类） ，运行看右边（子类）。实际用子类

class Demo2_Polymorphic {
    public static void main(String[] args) {
        /*Father f = new Son();
        System.out.println(f.num)

        Son s = new Son();
        System.out.println(s.num)*/

        Father f = new Son();
        f.print();
    }
}

class Father {
    int num = 10;
    public void print() {
        System.out.println("father");
    }
}

class Son extends Father {
    int num = 20;
    public void print() {
        System.out.println("son");
    }
}

多态中的成员访问特点之静态方法

* 静态方法

　　* 编译看左边（父类） ，运行看右边（子类）。实际用父类
　　* （静态方法和类相关，算不上重写，所以，访问还是左边的）
　　* 只有非静态的成员方法，编译看左边，运行看右边

class Demo2_Polymorphic {
    public static void main(String[] args) {
        /*Father f = new Son();
        System.out.println(f.num)

        Son s = new Son();
        System.out.println(s.num)*/

        Father f = new Son();
        //f.print();
        f.method();
    }
}

class Father {
    int num = 10;
    public void print() {
        System.out.println("father");
    }

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

class Son extends Father {
    int num = 20;
    public void print() {
        System.out.println("son");
    }
    public static void method() {
        System.out.println("son static method");
    }
}

向上转型和向下转型

Person p = new SuperMan();     // 向上转型  类似自动类型提升
SuperMan sm = (SuperMan)p;  // 向下转型  类似强制类型转化

 多态的好处和弊端

* 弊端：

　　* 不能调用子类特有的属性和方法

* 好处

　　* 提高了代码的可维护性（由继承保证）
　　* 提高了代码的可扩展性（由多态保证）

 * 案例演示

　　* 多态的好处
　　* 可以当作形式参数，可以接受任意子类对象

 * instanceof 关键字 的 使用

　　* 判断当前对象的类型

class Demo4_Animal {
    public static void main(String[] args) {
        //Cat c1 = new Cat();
        //c1.eat();
        method(new Cat());
        method(new Dog());
    }
    // 开发的时候很少在创建对象的时候用父类引用指向子类对象
    // 一般当作参数时，使用多态，具有较强的扩展性
    public static void method(Animal a) {  // Animal c = new Cat();  
        if (a instanceof Cat) {                 // Animal c = new Dog();
            Cat c = (Cat)a;
            c.eat();
            c.catchMouse();
        }else if (a instanceof Dog) {
            Dog d = (Dog)d;
            d.eat();
            d.lookHome();
        }else {
            a.eat();
        }
    }                                       
}

class Animal {
    public void eat() {
        System.out.println("动物吃饭");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void lookHome() {
        System.out.println("看家");
    }
}

 多态题目分析 1 

class Test1_Polymorphic {
    public static void main(String[] args) {
        Fu f = new Zi();
        //f.mothod();  // 编译报错，因为父类中没有定义
        f.show();
    }
}

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

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

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

 多态题目分析2

class Test2_Polymorphic {
    public static void main(String[] args) {
        A a = new B();
        a.show();

        B b = new C();
        b.show();
    }
}

class A {
    public void show() {
        show2();
    }

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

class B extends A {
    public void show2() {
        System.out.println("爱");
    }
}

class C extends B {
    public void show() {
        super.show();
    }

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

---

抽象类的概述及其特点

* A：抽象类概述
　　* 抽象就是看不懂的

* B：抽象类特点

　　* a：抽象类和抽象方法必须用abstract关键字修饰
　　　　* abstract class 类名 { }
　　　　* public abstract void eat();

　　* b：抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

　　*c：抽象类不能实例化
　　　　* 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态

　　* d：抽象类子类
　　　　* 要么是抽象类
　　　　* 要么重写抽象类中的所有抽象方法

* C：案例演示
　　* 抽象类特点

class Demo1_Abstract {
    public static void main(String[] args) {
        //Animal a = new Animal();  // 错误的，Animal是抽象的，无法实例化
        Animal a = new Cat();    // 父类引用指向子类对象
        a.eat();
    }
}

abstract class Animal {  // 抽象类
    public abstract void eat();  // 抽象方法，不加大括号
}

class Cat extends Animal {
    public void eat() {
        System.out.println("cat");
    }
}

抽象类的成员特点

* A：抽象类的成员特点

　　* a：成员变量：既可以是变量，也可以是常量。abstract 不能修饰成员变量
　　* b：构造方法：有
　　　　* 用于子类访问父类数据的初始化
　　* c：成员方法：既可以是抽象的，也可以是非抽象的

* B：案例演示
　　* 抽象类的成员特点

* C：抽象类的成员方法特性：
　　* a：抽象方法，    强制要求子类做的事情
　　* b：非抽象方法，子类继承的事情，提高代码的复用性

class Demo2_Abstract {
    public static void main(String[] args) {
        
    }
}

abstract class Demo {
    int num1 = 10;
    final int num2 = 20;

    public Demo() {
        System.out.println("空参构造");
    }

    public void print() {
        System.out.println("非抽象的方法");
    }

    public abstract void method();
}

class Test extends Demo {
    public void method() {    // 方法重写
        System.out.println("抽象的方法");
    }
}

抽象类中的面试题

* A：面试题 1

　　* 一个抽象类如果没有抽象方法，可不可以定义为抽象类？ 如果可以，有什么意义？
　　　　* 可以
　　　　* 这么做的目的只有一个，就是不让其他类创建本类对象，交给子类完成

* B：面试题 2
　　* abstract 不能和哪些关键字共存
　　　　* abstract 不能和 static 组合，   该方法没有抽象体，用类名调用没有意义。
　　　　* abstract 不能和 final 组合，     被abstract 修饰的方法 强制子类重写，而被final 修饰的方法则被禁止重写。
　　　　* abstract 不能和 private 组合， 被private 修饰的方法禁止子类访问，则abstract 方法无法被重写。

---

接口的概述及其特点

* A：接口概述

　　* 从狭义的角度将就是指 Java 中的 interface
　　* 从广义的角度将对外提供的规则的都是接口

* B：接口的特点

　　* a：接口用关键字 interface 表示
　　　　* interface 接口名 { }

　　* b：类 实现 接口用implements表示
　　　　* class 类名 implements 接口名 { }

　　* c：接口不能直接实例化
　　　　* 按照多态的方式来实例化

　　* d：接口的子类

　　　　* a：可以是抽象类，但是意义不大
　　　　* b：可以是具体类，要重写接口中的所有抽象方法

* C：案例演示

　　* 接口特点

class Demo1_Interface {
    public static void main(String[] args) {
        //Inter i = new Inter(); // 接口不能被实例化
        Demo i = new Demo();  // 父类引用指向子类对象
        i.print();
    }
}

interface Inter {
    public abstract void print();  // 抽象方法声明
    
}

class Demo implements Inter {  // 具体类继承
    public void print() {
        System.out.println("print");
    }
}

abstract class Demo2 implements Inter { // 抽象类继承
    
}

接口的成员特点

* A：接口成员特点

　　* 成员变量：只能是常量，并且是静态的、公开的
　　　　* 默认修饰符：public static final   三个关键字可以交换位置
　　　　* 建议：自己手动给出

　　* 构造方法：接口没有构造方法

　　* 成员方法：只能是抽象方法
　　　　* 默认修饰符：public abstract
　　　　* 建议：自己手动给出

* B：案例演示

　　* 接口成员的特点

class Demo2_Interface {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.print();
        System.out.println(Inter.num);
    }
}

interface Inter {
    //public Inter() {}  //接口中没有构造方法
    public static final int num = 10;  //接口中的变量都是常量
    //public void print() {}  //接口中不能定义非抽象方法
}

class Demo extends Object implements Inter {  // 构造方法默认继承 Object 的
    public Demo() {
        super();
    }
    
    public void print() {  // 权限不能降低
        //num = 20;  // num 是常量，不能被修改
        System.out.println(num);
    }

}

类与类，类与接口，接口与接口的关系

* A：类与类，类与接口，接口与接口的关系

　　* a：类与类：
　　　　* 继承关系，只能单继承，可以多层继承

　　* b：类与接口：
　　　　* 实现关系，可以单实现，也可以多实现
　　　　* 并且还可以在继承一个类的同时实现多个接口

　　* c：接口与接口
　　　　* 继承关系，可以单继承，也可以多继承

* B：案例演示

　　类与类，类与接口，接口与接口的关系

class Demo3_Interface {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.printA();
        d.printB();
    }
}

interface InterA {
    public abstract void printA();
}

interface InterB {
    public abstract void printA();
}

interface InterC extends InterA, InterB {  // 接口之间可以多继承

}

class Demo implements InterC {    // 类可以多实现
    public void printA() {
        System.out.println("A");
    }

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

抽象类和接口的区别

* A：成员区别

　　* 抽象类：
　　　　* 成员变量：可以是变量，也可以是常量
　　　　* 构造方法：有
　　　　* 成员方法：可以抽象，也可以非抽象

　　* 接口：
　　　　* 成员变量：只可以是常量
　　　　* 构造方法：无
　　　　* 成员方法：只可以是抽象

* B：关系区别
　　* 类与类
　　　　* 继承，单继承

　　* 类与接口
　　　　* 实现，单实现，多实现

　　* 接口与接口
　　　　* 继承，单继承，多继承

* C：设计理念区别
　　* 抽象类    被继承体现的是：“is a ”     的关系。 抽象类中定义的是该继承体系的共性功能
　　* 接口        被实现体现的是：“like a ”  的关系。 接口中定义的是该继承体系的扩展功能