java设计模式的几个原则（详解）

java设计模式的几个原则

一 介绍

       主要问题：明白什么是设计模式？为什么要用它？

答：设计模式就是一种用在某些重复的问题的模板核心。说白了就是用来解决重复修改代码的问题。Java设计模式就是一种用来防止代码高度耦合的核心。这样就可以在需求改变的时候一次一次的使用好的代码，不用一直去费力的改它做重复劳动。下面的几个原则可以加深我们的理解。

二 四个原则

            充分理解：4个原则要告诉我们什么？

• 面向抽象原则

原则	说明
面向对象	在新建立一个类的时候把该类的重要方法设计成抽象类或者接口

举例：

//假设一个人乘车回家比步行回家快1.2倍
//使用面向抽象的原则来设计！

//1.把重要的方法抽象出来。
abstract class GetTime{
//抽象一个获取时间的方法
    public abstract double getTime();
}


//2.建立一个步行类继承 GetTime类
class Walk extends GetTime{

//该类拥有时间属性
	private double Time;

//构造函数
	Walk(double Time){
		this.Time=Time;
	}

//实现抽象方法返回花费的时间。
    public double getTime() {
    	return Time;
    }
}


//3.建立一个乘车类
class Car extends GetTime{
//我们可以直接把Walk类当成该类的属性，理论是很简便的，但这样相当于写死了不利于以后的修改。
//这种情况下如果乘车所花费的时间不再是步行的1.2倍而是搭乘自行车的1.2倍，我们还需要回过头来更改该类的代码，就不符合设计模式要告诉我们的不要做重复劳动。
//使用面向抽象可以解决这种问题。
	GetTime time; //以 GetTime抽象类为类型的属性 ---->时间
	double  multiple;//倍数
  
//构造函数（输入一个walk实例和需要的倍率）
	Car(GetTime time,double  multiple){
		this.time=time;
		this.multiple=multiple;
	}
	 
//这样当需求改变的时候就不用改变任何Car类的代码了。
	 public double getTime() {
	    	return (time.getTime()* multiple);  
	    }
	
}
	

public static void main(String[] args) {

   //测试
   //步行花费25分钟	
	 Walk walk=new Walk(25);
   //输入步行需要的时间，和倍率1.2
     Car car=new Car(walk,1.2);
   //输出结果
	 System.out.println(car.getTime());
   //面向抽象原则把Walk类和Car类的联系变弱了。
   //需求改变时改的代码会减少。
}

• 开-闭原则

原则	说明
开-闭原则	设计遵守了开-闭原则那么这个设计一定是易于维护的，因为增加新代码时候不必改到核心代码

所谓的开就是添加新代码的能力。
所谓的闭就是核心代码要关闭不能更改。

还是刚才的代码保持不变：

//在上述代码不变的情况下使用开-闭原则添加自行车类
//建立一个自行车类
class Bicycle extends GetTime{
//时间属性
	private double Time;
//构造函数
	Bicycle(double Time){
		this.Time=Time;
	}
	//实现抽象方法
  public double getTime() {
  	return Time;
  }
}

public static void main(String[] args) {

   //测试
   //步行花费25分钟	
	 Walk walk=new Walk(25);
   //输入步行回家需要的时间，和倍率1.2
     Car car=new Car(walk,1.2);
   //输入自行车回家需要时间，和倍率1.2
     Bicycle bicycle=new Bicycle(18.2);
     Car car2=new Car(bicycle,1.2);
     
   //输出结果
	 System.out.println(car2.getTime());
  //可以看到我们仅仅只添加了一个自行车类没有改变关于Car类的任何代码，开-闭的重点在于闭的设计。
}

• 多用组合少用继承原则

原则	说明
多用组合少用继承原则	避开继承的缺点，多用组合的优点

这里结合UML的知识：

组合

包含

关联

依赖

1.关联：A类是B类的一个属性这就叫关联

class A{  
	int a;
}

class B{
	private A a; /* B类把A类当成一个属性（这里的A类最好是抽象类/接口） */
}

2.依赖：A类是B类中的某个方法的参数或者返回类型

class A{  
	int a;
}

class B{
	int b;

	public A GetA(A a) { /* 这个方法把A类当成参数和返回类型 ，这叫B依赖A*/
	   return a;
}

多使用上面的两种组合类型，注意其中A类最好为抽象类或接口，这样就可以满足面向抽象原则，以及开-闭原则等降低关联性，减少修改量的原则了。

• 高内聚-低耦合原则

原则	说明
高内聚-低耦合	避免修改一部分要跟着改掉另一个部分

• 高内聚就是一个类将尽可能做到独立不跟其他类扯上关系，防止一个类要改自己也要受到牵连。

• 耦合越高两个类就越说不清楚。一个类设计错误了另一个类也跟着犯错，所以设计代码的时候尽量低耦合。