多态

多态（Polymorphism）按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。

package test;
public class test{
	public static void main(String[] args) {
		Animal z = new Cat();   //多态的体现，父类引用指向子类对象
		z.eat();
	}
}
class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}
}
class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

多态的前提：

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

多态中的成员访问特点

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

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

package test;
public class test{
	public static void main(String[] args) {
		Animal z = new Cat();   //多态的体现,这个就是向上转型
		Cat z1 = (Cat)z; //向下转型，类似强制类型转换
		z.eat();
		z1.eat();
	}
}
class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}
}
class Cat extends Animal {
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

多态的好处。提高了代码的维护性(继承保证)，提高了代码的拓展性(多态保证)。
多态的弊端。不能使用子类特有的属性和行为。
多态题目分析题

看下面程序是否有问题，如果没有，说出结果
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");
	}
}

class Test1Demo {
	public static void main(String[] args) {
		Fu f = new Zi();
		f.method();
		f.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("你");
	}
}
public class Test2DuoTai {
	public static void main(String[] args) {
		A a = new B();
		a.show();
		
		B b = new C();
		b.show();
	}
}

过程:B从A中继承Show方法，所以调用子类的show2。打印’爱’，super.show调用父类的show方法。由于动态绑定。父类又会调用子类的show2方法。打印’你’。

抽象类的概述及其特点

抽象就是看不懂的，抽象类和抽象方法必须用abstract 关键字修饰。

abstract class 类名{}
public abstract void eat();
抽象类不一定要有抽象方法，但是有抽象方法的类一定是抽象类或者接口。
抽象类不能进行实例化，那么抽象类如何实例化呢？按照多态的方法，由具体的子类实例化。
其实这也是多态的一种，抽象类多态。

package test;
abstract class Demo{
	abstract public void Print();
}
class Demo1 extends Demo{
	public void Print() {
		System.out.println("Demo1");
	}
}
public class  test{
	public static void main(String[] args) {
		Demo zDemo = new Demo1();
		zDemo.Print();
	}
}

抽象类的成员特点

成员变量:既能是变量，也能是常量。abstract能修饰成员变量吗？不能，因为属性不存在违背实现的状态，抽象意味着暂时未被实现。
构造方法: 有，用于子类访问父类数据，进行初始化。
成员方法:既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：

抽象方法强制子类要做的事情。
非抽象方法子类继承的事情，提高代码的复用性。

抽象类中的面试题

1.一个抽象类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
可以，这么做的目的只有一个。不让创建本类对象，由子类完成。
2.abstract 不能和那些关键字共存。

不能和static关键字共存，被abstract 修饰的方法没有方法体。没意义
final。abstract强制子类重写。final不许子类重写。
private 被abstract修饰的是为了让子类看到并重写，被private修饰的是为了不让子类看到。这个是矛盾的。

接口的概述及其特点

从狭义的角度讲就是指java中的interface，从广义的角度讲对外提供规则的都是接口。
接口不能实例化，安装多态的方式来实例化。接口的子类可以是抽象类。但是意义不大。
可以是具体类。但是要重写接口中的所有抽象方法。

接口的成员特点

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

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

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

抽象类和接口的区别

抽象类：成员变量：可以变量，也可以常量，构造方法：有，成员方法：可以抽象，也可以非抽象。
接口:成员变量：只可以常量,成员方法：只可以抽象。
设计理念区别。抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

javaSE基础学习day9

文章目录

多态