java-多态（概念、扩展、转型、示例、多态中成员的特点、）

多态： 可以理解为事物存在的多种体现形态。
人： 男人，女人。
动物： 猫，狗。

猫 x=new 猫();

动物 x=new 猫();//实体类还可以具备其他类型，也就是事物的多种形态

多态如何应用？
 1.多态的体现

            父类的引用指向了自己的子类对象。

           父类的引用也可以接收自己的子类对象。
 2.多态的前提

            必须是类与类之间有关系，要么是继承、要么是实现。

           通常还有一个前提就是存在覆盖。
 3.多态的好处

            多态的出现大大地提高了代码的扩展性。

4.多态的弊端：

          提高了扩展性，但是只能使用父类的引用访问父类中的·成员。；；
 4.多态的应用

（二）：多态的扩展：

/*class Animal{
	void eat(){}
}
*/

abstract class Animal//不确定动物吃什么，用抽象类
{
	abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}


public class aaaa {
	public static void main(String [] args)
	{
		Cat c=new Cat();
		c.eat();
		
		Dog d=new Dog();
		d.eat();
	}
} 

/*

控制台输出结果：

吃鱼
吃骨头

*/

/*
 * 动物：猫，狗。
 */

/*class Animal{
	void eat(){}
}
*/

abstract class Animal//不确定动物吃什么，用抽象类
{
	abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}


public class aaaa {
	public static void main(String [] args)
	{
		/*Cat c=new Cat();
		c.eat();
		
		Dog d=new Dog();
		d.eat();
		*/
		Cat c=new Cat();
		Cat c1=new Cat();
		fun(c1);//提高代码的复用性
		fun(new Dog());//不需要去修改，因为是“重载”。
	}
	public static void fun(Cat c){
		c.eat();
	}
	public static void fun(Dog d)
	{
		d.eat();
	}
} 

/*
控制台输出结果：
吃鱼
吃骨头

*/

/*
 * 动物：猫，狗。
 */

/*class Animal{
	void eat(){}
}
*/

abstract class Animal//不确定动物吃什么，用抽象类
{
	abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}

class Pig extends Animal{
	public void eat(){
		System.out.println("饲料");
	}
	public void GongDi(){
		System.out.println("gongdi");
	}
}

public class aaaa {
	public static void main(String [] args)
	{
		/*Cat c=new Cat();
		c.eat();
		
		Dog d=new Dog();
		d.eat();
		*/
		Cat c=new Cat();
		Cat c1=new Cat();
		fun(c1);//提高代码的复用性
		fun(new Dog());//不需要去修改，因为是“重载”。
		fun(new Pig());
	}
	public static void fun(Cat c){
		c.eat();
	}
	public static void fun(Dog d)
	{
		d.eat();
	}
	public static void fun(Pig p)
	{
		p.eat();
	}
} 

吃鱼
吃骨头
饲料

//多态的表现
Animal c=new Cat();
c.eat();

Cat d=new Cat();
d.eat();

abstract class Animal//不确定动物吃什么，用抽象类
{
	abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}

class Pig extends Animal{
	public void eat(){
		System.out.println("饲料");
	}
	public void GongDi(){
		System.out.println("gongdi");
	}
}

public class aaaa {
	public static void main(String [] args)
	{
		/*Cat c=new Cat();
		c.eat();
		
		Dog d=new Dog();
		d.eat();
		*/
		/*Cat c=new Cat();
		Cat c1=new Cat();
		fun(c1);//提高代码的复用性
		fun(new Dog());//不需要去修改，因为是“重载”。
		fun(new Pig());
		*/
		
		//多态的表现
		//Animal c=new Cat();
		//c.eat();
		
		//Cat d=new Cat();
		//d.eat();
		
		function(new Cat());
		function(new Dog());
	}
	//提高代码的扩展性：
	public static void function(Animal a)//Animal a=new Cat();
	{
		a.eat();
	}
	/*public static void fun(Cat c){
		c.eat();
	}
	public static void fun(Dog d)
	{
		d.eat();
	}
	public static void fun(Pig p)
	{
		p.eat();
	}
	*/
} 


控制台输出结果：
吃鱼
吃骨头

（三）多态的转型：

abstract class Animal//不确定动物吃什么，用抽象类
{
	abstract void eat();
}
class Cat extends Animal{
	public void eat(){
		System.out.println("吃鱼");
	}
	public void catchMouse(){
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal{
	public void eat(){
		System.out.println("吃骨头");
	}
	public void KanJia(){
		System.out.println("看家");
	}
}

class Pig extends Animal{
	public void eat(){
		System.out.println("饲料");
	}
	public void GongDi(){
		System.out.println("gongdi");
	}
}

public class aaaa {
	public static void main(String [] args)
	{
		Animal a=new Cat();//类型提升,把猫提升为了动物，也就是向上转型
		a.eat();
		
		//如果想要调用猫的特有方法是，如何提升？
		//强制将父类的引用，转成子类类型，向下转型
		Cat c=(Cat)a;
		c.catchMouse();
	}
	public static void function(Animal a)//Animal a=new Cat();
	{
		a.eat();
	}
} 



控制台输出结果：
吃鱼
抓老鼠

两种类型的类型转换：
（1）：向上类型转换（Upcast）：将子类型转换为父类型：
       对向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。
       //向上类型转换
        Cat cat = new Cat();
        Animal animal = cat;
        animal.sing();
（2）：向下类型转换（Downcast）:将父类型转换为子类型：
       对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换。
       //向下类型转换
        Animal a = new Cat();
        Cat c = (Cat)a;
        c.sing();
        c.eat();
千万不要出现这样的情况，就是将父类对象转成子类类型。

我们能转换的是父类引用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。

多态自始至终都是子类对象在做着变化。

（四）多态的示例：

//多态示例代码

public class aaaa
{
    public static void main(String[] args)
    {
        
        //向上类型转换
        Cat cat = new Cat();
        Animal animal = cat;
        animal.sing();

                
        //向下类型转换
        Animal a = new Cat();
        Cat c = (Cat)a;
        c.sing();
        c.eat();


        //编译错误
        //用父类引用调用父类不存在的方法
        //Animal a1 = new Cat();
        //a1.eat();
        
        //编译错误
        //向下类型转换时只能转向指向的对象类型        
        //Animal a2 = new Cat();
        //Cat c2 = (Dog)a2;
    }
}
class Animal
{
    public void sing()
    {
        System.out.println("Animal is singing!");
    }
}
class Dog extends Animal
{
    public void sing()
    {
        System.out.println("Dog is singing!");
    }
}
class Cat extends Animal
{
    public void sing()
    {
        System.out.println("Cat is singing!");
    }
    public void eat()
    {
        System.out.println("Cat is eating!");
    }
}

/*
控制台输出结果：
Cat is singing!
Cat is singing!
Cat is eating!

*/