新手小白学JAVA 面向对象之多态

- 日理万妓 2021-09-07 16:50 387阅读 0赞

# 多态 #

## 1. 概念 ##

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

比如，你的女盆友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这个就是生活中多态的体现

再比如，小猫、小狗、小猪我们可以把他们都归纳成小动物，每种小动物都需要吃东西,所以我们可以统一设置他们都必须吃，但是每种小动物的习性不一样，那这个就可以设置成小动物自己特有的功能,多态对象只能调用父类中定义子类中重写的功能,并不能调用子类的特有功能,这样就实现了代码的统一

class Animal{ //1.定义父类Animal
    	....eat(){ syso("吃啥都行")}
    }
    class Cat extends Animal{ //2.1定义子类Cat
    	....eat(){ syso("吃小鱼干")}
    	....jump(){ syso("小猫爱跳")}
    }
    class Dog extends Animal{ //2.2定义子类Dog
    	....eat(){ syso("吃肉骨头")}
    	....run(){ syso("小狗爱跑")}
    }
    main(){ 
    	//3.创建子类对象
    	Cat c = new Cat();//小猫是小猫
    	Dog d = new Dog();//小狗是小狗
    	Pig p = new Pig();//小猪是小猪
    	//4.创建多态对象(父类引用指向子类对象/编译看左边,运行看右边)
    	Animal a1 = new Cat();//小猫是小动物
    	Animal a2 = new Dog();//小狗是小动物
    	a1.eat();//吃小鱼干
    	a2.eat();//吃肉骨
    	//a1.jump();//报错:多态对象把自己看做父类型,不能调用子类特有方法
    	//a2.run();//报错:同上,如果想要调用子类特有功能,就创建子类对象

## 2 . 特点 ##

1.  多态的前提1：是继承
2.  多态的前提2：要有方法的重写
3.  父类引用指向子类对象,如：Animal a = new Cat();
4.  多态中，编译看左边，运行看右边  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]

## 3. 练习：多态入门案例 ##

创建包: cn.tedu.oop  
创建类: TestDemo.java

package cn.tedu.oop;
    /*本类用作多态的入门案例*/
    public class TestDemo { 
        public static void main(String[] args) { 
            //6.创建”纯纯的“对象用于测试
            Animal a = new Animal();
            Cat c = new Cat();
            Dog d = new Dog();
            //7.调用方法进行测试
            a.eat();//小动物Animal吃啥都行~
            c.eat();//小猫爱吃小鱼干~执行的是重写以后的功能
            d.eat();//小狗爱吃肉骨头~执行的是重写以后的功能
            /*2.父类不能调用子类的特有功能*/
            //a.play();
            c.play();//小猫Cat跳的老高啦~,子类可以调用自己的功能
            d.play();//小狗Dog跑的老快啦~,子类可以调用自己的功能
    
            //8.创建多态对象进行测试
            /*3.口诀1：父类引用指向子类对象 * 解释：创建出来的子类对象的地址值交给父类类型的引用类型变量来保存*/
            Animal a2 = new Cat();
            Animal a3 = new Dog();
            /*4.口诀2：编译看左边 运行看右边 * 解释：必须要父类定义这个方法，才能通过编译，编译时，把多态对象看作是父类类型 * 必须要子类重写这个方法，才能满足多态，运行时实际干活的是子类*/
            a2.eat();//小猫爱吃小鱼干~，多态对象可以调用重写后的方法
            //a2.play();//多态对象把自己看作是父类类型，不能使用子类的特有方法
    
        }
    
    }
    /*1.多态的前提：继承+重写*/
    //1.创建父类
    class Animal{ 
        //3.提供父类的普通方法
        public void eat(){ 
            System.out.println("小动物Animal吃啥都行~");
        }
    }
    //2.1创建子类小猫类Cat并与Animal建立继承关系
    class Cat extends Animal{ 
        //4.1添加子类重写的方法
        @Override//此注解表明本方法是一个重写的方法
        public void eat(){ 
            System.out.println("小猫爱吃小鱼干~");
        }
        //5.1添加子类特有的功能
        public void play(){ 
            System.out.println("小猫Cat跳的老高啦~");
        }
    }
    //2.2创建子类小狗类Dog并与Animal建立继承关系
    class Dog extends Animal{ 
        //4.2添加子类重写的方法
        @Override//此注解表明本方法是一个重写的方法
        public void eat(){ 
            System.out.println("小狗爱吃肉骨头~");
        }
        //5.2添加子类特有的功能
        public void play(){ 
            System.out.println("小狗Dog跑的老快啦~");
        }
    }

## 4. 多态的好处 ##

1.  多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2.  提高了程序的可扩展性和可维护性

## 5. 多态的使用 ##

前提:多态对象把自己看做是父类类型

1.  成员变量: 使用的是父类的
2.  成员方法: 由于存在重写现象,所以使用的是子类的
3.  静态成员: 随着类的加载而加载,谁调用就返回谁的

## 6. 练习：多态成员使用测试 ##

创建包: cn.tedu.oop  
创建类: TestDemo2.java

