首页 / 设计模式 / [设计模式]3.创建型模式

[设计模式]3.创建型模式

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了[设计模式]3.创建型模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7590字，纯文字阅读大概需要11分钟。

内容图文

一、创建型模式的特点与分类

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。这样可以降低系统的耦合度，使用者不需要关注对象的创建细节，对象的创建由相关的工厂来完成。就像我们去商场购买商品时，不需要知道商品是怎么生产出来一样，因为它们由专门的厂商生产。

  • 单例模式：某个类只能有一个实例，提供一个全局的访问点。
  • 简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。
  • 工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。
  • 抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。
  • 建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。
  • 原型模式：通过复制现有的实例来创建新的实例。

卖票

//测试
public class CilentTest {
	public static void main(String arg[]){
		Customer p1=new Children();
		System.out.println(p1.calculate(100.00));		
		Customer p3=new Vip();
		System.out.println(p3.calculate(100.00));
	}
}
//
interface Customer {
	public double calculate(double price);
}
//vip票
class Vip implements Customer {
    private String name="VIP";
    private double jifeng=0;
    
	public double calculate(double price){	
		jifeng=jifeng+0.1*price;	
		System.out.println("Welcome VIP,Now your jifen is "+jifeng);	
		System.out.print(name+"'s price is ");	
		return 0.8*price;
	}	
}
//儿童票
class Children implements Customer{
	private String name="children";
	public double calculate(double price){	
		System.out.print(name+"'s price is ");
		return 0.5*price;
	}
}
//学生票
class Student implements Customer{
	private String name="student";	
	public double calculate(double price){		
		System.out.print(name+"'s price is ");		
		return 0.8*price;
	}
}

简单工厂模式

1、工厂模式的定义

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。在简单工厂模式中创建实例的方法通常为静态方法，因此简单工厂模式又叫作静态工厂方法模式

2、简单工厂模式的主要角色

  • 简单工厂（SimpleFactory）：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
  • 抽象产品（Product）：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
  • 具体产品（ConcreteProduct）：是简单工厂模式的创建目标。

[设计模式]3.创建型模式 - 文章图片

3、该模式的代码

//测试
public class CilentTest {
    public static  void  main(String[] args){
        Fruit fruit=FruitFarm.getFruit("apple");
        fruit.eat();

        Fruit fruit1=FruitFarm.getFruit("orange");
        fruit1.eat();
    }
}
//抽象产品
interface Fruit {
    public void eat();
}
//具体产品1：Apple
class Apple implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat Apple!");
    }
}
//具体产品2：Orange
class Orange implements Fruit{
    @Override
    public void eat() {
        System.out.println("eat Orange!");
    }
}
//SimpleFactory工厂
class FruitFarm {
    public static Fruit getFruit(String args){
        if(args.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(args.equalsIgnoreCase("orange")){
            return new Orange();
        }else{
            return null;
        }
    }
}

C++的浅拷贝与深拷贝对比Java的浅克隆与深克隆

C++部分

#include<iostream>
#include<string>
using namespace std;

class Email {
private:
	string title;
    /*这里是一个指针，当经行拷贝时，会产生另一个指针也指向它堆对应的地址。
      当用户删除原来的指针时，会把对象里面的这个指针也删除，那么此时，第二个指向里面的对象就会丢失对象中的int指针。
    */
	int* pNumber;
public:
	Email(string title) {
		this->title = title;
		this->pNumber = new int(666);
	}
	Email(const Email& email) {
		this->title = email.title;
		this->pNumber = email.pNumber;
	}
	~Email() {
		delete pNumber;
	}
};

int main() {
		Email e1("message");
		Email e2 = e1;
	return 0;
}

Java部分

import java.util.ArrayList;
import java.util.List;
public class Student implements Cloneable{//想要拷贝就得实现这个接口
    private String name;
    private int age;
    private String gender;
    private List<String> friends;

