Java之常用设计模式

设计模式代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

工厂模式：
工厂模式是Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

步骤 1:

/**抽象类
 * @author Administrator
 */
public interface Mouse {
	
    public abstract void  sayhello();
    
}

步骤 2：

/**DellMouse实现类类
 * @author Administrator
 */
public class DellMouse implements Mouse {

	@Override
	public void sayhello() {
		
		System.out.println("我是Dellmouse");
	}  
	
}

步骤 3：

/**Lenovo实现类
 * @author Administrator
 */
public class Lenovo implements Mouse{

	@override
	public void sayhello() {		
		System.out.println("我是Lenovomouse");		
	}

}

步骤 4：

/**
 * 创建工厂
 * @author Administrator
 */
public class MouseFactory {
    public static Mouse creatmouse(String str){   //返回值是：Mouse类型，因为DellMouse类和Lenovo类共有一个父类Mouse
    	Mouse mouse = null;
    	if(str.equals("Dell")){
    		mouse = new DellMouse();
    	}else if(str.equals("Lenovo")){
    		mouse = new Lenovo();
    	}
    	return mouse;
    }
}

步骤 5：
Test：

public class Text {
	public static void main(String[] args) {
		Mouse mouse =  MouseFactory.creatmouse("Dell");  //因为creatmouse（）返回的就是Mouse类型
         mouse.sayhello();  //new的哪个类就调用哪个类的方法
         Mouse lenovomouse =  MouseFactory.creatmouse("Lenovo");
         lenovomouse.sayhello();
	}
}

运行结果：

抽象工厂模式：

抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

超级工厂：
步骤 1：

public abstract class Pcfactiry {
         public abstract Mouse createfactory();
}

步骤 2：

//Dell工厂
public class DellFactiry extends Pcfactiry{
	@Override
	public Mouse createfactory() {
		return new DellMouse();
	}
}

步骤 3：

/**联想工厂
 * @author Administrator
 */
public class Lenovofactory extends Pcfactiry{

	@Override
	public Mouse createfactory() {
		return new Lenovo();
	}
}

步骤 4：

public static void main(String[] args) {
		
		Pcfactiry pcfactory = new DellFactiry();
		Mouse mouse = pcfactory.createfactory();
		mouse.sayhello();
		
		pcfactory = new Lenovofactory();
		mouse = pcfactory.createfactory();
		mouse.sayhello();
	}

运行结果：

单例模式：

顾名思义，该类只创建一个实例，并且提供一个全局的访问方法供其他的类调用，目的是解决一个全局使用的类频繁地创建与销毁，节省系统资源。

单例模式的几种实现方式：

1、懒汉式，线程不安全

public class SecondSingleton {
//	懒汉式，只声明，不创建
	private static  SecondSingleton instance=null; 
	
//	构造方法private
	private SecondSingleton(){}  
	
//	当第一次调用getInstance方法时，创建唯一实例
	public static SecondSingleton getInstance(){ 
		
		if(instance==null){    //说明还没有创建过
			instance=new SecondSingleton();   //只再次创建一次
		}
		return instance;  
	}  

}

2、懒汉式，线程安全

public class SecondSingleton {
//	懒汉式，只声明，不创建
	private static  SecondSingleton instance=null; 
	
//	构造方法private
	private SecondSingleton(){}  
	
//	当第一次调用getInstance方法时，创建唯一实例
	public static synchronized  SecondSingleton getInstance(){ 
		
		if(instance==null){    //说明还没有创建过
			instance=new SecondSingleton();   //只再次创建一次
		}
		return instance;  
	}  
}

3、饿汉式

//饿汉式单例，类加载时创建对象
public class FirstSingleton {
	
//	饿汉式单例，声明并创建一个自身的static实例,private保证一个类只有一个实例
	private static FirstSingleton instance=new FirstSingleton();
	
//	构造方法是private，防止外界创建该类对象
	private FirstSingleton(){ 
	}  
	
//	提供静态public方法，返回自己创建的唯一实例,FirstSingleton表明返回的值是类
	public static FirstSingleton getInstance(){ 
		return instance;  
	}  
}

4、双检锁/双重校验锁

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}

还有登记式/静态内部类跟枚举………

代理模式:

代理模式中，一个类代表另一个类的功能,目的是为其他对象提供一种代理以控制对这个对象的访问。

步骤1：
创建一个接口：

public interface Image { void display(); }

步骤2：
创建一个实现类：

public class RealImage implements Image {
	 
	   private String fileName;
	 
	   public RealImage(String fileName){
	      this.fileName = fileName;
	      loadFromDisk(fileName);   //在创建类的时候就执行下面的方法
	   }
	 
	   @Override
	   public void display() {
	      System.out.println("Displaying " + fileName);
	   }
	 
	   private void loadFromDisk(String fileName){
	      System.out.println("Loading " + fileName);
	   }
}

步骤3：

public class ProxyImage implements Image{
	 
	   private RealImage realImage;
	   private String fileName;
	 
	   public ProxyImage(String fileName){
	      this.fileName = fileName;
	   }
	 
	   @Override
	   public void display() {
	      if(realImage == null){
	         realImage = new RealImage(fileName);
	      }
	      realImage.display();
	   }
	}

步骤4：

当被请求时，使用 ProxyImage 来获取 RealImage 类的对象：

public class ProxyPatternDemo {
	   
	   public static void main(String[] args) {
	      Image image = new ProxyImage("test_10mb.jpg");
	 
	      // 图像将从磁盘加载
	      image.display(); 
	      System.out.println("");
	      // 图像不需要从磁盘加载
	      image.display();  
	   }
	}

运行结果：

Loading test_10mb.jpg
Displaying test_10mb.jpg
Displaying test_10mb.jpg

Java的设计模式还有很多，一共23种，详情请参考：
https://www.runoob.com/design-pattern/design-pattern-tutorial.html

欢迎留言讨论，感谢关注。

本文地址：https://blog.csdn.net/weixin_42409759/article/details/107594334