9.Java的多态

0. 面向对象的简介(多态)

• 多态是同一个行为具有多个不同表现形式或形态的能力,
  就像是键盘上同一个按键，不同的程序，执行的结果就会不同。
  比如我们按下 F1 键这个动作：
  如果当前在 PPT 下弹出的就是 PPT 帮助；
  
  在 Windows 下弹出的就是 Windows 帮助和支持。
  

  那么在Java中也是一样，同一个事件发生在不同的对象上会产生不同的结果。
  多态就是同一个接口，使用不同的实例而执行不同操作.

多态的好处：

提高了代码的维护性（继承保证）；提高了代码的扩展性。

• 多态的实现方法

1. 重写继承(父类引用指向子类对象)
2. 抽象类继承
3. 接口

1.重写继承

class Demo1DuoTai {
	public static void main(String[] args) {
		Fu f = new Zi();
		System.out.println(f.num);  //输出:10

		Zi z = new Zi();
		System.out.println(z.num);	//输出:20

		f.print();			//输出:Zi
		f.method();			//输出:Fu static
		Fu.method();		//输出:Fu static
	}
}

class Fu {
	int num = 10;

	public void print() {
		System.out.println("Fu");
	}

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

class Zi extends Fu {
	int num = 20;

	public void print() {
		System.out.println("Zi");
	}

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

Demo1DuoTai代码说明：

在多态中

• 成员变量，静态的成员方法(静态的成员方法不存在覆盖的说法) 都是以父类的值为准。
• 只有非静态的成员方法是 编译看父类运行看子类。

多态一个小分析题

public class Test2DuoTai {
	public static void main(String[] args) {
		B b = new C();  
		b.show(); 		//输出：你
	}			//因为编译看的是B类里面从A继承来的show()方法，
}				//但是运行的时候,看的是C里面的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("你");
	}
}

2.多态中抽象类

• 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

• 1.抽象类规定

  1. 抽象类(必须用abstract修饰)不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

  2. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

  3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

  4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

  5. 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

  6. 对于那些非抽象方法，子类是可以直接使用的。

class Demo1Abstract {
	public static void main(String[] args) {
		Animal a = new Animal();  //java:3: 错误: Animal是抽象的; 无法实例化	

		Cat c = new Cat();  //输出：吃鱼
		c.eat();

		Dog d = new Dog();
		d.eat();		//输出：吃鱼
		d.sleep();		//输出：动物睡觉

		System.out.println(c.num);  //输出：10
	}
}

abstract class Animal {						//抽象类
	int num = 10;
	public abstract void eat();				//抽象方法

	public void sleep() {					//抽象类是不能被实例化(创建对象)
		System.out.println("动物睡觉");
	}

	public Animal() {
		
	}
}

 class Cat extends Animal {
	public Cat(){  //这个是子类调用父类的构造器，不写也是默认存在的！
		super();
	}
	public void eat() {			//因为eat()是Animal中的抽象方法，所以必须重写
		System.out.println("吃鱼");
	}
}

class Dog extends Animal {
	public void eat() {			//因为eat()是Animal中的抽象方法，所以必须重写
		System.out.println("吃肉");
	}
}

• 2.抽象类的面试题：
  A:面试题1
  • 一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
    答：可以， 这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成
    B:面试题2
  • abstract不能和哪些关键字共存
    答： private, static, final. 具体解释如下：
    • private是私有不让子类看到,abstract是抽象就是为了让子类重写,他俩矛盾。
    • 静态修饰的方法,可以直接类名.调用,而类名.调用抽象方法是没有意义的。
    • final是最终的,修饰的方法不让子类重写,而abstract修饰的方法就是为了让子类重写。

3.多态中的接口

1.接口特点

• a:接口用关键字interface表示
  interface 接口名 {}

• b:类实现接口用implements表示
  class 类名 implements 接口名 {}

• c:接口不能实例化, 那么接口如何实例化呢?
  按照多态的方式来实例化。

• d:接口的子类
  a:可以是抽象类。但是意义不大。
  b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

• e: 重写接口方法的权限必须是public。

1.1接口成员特点

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

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

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

class Demo1Interface {
	public static void main(String[] args) {
		DemoE e = new DemoE();
		e.method();    //输出:method
		e.show();		//输出:show
	System.out.println("-------------");
		DemoG d = new DemoG();
		d.method();		//输出:method
		d.show();		//输出:show
	}
}
/*
类与类,类与接口,接口与接口的关系
*/

interface DemoA {
	public void show();
} 

interface DemoB {
	public void method();
}

abstract class DemoC {
	public abstract void print();
}

abstract	class  DemoD extends DemoC {				//类与类之间是继承关系,只能单继承
}
class DemoE implements DemoA,DemoB {		//类与接口直接是实现关系,既可以单实现也可以多实现
	public void show() {
		System.out.println("show");
	}

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

interface DemoF extends DemoA,DemoB{		//接口和接口直接是继承关系,既可以单继承也可以多继承

}

class DemoG implements DemoF {
	public void show() {
		System.out.println("show");
	}

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

2.2 接口和抽象类的区别

• A:成员区别

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

• B:关系区别

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

• C:设计理念区别

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

• 下面来举例：

class Demo5Interface {
	public static void main(String[] args) {
		Dog d = new Dog("八公",30);
		d.eat();
		d.sleep();
		d.jump();

		System.out.println(d.getName() + "," + d.getAge());
	}
}

/*
* A:案例演示
	* 动物类：姓名，年龄，吃饭。
	* 动物培训接口：跳高
*/
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 void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public abstract void eat();

}

interface Jump {
	public void jump();
}

class Dog extends Animal implements Jump {
	public Dog(){}

	public Dog(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("吃肉");
	}	
	}
	public void jump() {//这个跳高就是Dog相对于Animal附加进来的方法
		System.out.println("跳高"); 
	}
}

多态中成员访问特点

如，Fu f= new Zi();//左父类右子类

重点：成员方法，运行时，结果为子类重写的成员方法的结果。

成员变量：编译看左边，运行看左边。
构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
成员方法：编译看左边，运行看右边。（方法重写的意义）
静态方法：编译看左边，运行看左边。静态和类相关，算不上重写，所以访问还是左边的。

注：只要记得继承以及方法重写存在的意义所在，就好理解啦。