一，單一職責原則：就一個類而言，應該僅有一個引起它變化的原因（就是實現類要責任單一）

英文--Single Responsibility Principle 

簡寫：SRP

舉個例子：

   父類：Animal

public class Animal {
	
	 void move(String animal){
		System.out.println(animal + "是主要用腳來移動的");
	}
}

測試類：

  <pre name="code" class="java">public class SRPTest {

	public static void main(String[] args) {
		Animal animal = new Animal();
		animal.move("狗");
		animal.move("貓");
		animal.move("老鼠");

	}

}
 

輸出：

狗是主要用腳來移動的
貓是主要用腳來移動的
老鼠是主要用腳來移動的

那麼問題來了，當你新增鳥時，打印出，鳥主要是用腳來移動的，（但好像是翅膀，這裡假設為翅膀）

這時，需要改程式碼了：

如果這樣改：

public class Animal {
	
	 void move(String animal){
		if("鳥".equals(animal)){
			System.out.println(animal + "是主要靠翅膀來移動的");
		}
		else{
			System.out.println(animal + "是主要用腳來移動的");
		}
	}
}

沒錯，可以真確輸出，但違背了單一職責原則，假如又要分為類似於貓頭鷹等主要靠翅膀在夜間移動的鳥，和靠翅膀在白天移動的鳥，又該如何呢，，，再分呢？

這個時候就要考慮單一職責原則了：

第一種：好像有點違背，但在方法上又好像不違背：

public class Animal {
	
	 void move(String animal){
			System.out.println(animal + "是主要靠翅膀來移動的");
		}
    void moveN(String animal){
			System.out.println(animal + "是主要用翅膀來移動的");
		}
    
}

第二種：

用兩個類，即一個類管理一個原則：

public class Animal {
	
	 void move(String animal){
			System.out.println(animal + "是主要靠翅膀來移動的");
		}

}
 

public class Birds {
	void move(String animal) {
		System.out.println(animal + "是主要靠翅膀來移動的");
	}
}

測試類：

public class SRPTest {

	public static void main(String[] args) {
		Animal animal = new Animal();
		animal.move("狗");
		animal.move("貓");
		animal.move("老鼠");
		Birds birds = new Birds();
		birds.move("鳥");

	}

}

二，開放封閉原則：對擴充套件---開發 ， 對更改----封閉

英文：OpenClosePrinciple

簡寫：OCP

就是說：不要更改原始碼（現有程式碼），而應該增加一個新的類（如子類等）

如版本更新等

版本更新：儘量不更改原始碼，可以增加新功能

員工遲到問題：可以制定遲到的晚下班，遲到多久就得加班多久等制度

即：上班總時長封閉，對於遲到一點開放

三，里氏代換原則：子代父，程式行為不變化（有點類似於繼承）

英文：Liskov Substitution Principle 

簡寫：LSP

理解：子類必須能夠替換他們的父型別，使得父類模組在不改變的情況下，自己可以用擴充套件性

如  動物，

子：狗，貓，牛

又如一個四則運算的例子：

求加法：

package testtwo;

public class Console {
	int addNumber(int a , int b){
		return (a + b);
	}
}

測試類：

package testtwo;

public class Test {

	public static void main(String[] args) {
		Console console = new Console();
		int result = console.addNumber(8, 2);
		System.out.println("結果是： " + result);
	}
}

輸出結果：

結果是： 10

假如要先求加法再乘法呢，如 （8 + 2）* 4

那麼你可能說我直接在Console更改就行啦，但萬一，你有好多個類使用了Console的例子呢，那麼容易出錯，

於是可以新建類來繼承，Console不變，

如程式碼：

package testtwo;

public class AConsonle extends Console{
	int addNumber(int a , int b){
		return (a + b);
	}
	int mulNumber(int a , int b){
		return (a * b);
	}
}

測試類：

package testtwo;

public class Test {

	public static void main(String[] args) {

		AConsonle aConsole = new AConsonle();
		int c = aConsole.addNumber(8, 2);
		int result = aConsole.mulNumber(c, 4);
		System.out.println("輸出結果是：" + result);
		
	}
}

輸出：

輸出結果是：40

四：依賴倒轉(置)原則:  

英文：Dependence Inversion Principle，

簡稱 DIP

理解：

(1)抽象不應該依賴細節，細節應該依賴於抽象

    （針對介面程式設計，不要針對現實程式設計）

(2)高層模組不應該依賴底層模組，兩個都應該依賴抽象

抽象：指介面或者抽象類

例子1：假如高層要訪問資料庫，這時，習慣性的我們喜歡寫一個類來實現訪問資料庫的操作（低層），

即   高層-------底層--------》資料庫