    public Student clone() throws CloneNotSupportedException{
            Student student=(Student) super.clone();
            List<String> new_friends=new ArrayList<String>();//在这里自己重新开辟一个新的对象，把新的对象赋给新cpoy的Students
            for(String friends:this.getFriends()){
                new_friends.add(friends);//把以前的list中的数据拷贝到新的friends中去
            }
            student.setFriends(new_friends);
            return student;//把加工后的student返回    
   	 }
	//set、get方法略

}
////////////////////////////////////////////////////////////////////////////
import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        Student s1=new Student();
        /*Student s2=s1;
        System.out.println(s1==s2);//true，指向的是堆里面的同一个对象的地址*/

        //继承了Cloneable方法
        List<String> friends=new ArrayList<String>();
        friends.add("swift");
        friends.add("jack");
        s1.setFriends(friends);
        Student s2=s1.clone();//调用Java给的克隆方法实现克隆
        System.out.println(s1==s2);//false
        System.out.println(s1.getFriends());//[swift, jack]
        System.out.println(s2.getFriends());//[swift, jack]
        friends.add("newFriend");
        s1.setFriends(friends);//对s1更改，看s2是否变化
        System.out.println(s1.getFriends());
        System.out.println(s2.getFriends());//s2也变了，说明两个对象指向的是同一个friends对象

        //对clone方法更改后，发现s2没有变化了，说明他们两个student对象独立了
                /*false
                [swift, jack]
                [swift, jack]
                [swift, jack, newFriend]
                [swift, jack]*/
    }
}

建造者模式

1、建造者（Builder）模式的定义

是指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

2、模式的结构

建造者（Builder）模式的主要角色：

  1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。

  2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。

  3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

  4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

[设计模式]3.创建型模式 - 文章图片

3、 模式的实现

(1) 产品角色：包含多个组成部件的复杂对象。

//Actor类
public class Actor {
    private String type;
    private String sex;
    private String face;
    private String costume;
    private String hairstyle;
	
    //set.get方法略
}

(2) 抽象建造者：包含创建产品各个子部件的抽象方法。

//ActorBuilder 类
public abstract class ActorBuilder {
    Actor actor = new Actor();  //创建角色对象

    public abstract void BuildType();
    public abstract void BuildSex();
    public abstract void BuildFace();
    public abstract void BuildCostume();
    public abstract void BuildHairstyle();
    
	//返回角色对象
    public Actor CreateActor(){
         return actor;
    }
}

(3) 具体建造者：实现了抽象建造者接口。

//DevilBuilder类
public class DevilBuilder extends ActorBuilder{

    @Override
    public void BuildType() {
        this.actor.setType("恶魔");
    }

    @Override
    public void BuildSex() {
        this.actor.setSex("男");
    }
	// BuildFace()、BuildCostume()、BuildHairstyle()省略
    
    @Override
    public Actor CreateActor() {
        BuildType();BuildSex();BuildFace();BuildCostume();BuildHairstyle();
        return this.actor;
    }
////////////////////////////////////////
//AngelBuilder类
public class AngelBuilder extends ActorBuilder{
   //省略。。。
}

(4) 指挥者：调用建造者中的方法完成复杂对象的创建。

//ActorController类
public class ActorController {
    public Actor Construct(ActorBuilder ab){
        return ab.CreateActor();
    }
}

(5) 客户类。

// Client测试类
public class Client {
    public static void main(String[] args) {
        ActorController ac = new ActorController();
        ActorBuilder ab = new DevilBuilder();
        Actor actor = ac.Construct(ab);
        System.out.println(actor);
    }
}

4、建造者模式和工厂模式的区别

区别：

  • 建造者模式更加注重方法的调用顺序，工厂模式注重创建对象。
  • 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样
  • 关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成。
  • 建造者模式根据建造过程中的顺序不一样，最终对象部件组成也不一样。

http://c.biancheng.net/view/1354.html

内容总结

以上是互联网集市为您收集整理的[设计模式]3.创建型模式全部内容，希望文章能够帮你解决[设计模式]3.创建型模式所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/991092.html

来源：【匿名】