设计模式

1.抽象工厂模式
简单工厂模式意义不大，算不上工厂,抽象工厂好处就是新增动物类别,就新创建个factory,也遵循开闭原则,可新增不可修改

public interface AnimalFactory {
	//获得狗的方法
	public Dog createDog();

	//获得猫的方法
	public Cat createCat();
}

猫的工厂

public class CatFactory implements AnimalFactory {
	@Override
	public Cat createCat() {
		return new Cat();
	}

	@Override
	public Dog createDog() {
		return null;
	}
}

狗的工厂

public abstract class DogFactory implements AnimalFactory {

	@Override
	public Dog createDog() {
		return new Dog();
	}

	@Override
	public Cat createCat() {
		return null;
	}
}

public class Test {
	public static void main(String[] args) {
		AnimalFactory catFactory = new CatFactory();
		//获取猫对象
		catFactory.createCat();
		
		AnimalFactory dogFactory = new CatFactory();
		//获取狗对象
		dogFactory.createDog();
	}
}

2.建造者模式
一个对象的任意一个属性,创建对象

public class Response implements Serializable {

	private static final long serialVersionUID = 1L;
	
	private int retcode;
	private String msg;
	private Object data;
	
	public int getRetcode() {
		return retcode;
	}
	public Response setRetcode(int retcode) {
		this.retcode = retcode;
		return this;
	}
	public String getMsg() {
		return msg;
	}
	public Response setMsg(String msg) {
		this.msg = msg;
		return this;
	}
	public Object getData() {
		return data;
	}
	public Response setData(Object data) {
		this.data = data;
		return this;
	}
	
	public static Response build(){
		return new Response();
	}
}

public class Test {
	public static void main(String[] args) {
		Response.build()
				.setRetcode(ErrorCode.SUCCESS.getCode())
				.setMsg(ErrorCode.SUCCESS.getMessage())
				.setData(accountData)
	}
}

3.单利模式
饿汉式:

public class Singleton {
	private Singleton(){}

	private static class SingletonBuild{
		private static Singleton value = new Singleton();
	}

	public static Singleton getInstance(){  return  SingletonBuild.value ;}

}

4.原型模式
用的比较少

5.适配器模式
(1).类适配器

public interface IPeople {
	public void getPeople();
}

public interface IUser {
	public void getUser();
}

IUser的实现类

public interface UserImpl {
	@Override
	public void getUser(){
		System.out.println("method : getUser");
	};
}

写一个方法,这个方法原本调用IPeople 接口,但是发现IUser 有对应的实现,就可以写个adapter

 public class Adapter extends UserImpl  implements IPeople {
	@Override
     public void getPeople2() {
         getUser();
     }
}

(2).对象适配

IUser ,IPeople ,UserImpl 不变

public class Adapter implements IPeople{
	
	private IUser iuser;
	
	public Adapter(IUser user) {
		this.iuser = user;
	}
	
	@Override
	public void getPeople() {
		iuser.getUser();
	}
}

public class Test {
	public static void main(String[] args) {
		
		IPeople ip = new Adapter(new UserImpl());
		//调用Adapter 中的getPeople(),其实就是调用iuser.getUser();
		ip.getPeople();
	}
}

输出:

method : getUser

(3).接口适配 + 装饰者模式
父接口

public interface Port {
	public void redis();
	public void tomcat();
}

抽象类实现接口,也是装饰者类

//装饰者
public abstract class AbstratPort implements Port{

	@Override
	public void redis() {
		System.out.println("3306");
	}

	@Override
	public void tomcat() {
		System.out.println("8080");
	}
	
}

A子类

public class PortImplA extends AbstratPort{

	@Override
	public void redis() {
		System.out.println("实现类A 6379");
	}

	@Override
	public void tomcat() {
		System.out.println("实现类A 8080");
	}
	

}

B子类,装饰者的体现

public class PortImplB extends AbstratPort{
	
	@Override
	public void redis() {
		System.out.println("实现类B 3306");
	}

}

测试

public static void main(String[] args) {
		
		Port porta = new PortImplA();
		porta.tomcat();
		porta.redis();
		Port portb = new PortImplB();
		portb.tomcat();
		portb.redis();
	}

实现类A 8080
实现类A 6379
8080
实现类B 3306

接口适配:抽象类实现接口,使用不同的子类继承抽象类,重写目标方法
装饰者:抽象类实现接口,子类继承抽象类中目标方法,只需重写目标方法,不需全部实现接口全部方法.

6.策略模式
点击查看

7.代理模式
未完~