面向对象（四）：多态；抽象类；接口

面向对象（四）

一、多态

1、多态的概述及格式

	某一个事物，在不同时刻表现出来的不同状态。
	前提：a:要有继承关系;
		 b:要有方法重写;
		 c:要有父类引用指向子类对象。
		      父 f =  new 子();

举例：

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();    //狗属于狗类
        dog.eat();
        System.out.println("--------------------------");
        Animal an = new Dog();  //狗也属于动物类
        an.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
运行结果：
狗吃骨头
--------------------------
狗吃骨头

Process finished with exit code 0

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

A:多态中的成员访问特点
	a:成员变量
		编译看左边，运行看左边。
	b:构造方法
		创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
	c:成员方法
		编译看左边，运行看右边。
	d:静态方法
		编译看左边，运行看左边。
		(静态和类相关，算不上重写，所以，访问还是左边的)

public class Test {
    public static void main(String[] args) {
        //创建子类对象的时候，会先访问父类的构造方法，对父类的数据进行初始化
        Zi zi = new Zi();
        Fu fu = new Zi();
        //成员变量：编译看左边，运行看左边
        System.out.println(zi.num); //左边是zi,就是子类成员变量   打印：100
        System.out.println(fu.num); //左边是fu,就是父类成员变量   打印：10
        //成员方法：编译看左边，运行看右边
        zi.show();
        fu.show();  //父类引用调用方法，运行子类重写过后的方法
    }
}
class Fu {
    int num = 10;
    public Fu() {
        System.out.println("父类构造执行了");
    }
    public void show() {
        System.out.println("fu show");
    }
}
class Zi extends Fu{
    int num=100;
    public Zi() {
        System.out.println("子类构造执行了");
    }
    @Override
    public void show() {
        System.out.println("zi show");
    }
}
运行结果：
父类构造执行了
子类构造执行了
父类构造执行了
子类构造执行了
100
10
zi show
zi show

Process finished with exit code 0

3、多态的利弊

优点：a:提高了代码的维护性(继承保证)
	 b:提高了代码的扩展性(由多态保证) 
弊端：不能使用子类特有的功能
解决办法：把父类的引用强制转换为子类的引用(向下转型)。
	示例：Animal an = new Cat();//多态就是向上转型
		 Cat cat= (Cat) an; //向下转型 将父引用转成他所指向的那个子类型

4、多态的内存图解

二、抽象类

1、抽象类的概述及其特点

概述：在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，则该类必须定义为抽象类。
特点：
	a:抽象类和抽象方法必须用abstract关键字修饰
		抽象类格式:		abstract class 类名 {}
		抽象方法格式:	public abstract void eat();
	b:抽象类不一定有抽象方法，但有抽象方法的类一定是抽象类；
	c:抽象类不能进行实例化,有构造方法,构造方法用于子类访问父类数据时的初始化；
	d:抽象类不能直接实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态；
	e:抽象类的子类，要么是抽象类，要么重写抽象类中的所有抽象方法。

2、抽象类的成员特点

	a:成员变量：既可以是变量，也可以是常量。
	b:构造方法：用于子类访问父类数据的初始化。
	c:成员方法：抽象方法：强制要求子类做的事情。
			  非抽象方法：子类选择继承的事情，提高代码复用性

3、案例演示

	假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
	经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
	然后定义工作的方法.
	请使用继承的思想设计出员工类和经理类。

示例：

public class MyTest {
    public static void main(String[] args) {
        Employee p=new OrdinaryEmployee();
        p.name="张三";
        p.id=1;
        p.sal=3000;
        System.out.println("姓名："+p.name+"；ID："+p.id+"；工资："+p.sal);
        p.work();

        p=new Manager();
        p.name="李四";
        p.id=2;
        p.sal=5000;
        Manager m= (Manager) p;
        m.bonus=1000;
        System.out.println("姓名："+p.name+"；ID："+p.id+"；工资："+p.sal+"；奖金："+m.bonus);
        p.work();
    }
}
//定义抽象类
abstract class Employee {
    int id;
    String name;
    double sal;
    public abstract void work();
}
//定义普通员工类
class OrdinaryEmployee extends Employee {
    @Override   //重写工作方法
    public void work() {
        System.out.println("做一些一线的工作");
    }
}
//定义经理类
class Manager extends Employee {
    double bonus;   //定义经理特有属性
    @Override
    public void work() {
        System.out.println("做管理的工作");
    }
}
运行结果：
姓名：张三；ID：1；工资：3000.0
做一些一线的工作
姓名：李四；ID：2；工资：5000.0；奖金：1000.0
做管理的工作

Process finished with exit code 0

三、接口

1、接口的概述及特点

	概述：接口中定义的是一个继承体系的扩展功能。
	特点：
	a:接口用关键字interface定义		 格式: 	interface 接口名 {}
	b:类实现接口用implements修饰	 格式:	class 类名 implements 接口名 {}
	c:接口不能直接实例化，需要按照多态的方式来实例化；
	d:接口的子类：
		1:可以是抽象类，但是意义不大；
		2:可以是具体类，要重写接口中的所有抽象方法。

2、接口的成员特点

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

3、类与类,类与接口,接口与接口的关系

	a:类与类：
		继承关系,只能单继承,可以多层继承。
	b:类与接口：
		实现关系,可以单实现,也可以多实现。
		并且还可以在继承一个类的同时实现多个接口。
	c:接口与接口：
		继承关系,可以单继承,也可以多继承。

4、示例

public class Test {
    public static void main(String[] args) {
        Animal an = new Cat();
        an.eat();
        Cat cat= (Cat) an;  //向下转型
        cat.jump();
        cat.run();
    }
}
interface HighJump {
    void jump();
}
interface Run{
    void run();
}
//接口可以多继承
interface AA extends HighJump,Run{

}
abstract class Animal {
    public abstract void eat();
}
//一个类在继承另一个类的同时可以实现多个接口
class Cat extends Animal implements HighJump,Run{
    //实现接口HighJump的方法
    @Override
    public void jump() {
        System.out.println("跳高");
    }
    //实现接口Run的方法
    @Override
    public void run() {
        System.out.println("跑");
    }
    //实现抽象类Animal的方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
运行结果：
猫吃鱼
跳高
跑

Process finished with exit code 0