【设计模式系列】--原型模式

淡淡的烟草味﹌ 2022-07-15 02:14 131阅读 0赞

在前面的博文中，小编介绍了设计模式的相关知识，今天这篇博文，咱们继续来学习设计模式的相关知识，今天小编向大家介绍的模式是原型模式，还请小伙伴多多指教，小编会从什么是原型设计模式、原型模式的结构图、原型模式的demo以及原型模式的特点和应用场景等方面一一进行介绍，希望对有需要的小伙伴有帮助。

**什么是原型模式**

原型模式英文名称叫Prototype，是一种创建型模式，她采用复制原型对象的方法来创建对象的实例，使用Prototype模式创建的实例，具有与原型一样的数据，我们来看一下原型模式的结构图，如下所示：

![Image 1][]

**原型模式Demo**

接着，小编结合相关的demo来进一步讲解原型模式，新建java项目Prototype，新建类Person，编写相关代码，如下所示：

public class Person {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	//性别
    	private String sex;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	
    
    }

新建MainClass类，编写相关代码，如下所示：

我们创建了两个对象，肯定是不相同的是不是，发现除了name，其她地方都相同，我们希望，不用在重复设置，person2呢等于person1，只是name不同，我想复制这个对象，这个时候，我们就可以使用原型模式，我们来看一下原型模式的特点：

a、由原型对象自身创建目标对象，也就是说，对象创建这一动作发自原型对象本身。

b、目标对象是原型对象的一个克隆，也就是说，通过原型模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。

c、根据对象克隆深度层次的不同，有浅度克隆和深度克隆。

结合demo，原型对象person1，目标对象person2，我们希望通过1创建2，java里面有一个接口叫做Cloneable，只有实现了这个接口，才能被克隆，所以，我们需要提供一个clone的方法，完善Person里面的代码，如下所示：

public class Person implements Cloneable  {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	//性别
    	private String sex;
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	public Person clone(){
    		try{
    			return (Person)super.clone();
    		} catch (CloneNotSupportedException e){
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	
    
    }

编写MainClass里面的代码部分，如下所示：

public class MainClass {
    	public static void main(String[] args) {
    		Person person1 = new Person();
    		person1.setName("dingguohua");
    		person1.setAge(22);
    		person1.setSex("女");
    		
    		Person person2 = person1.clone();
    		
    		System.out.println(person1.getName());
    		System.out.println(person1.getAge());
    		System.out.println(person1.getSex());
    		
    		
    		System.out.println(person2.getName());
    		System.out.println(person2.getAge());
    		System.out.println(person2.getSex());
    		
    	}
    
    }

运行，如下所示：

![Image 1][]  
这样，就实现了我们的原型模式，接着，我们来看深度克隆和浅度克隆，什么是深度克隆和浅度克隆呢？比如我们在Person里面新添加一个属性，并且生成get和set方法，如下所示：

import java.util.List;
    
    
    public class Person implements Cloneable  {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	//性别
    	private String sex;
    	//朋友
    	private List<String> friends;
    	
    	public List<String> getFriends() {
    		return friends;
    	}
    	public void setFriends(List<String> friends) {
    		this.friends = friends;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	public Person clone(){
    		try{
    			return (Person)super.clone();
    		} catch (CloneNotSupportedException e){
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	
    
    }

编写MainClass中的代码部分，如下所示：

import java.util.ArrayList;
    import java.util.List;
    
    
    public class MainClass {
    	public static void main(String[] args) {
    //		Person person1 = new Person();
    //		person1.setName("dingguohua");
    //		person1.setAge(22);
    //		person1.setSex("女");
    //		
    //		Person person2 = person1.clone();
    //		
    //		System.out.println(person1.getName());
    //		System.out.println(person1.getAge());
    //		System.out.println(person1.getSex());
    //		
    //		
    //		System.out.println(person2.getName());
    //		System.out.println(person2.getAge());
    //		System.out.println(person2.getSex());
    		
    		Person person1 = new Person();
    		List<String> friends = new ArrayList<String>();
    		friends.add("xiaodingding");
    		friends.add("xiaoxiaoding");
    		
    		person1.setFriends(friends);
    		Person person2 = person1.clone();
    		
    		System.out.println(person1.getFriends());
    		System.out.println(person2.getFriends());
    		
    	}
    
    }

运行代码，效果如下所示：

![Image 1][]  
如果这个时候，再加上一个呢？完善代码，如下所示：

运行，如下所示：

![Image 1][]  
这是一种浅度的克隆，那么怎么样才算是深度的克隆呢？完善Person的代码，如下所示：

import java.util.ArrayList;
    import java.util.List;
    
    
    public class Person implements Cloneable  {
    	//姓名
    	private String name;
    	//年龄
    	private int age;
    	//性别
    	private String sex;
    	//朋友
    	private List<String> friends;
    	
    	public List<String> getFriends() {
    		return friends;
    	}
    	public void setFriends(List<String> friends) {
    		this.friends = friends;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getSex() {
    		return sex;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	public Person clone(){
    		try{
    			Person person =(Person)super.clone();
    			List<String> newfriends = new ArrayList<String>();
    			for(String friends :this.getFriends()){
    				newfriends.add(friends);
    			}
    			person.setFriends(newfriends);
    			return person;
    		} catch (CloneNotSupportedException e){
    			e.printStackTrace();
    			return null;
    		}
    	}
    	
    	
    
    }

运行，效果如下所示：

![Image 1][]  
这样就是先了深度克隆，接着，我们来看一下原型模式应用的场景。

**原型模式应用场景**

a、在创建对象的时候，我们不只是希望被创建的对象继承其基类的基本结构，还希望继承原型对象的数据。

b、希望对目标对象的修改不影响既有的原型对象，深度克隆的时候可以完全互不影响。

c、隐藏克隆操作的细节，很多时候，对对象本身的克隆需要涉及到类本身的数据细节。

**小编寄语：**该博文，小编主要简单的介绍了原型模式，从什么是原型模式，原型模式的结构图，原型模式的特点以及应用场景等方面一一对原型模式进行了相关的讲解，总得来说，原型模式主要解决的问题是，某些结构复杂的对象的创建工作，由于需求的变化，这些对象经常面临着剧烈的变化，但是她们却用用比较稳定的一致的接口。

[Image 1]: