2019-05-17 Java学习日记之面向对象_多态&抽象类&接口

Posted 2021-12-01 clqbolg

多态 

多态的概述：

A：多态（polymorphic）

事物存在的多种形态

B：多态前提

a：要有继承关系

b：要有方法重写
c：要有父类引用指向子类对象

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

成员变量：编译看左边（父类），运行看左边（父类）
多态中的成员访问特点之成员方法：
成员方法：编译看左边（父类），运行看右边（子类）
多态中的成员访问特点之静态成员方法：
静态方法：
编译看左边（父类），运行看左边（父类）
（静态和类相关，算不上重写，所以访问还是左边的）
只有非静态的成员方法，编译看左边，运行看右边

多态的好处与弊端：

A：多态的好处

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

B：可以当作形式参数，可以接收任意子类对象

C：多态的弊端

不能使用子类特有属性和行为
多态中的题目分析题：

看下面的题目是否有问题

class A {
    public void show() {
        how2();
    }
    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("你");
    }
}
    public class TestDuoTai(){
    public static void main(String[] args){
        A a = new B();
        a.show();

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

抽象类

抽象类的概述及其特点:

A：概述

抽象就是看不懂的

B：特点

a：抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名 {}
public abstract void eat（）；

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

c：抽象类不能实例化，那么抽象类如何实例化呢？

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

d：抽象类的子类

要么是抽象类
要么重写抽象类中的所有抽象方法

抽象类的成员成员特点：

A：特点

a：成员变量：即可以是变量，也可以是常量。

abstract不能修饰成员变量

b：构造方法：用于子类访问父类数据的初始化

c：成员方法：即可以是抽象的，也可以是非抽象的

B:抽象类的成员方法特性：

a：抽象方法 强制要求子类做的事情

b：非抽象方法 子类继承的事情，提高代码的复用性。

abstract不能和哪些关键字共存

abstract和static

被abstract修饰的方法没有方法体
被static崔氏的可以用类名.调用,但是类名.调用抽象方法是没有意义的

abstract和final

被abstract修饰的方法强制子类重写
被final修饰的不然让子类重写,所以他俩是矛盾的

abstract和private

被abstract修饰的是为了让子类看到并强制重写
被private修饰的不让子类访问,所以他俩是矛盾的

接口

接口的概述及其特点：

A：概述

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

B：特点

a：接口用关键字interface表示

interface 接口名 {}

b：类实现接口用implements表示

class 类名 implements 接口名 {}

c：接口不能被实例化，因为调用抽象方法没有意义

可以按照多态的方式实例化

d：接口的子类

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

接口成员特点：

成员变量：

只能是常量，并且是静态的并公共的
默认修饰符：public static final（最好自己手动给出）
构造方法：接口没有构造方法

成员方法：

只能是抽象方法
默认修饰符：public abstract（最好自己手动给出）

类与类、类与接口、接口与接口的关系：

a：类与类

继承关系，只能单继承，可以多层继承

b：类与接口

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

c：接口与接口

继承关系，可以单继承，也可以多继承

抽象类和接口的区别：

A：成员区别

抽象类：

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

接口：

成员变量：只可以常量

成员方法：只可以抽象

B：关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C：设计理念区别

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

Demo：

class Test_Animal {
    public static void main(String[] args){
        Cat c = new Cat("加菲",8);
        c.eat();
        c.sleep();

        JumpCat js = new  JumpCat("跳高猫",9);
        jc.eat();
        jc.sleep();
        jc.jump();
}

abstract class Animal {
    private String name;                    <!-- 姓名 -->
    private int age;                        <!-- 年龄 -->

    public Animal(){}                        <!-- 空参构造 -->

    public Animal(String name,int age){        <!-- 有参构造 -->

            this.name = name;
            this.age = age;
    }

    public void setName(String name){        <!-- 设置姓名 -->
        this.name = name;
    }

    public String getName(){                <!-- 获取姓名 -->
        return name;
    }

    public void setAge(int age){            <!-- 设置年龄 -->
        this.age = age;
    }

    public String getAge(){                    <!-- 获取年龄 -->
        return age;
    }

    public abstract void eat();                <!-- 吃饭 -->

    public abstract void sleep();            <!-- 睡觉 -->


}
interface Jumping {                            <!-- 跳高接口 -->
    public void jump(){};
}
class Cat extends Animal
{
    public Cat(){}                            <!-- 空参构造 -->

    public Cat(String name,int age){        <!-- 有参构造 -->
        super(name,age);
    }

    public void eat(){                        
        System.out.println("猫吃鱼");
    }
    public void sleep(){
        System.out.println("躺着睡");
    }

}

class JumpCat extends Cat implements Jumping {
    public void jump(){

    public JumpCat(){}                            <!-- 空参构造 -->

    public JumpCat(String name,int age){        <!-- 有参构造 -->
        super(name,age);
    }
    System.out.println("猫跳高");
    }
}