但這時，突然客戶要求可以根據自己愛好選擇不同的儲存方式呢，又該如何呢？

例子2：通過程式碼例子，

package threetest;

public class Dog  {
	public void eat(){
		System.out.println("狗正在吃飯！");
	}

}

動物類：

public class Animal {
	public void animal (Dog dog){
		dog.eat();
	}
}

測試類：

<pre name="code" class="java">package threetest;

public class Test {
	public static void main(String[] args){
		Animal a = new Animal();
		Dog dog = new Dog();
		a.animal(dog);
		a.animal(dog);
		a.animal(dog);
	
	}
}

輸出結果：

狗正在吃飯！狗正在吃飯！狗正在吃飯！

那麼這個時候，突然想在測試類，再增加貓正在吃飯，該如何改呢？（增加老鼠呢、、、？）

那麼就該想到，依賴抽象，這裡以介面為例：

程式碼：

介面類Ieat:

package threetest;

public interface Ieat {
	public void eat();
}

狗類：

package threetest;

public class Dog  implements Ieat{
	public void eat(){
		System.out.println("狗正在吃飯！");
	}

}

貓類：

package threetest;

public class Cat implements Ieat{
	public void eat(){
		System.out.println("貓正在吃飯！");
	}
}

高層類：

package threetest;

public class Animal {
	public void animal(Ieat ieat){
		ieat.eat();
	}
}

測試類：

package threetest;

public class Test {
	public static void main(String[] args){
		Animal a = new Animal();
		Dog dog = new Dog();
		Cat cat = new Cat();
		a.animal(dog);
		a.animal(dog);
		a.animal(dog);
		a.animal(cat);
		a.animal(cat);
		a.animal(cat);
	}
}

輸出結果：

狗正在吃飯！
狗正在吃飯！
狗正在吃飯！
貓正在吃飯！
貓正在吃飯！
貓正在吃飯！

由此可見：高層類Animal依賴於抽象（這裡是介面）

              底層類 ：Cat , Dog 也依賴於抽象（這裡是介面）

五，迪米特法則：降低類之間的耦合

英文（Law of Demeter，LoD）也稱為最少知識原則（Least Knowledge Principle，LKP）

根本思想：是強調了類之間的鬆耦合，

.....類對自己依賴的類知道的越少越好

 ......與直接朋友交流

直接朋友包括：

1)當前物件本身(this)
2)以參量形式傳入到當前物件方法中的物件
3)當前物件的例項變數直接引用的物件
4)當前物件的例項變數如果是一個聚集，那麼聚集中的元素也都是朋友
5)當前物件所建立的物件
任何一個物件，如果滿足上面的條件之一，就是當前物件的"朋友";否則就是"陌生人"。

也可以說：

出現在成員變數、方法的輸入輸出引數中的類稱為成員朋友類，而出現在方法體內部的類不屬於朋友類。

例子：

Animal類：Dog類屬於直接朋友類，因為它是通過方法的輸入輸出引數成為朋友的，當Foot在方法體count內，不屬於直接朋友

方法屬於類的行為，一個類竟然不知道他的行為與其他類有依賴關係，這就違反了迪米特法則。

package fourtest;

import java.util.ArrayList;
import java.util.List;

public class Animal {
	public void count(Dog dog) {
		List<Foot> list = new ArrayList<Foot>();
		for(int i = 0 ; i < 10 ; i++){
			list.add(new Foot());
		}
		dog.countFoot(list);
		
	}
}

</pre><pre name="code" class="java">Dog類：

</pre><pre name="code" class="java"><pre name="code" class="java">package fourtest;
import java.util.List;
public class Dog {
	void countFoot(List list){
		System.out.println("腳共有 ：" + list.size() + "只");
	}
}

Foot類：這裡不寫程式碼

package fourtest;
public class Foot {

}

測試類：

package fourtest;
public class Test {
	public static void main(String[] args){
		Animal al = new Animal();
		Dog dog = new Dog();
		al.count(dog);
	}
}

輸出：

腳共有 ：10只

沒錯，結果沒錯，但卻違背了迪米特法則。

應該改為：

Animal類：

package fourtest;
import java.util.ArrayList;
import java.util.List;
public class Animal {
	public void count(Dog dog) {
		dog.countFoot();
		
	}
}

Dog類：

package fourtest;
import java.util.ArrayList;
import java.util.List;
public class Dog {
	public List<Foot> list ;
	public Dog(List<Foot> footList){
		this.list = footList;
	}
	void countFoot(){
		System.out.println("腳共有 ：" + list.size() + "只");
	}	
}

Foot類不變，還是沒程式碼：

Test類：

