向上转型于与向下转型理解

 向上转型：子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。

public class Animal {
	public void eat() {
		System.out.println("animal eatting...");
	}
	
}

class Cat extends Animal {

	public void eat() {
		System.out.println("我吃鱼");
		//super.eat();
	}
	
}
class Dog extends Animal {
	public void eat() {
		System.out.println("我吃骨头");
		//super.eat();
	}
	public void run(){
        System.out.println("我会叫，，汪，汪，汪");
    }
}
public class Test{
    public static void main(String[] args) {
		 //Animal animal = new Cat(); //向上转型
	     //animal.eat();
	     //animal = new Dog();
	     //animal.eat();
        eat(new Cat());
		eat(new Dog());
            
	}
     public static void eat(Animal A) {//方法的参数是父类------！！！
		 A.eat();
    }
}

Animal animal = new Cat();将子类对象Cat转化为父类对象Animal。这个时候animal这个引用调用的方法是子类方法。

向下转型

package com.sheepmu;
 class Fruit
  {
	public void myName(){
		System.out.println("我是父类  水果...");
	}
}
 
class Apple extends Fruit
{ 
	@Override
	public void myName() { 
		System.out.println("我是子类  苹果...");
	}


	public void myMore(){
		System.out.println("我是你的小呀小苹果~~~~~~");
	}
}
 
public class Sys{ 
	public static void main(String[] args) { 
		Fruit a=new Apple(); //向上转型
		a.myName();
        //a.myMore();当编译到这里时，会出错，提示编译错误，
        //因为myMore()这个方法是在子类中独有的，父类中并没有。我们的编译器根本不知道你创建的是        
        //什么样的子类对象,所以呢我们需要向下转型。
		
		Apple aa=(Apple)a; //向下转型,编译和运行皆不会出错(正确的)
		aa.myName();//向下转型时调用的是子类的
		aa.myMore();;
		  
		Fruit f=new Fruit();
        Apple aaa=(Apple)f; //-不安全的---向下转型,编译无错但会运行会出错
  		aaa.myName();
  		aaa.myMore(); 
	}
}

多态的优缺点：

• 减少重复代码，使代码变得简洁。
• 提高系统扩展性。

                        

package com.itheima_01;
/*
 *	
 * 	多态的优缺点
 * 		优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性
		缺点：无法直接访问子类特有的成员
 */
public class PoymorphicDemo4 {
	public static void main(String[] args) {
		MiFactory factory = new MiFactory();
		factory.createPhone(new MiNote());
		
		factory.createPhone(new RedMi());
	}

	
}

class MiFactory {
	/*public void createPhone(MiNote mi) {
		mi.call();
	}
	
	public void createPhone(RedMi mi) {
		mi.call();
	}*/
	
	public void createPhone(Phone p) {
		p.call();
	}
	
}

interface Phone {
	public void call();
}

//小米Note
class MiNote implements Phone{
	publicvoid call() {
		System.out.println("小米Note打电话");
	}
}

//红米
class RedMi implements Phone {
	publicvoid call() {
		System.out.println("红米打电话");
	}
}

上边的案例原来是这样的，首先我们定义一个class MiNote（小米类）类，里边有一个打电话的功能方法；然后在定义一个class RedMi（红米类），里边也有一个打电话的功能方法；然后创建一个工厂生产小米手机，红米手机，创建一个方法测试是否能打电话，如果我们的工厂要几十种手机，那我们就得创建几十种测试方法，这样呢就显得代码十分的臃肿不堪。接下来呢我们就进行了改变，我就就抽取了所有手机的一个共性（都能打电话的功能方法）及它都是手机（interface Phone {
                                                                                                                                         public void call();
                                                                                                                                                              }）这样我们工厂里边不管生产什么类型的手机，我都可以调用它去执行测试。这就是多态的优点之一（提高了代码的可扩展性）

 

缺点：无法访问子类特有的成员，由于在编译时，我们的编译器根本不知道你创建的是什么样的子类对象，所以他只能让你访问父类的。