向上转型、向下转型和动态绑定机制

1. 分类：向上转型，向下转型
2. 向上转型： Father f = new Son();（形成指向子类对象的父类引用）
3. 向下转型： Son s = (Son) f;
4. 上面的都是指向Son对象
5. 子类对象不能指向父类对象
   Father f = new Father();
   Son s = (Son)f;//错误
6. 总结：

1、父类引用指向子类对象，而子类引用不能指向父类对象。

2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转换吗，如：

Father f1 = new Son();
3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting)，要强制转换，如：（向上转型后再强制赋给子类引用）

f1 就是一个指向子类对象的父类引用。把f1赋给子类引用 s1 即 Son s1 = (Son)f1;

其中 f1 前面的(Son)必须加上，进行强制转换。

class Animal{
	public void eat(){
		System.out.println("动物吃东西")；		
	}
}
class Bird extends Animal{
	public void eat(){
		System.out.println("鸟儿在吃虫子");
	}
	public void fly(){
		System.out.println("鸟儿在飞");
	}
}
public class Main{
	public static void main(String []args){
		Animal animal = new Bird();//向上转型
		animal.eat();
		//animal.flu();//错误
		Bird bird = (Bird)animal;//向下转型
		bird.eat();
		bird.fly();
		dosleep(new male());
		dosleep(new femal())
	}
	public static void dosleep(Human h){
		h.sleep();
	}
}
public class Human {
  public void sleep() {
    System.out.println("Human sleep..");
  }
}
class Male extends Human {
  @Override
  public void sleep() {
    System.out.println("Male sleep..");
  }
}
class Female extends Human {
  @Override
  public void sleep() {
    System.out.println("Female sleep..");
  }
}

2、向上转型的好处

看上面的代码：

public static void dosleep(Human h) {
h.sleep();
}
这里以父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。不然的话，如果 dosleep 以子类对象为参数，则有多少个子类就需要写多少个函数。这也体现了 JAVA 的抽象编程思想。
二、向下转型。
与向上转型相反，即是把父类对象转为子类对象

public class Girl {
  public void smile(){
    System.out.println("girl smile()...");
  }
}
class MMGirl extends Girl{
  
  @Override
  public void smile() {
    
    System.out.println("MMirl smile sounds sweet...");
  }
  public void c(){
    System.out.println("MMirl c()...");
  }
}
class Mian(){
	public static void main(String []args){
	//向下转型的前提是有向上转型
		Girl girl = new MMGirl();
		girl.smile();
		MMGirl mmg = (MMGirl)girl;
		mmg.smile();
		mmg.c();
		/*Girl g = new Girl();
		MMGirl mmg = (MMGirl) g;//不安全的向下转型,编译无错但会运行会出错
		*/
		
	}
}

**

静态绑定和动态绑定

• 绑定就是将方法调用和所在的类连接起来
• 为了实现多态
• 分类：动态绑定和静态
• 静态：程序运行之前（和普通类一样，美区别）
• 动态: 根据需要绑定（动态产生对象）

    
Human human[] = new Human[5];
for(int i = 0;i < human.length;i++){
	int n = (int)(Math.random()*3);
	switch(n){
		case 0: human[i] = new Chinese();break;
		case 1: human[i] = new American();break;
		case 2:human[i] = new British();break;
	}
}
for(int i = 0;i < human.length;i++){
	human[i].speak();
}

动态产生chinese,american,british 对象