面向对象设计-三大特性、七项原则

逃离我推掉我的手 2022-05-06 11:29 208阅读 0赞

## 三大特性 ##

*  封装：对具有相同属性的事物进行统一描述
 *  继承：一个类获取另外一个类的属性的方式
 *  多态：一个类实例的相同方法在不同情形有不同表现形式，说白了就是父类指针指向子类对象

--------------------

## 七项原则：目的就是实现   高内聚、低耦合 ##

*  单一职责原则（Single Responsibility Principle，SRP）：类的职责单一，对外只提供一种功能，而引起类变化的原因都应该只有一个  
      
    
 *  开闭原则（Open-Closed Principle，OCP）：增加功能是通过增加代码，而不是修改代码

class Calculater
    { 
    public:
    int calculate(int a,int b,char c)
    { 
    	if(c=='+')
    	{ 
    		return a+b;
    	}
    	if(c=='-')
    	{ 
    		return a-b;
    	}
    	if(c=='*')
    	{ 
    		return a*b;
    	}
    	if(c=='/')
    	{ 
    		return a/b;
    	}
    }
    如果我再想加入 % 功能，则需要修改 calculate 方法， 得修改源代码
    };

class Calculater
    { 
      public:
      virtual int calculate()=0;
    }
    
    class Plus:public Calculater
    { 
       virtual int calculate(int a,int b)
       { 
       		return a+b;
       }
    }
    
    class Subtrct:public Calculater
    { 
       virtual int calculate(int a,int b)
       { 
       		return a-b;
       }
    }
    
    class Multiply:public Calculater
    { 
       virtual int calculate(int a,int b)
       { 
       		return a*b;
       }
    }
    
    class Devide:public Calculater
    { 
       virtual int calculate(int a,int b)
       { 
       		return a/b;
       }
    }
    
    这时候如果想添加功能就直接 再继承一个抽象类，不用修改其他代码

*  里氏代换原则（Liskov Substitution Principle，LSP）：任何抽象类出现的地方都可以用他的实现类进行替换，实际就是虚拟机制（多态），语言级别实现面向对象功能  
      
    
 *  依赖倒转原则（Dependence Inversion Principle，DIP）：依赖于抽象(接口)，不要依赖具体的实现(类)，也就是针对接口编程  
      
    
 *  接口隔离原则（Interface Segregation Principle，ISP）：一个方法对外只提供一个功能  
      
    
 *  合成复用原则（Composite Reuse Principle，CRP）：如果使用继承，会导致父类的任何变换都可能影响到子类的行为。如果使用对象组合（将另一个对象当做成员），就降低了这种依赖关系。对于继承和组合，优先使用组合

错误的做法

class Car
    { 
    public:
    	virtual void setcar() = 0;
    };
    
    
    class tuolaji : public Car
    { 
    public:
    	virtual void setcar()
    	{ 
    		cout << "拖拉机";
    	}
    
    };
    
    class Person : public tuolaji  //继承，这样就能使用其中方法
    { 
    public:
    	void Party()
    	{ 
    		cout << "julain开着"; 
    		setcar(); 
    		cout << "去开Party"<<endl;
    	}
    };
    
    int main()
    { 
    	Person p;
    	p.Party();	
    	return 0;
    }

正确的做法

class Car
    { 
    public:
    	virtual void setcar() = 0;
    };
    
    class tuolaji : public Car
    { 
    public:
    	virtual void setcar()
    	{ 
    		cout << "拖拉机";
    	}
    };
    
    class Person
    { 
    public:
    	void Set(Car *c)
    	{ 
           car = c;
    	}
    	void Party()
    	{ 
    		cout << "julian开着"; 
    		car->setcar(); 
    		cout << "去Party" << endl;
    	}
    
    	string name;
    	Car* car;   // 作为成员：类的组合 ，而不是继承
    
    };
    
    int main()
    { 
    	Person p;
    	BMW * bmw = new BMW;
    	p.Set(bmw);
    	p.Party();
    	
    	return 0;
    }

*  笛米特原则 （Law of Demeter Principle，LoD）：一个对象应当对其他对象尽可能少的了解，从而降低各个对象之间的耦合，提高系统的可维护性

情况1：调用者直接对每个类进行操作，需要了解每个类的细节  
![在这里插入图片描述][20181013185659456]  
  
  
情况2：调用者通过中介对类ABC进行操作，并不去了解类ABC的细节，只操作中介提供的接口  
![在这里插入图片描述][2018101319003238]

[20181013185659456]: /images/20220506/d1932f3a9e494226aa14f445beb2aaba.png
[2018101319003238]: /images/20220506/97a712a6e9dc46229e72ad076f0acfe2.png