JAVA基础之多态

[b]一、概念[/b]
对象的多种形态
1.引用多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象（反过来是不允许的）
示例：
按照之前的文章创建 父类Animal和子类Dog
在主函数中创建对象的时候我们可以如下创建：

public class Control {
	public static void main(String[] args) {
	//父类的引用指向本类的对象
	Animal obj1=new Animal();
	//父类的引用指向子类的对象
	Animal obj2=new Dog();
	}
}

2.方法多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法，但是不能调用子类独有的方法

//创建父类
public class Animal {
	public void eat(){
		System.out.println("动物具有吃的能力");
	}
}

//创建子类，继承父类
public class Dog extends Animal {
	public void eat(){
		System.out.println("狗是吃骨头的");
	}
        //子类独有的方法
	public void watchDoor(){
		System.out.println("狗可以看门");
	}
}

//控制类
public class Control {
	public static void main(String[] args) {
	//父类的引用指向本类的对象
	Animal obj1=new Animal();
	//父类的引用指向子类的对象
	Animal obj2=new Dog();
	//执行本类方法
	obj1.eat();
	//执行子类方法
	obj2.eat();
	}
}

运行结果：
动物具有吃的能力
狗是吃骨头的
[b]二、引用类型转换[/b]
1.向上类型转换（隐式/自动类型转换），小类型到大类型的转换
2.向下类型转换（强制类型转换），大类型到小类型的转换
3.instanceof运算符，可以解决引用对象类型时，避免出现类型转换的安全性问题

public class Control {
	public static void main(String[] args) {
	Dog dog1=new Dog();
	Animal animal=dog1;//自动类型提升
	//instanceof判断animal是否是Dog类的对象
	if(animal instanceof Dog){
		Dog dog2=(Dog)animal;//强制类型转换
	}else{
		System.out.println("无法进行类型转换");
	}
	}
}

[b]三、抽象类[/b]
1.语法
定义的时候 用abstract关键字修饰
2.应用场景：
a.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
b.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意行。
3.作用
限制规定子类必须实现某些方法，但不关注实现细节
4.使用规则
a.abstract定义抽象类
b.abstract定义抽象方法，只有声明，不需要实现，但是继承的子类必须实现
抽象方法没有方法体，以分号结束
c.包含抽象方法的类是抽象类
d.抽象类中可以包含普通的方法，也可以没有抽象方法
e.抽象类不能直接创建，可以定义引用变量

//创建抽象父类
public abstract class Animal {
	public abstract void eat();
	public abstract void function();
}

//创建子类，继承父类
public class Dog extends Animal {
	public void eat(){
		System.out.println("狗是吃骨头的");
	}
	public void function() {
		System.out.println("狗可以看门");
	}
}

//创建子类，继承父类
public class Cat extends Animal{
	public void eat(){
		System.out.println("猫是吃鱼的");
	}
	public void function() {
		System.out.println("猫可以抓老鼠");
	}
}

//控制类
public class Control {
	public static void main(String[] args) {
		Dog dog=new Dog();
		Cat cat=new Cat();
		dog.eat();
		dog.function();
		cat.eat();
		cat.function();
	}
}

运行结果：
狗是吃骨头的
狗可以看门
猫是吃鱼的
猫可以抓老鼠
[b]四、接口[/b]
1.概念
接口可以理解为一种特殊的类，由全局变量和公共的抽象方法所组成。
接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
2.语法
修饰符 interface 接口名[extends 父接口1，父接口2]{
零个到多个常量定义
零个到多个抽象方法的定义
}
接口是要被继承和实现的，一般修饰符是public
java里面的类是单继承的，但是接口是多继承的
接口中的属性是常量，即使定义时不添加public static final修饰符，系统也会自动加上
方法同理，会有public abstract修饰符
3.使用接口
一个类可以实现一个或多个接口，实现接口使用implements关键字。
如：
修饰符 class 类名 extends 父类 implements 接口1，接口2...{
如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法
}

//创建接口
public interface Iplay {
	public void play();
}

//实现接口的类Dog
public class Dog extends Animal implements Iplay {
	public void eat(){
		System.out.println("狗是吃骨头的");
	}
	public void function() {
		System.out.println("狗可以看门");
	}
	public void play() {
		System.out.println("主人可以带它出去玩");
	}
}

//控制类
public class Control {
	public static void main(String[] args) {
		//接口引用指向实现了接口的类
		Iplay p1=new Dog();
		Iplay p2=new Bike();
		p1.play();
		p2.play();
	}
}

运行结果：
主人可以带它出去玩
主人可以带它出去玩