package cn.tedu.oopstatic;
    /**本类用于多态中的元素测试*/
    public class TestDemo2 { 
    	public static void main(String[] args) { 
    		//7.创建子类对象进行测试
    		Dog2 d = new Dog2();
    		System.out.println(d.sum);//20
    		d.eat();//小狗要吃肉骨头
    		d.play();//小狗爱打滚儿~~~
    		
    		//10.创建多态对象进行测试
    		/**口诀1:父类引用指向子类对象*/
    		/**口诀2:编译(保存)看左边,运行(测试)看右边*/
    		Animal2 a = new Dog2();
    		/**2.多态中,成员变量使用的都是父类的*/
    		System.out.println(a.sum);//10
    		/**3.多态中,成员方法使用的是父类的声明,子类的实现*/
    		a.eat();
    		/**4.多态中,如果父子类都有静态方法,使用的是父类的*/
    		a.play();//玩啥都行
    	}
    }
    
    //1.创建父类
    class Animal2{ 
    	//2.创建成员变量
    	int sum = 10;
    	//3.创建成员方法
    	public void eat() { 
    		System.out.println("吃啥都行");
    	}
    	//8.父类中定义静态方法play()
    	public static void play() { 
    		System.out.println("玩啥都行");
    	}
    }
    /**1.多态的前提:继承+重写*/
    //4.定义子类Dog2
    class Dog2 extends Animal2{ 
    	//5.定义子类的成员变量
    	int sum = 20;
    	//6.重写父类的eat()
    	/**@Override 这个注解加在方法上,表示这是一个重写的方法*/
    	@Override //注解--标签
    	public void eat() { 
    		System.out.println("小狗要吃肉骨头");
    	}
    	
    	//9.定义子类的静态方法play()
    	//@Override --不是重写,不能加这个注解
    	public static void play() { 
    		System.out.println("小狗爱打滚儿~~~");
    	}
    }
    	/**注意!!!静态资源属于类,不存在重写现象,只是两个类中有同样声明的方法而已,不属于重写*/

## 7 拓展 ##

### 7.1 设计汽车综合案例 ###

创建包: cn.tedu.oopexec  
创建类: DesignCar.java

package cn.tedu.design;
    /*本类用于完成OOP汽车设计综合案例*/
    public class DesignCar { 
        //创建程序的入口函数
        public static void main(String[] args) { 
            //8.创建一个纯纯的父类对象进行测试
            Car c = new Car();
            System.out.println(c.getColor());//null,需要使用get()/默认值
            c.start();//父类自己的功能
            c.stop();//父类自己的功能
            //c.fly();//父类不能使用子类的特有功能
            //9.创建一个纯纯的子类宝马类对象
            BMW b = new BMW();
            System.out.println(b.color);//五彩斑斓的黑,子类新定义的同名属性
            b.start();//没重写，使用的是父类的功能
            b.stop();//重写了，使用的是自己重写以后的功能
            //10.创建一个纯纯的子类保时捷类对象
            BSJ b2 = new BSJ();
            System.out.println(b2.getColor());//null
            System.out.println(b2.color);//黑不溜秋的白
            b2.start();//使用的是继承过来的父类中的功能
            b2.fly();//使用的是子类特有的功能
        }
    }
    
    //1.通过归纳总结，使用关键字class抽象封装形成一个"类"组件来描述一类事物
    class Car{ 
        //2.属性--通过成员变量来描述
        //2.1 属性的封装--通过关键字private对属性进行封装
        private String brand;//品牌
        private String color;//颜色
        private double price;//价格
        private double size;//尺寸
    
        //3.行为--通过方法来描述
        public void start(){ 
            System.out.println("我的车车启动啦~");
        }
        public void stop(){ 
            System.out.println("哎呀妈，我的车车熄火了~");
        }
    
        //2.2 给被封装的属性提供公共的属性值设置和访问方式--GetXxx()、SetXxx()
        //快捷方式：右键->Generate->Getter and Setter->Shift全选->ok
        public String getBrand() { 
            return brand;
        }
    
        public void setBrand(String brand) { 
            this.brand = brand;
        }
    
        public String getColor() { 
            return color;
        }
    
        public void setColor(String color) { 
            this.color = color;
        }
    
        public double getPrice() { 
            return price;
        }
    
        public void setPrice(double price) { 
            this.price = price;
        }
    
        public double getSize() { 
            return size;
        }
    
        public void setSize(double size) { 
            this.size = size;
        }
    }
    
    //4.创建一个宝马类并且继承汽车类--通过关键字extends建立继承关系
    class BMW extends Car{ 
        String color = "五彩斑斓的黑";
        //6.子类对父类方法不满意时可以重写父类中的方法
        //重写遵循两同两小一大原则，重写后，子类对象使用重写后的方法
        @Override
        public void stop(){ 
            System.out.println("宝马当然要帅气的停的稳当些啦~");
        }
    }
    //5.创建一个保时捷类并且继承汽车类--通过关键字extends建立继承关系
    class BSJ extends Car{ 
        String color = "黑不溜秋的白";
        //7.新增子类特有功能--父类不可使用，只有子类对象可使用此功能
        public void fly(){ 
            System.out.println("启动加速度，我要起飞啦UP~UP~");
        }
    }

### 7.2 静态变量和实例变量的区别 ###

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。  
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

### 7.3 向上转型和向下转型 ###

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。  
那么在这个过程中就存在着多态的应用。存在着两种转型方式，分别是：向上转型和向下转型。  
向上转型：可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。  
比如：父类Parent,子类Child  
父类的引用指向子类对象：Parent p=new Child();  
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类中声明过的方法，方法体执行的就是子类重过后的功能。但是此时对象是把自己看做是父类类型的，所以其他资源使用的还是父类型的。  
比如：花木兰替父从军，大家都把花木兰看做她爸，但是实际从军的是花木兰，而且，花木兰只能做她爸能做的事，在军营里是不可以化妆的。

向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。这个是之前向上造型过的子类对象仍然想执行子类的特有功能，所以需要重新恢复成子类对象  
Parent p = new Child();//向上转型，此时，p是Parent类型  
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child  
其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的  
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。  
比如：花木兰打仗结束，就不需要再看做是她爸了，就可以”对镜贴花黄”了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4NDIzNA_size_16_color_FFFFFF_t_70]: /images/20210827/b8a84cc01d834eab90811ef2b06cd570.png