【Java多态&转型 10】
一、转型
1、向上转型：父类-->子类，自动类型转换
向下转型：子类-->父类，强制类型转换，在前面加（数据类型）
2、转型必须是有继承关系，否则不能进行转型
3、转型的两个阶段：
编译阶段：静态加载 (引用部分就是编译阶段)
运行阶段：动态加载 （创建对象就是运行阶段）
例如：Animal a1 = new Cat(); Animal a1是编译阶段，new Cat()是运行阶段 这种情况就叫”多态“
4、向上转型，只要编译没问题，运行都能通过
向下转型，编译没有问题，也有可能会报：java.lang.ClassCastException异常
原因： 父类的引用指向了其中一个子类的对象，此引用又强制转换成没有指向的子类类型，就会报异常
解决方案：采用instanceof运算符，此运算符是一个boolean类型
语法：（引用 instanceof 类型）
例如：（a instanceof Cat）
如果结果是true，表示a引用指向的堆中的java对象是Cat类型
如果结果不是true，表示a引用指向的堆中的java对象不是Cat类型
package com.JavaStudy.study0429; /** 方法覆盖 */ public class Animal { public void move(){ System.out.println("动物在移动！"); } }
package com.JavaStudy.study0429; public class BackCat extends Cat{ public void move(){ System.out.println("黑猫警长在移动！"); } }
package com.JavaStudy.study0429; public class Cat extends Animal { @Override //注解，作用是校验是否满足当前的语言 public void move(){//方法覆盖发生在继承类内，并且方法名，类型都相同 System.out.println("猫在移动！"); } public void fly(){ System.out.println("猫不会飞！"); } }
package com.JavaStudy.study0429; public class Test1 { public static void main(String[] args){ Animal a1 = new Cat(); a1.move();//自动类型转型（向上转型） Cat a2 = (Cat)a1;//强制类型转型（向下转型） a2.fly(); BackCat a3 = (BackCat) a1;//指向Cat的引用，强制转型为BackCat的引用，会报java.lang.ClassCastException异常 if(a1 instanceof Cat){//java中规范要求在做任何强制类型转换之前都需要用instanceof运算符 BackCat a4 = (BackCat) a1; }//判断a1指向Cat类型，执行结果为false，所以会报异常 if(a1 instanceof BackCat){ BackCat a5 = (BackCat)a1; }//判断a1指向BackCat对象，执行结果为true，所以不会报异常 } }
例2：
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Animal { public void eat(){ System.out.println("Animal eat!"); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Bird extends Animal{ public void eat(){ System.out.println("Bird eat!!!"); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Cat extends Animal{ public void eat(){ System.out.println("Cat eat!"); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Dog extends Animal{ public void eat(){ System.out.println("Dog eat"); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Fish extends Animal{ public void eat(){ System.out.println("Fish eat"); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:19 */ public class Person { // public void feed(Bird b){ // b.eat(); // } // // public void feed(Cat c){ // c.eat(); // } // // public void feed(Dog d){ // d.eat(); // } // // public void feed(Fish f){ // f.eat(); // } /* 多态的一个好处：降低耦合性，提高扩展性 */ public void feed(Animal a){ //父类的对象引用 a.eat(); } }
package com.JavaStudy.study0508; /** * @Author wufq * @Date 2020/5/8 16:20 */ public class Test { public static void main(String[] args){ //创建宠物 Bird b = new Bird(); Cat c = new Cat(); Dog d = new Dog(); Fish f = new Fish(); //创建主人 Person p = new Person(); //喂养 p.feed(b);//传入子类的对象引用，这样在执行的时候，就发生了多态（Animal a = new Bird();） p.feed(c); p.feed(d); p.feed(f); } }
二、运用多态说明私有方法和静态方法不能覆盖
私有方法
package com.JavaStudy.study0508New; /** * @Author wufq * @Date 2020/5/8 17:46 */ public class A { //私有方法 private void m1(){ System.out.println("A 中的m1方法被调用！"); } public static void main(String[] args){ A a = new B(); a.m1(); } } class B extends A{ public void m1(){ System.out.println("B 中的m1方法被调用！"); } } /* 假设私有方法可以进行覆盖，那么多态调用m1方法后，应该打印：B 中的m1方法被调用！ 实际打印：A 中的m1方法被调用！ 说明：私有方法不能被覆盖 */
静态方法
