23个设计模式中最常用的设计模式_设计模式常考模式-CSDN博客

本文链接：https://blog.csdn.net/qq_36303847/article/details/79817224

分为三大类：

创建型模式：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式

结构型模式：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式

行为型模式：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。

代理模式：

静态代理

public class Test {
	
	public static void main(String[] args) {
		//手机要打电话
		Phone phone = new IPhone();
		phone.call();
		System.out.println("------------------------------");
		//如果要听歌
		Music music = new Music(phone);
		music.call();
		
		
	}
}
class IPhone implements Phone{

	@Override
	public void call() {
		System.out.println("手机可以打电话");
	}

}
interface Phone {
	
	//打电话
	void call();
}

class Music implements Phone{
	
	private Phone i;
	public Music(Phone p){
		this.i=p;
	}
	
	@Override
	public void call() {
		i.call();
		System.out.println("手机可以听歌");
		
	}
	
}

jdk动态代理

public class TT {

	/**
	 * @测试类
	 */
	public static void main(String[] args) {
		final QQ qq=new QQ();
				
		//两者都一样
		//Car qqProxy=(Car)Proxy.newProxyInstance(QQ.class.getClassLoader(),new Class[]{Car.class},new InvocationHandler() {
		Car qqProxy=(Car)Proxy.newProxyInstance(qq.getClass().getClassLoader(),qq.getClass().getInterfaces(),new InvocationHandler() {
					
			
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

				if("run".equals(method.getName())){
					System.out.println("加上电池");
					Object bj = method.invoke(qq, args);
					System.out.println("五秒破百");
					return bj;
				}
				
				return method.invoke(qq, args);
			}
		});
		
		qqProxy.run();
		qqProxy.start();
	}

}
interface Car {
	public void run();
	public void start();
}
class QQ implements Car {

	public void run() {
		System.out.println("qq在跑");

	}

	public void start() {
		System.out.println("qq刹车了");

	}

}

cgLib代理：请自行百度。

工厂模式：

简单工厂模式：

简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

        简单工厂模式的缺点是：
        1. 工厂类过于庞大，包含了大量的if…else代码，导致为何和测试的难度增大。
        2. 系统扩展不灵活，如果增加新类型的产品，必须修改静态工厂方法的业务逻辑，违反了开闭原则。

public class Test {
	public static void main(String[] args) {
		//自己创建对象
		 Animal a=new Dog();
		 a.eat();
		 a=new Cat();
		 a.eat();
		
		System.out.println("-----------");
		//简单工厂模式
		Animal d =AnimalFactory.ca("Dog");
		d.eat();
		
		d=AnimalFactory.ca("Cat");
		d.eat();
		d=AnimalFactory.ca("Pat");
		//先判断不为null再使用
		if(d!=null){
			d.eat();
		}
		
	}
abstract class Animal {
	public abstract void eat();
}	
class AnimalFactory {
	private AnimalFactory(){}
	
	//传一个参数过来，返回一个动物
	public static Animal ca(String type){
		if("Dog".equals(type)){
			return new Dog();
		}else if("Cat".equals(type)){
			return new Cat();
		}else{
			System.out.println("没有这种动物");
			return null;
		}
	}
	
}	
class Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
}	
class Dog extends Animal {
	 @Override
	 public void eat() {
	 System.out.println("狗狗吃狗粮");
	 }

}

}

工厂方法模式：

工厂方法模式：定义一个用于创建对象的接口，让子类决定将哪个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

public class Test {
	public static void main(String[] args) {
		//工厂方法模式
		//需求：我要买只狗
		Factory f=new DogFactory();
		Animal a=f.ca();
		a.eat();
		
		
	}
}
abstract class Animal {
	public abstract void eat();
}
interface Factory {
	public abstract Animal ca();
}
class DogFactory implements Factory{

	public  Animal ca() {
		return new Dog();
	}

}

class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}

}

抽象工厂模式：具体百度。

单例模式：

懒汉式

public class Teacher {
	private Teacher(){}
	
	private static Teacher t=null;
	
	//面试这样的话，才正确。加上同步关键字（synchronized）  饿汉式
	public synchronized static Teacher getTeacher(){
		if(t==null){
			t=new Teacher();
		}
		return t;
	}			
}

饿汉式

public class Singleton{  
    //类加载时就初始化  
    private static final Singleton instance = new Singleton();  
      
    private Singleton(){}  
  
    public static Singleton getInstance(){  
        return instance;  
    }  
}

委派模式：

委派模式（Delegate）是面向对象设计模式中常用的一种模式。这种模式的原理为类B和类A是两个互相没有任何关系的类，B具有和A一模一样的方法和属性；并且调用B中的方法，属性就是调用A中同名的方法和属性。B好像就是一个受A授权委托的中介。第三方的代码不需要知道A的存在，也不需要和A发生直接的联系，通过B就可以直接使用A的功能，这样既能够使用到A的各种公能，又能够很好的将A保护起来了。一举两得，岂不很好！下面用一个很简单的例子来解释下：

class A{
   method1();
   method2();
}
class B{  
    //delegation  
    A a = new A();  
   //method with the same name in A  
    void method1(){ a.method1();}  
    void method2(){ a.method2();}  
    //other methods and attributes  
    ...  
}  
public class Test{  
     public static void main(String args[]){  
    B b = new B();  
    b.method1();//invoke method2 of class A in fact  
    b.method2();//invoke method1 of class A in fact  
    }  
      
}

策略模式：

https://blog.csdn.net/fiendvip/article/details/51113967

原型模式：

https://blog.csdn.net/o279642707/article/details/62046780

模板模式：

https://www.cnblogs.com/qq-361807535/p/6854191.html

六大设计原则请参考：https://blog.csdn.net/qq_36303847/article/details/77992671