package fourtest;
import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args){
		List<Foot> list = new ArrayList<Foot>();	//建立一個List表，型別為Foot
		for(int i = 0 ; i < 10 ; i++){				//存放資料
			list.add(new Foot());
		}
		Dog dog = new Dog(list);				//建立Dog物件，list作為引數
		Animal al = new Animal();			//建立Animal物件
		al.count(dog);						//呼叫Animal物件的count方法，dog作為物件
		
	}
}

輸出：

腳共有 ：10只

又如圖片：

發現每個控制元件都與其他控制元件有關係，這樣如若修改一個控制元件，則可能會帶動其他控制元件，

如若用迪米特法則則可以改為：增加一箇中介（中間類）來管理，如下：

六，介面隔離原則：

英文：Interface Segregation Principle

簡寫：ISP

客戶端不應該依賴它不需要的介面，一個類對一個類的依賴應該建立在最小的介面上

注意：
   (1)介面儘量小，但是要有限度。

   (2)為依賴介面的類定製服務，只暴露給呼叫的類它需要的方法，它不需要的方法則隱藏起來。
   (3)提高內聚，減少對外互動。使介面用最少的方法去完成最多的事情。

舉個例子：

Animal介面：

package fivetest;
interface Animal {
	public void eat();
	public void move();
	public void sleep();
	public void relax();
}

類Dog:

package fivetest;
public class Dog implements Animal{
	//不是abstract，需重寫
	//我們重寫前面三個方法
	public void eat() {
		System.out.println("狗正在吃飯");
	}
	public void move() {
		System.out.println("狗正在移動");
	}
	public void sleep() {
		System.out.println("狗正在睡覺");	
	}
	public void relax() {}
}

Cat類：

package fivetest;
public class Cat implements Animal{
	public void eat() {}
	//這裡重寫後三個方法
	public void move() {
		System.out.println("貓正在移動");	
	}
	public void sleep() {
		System.out.println("貓正在睡覺");		
	}
	public void relax() {
		System.out.println("貓正在休息");	
	}
}

Danimal類：

package fivetest;

public class Danimal {
	public void a1(Animal animal){
	    animal.eat();
	}
	public void a2(Animal animal){
		animal.move();
	}
	public void a3(Animal animal){
		animal.sleep();
	}
}

Canimal類：

package fivetest;

 class Canimal {
	public void b2(Animal animal){
		animal.move();
	}
	public void b3(Animal animal){
		animal.sleep();
	}
	public void b4(Animal animal){
	    animal.relax();
	}
}

測試類：Test

package fivetest;

public class Test {
	public static void main(String[] args){

		Canimal c = new Canimal();
		Cat cat   = new Cat();
		c.b2(cat);
		c.b3(cat);
		c.b4(cat);
		
		Danimal d = new Danimal();
		Dog   dog = new Dog();
		d.a1(dog);
		d.a2(dog);
		d.a3(dog);
	}	
}

輸出結果：

貓正在移動
貓正在睡覺
貓正在休息
狗正在吃飯
狗正在移動
狗正在睡覺

利用迪米特法則改後代碼為：

介面：4個：

public interface Eat {
	public void eat();
}

public interface Move {
	public void move();
}

public interface Sleep {
	public void sleep();
}

public interface Relax {
	public void relax();
}

Dog類：

public class Dog implements Eat , Move , Sleep{
	//我們重寫前面三個方法
	public void eat() {
		System.out.println("狗正在吃飯");
	}
	public void move() {
		System.out.println("狗正在移動");
	}
	public void sleep() {
		System.out.println("狗正在睡覺");	
	}
}

Cat類：

public class Cat implements Move , Sleep , Relax{
	//這裡重寫後三個方法
	public void move() {
		System.out.println("貓正在移動");	
	}
	public void sleep() {
		System.out.println("貓正在睡覺");		
	}
	public void relax() {
		System.out.println("貓正在休息");	
	}
}

Danimal類：

public class Danimal {
	public void a1(Eat e){
	    e.eat();
	}
	public void a2(Move m){
		m.move();
	}
	public void a3(Sleep s){
		s.sleep();
	}
}

Canimal類：

 class Canimal {
	public void b2(Move m){
		m.move();
	}
	public void b3(Sleep s){
		s.sleep();
	}
	public void b4(Relax r){
	    r.relax();
	}
}

測試類：

public class Test {
	public static void main(String[] args){

		Canimal c = new Canimal();
		Cat cat   = new Cat();
		c.b2(cat);
		c.b3(cat);
		c.b4(cat);
		
		Danimal d = new Danimal();
		Dog   dog = new Dog();
		d.a1(dog);
		d.a2(dog);
		d.a3(dog);
	}	
}

輸出結果：

貓正在移動
貓正在睡覺
貓正在休息
狗正在吃飯
狗正在移動
狗正在睡覺