常见的设计模式

单例模式

设计原则：

• 1.单一职责原则:
• 又称单一功能原则。所谓职责是指类变化的原因。如果一个类有 多于一个的动机被改变,那么这个类就具有多于-一个的职责。
• 而单一-职责原则就是指一 一个类或者模块应该有且只有一个改变的原因。
• 2.开放封闭原则:
• 是所有面向对象原则的核心。其核心的思想是:软件实体应该是可扩展,而不可修改的。
• 也就是说,对扩展是开放的,而对修改是封闭的。主要体现在两个方面:
• -对扩展开放，意味着有新的需求或变化时,可以对现有代码进行扩展，以适应新的情况。
• -对修改封闭，意味着类一旦设计完成 ，就可以独立完成其工作，而不要对类进行任何修改。
• 3.依赖倒置原则:
• 是程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,
• 不要对实现进行编程,这样就降低了客户与实现模块间的耦合。主要体现在两方面:
• -高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。
• -抽象不应该依赖于具体实现,具体实现应该依赖于抽象。
• 4.接口隔离原则:
• 使用多个专门的接口比使用单一的总接口要好，一个类对另外一个类的依赖性应当
• 是建立在最小的接口上的，一个接口代表一个角色，不应当将不同的角色都交给一个接口。
• 5.里氏代换原则:
• 使用多个专门的接口比使用单一的总接口要好，一个类对另外一个类的依赖性应当是建立在最小的接口上的，
• 一个接口代表一个角色，不应当将不同的角色都交给一个接口。使用多个专门的接口比使用单一的总接口要好，
• 一个类对另外一个类的依赖性应当是建立在最小的接口上的，一个接口代表一个角色，不应当将不同的角色都交给一个接口。

饿汉式

//饿汉式单例类.在类初始化时，已经自行实例化 
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

懒汉式

package cn.iceson.singlen;
/**
 * 
 * @author lucky_ice
 *
 */
public class SingleTon {
	protected double d=Math.random();//生成0~1之间的随机一个浮点数
	
	private static SingleTon singleTon=null;
	
	//私有化构造器，不让其他类创建本类的对象
	private SingleTon(){
		
	}
	
	//静态工厂:专门用来生成类的实例
	public static SingleTon singleTon2(){
		if (singleTon==null) {
			singleTon=new SingleTon();
		}
		return singleTon;
	}
}

工厂模式

简单工厂模式

Car.java

package cn.iceson.factory.jd;

//抽象产品角色
public abstract class Car {
	public abstract void drive();
}

//具体产品角色：Bike
class Bike extends Car{

	@Override
	public void drive() {
		System.out.println("骑自行车！");
	}
	
}

//具体产品角色：Bus
class Bus extends Car{

	@Override
	public void drive() {
		System.out.println("开公共汽车！");
	}
}

Factory.java

package cn.iceson.factory.jd;
/**
 * 简单工厂模式
 * @author lucky_ice
 *
 */

//工厂类
public class Factory {
	
	static Car car=null;//定义一个父类引用
	//静态方法：生产具体产品，参数表示用户需求
	public static Car product(int i) {
		switch (i) {
		case 1:
			car=new Bike();//生产Bike类的实例
			break;
		case 2:
			car=new Bus();//生产Bus类的实例
			break;
		default:
			break;
		}
		return car;
	}
}

Test.java

package cn.iceson.factory.jd;

public class Test {
	public static void main(String[] args) {
		Car car=Factory.product(1);//向上转型
		car.drive();//调用Bike类中的方法
	}
}

工厂方法模式

Car.java

package cn.iceson.factory.ff;

//抽象产品角色
public abstract class Car {
	//抽象行为：所有子类都具有，但实现机制不一样
	public abstract void drive();
}

//具体产品角色：Bike
class Bike extends Car{

	@Override
	public void drive() {
		System.out.println("骑自行车！");
	}
	
}

//具体工厂角色
class Bus extends Car{

	@Override
	public void drive() {
		System.out.println("开公共汽车！");
	}
	
}

FactoryMethod.java

package cn.iceson.factory.ff;
/**
 * 工厂方法模式
 * @author lucky_ice
 *
 */
//抽象工厂角色
public abstract class FactoryMethod {
	//抽象行为：所有子类都具有的行为，但生产的产品不一致
	public abstract Car product();
}

//具体工厂角色：用于生产Bike实例
class BikeFactory extends FactoryMethod{

	@Override
	public Car product() {
		return new Bike();
	}
	
}

//具体工厂角色：用于生产Bus实例
class BusFactory extends FactoryMethod{

	@Override
	public Car product() {
		return new Bus();
	}
	
}

Test.java

package cn.iceson.factory.ff;

public class Test {

	public static void main(String[] args) {
		//获取具体工厂对象
		FactoryMethod factoryMethod= new BikeFactory();
		//通过工厂生产具体产品
		Car car=factoryMethod.product();
		//调用Bike类中的方法
		car.drive();
	}

}

抽象工厂模式

Car.java

package cn.iceson.factory.cx;

//抽象产品类
public abstract class Car {
	public abstract void drive();
}

//具体产品类
class Bus extends Car{

	@Override
	public void drive() {
		System.out.println("开走汽车");
	}
	
}

Chairs.java

package cn.iceson.factory.cx;

