Java面向对象--多态

多态：多种形态，是java面向对象最核心的特征，允许不同类的对象对同一个消息作出不同的响应

•编译时多态：设计时多态方法重载

•运行时多态：程序运行时，动态决定调用哪个方法(java中常用)

多态需要满足两个必要条件：
•满足继承关系

•父类引用指向子类对象

---

向上转型：

Animal类：

public class Animal {
	// 属性：昵称、年龄
	private String name;
	private int month;

	// setter getter
	public String getName() {
		return name;
	}

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

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	// 无参构造
	public Animal() {

	}

	// 多参构造
	public Animal(String name, int month) {
		this.setName(name);
		this.setMonth(month);
	}

	// 吃东西方法
	public void eat() {
		System.out.println("动物都有吃东西的能力");
	}

}

Animal子类Cat类：

public class Cat extends Animal {
	// 属性：体重
	private double weight;

	// setter getter
	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}

	// 无参构造
	public Cat() {

	}

	// 带参构造
	public Cat(String name, int month, double weight) {
		super(name, month);
		this.setWeight(weight);

	}

	// 方法：跑动
	public void run() {
		System.out.println("小猫快乐的奔跑");
	}

	// 方法：吃东西(重写父类)
	@Override
	public void eat() {
		System.out.println("猫吃鱼～～");
	}

}

Animal子类Dog类：

public class Dog extends Animal {

	// 属性：性别
	private String sex;

	// setter getter
	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	// 无参构造
	public Dog() {

	}

	// 带参构造
	public Dog(String name, int month, String sex) {
		super(name, month);
		this.setSex(sex);
	}

	// 方法：睡觉
	public void sleep() {
		System.out.println("小狗要午睡");
	}

	// 方法：吃东西(重写父类)
	@Override
	public void eat() {
		System.out.println("小狗吃肉～～");
	}

}

测试代码：
 

public class Test {

	public static void main(String[] args) {
		Animal one = new Animal();
		// 向上转型、隐式转型、自动转型
		// 父类引用指向子类对象,可以调用子类重写父类的方法以及父类派生的方法，
		// 无法调用子类的特有方法
		// 小类转型为大类
		Animal two = new Cat();
		Animal three = new Dog();

		one.eat();
		two.eat();
		// 不能够调用Cat类特有的方法
		// two.run();
		three.eat();
	}

}

输出结果：
 

动物都有吃东西的能力
猫吃鱼～～
小狗吃肉～～

---

向下转型：
测试代码：

package com.imooc.test;

import com.imooc.animal.*;

public class Test {

	public static void main(String[] args) {
		Animal two = new Cat();
		
		//向下转型、强制类型转换
		//子类引用指向父类对象，此处可以进行强转，
		//可以调用子类特有的方法
		//必须满足转型条件才能转换
		Cat temp = (Cat)two;
		temp.eat();
		temp.run();
		
	}

}

输出结果：

猫吃鱼～～
小猫快乐的奔跑

---

instanceof运算符：
用法：用来判断左边的对象是否具有右边类的特征，返回的是布尔值

对象 instanceof 类，左边是对象，右边是类

package com.imooc.test;

import com.imooc.animal.*;

public class Test {

	public static void main(String[] args) {

		Animal two = new Cat();
		// 向下转型、强制类型转换
		// 子类引用指向父类对象，此处可以进行强转，
		// 可以调用子类特有的方法
		// 必须满足转型条件才能转换
		// instanceof运算符：返回true 或 false
		if (two instanceof Cat) {
			Cat temp = (Cat) two;
			temp.eat();
			temp.run();
			System.out.println("two可以转成Cat类型");
		}
		if (two instanceof Dog) {
			Dog temp2 = (Dog) two;
			temp2.eat();
			temp2.sleep();
			System.out.println("two可以转成Dog类型");
		}
		
		if (two instanceof Object) {
			System.out.println("two可以转成Object类型");
		}

	}

}

输出结果：

猫吃鱼～～
小猫快乐的奔跑
two可以转成Cat类型
two可以转成Object类型

---

父类中的静态方法：不允许被子类重写，但是子类可以定义相同名字的方法，这时不属于重写父类方法

	//动物打招呼
	public static void say() {
		System.out.println("动物打招呼");
	}

子类中的静态方法：

	//猫的打招呼
	public static void say() {
		System.out.println("猫咪打招呼");
	}

测试方法：

public class Test {

	public static void main(String[] args) {

		Animal one = new Animal();
		Animal two = new Cat();
		two.say();
       }
}

输出结果：

动物打招呼

如果想调用子类的say()方法，再进行向下转型：

public class Test {

	public static void main(String[] args) {

		Animal two = new Cat();
		two.say();
		Cat cat = (Cat)two;
		cat.say();
        }
}

输出结果：

动物打招呼
猫咪打招呼

---

类型转换综合案例：

创建Master类：
 

public class Master {
	// 喂宠物
	// 喂猫咪：吃完东西后，主人带着去玩线球
	// 喂狗狗：吃完东西后，主人带着去睡觉
	
	
	//方案1：编写方法，传入不同类型的动物，调用不同的方法
	public void feed(Cat cat) {
		cat.eat();
		cat.playBall();
		System.out.println("方案1");
	}

	public void feed(Dog dog) {
		dog.eat();
		dog.sleep();
		System.out.println("方案1");

	}
	
	//方法2:编写方法传入动物的父类，方法中通过类型转换，调用指定子类的方法
	public void feed(Animal animal) {
		if (animal instanceof Cat) {
			Cat temp = (Cat)animal;
			temp.eat();
			temp.playBall();
			System.out.println("方案2");
		}else if(animal instanceof Dog) {
			Dog temp = (Dog)animal;
			temp.ea