Java开发必备点09

Java开发必备点09"/>

Java开发必备点09

面向对象三大特性之多态

引出案例

Java是强类型语言  变量的类型  和  数据的类型  一致
案例：
public class Demo{public static void main(String[] args) {//声明一个动物类的引用  创建一个狗的对象放到动物类的引用中Animal a = new Dog();    }}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//叫public void shout() {System.out.println("狗叫");}
}

多态概念

概念：父类引用指向子类对象
你认为他是什么-----引用
他真正的是什么-----子类的对象继承是多态的前提

多态的特点

编译时多态

编译时多态：在编译时只能调用引用类型所对应类中声明的方法  //没有打开箱子
案例：
public class Demo{public static void main(String[] args) {//声明一个动物类的引用  创建一个狗的对象放到动物类的引用中Animal a = new Dog();a.eat();a.sleep();a.shout(); //编译报错  }}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//叫public void shout() {System.out.println("狗叫");}
}案例：证明 在编译的时候不能确定引用中所放的数据类型
import java.util.*;
public class Demo{public static void main(String[] args) {Scanner s = new Scanner(System.in);int i = s.nextInt();Animal a ;if (i%2==0) {a = "ashjlfa"} else {a = new Cat();}//声明一个动物类的引用  创建一个狗的对象放到动物类的引用中/*Animal a = new Dog();a.eat();a.sleep();a.shout();  */ }}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{}

运行时多态

运行时多态：在多态发生时，运行时调用的是子类覆盖父类后的方法  //当打开箱子时 调用的方法时 里边存放的对象的方法
案例：
import java.util.*;
public class Demo{public static void main(String[] args) {//声明一个动物类的引用  创建一个狗的对象放到动物类的引用中Animal a = new Dog();a.eat();a.sleep();}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}public void sleep() {System.out.println("狗趴着睡");  }//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}

对象一旦创建 对象的类型是不可变的

案例：
import java.util.*;
public class Demo{public static void main(String[] args) {//声明一个动物类的引用  创建一个狗的对象放到动物类的引用中/*Animal a1 = new Dog();a1.eat();a1.sleep();Animal a2 = new Cat();a2.eat();a2.sleep();*/Cat c = new Dog();//编译报错}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}

向上转型

将子类的引用赋值给父类引用案例：
import java.util.*;
public class Demo{public static void main(String[] args) {Dog d = new Dog();Animal a = d;}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}

向下转型

将父类的引用 赋值给子类的引用当多态发生时，想调用子类特有的方法时，需要将父类的引用向下转型为子类的引用，但是可能失败向下转型时可能会失败，如果对象的类型和引用的类型不兼容 那么会报  类型转换异常 ClassCastException
案例：
import java.util.*;
public class Demo{public static void main(String[] args) {Animal a = new Cat();Dog d = (Dog)a;d.eat();}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}//需求 我要调用狗中shout（）案例：
import java.util.*;
public class Demo{public static void main(String[] args) {Animal a = new ErHa();Dog d =(Dog)a;d.eat();d.sleep();d.fanEr();}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}
class ErHa extends Dog{public void eat() {System.out.println("二哈");    }public void sleep() {System.out.println(" 二哈");  }public void fanEr() {System.out.println("犯二");}}总结：编译看左边  运行看右边

两个没有继承关系的类 引用之间是否可以转换

两个没有继承关系的类  引用之间是不可以转换的  因为对象的类型是不可变的  即使强转也不成功 编译也不通过
案例：
import java.util.*;
public class Demo{public static void main(String[] args) {Cat c = new Cat();Dog d = (Dog)c;}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{public void eat() {System.out.println("猫喵喵的吃鱼");    }public void sleep() {System.out.println(" 猫妩媚的睡");  }
}
class ErHa extends Dog{public void eat() {System.out.println("二哈");    }public void sleep() {System.out.println(" 二哈");  }public void fanEr() {System.out.println("犯二");  } 
}

instanceof语句

语句语法：
父类引用  instanceof  子类类名
结果是 boolean
案例：
import java.util.*;
public class Demo{public static void main(String[] args) {//Animal a = new Dog();Animal a = new Cat();if(a instanceof Dog){Dog d = (Dog)a;d.eat();d.sleep();d.shout();}else{a.eat();a.sleep();}}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{}案例：
import java.util.*;
public class Demo{public static void main(String[] args) {//Animal a = new Dog();Animal a = new Cat();Dog a = new Dog();//Cat c = new Cat();if(c instanceof Dog){Dog d = (Dog)c;d.eat();d.sleep();d.shout();}else{c.eat();c.sleep();}}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//定义一个 狗类 继承  动物类  叫
class Dog extends Animal{//重写 吃和睡public void eat() {System.out.println("狗舔着吃屎");}//叫public void shout() {System.out.println("狗叫");}
}class Cat extends Animal{}

多态的应用

多态用在数组中

案例： 有   狗  猫 羊 猴子  老虎    继承 动物类 import java.util.*;
public class Demo{public static void main(String[] args) {//分别创建子类的对象  调用吃的方法/*Dog d = new Dog();Cat c = new Cat();Sheep s = new Sheep();Monkey m = new Monkey();Tiger t = new Tiger();d.eat();c.eat();s.eat();m.eat();t.eat();*/Animal[]  animals = {new Dog(),new Cat(),new Sheep(),new Monkey(),new Tiger()};//遍历for(int i = 0;i<animals.length;i++){animals[i].eat();animals[i].sleep();           }}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//狗
class Dog extends Animal{public void eat() {System.out.println("狗吃骨头");    }}
//羊
class Sheep extends Animal{public void eat() {System.out.println("羊吃草");    }}
//猫
class Cat extends Animal{public void eat() {System.out.println("猫吃鱼");    }}
//猴子
class Monkey extends Animal{public void eat() {System.out.println("猴子吃桃");    }  
}
//老虎
class Tiger extends Animal{public void eat() {System.out.println("老虎吃羊");    }
}

多态用在方法的参数上

能够提高方法的通用性
案例：
import java.util.*;
public class Demo{public static void main(String[] args) {//分别创建子类的对象  调用吃的方法/*Dog d = new Dog();Cat c = new Cat();Sheep s = new Sheep();Monkey m = new Monkey();Tiger t = new Tiger();*/useEat(new Dog());useEat(c);useEat(s);useEat(m);useEat(t);}public static void useEat(Animal a) {a.eat();}}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//狗
class Dog extends Animal{public void eat() {System.out.println("狗吃骨头");    }}
//羊
class Sheep extends Animal{public void eat() {System.out.println("羊吃草");    }}
//猫
class Cat extends Animal{public void eat() {System.out.println("猫吃鱼");    }}
//猴子
class Monkey extends Animal{public void eat() {System.out.println("猴子吃桃");    }}
//老虎
class Tiger extends Animal{public void eat() {System.out.println("老虎吃羊");    }
}class Chick extends Animal{}

多态用在方法的返回值类型上

案例：
import java.util.*;
public class Demo{public static void main(String[] args) {/*定义一个方法  功能卖动物 如果给 50  给你  猫如果   100  狗如果   2000  羊  如果   3000  猴如果   大于10000 老虎其他情况     小鸡 *///参数  double Scanner s = new Scanner(System.in);System.out.println("请输入钱数：");double d = s.nextDouble();Animal a =  sellAnimal(d);a.eat();}public static Animal sellAnimal(double d) {if (d==50) {return new Cat();} else if (d==100) {return new Dog();}else if (d==2000) {return  new Sheep();} else if (d==3000) {return new Monkey();} else if (d>10000) {return new Tiger();}else{return new Chick();} }}class Animal{public void eat() {System.out.println("动物吃");    }public void sleep() {System.out.println("动物睡");  }}//狗
class Dog extends Animal{public void eat() {System.out.println("狗吃骨头");    }}
//羊
class Sheep extends Animal{public void eat() {System.out.println("羊吃草");    }}
//猫
class Cat extends Animal{public void eat() {System.out.println("猫吃鱼");    }}
//猴子
class Monkey extends Animal{public void eat() {System.out.println("猴子吃桃");    }}
//老虎
class Tiger extends Animal{public void eat() {System.out.println("老虎吃羊");    }}
class  Chick extends Animal{public void eat() {System.out.println("小鸡吃霍冠霖");    }
}

多态的好处

1.屏蔽子类之间的差异性 
2.增强了方法的通用性
3.利于程序的扩展