Java开发必备点09_面向对象三大特性之多态

最新推荐文章于 2024-07-31 19:38:21 发布

炳烛之明科技

最新推荐文章于 2024-07-31 19:38:21 发布

阅读量74

点赞数

分类专栏： CoreJava 文章标签： java

本文链接：https://blog.csdn.net/qq_40828705/article/details/117414762

版权

CoreJava 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

面向对象三大特性之多态

引出案例

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.利于程序的扩展

炳烛之明科技

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java开发必备点09_面向对象三大特性之多态

面向对象三大特性之多态引出案例Java是强类型语言变量的类型和数据的类型一致案例：public class Demo{ public static void main(String[] args) { //声明一个动物类的引用创建一个狗的对象放到动物类的引用中 Animal a = new Dog(); } }class Animal{ public void eat() { Syst
复制链接

扫一扫