Java基础8---面向对象之多态、抽象类、接口

一、多态polymorphic

1.多态的前提

• 要有继承关系。
• 要有方法重写。
• 要有父类引用指向子类对象。

2.多态中的成员访问特点

1）成员变量

编译看左边(父类)，运行看左边(父类)。

//多态：成员变量的访问
public class Polymorphic_Demo {
    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;
}

2）成员方法

编译看左边(父类)，运行看右边(子类)。也叫动态绑定

//多态：动态绑定
public class Polymorphic_Demo2 {
    public static void main(String[] args) {
        Father f = new Son();
        f.lu();

        Son s = new Son();
        s.lu();
    }
}

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

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

3）静态成员方法

编译看左边(父类)，运行看左边(父类)。

• (静态和类相关，算不上重写，所以，访问还是左边的)
• 只有非静态的成员方法,编译看左边,运行看右边

二、多态中向上转型和向下转型

Person p = new DongShuai();向上转型
DongShuai ds = (DongShuai)p;向下转型

三、多态的好处和弊端

• 多态的好处
  
  • a:提高了代码的维护性(继承保证)
  • b:提高了代码的扩展性(由多态保证)
• 多态的弊端
  
  • 不能使用子类的特有属性和行为。

四、抽象类

1.抽象类和抽象方法必须用abstract关键字修饰

• abstract class className {}
• public abstract void watchAV();

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

3.抽象类不能实例化

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

4.抽象类的子类

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

5.抽象类的成员特点

• 成员变量：既可以是变量，也可以是常量。abstract不能修饰成员变量
• 构造方法：有。用于子类访问父类数据的初始化。
• 成员方法：既可以是抽象的，也可以是非抽象的。
  抽象类的成员方法特性：
  
  • 抽象方法 强制要求子类做的事情。
  • 非抽象方法 子类继承的事情，提高代码复用性

public class Abstract_Test {
    public static void main(String[] args) {
        DongShuai ds = new DongShuai("dongshuai",23);
        ds.teach();
    }
}

abstract class Teacher {
    String name;
    int age;
    public Teacher() {}
    public Teacher(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int age() {
        return age;
    }

    public abstract void teach();
}

class DongShuai extends Teacher {
    public DongShuai(String name,int age) {
        super(name,age);
    }

    public void teach() {
        System.out.println(name + " " + age + " : " + "去山区支教");
    }
}

6.抽象类中的面试题

• 题1
  一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?可以，这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
• 题2
  abstract不能和哪些关键字共存？private, static, final

五、接口的概述及其特点

      用关键字interface表示 ，从狭义的角度讲就是指java中的interface，从广义的角度讲对外提供规则的都是接口 。类实现接口用implements表示。

1.接口不能实例化，需要按照多态的方式来实例化。

2.接口的子类，可以是抽象类。但是意义不大。也可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

3.接口的成员特点

• 接口成员特点
  
  • 成员变量；只能是常量，并且是静态的并公共的。
    
    • 默认修饰符：public static final
    • 建议：自己手动给出。
  • 构造方法：接口没有构造方法。
  • 成员方法：只能是抽象方法。
    
    • 默认修饰符：public abstract
    • 建议：自己手动给出。

public class Interface_Test {
    public static void main(String[] args) {
        DongShuai ds = new DongShuai(123);
        ds.circleArea();
    }
}

interface Inter {
    //public static final double PI = 3.1415926;
    double PI = 3.1415926;
    //public abstract void circleArea();
    void circleArea();
}

class DongShuai implements Inter {
    private double r;
    public DongShuai(double r) {
        this.r = r;
    }
    public void circleArea() {
        System.out.println("面积是：" + 2 * PI * r * r);
    }
}

4.类与类,类与接口,接口与接口的关系

• 类与类,类与接口,接口与接口的关系

1）类与类：继承关系,只能单继承,可以多层继承。

2）类与接口：实现关系,可以单实现,也可以多实现。并且还可以在继承一个类的同时实现多个接口。

3）接口与接口：继承关系,可以单继承,也可以多继承。

5.抽象类和接口的区别)

1）成员区别

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

2）关系区别

• 类与类
  
  • 继承，单继承
• 类与接口
  
  • 实现，单实现，多实现
• 接口与接口
  
  • 继承，单继承，多继承

3）设计理念区别

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