六大原则
单一职责原则
定义
确保单例类只有一个实例，并且这个单例类提供一个函数接口让其他类获取到这个唯一的实例。
解释：一个类只负责一个职责，不要存在多于一个导致类变更的原因。
代码解释
比如一个类记录一些食品的名称，但同时又记录食品的做法。前者属于业务对象，后者属于业务逻辑，根据单一职责原则，我们需要将业务和数据分开
未遵守单一原则
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"; } } )
接口隔离原则
定义
定义：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
简单来说，一个类只需要实现自己需要的方法，不相干的方法不需要实现
代码解释
比如一个接口实现动物所有的运动方式，比如：跑、爬、游、飞、跳。老鹰就只需要实现飞，狗就只需要实现跑，但是实现这个接口的话，必须实现所有方法，就会很臃肿，并且有的方法不需要实现。我们只需要将他们拆分成四个接口，不同的动物，实现不同的运动方式即可。
未遵守接口隔离原则
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 )+"" );
2021-10-27 21:27:32.893 25595-25595/com.franzliszt.solid D/Result=: 2
