面向对象·四级

多态的概述及其代码实现

* 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 ” 的关系。接口中定义的是该继承体系的扩展功能

巴特西

Java 面向对象 04

面向对象·四级

多态的概述及其代码实现

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

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

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

向上转型和向下转型

多态的好处和弊端

多态题目分析 1

多态题目分析2

抽象类的概述及其特点

抽象类的成员特点

抽象类中的面试题

接口的概述及其特点

接口的成员特点

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

抽象类和接口的区别

最新文章

热门文章