设计模式:七大原则

①.单一职责原则：每一个类只干一件事，只对一件事负责。

②.接口隔离原则：每一个类只实现最小的接口 对于接口中有不会用到的类，我们将接口分开变小。

③.依赖倒置原则：面向接口编程。依赖传递关系的三种方法：接口传递、构造器传递、setter方法传递。

package com.acofkings.principle.inversion;

public class DependecyInversion {

	public static void main(String[] args) {
		
		ChangHong changhong = new ChangHong();
		//1.接口传递依赖
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.open(changhong);
//		//2.构造器传递依赖
//		OpenAndClose openAndClose = new OpenAndClose(changhong);
//		openAndClose.open();
//		//3.setter方法传递
//		OpenAndClose openAndClose = new OpenAndClose();
//		openAndClose.setITV(changhong);
//		openAndClose.open();
	}
}
//1.接口传递依赖
interface IOpenAndClose{
	public void open(ITV tv);
}
interface ITV{
	public void play();
}
class OpenAndClose implements IOpenAndClose{

	@Override
	public void open(ITV tv) {
		// TODO Auto-generated method stub
		tv.play();
	}
}
class ChangHong implements ITV {
	
	@Override
	public void play()
	{
		System.out.println("长虹电视机，打开");
	}
}
2.构造器传递依赖
//interface IopenAndClose{
//	public void open();
//}
//interface ITV {
//	public void play(); 
//}
//class OpenAndClose implements IopenAndClose{
//	public ITV tv;
//	public OpenAndClose(ITV tv){
//		this.tv = tv;
//	}
//	@Override
//	public void open() {
//		// TODO Auto-generated method stub
//		this.tv.play();
//	}
//}
//class ChangHong implements ITV{
//
//	@Override
//	public void play() {
//		// TODO Auto-generated method stub
//		System.out.println("长虹电视机，打开");
//	}
//}
3.setter方法传递
//interface IOpenAndClose{
//	public void open();
//}
//interface ITV{
//	public void play();
//}
//class OpenAndClose implements IOpenAndClose{
//	private ITV tv;
//	public void setITV(ITV tv)
//	{
//		this.tv = tv;
//	}
//	@Override
//	public void open() {
//		// TODO Auto-generated method stub
//		tv.play();
//	}
//}
//class ChangHong implements ITV{
//
//	@Override
//	public void play() {
//		// TODO Auto-generated method stub
//		System.out.println("长虹电视机，打开");
//	}
//}

④.里式替换原则：在子类中尽量不要重写父类的方法。继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖 来解决问题。

⑤.开闭原则:当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

把创建Shape类做成抽象类，并提供一个抽象的draw方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承Shape，并实现draw方法即可，使用方的代码就不需要修改

package com.acofkings.principle.ocp;

public class Ocp {

	public static void main(String[] args) {
		 GraphicEditor graphicEditor = new GraphicEditor();
		 graphicEditor.drawShape(new Rectangle());
		 graphicEditor.drawShape(new Circle());
		 graphicEditor.drawShape(new Triangle());
		 graphicEditor.drawShape(new Other());
	}
}

class GraphicEditor{
	public void drawShape(Shape s)
	{
		s.draw();
	}
}

abstract class Shape{
	public abstract void draw();
}

class Rectangle extends Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制一个矩形");
	}
}
class Circle extends Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制一个圆形");
	}
}

class Triangle extends Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制一个三角形");
	}
	
}
//当需要改变时，我们只需要新增而不需要修改原有代码
class Other extends Shape{

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println("绘制其他图形");
	}
}

⑥.迪米特法则：又称为最少知道原则，只与直接朋友（称出现成员变量，方法参数，方法返回值中的类为直接的朋友）进行通信，降低类之间的耦合。

⑦.合成复用原则：原则是尽量使用合成/聚合的方式，而不是使用继承

//依赖
class A{
}
class B{
	public void function(A a) {
		
	}
}

//组合：整体和部分不可分开
class A{
}
class B{
	A a = new A();
}

//聚合：整体和部分可分开
class A{
}
class B{
	A a;
	public void setA(A a)
	{
		this.a =a;
	}
}