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";
}
} );
接口隔离原则
定义
定义：客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
简单来说，一个类只需要实现自己需要的方法，不相干的方法不需要实现
代码解释
比如一个接口实现动物所有的运动方式，比如：跑、爬、游、飞、跳。老鹰就只需要实现飞，狗就只需要实现跑，但是实现这个接口的话，必须实现所有方法，就会很臃肿，并且有的方法不需要实现。我们只需要将他们拆分成四个接口，不同的动物，实现不同的运动方式即可。
未遵守接口隔离原则
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