Java基础---认识多态

多态

1.概念：一个事物具有多种状态 polymorphic
  对象的多态性：同一个对象，可以具有不同的名称，同一个对象，有不同的类
              型的引用指向他。本质：同一个物体，有不同的名称和描述。
  类型的多态性：同一个类型，可以有不同的子类实现。本质：同一个名字和描
              述，在不同的场景有不同的真实实现。
2.多态的前提：
  要有子父类的继承关系，实现关系
  要有方法的重写
  父类引用指向子类对象

多态种成员变量的访问特点

编译看左边，运行看左边
编译时，看=左边的引用类型中是否有该变量的定义
运行时，看=左边的引用类型中该变量的赋值

多态种成员方法的访问特点

编译看左边，运行看右边
编译时，看=左边的引用类型中是否有该方法的定义，如果有，编译成功，如果没有，就编译失败。
运行时，看=右边的对象类型中是如何实现该方法的，运行结果是子类中重写后的方法实现

向上向下转型

向上转型：
   子类引用指向子类对象----正常情况
   父类引用指向子类对象----向上转型
缩小了对象的访问权限，只能访问父类中定义的内容。
向下转型：
   让子类对象的父类引用恢复成子类引用
   子类类型  引用名称 = （子类类型）父类引用名称
恢复了子类类型原本就有的访问范围

package com.DaYu;

public class Demo01 {
	public static void main(String[] args) {
		Animal_1 an = new Dog_1();
		//多态中访问成员变量
		System.out.println(an.name);//动物   结果看左边，即父类
//		System.out.println(an.sex); //父类中没有sex属性，所以访问不了
		
		//多态中访问成员方法   编译看左边，运行看右边
		an.eat();// 狗吃肉    结果看右边
//		an.sleep(); //无法访问子类中特有的方法
		
        //向下转型
		Dog_1 d1 = (Dog_1)an;
		System.out.println(d1.name);//小狗
		System.out.println(d1.sex);//公
		d1.eat();//狗吃肉
		d1.sleep();//睡觉
	}	
}

class Animal_1 {
	String name = "动物";
	int age = 4;

	public void eat() {
		System.out.println("吃东西");
	}
}

class Dog_1 extends Animal_1 {
	String name = "小狗";
	String sex = "公";

	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
	//子类中特有的方法
	public void sleep() {
		System.out.println("睡觉");
	}
}

多态的好处

1.提高的代码的可扩展性
2.忽视了子类类型之间的差异
     在方法的参数列表中，可以定义父类类型的引用，将来调用方法的时候，所有子类类型的对象，都可以作为实际参数。
     在方法体中，使用父类类型的引用指向子类的对象，也能提高代码的扩展性，代码编译阶段，无法知道对象的具体的子类类型，
     需要使用父类引用，操作不知道子类类型的数据。

package com.DaYu;

import java.util.Scanner;

public class Demo02 {
	public static void main(String[] args) {
		JuiceMachine  jm = new JuiceMachine();

		Apple a = new Apple();
		jm.makeJuice(a);
				
		WaterMelon wm = new WaterMelon();
		jm.makeJuice(wm);
		
		Fruit fruit = new Apple();
		jm.makeJuice(fruit);
		Fruit fruit1 = new Orange();
		jm.makeJuice(fruit1);
	
	}
}
class JuiceMachine {
//参数为父类引用，免去了定义以各种水果为参数的繁琐
	public void makeJuice(Fruit fruit) {
		fruit.flow();
	}

}

class Fruit{
	public void flow() {
		System.out.println("流出果汁");
	}
}


class Apple extends Fruit{
	public void flow() {
		System.out.println("流出苹果汁");
	}
}

class WaterMelon extends Fruit{
	public void flow() {
		System.out.println("流出西瓜汁");
	}
}

class Orange extends Fruit{
	public void flow() {
		System.out.println("流出橙子汁");
	}
}

package com.DaYu;
public class Demo1 {
 public static void main(String[] args) {
 int a = 50;
 
 Animal animal = getAnimal(a);//父类引用指向子类对象 忽视了子类之间的差异 
 
 }
 
 public static Animal getAnimal(int money) {
 if (money>0&&money<=20) {
 return new Dog();
 }else if ( money<=30) {
 return new Cat();
 }else if (money<=50) {
 return new Duck();
 }else {
 return new Sheep();
 }
 } }
//定义一个动物类
class Animal {
 
}
// 定义一个狗类 继承 动物类
class Dog extends Animal {
 
}
//定义一个猫类 继承 动物类
class Cat extends Animal {
}

class Sheep extends Animal{
 
}

class Duck extends Animal{
 
}