码迷,mamicode.com
首页 > 其他好文 > 详细

多态在开发中的作用

时间:2020-06-08 23:19:27      阅读:84      评论:0      收藏:0      [点我收藏+]

标签:instr   继承   产生   main   是什么   ring   提高   高手   color   

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());
    }
}

多态在开发中的作用

标签:instr   继承   产生   main   是什么   ring   提高   高手   color   

原文地址:https://www.cnblogs.com/xlwu/p/13069203.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!