多态在开发中的作用

Posted 2020-12-09 xlwu

1 多态在开发中有什么作用？

    非常重要：五颗星......

    多态在开发中的作用是：

        降低程序的耦合度，提高程序的扩展力。

        

        public class Master{

            public void feed(Dog d){}

            public void feed(Cat c){}

        }

        

        以上的代码中表示：Master和Dog以及Cat的关系很紧密（耦合度高）。导致扩展力很差

        

        public class Master{

            public void feed(Pet pet){}

        }

        

    以上的发表中表示，Master和Dog以及Cat的关系就脱离了，Master关注的是Pet类。

    这样Master和Dog以及Cat的耦合度就降低了，提高了软件的扩展性。

    

    面相对象的三大特征：

        封装、继承、多态

        

        真的是一环扣一环。

        

        有了封装，有了这种整体的概念之后。

        对象和对象之间产生了继承。

        有了继承之后，才有了方法的覆盖和多态。

        

        这里提到了一个软件开发原则：

            七大原则最基本的原则：OCP（对扩展开放，对修改关闭)

            目的是：降低程序耦合度，提高程序扩展力。

            面相抽象编程，不建议面相具体编程。

 

 

 

案例：

宠物的父类：
// 所有宠物的父类
public class Pet{
    // 吃的行为（这个方法可以不给具体的实现）    
    public void eat(){
        
    }
}

 

子类猫类：
// 创建猫类
public class Cat extends Pet{
    // 吃的实例方法
    public void eat(){
        System.out.println("猫咪喜欢吃鱼，吃的很香！");
    }
}

 

子类狗类：
// 宠物狗狗类
public class Dog extends Pet{
    // 吃
    public void eat(){
        System.out.println("狗狗喜欢啃骨头，吃的很香。");
    }
}

 

子类鹦鹉类：
// OCP ： 对扩展开发，对修改关闭
public class YingWu extends Pet{
    public void eat(){
        System.out.println("鹦鹉再吃鹦鹉屎，吃的很香！");
    }
}

 

主人类：
// 主人类
public class Master{
    // 假设主任起初的时候只是喜欢养宠物狗狗
    // 喂养宠物狗狗 实例方法
    /*
    public void feed(Dog d){
        d.eat();
    }
    
    // 由于新的需求产生，导致我们“不得不”去修改Master这个类的代码
    public void feed(Cat c){
        c.eat();
    }
    */
    
    // 能不能让Master主人这个类以后不再修改了
    // 即使主人又喜欢养其他动物了，Master也不需要改。
    // 这个时候就需要使用：多态机制。
    // 最好不要写具体的宠物类型，这样会影响程序的扩展性。
    public void feed(Pet pet){
        // 编译的时候，编译器发现pet是Pet类，会去找Pet类中找eat（）方法，结果找到了，编译通过。
        // 运行的时候，底层实际的对象是什么，就自动调用到该实际对象对应的eat（）方法上。
        // 这就是多态的使用。
        pet.eat();
    }
}

/*

    注意这里的分析：

        主人起初的时候只喜欢养宠物狗狗

        随着时间的推移，主人又喜欢上养“猫咪”

        在实际的开发中这就表示客户产生了新的需求。

        作为软件的开发人员来说，必须满足客户的需求

        我们怎么回去满足客户的需求呢？

            再不使用多台机智的前提下，目前我们只能在Master类中添加一个新的方法。

            

        思考：软件在扩展新需求的过程当中，修改Mater这个类有什么问题？

            一定要记住：软件在扩展过程当中，修改的越少越好。

            修改的乐队，你的系统当前的稳定性就越差，未知的风险就越多。

            2010年开发了农行的内部系统......

            2020年农行内部系统需要升级

            

            其实这里涉及到一个软件的开发原则：

                软件开发原则有七大原则（不属于java，这个开发原则属于整个软件业）：

                    其中有一条最基本的原则：OCP（开闭原则）

                    

                什么是开闭原则？

                    对扩展开放（你可以额外的添加，没问题），对修改关闭（最好很少的修改现有程序）。

                    在软件的扩展过程当中，修改的越少越好。

                    

            高手开发项目不是仅仅为了实现客户的需求，还需要考虑软件的扩展性。

            

            什么是软件扩展性？

                假设电脑中的内存部件坏了，我们可以买一个新的插上，直接使用。

                这个电脑的设计就考虑了“扩展性”。内存条的扩展性很好。

                

            面相父类型变成，面相更加抽象进行变成，不建议面相具体变成。

            因为里面相具体变成会让软件的扩展力很差。

*/

 

测试类：
/*
    测试多态在开发中的作用
*/
public class Test{
    public static void main(String[] args){
        // 创建主人对象
        Master zhangsan = new Master();
        // 创建狗狗对象
        Dog zangAo = new Dog();
        // 主人喂
        zhangsan.feed(zangAo);
        // 创建宠物对象
        // 主人喂
        Cat jinJianCeng = new Cat();
        zhangsan.feed(jinJianCeng);
        
        YingWu yw = new YingWu();
        zhangsan.feed(yw);
    }
}

 

案例2：

乐器类 父类：
// 定义乐器类 父类
public class Instrument{
    // 父类中的实例方法
    public void makeSound(){}
}

 

子类 二胡类：
// 子类 乐器二胡 继承父类乐器类
public class Erhu extends Instrument{
    // 重写父类中的乐器方法
    public void makeSound(){
        System.out.println("一曲肝肠断，天涯何处觅知音。");    
    }
}

 

子类 钢琴类：
// 子类钢琴 继承父类乐器类
public class Piano extends Instrument{
    // 重写父类中的乐器方法
    public void makeSound(){
        System.out.println("他的手指像蝴蝶一样在钢琴上偏偏起舞！");    
    }
}

 

子类小提琴类：
// 子类小提琴  继承父类乐器类
public class Violin extends Instrument{
    // 重写父类中的方法
    public void makeSound(){
        System.out.println("他站着，拉着他手中的小提琴，真是一幅优美的画面。");
    }
}

 

乐手类：
public class Musician{
    public void play(Instrument i){
        i.makeSound();
    }
    
    // 第一种写法
    /*
    // 创建一个实例变量
    Instrument i;
    
    // 构造方法
    public Musician(){}
    public Musician(Instrument i){
        this.i = i;
    }
    
    // 创建演奏乐器的方法
    public void play(){
        i.makeSound();
    }*/
}

 

测试类：
// 测试类
public class Test02{
    public static void main(String[] args){
        
        // 第一种写法
        // 创建乐手对象
        /*
        Musician lZ = new Musician(new Erhu());
        lZ.play();
        */
        
        //第二种写法
        Musician lZ = new Musician();
        
        /*
        // 创建二胡对象
        Erhu e = new Erhu();
        
        // 创建小提琴对象
        Violin v = new Violin();
        
        // 创建钢琴对象
        Piano p = new Piano();
        */
        
        /*
        // 创建二胡对象
        Instrument e = new Erhu();
        
        // 创建小提琴对象
        Instrument v = new Violin();
        
        // 创建钢琴对象
        Instrument p = new Piano();
        
        // 让乐手去拉二胡  你需要让乐手演奏什么，就把什么对象传给演奏者进行呀演奏。
        lZ.play(e);
        // 让乐手去拉小提琴
        lZ.play(v);
        // 让乐手去弹钢琴
        lZ.play(p);
        */
        
        lZ.play(new Erhu());
        // 让乐手去拉小提琴
        lZ.play(new Violin());
        // 让乐手去弹钢琴
        lZ.play(new Piano());
    }
}