< 返回技术文档列表

Android设计模式SOLID六大原则是什么

发布时间:2021-11-07 01:34:50

本篇内容主要讲解“Android设计模式SOLID六大原则是什么”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“Android设计模式SOLID六大原则是什么”吧!

    单一职责原则

    定义

    定义:

    确保单例类只有一个实例,并且这个单例类提供一个函数接口让其他类获取到这个唯一的实例。

    解释:一个类只负责一个职责,不要存在多于一个导致类变更的原因。

    代码解释

    比如一个类记录一些食品的名称,但同时又记录食品的做法。前者属于业务对象,后者属于业务逻辑,根据单一职责原则,我们需要将业务和数据分开

    未遵守单一原则
    public class Foods {
        private String fish;
        private String meat;
    
        public String getFish() {
            return fish;
        }
    
        public void setFish(String fish) {
            this.fish = fish;
        }
    
        public String getMeat() {
            return meat;
        }
    
        public void setMeat(String meat) {
            this.meat = meat;
        }
        public void RedCookedFish(){
            //do something...
        }
        public void RedCookedMeat(){
            //do something...
        }
    }
    遵守单一原则
    public class Foods {
        private String fish;
        private String meat;
    
        public String getFish() {
            return fish;
        }
    
        public void setFish(String fish) {
            this.fish = fish;
        }
    
        public String getMeat() {
            return meat;
        }
    
        public void setMeat(String meat) {
            this.meat = meat;
        }
    }
    public class Practices {
        public void RedCookedFish(){
        //do something...
        }
        public void RedCookedMeat(){
        //do something...
        }
    }

    开闭原则

    定义

    定义:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

    当一个系统有了新的需要,我们并不想在原来的功能类去修改,导致破坏原来的逻辑,以至于出现新的BUG,所有我们在设计系统时尽量通过扩展的方式实现新的功能,简单的就是说让我们好好利用继承和接口。

    代码解释

    比如有一个动物,有姓名和运动方式两种属性,当它成年时,需要结交异性,又需要增加繁衍后代的功能,我们通过继承或者接口的方式进行扩展新功能,遵守开闭原则。

    public class Animal {
        private String mName;
        private String mMovementMode;
        public Animal(String mName,String mMovementMode){
            this.mName = mName;
            this.mMovementMode = mMovementMode;
        }
    
        public String getmName() {
            return mName;
        }
    
        public String getmMovementMode() {
            return mMovementMode;
        }
    }
    public class Multiply extends Animal {
        public Multiply(String mName, String mMovementMode) {
            super( mName, mMovementMode );
        }
        public void MultiplyMethod(){
        //do something...
        }
    }

    里氏替换原则

    定义

    定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序
    P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类
    型。

    定义2:所有引用基类的地方必须能透明地使用其子类的对象

    解释:打比方抽象类的抽象方法,子类必须实现

    代码解释

    比如一个动物类有一个运动方式的属性,其余具体动物,比如:鱼,鹰等需要继承其方法,实现自己的运动方式。

    public abstract class Animal {
        public abstract void MultiplyMethod(String Multiply);
    }
    public class Fish extends Animal {
        @Override
        public void MultiplyMethod(String Multiply) {
            // set Multiply Method
        }
    }

    依赖倒置原则

    定义

    定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。

    依赖倒置原则的核心思想是面向接口编程。

    代码解释

    比如现阶段热门的编程语言,java,c,python等,但随着时间的推移,随着科技的发展,会根据需求不同,产生新的语言。如果我们需要在一个类中一个个添加,那样太麻烦,使用接口进行配置,则会简单很多。

    未遵守依赖导致原则
    class C{
        public String get(){
            return "C";
        }
    }
    class Java{
        public String get(){
            return "Java";
        }
    }
    class Python{
        public String get(){
            return "Python";
        }
    }
    class GetLanguage{
        public GetLanguage(){
    
        }
        public void getLanguage(C c){
            Log.d( "Language",c.get() );
        }
        public void getLanguage(Java java){
            Log.d( "Language",java.get() );
        }
    }
     GetLanguage language = new GetLanguage();
            language.getLanguage( new C() );
            language.getLanguage( new Java() );
    遵守依赖导致原则

    定义接口

    public interface ILanguage {
        String get();
    }
    public class Language {
       public void getLanguage(ILanguage iLanguage){
           Log.d( "Language",iLanguage.get() );
       }
    }
     Language language = new Language();
            language.getLanguage( new ILanguage() {
                @Override
                public String get() {
                    return "C";
                }
            } );

    Android设计模式SOLID六大原则是什么

    接口隔离原则

    定义

    定义:客户端不应该依赖它不需要的接口;一个类对另一个类的依赖应该建立在最小的接口上。

    简单来说,一个类只需要实现自己需要的方法,不相干的方法不需要实现

    代码解释

    比如一个接口实现动物所有的运动方式,比如:跑、爬、游、飞、跳。老鹰就只需要实现飞,狗就只需要实现跑,但是实现这个接口的话,必须实现所有方法,就会很臃肿,并且有的方法不需要实现。我们只需要将他们拆分成四个接口,不同的动物,实现不同的运动方式即可。

    未遵守接口隔离原则
    public interface IAnimal {
        void run();
        void swim();
        void climb();
        void fly();
    }
    class Dog implements IAnimal{
    
        @Override
        public void run() {
    
        }
    
        @Override
        public void swim() {
    
        }
    
        @Override
        public void climb() {
    
        }
    
        @Override
        public void fly() {
    
        }
    }
    遵守接口隔离原则
    public interface  Swim{
            void swim();
        }
        public interface  Run{
            void run();
        }
        public interface  Climb{
            void climb();
        }
        public interface  Fly{
            void fly();
        }
    class Dog implements Run{
    
            @Override
            public void run() {
    
            }
        }

    迪米特原则

    定义

    定义:一个对象应该对其他对象保持最少的了解。

    代码解释

    假如一个类实现了加减乘除四个方法,同时在加减乘除方法内实现了对进行运算的数值进行类型判断。类型判断中又实现了范围判断。我们只需要将加减乘除四个方法暴露即可,其余方法不需要暴露。

    public class Operation {
        public Object Add(Object num1,Object num2){
           Object flag = JudgeType(num1,num2);
           int num = (Integer) flag;
           switch (num){
               case 0:
                   return (Integer)num1 + (Integer)num2;
               case 1:
                   return (Double)num1 + (Double) num2;
                default:
                    return null;
           }
        }
        private void Sub(Object num1,Object num2){
    
        }
        private void Ride(Object num1,Object num2){
    
        }
        private void Division(Object num1,Object num2){
    
        }
        private Object JudgeType(Object num1,Object num2){
            if (num1 instanceof Integer){
              return 0;
            }else if (num1 instanceof Double){
                return 1;
            }
            return 3;
        }
    //    private boolean JudgeIntRange(int num){
    //        if (num < 65535 && num > -65535){
    //            intFlag = true;
    //            return true;
    //        }
    //        intFlag = false;
    //        return false;
    //    }
    }
    Operation operation = new Operation();
    Log.d( "Result=",operation.Add( 1,1 )+"" );

    到此,相信大家对“Android设计模式SOLID六大原则是什么”有了更深的了解,不妨来实际操作一番吧!这里是血鸟云网站,更多相关内容可以进入相关频道进行查询,关注我们,继续学习!


    /template/Home/Zkeys/PC/Static