//抽象产品类
public abstract class Chairs {
	public abstract void shape();
}

//具体产品类
class CarChairs  extends Chairs{

	@Override
	public void shape() {
		System.out.println("汽车椅子！");
	}
	
}

Wheel.java

package cn.iceson.factory.cx;

//抽象产品类
public abstract class Wheel {
	public abstract void run();
}

//具体产品类
class CarWheel extends Wheel{

	@Override
	public void run() {
		System.out.println("汽车轮子！");
	}
	
}

Factory.java

package cn.iceson.factory.cx;
/**
 * 抽象工厂模式
 * @author lucky_ice
 *
 */

//抽象工厂类
public abstract class Factory {
	//生产Chairs的实例
	public abstract Chairs productChairs();
	//生产Wheel的实例
	public abstract Wheel productWheel();
	//生产Car的实例
	public abstract Car productCar();
}

//抽象工厂类：生产有依赖关系的多个
class CarFactory extends Factory{

	@Override
	public Chairs productChairs() {
		return new CarChairs();
	}

	@Override
	public Wheel productWheel() {
		return new CarWheel();
	}

	@Override
	public Car productCar() {
		return new Bus();
	}	
}

代理模式

Subject.java

package cn.iceson.proxy;
/**
 * 抽象主题角色
 * @author lucky_ice
 *
 */
public abstract class Subject {
	public abstract void operate();
}

//真实角色(被代理角色)
class RealSubject extends Subject{

	//真正完成业务逻辑的方法
	@Override
	public void operate() {
		System.out.println("operate...");
	}	
}

Porxy.java

package cn.iceson.proxy;
/**
 * 代理类
 * @author lucky_ice
 *
 */
public class Proxy extends Subject{
	Subject subject;
	public Proxy(){
	}
	
	//构造器：决定哪一个是真实角色
	public Proxy(Subject subject) {
		this.subject=subject;
	}
	@Override
	public void operate() {
		System.out.println("before...");//预处理
		
		subject.operate();//真正做事情
		
		System.out.println("after...");//善后工作
	}
}

Test.java

package cn.iceson.proxy;

public class Test {

	public static void main(String[] args) {
		//创建真实角色对象
		Subject subject=new RealSubject();
		
		//创建代理对象，并将真实角色对象作为参数传入
		Proxy proxy=new Proxy(subject);
		
		//触发事件被执行
		proxy.operate();
	}
}

观察者模式

Visitor.java

package cn.iceson.observer;
/**
 * 抽象观察者角色
 * @author lucky_ice
 *
 */
public abstract class Visitor {
	//在主题发生改变时，需要更新自己的状态与状态相协调
	public abstract void update();
}

//具体的观察者角色
class Protector extends Visitor{

	@Override
	public void update() {
		System.out.println("保护运钞车");
	}
}

//具体观察者角色
class Thief extends Visitor{

	@Override
	public void update() {
		System.out.println("准备动手");
	}
}

TransferCar.java

package cn.iceson.observer;

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

/**
 * 抽象主体角色
 * @author lucky_ice
 *
 */
public abstract class TransferCar {
	
	//添加观察者角色
	public abstract void add(Visitor visitor);
	
	//删除观察者角色
	public abstract void delete(Visitor visitor);
	
	//通知所有的观察者角色来更新自己的状态
	public abstract void notice();
}

class TransferCarMoney extends TransferCar{
	
	//创建集合，用来装观察者对象
	List<Visitor> list=new ArrayList<Visitor>();
	//添加观察者角色
	@Override
	public void add(Visitor v) {
		list.add(v);
	}

	//删除观察者角色
	@Override
	public void delete(Visitor v) {
		list.remove(v);
	}

	//通知所有的观察者角色来更新自己的状态
	@Override
	public void notice() {
		//遍历集合list，得到每一个观察者对象，并且通过调用方法来更新自己
		for (Visitor visitor : list) {
			visitor.update();
		}
	}	
}

Test.java

package cn.iceson.observer;

public class Test {

	public static void main(String[] args) {
		Visitor p=new Protector();//观察者对象Protector
		
		Visitor t=new Thief();//观察者对象Thief
		
		TransferCar tc=new TransferCarMoney();//具体主题角色对象TransferCarMoney
		
		//添加两个观察者
		tc.add(p);
		tc.add(t);
		
		//具体主题角色发生状态改变时
		tc.notice();
	}
}

适配器模式

Adaptee.java

package cn.iceson.adapter;
/**
 * 源角色：本身所具有的
 * @author lucky_ice
 *
 */
public class Adaptee {
	//普通接口
	public void operate1(){
		System.out.println("普通接口");
	}	
}

Target.java

package cn.iceson.adapter;

/**
 * 目标接口
 * @author lucky_ice
 *
 */
public interface Target {
	public abstract void operate1();//普通接口 （三孔插座）
	
	public abstract void operate2();//特殊接口（二孔插座）
}

Adapter.java

package cn.iceson.adapter;
/**
 * 适配器(Adapter)
 * @author lucky_ice
 *
 */
public class Adapter extends Adaptee implements Target{

	@Override
	public void operate2() {
		System.out.println("特殊接口");
	}	
}

Test.java

package cn.iceson.adapter;

public class Test {

	public static void main(String[] args) {
		Adapter adapter=new Adapter();
		adapter.operate1();
		adapter.operate2();
	}
}