创建型设计模式，顾名思义，它是Java用来创建对象的结构

目录

单例模式

简单工厂模式

抽象工厂模式

生成器模式

原型模式

---

单例模式

单例模式确保一个类的对象只能再类本省创建，外部类不可调用此类的构造函数来创建对象，示例如下：

/**
 * 单例设计模式
 * @author Swing
 */
public class Test {
    //make constructor private
    private Test(){
        System.out.println("I am a test");
    }
    //static function to return a instance
    public static Test getInstance(){
        return new Test();
    }
    public static void main(String[] args) {
        Test test=Test.getInstance();
    }
}

简单工厂模式

/**
 * 宠物接口
 */
interface Pet {
    void color();
}

/**
 * 工厂模式
 *
 * @author Swing
 */
public class Test {
    public static void main(String[] args) {
        Pet petRabbit = PetFactory.getPet("Rabbit");
        petRabbit.color();
        Pet petDog = PetFactory.getPet("dog");
        petDog.color();
        Pet petCat = PetFactory.getPet("cat");
        petCat.color();
    }
}

/**
 * 兔子类
 */
class Rabbit implements Pet {
    @Override
    public void color() {
        System.out.println("I am a white Rabbit");
    }
}

/**
 * 小狗类
 */
class Dog implements Pet {
    @Override
    public void color() {
        System.out.println("I am a yellow Dog");
    }
}

/**
 * 小猫类
 */
class Cat implements Pet {
    @Override
    public void color() {
        System.out.println("I am a black Cat");
    }
}

/**
 * 宠物工厂
 */
class PetFactory {
    public static Pet getPet(String petName) {
        if (petName == null) return null;
        if (petName.equalsIgnoreCase("rabbit")) return new Rabbit();
        else if (petName.equalsIgnoreCase("dog")) return new Dog();
        else if (petName.equalsIgnoreCase("cat")) return new Cat();
        return null;
    }
}

 

抽象工厂模式

抽象工厂模式又称工厂的工厂，使用一个抽象工厂来创建多个工厂，每个工厂再生产它对应的产品，一上面的例子为基础，假设宠物工厂还有上级部门，叫做动物组织，动物组织旗下还有一个与宠物工厂平级的部门叫做野生动物工厂，则此时设计模式应优化为

代码示例：

/**
 * 宠物接口
 */
interface Pet {
    void color();
}

/**
 * 野生动物接口
 */
interface Wild {
    void eat();
}

/**
 * 动物组织接口
 */
interface AnimalOrganization {
    Pet getPet(String petName);

    Wild getWild(String wildName);
}

/**
 * 抽象工厂模式
 *
 * @author Swing
 */
public class Test {
    public static void main(String[] args) {
        //获取宠物工厂
        AnimalOrganization petFactory = AnimalOrganizationFactory.getAnimalOrganization("PetFactory");
        //获取野生动物工厂
        AnimalOrganization wildFactory = AnimalOrganizationFactory.getAnimalOrganization("WildFactory");
        petFactory.getPet("rabbit").color();
        petFactory.getPet("dog").color();
        petFactory.getPet("cat").color();
        wildFactory.getWild("tiger").eat();
        wildFactory.getWild("elephant").eat();
        wildFactory.getWild("shark").eat();
    }
}

/**
 * 兔子类
 */
class Rabbit implements Pet {
    @Override
    public void color() {
        System.out.println("I am a white Rabbit");
    }
}

/**
 * 小狗类
 */
class Dog implements Pet {
    @Override
    public void color() {
        System.out.println("I am a yellow Dog");
    }
}

/**
 * 小猫类
 */
class Cat implements Pet {
    @Override
    public void color() {
        System.out.println("I am a black Cat");
    }
}

/**
 * 老虎类
 */
class Tiger implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a tiger,i eat meat");
    }
}

/**
 * 大象类
 */
class Elephant implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a tiger,i eat grass");
    }
}

/**
 * 鲨鱼类
 */
class Shark implements Wild {
    @Override
    public void eat() {
        System.out.println("I am a shark,i eat fish");
    }
}

/**
 * 宠物工厂
 */
class PetFactory implements AnimalOrganization {
    public Pet getPet(String petName) {
        if (petName == null) return null;
        else if (petName.equalsIgnoreCase("rabbit")) return new Rabbit();
        else if (petName.equalsIgnoreCase("dog")) return new Dog();
        else if (petName.equalsIgnoreCase("cat")) return new Cat();
        return null;
    }

    @Override
    public Wild getWild(String wildName) {
        return null;
    }
}

/**
 * 野生动物工厂
 */
class WildFactory implements AnimalOrganization {
    @Override
    public Pet getPet(String petName) {
        return null;
    }

    @Override
    public Wild getWild(String wildName) {
        if (wildName == null) return null;
        else if (wildName.equalsIgnoreCase("tiger")) return new Tiger();
        else if (wildName.equalsIgnoreCase("elephant")) return new Elephant();
        else if (wildName.equalsIgnoreCase("shark")) return new Shark();
        return null;
    }
}

/**
 * 动物组织工厂
 */
class AnimalOrganizationFactory {
    public static AnimalOrganization getAnimalOrganization(String animalOrganizationName) {
        if (animalOrganizationName == null) return null;
        else if (animalOrganizationName.equalsIgnoreCase("PetFactory")) return new PetFactory();
        else if (animalOrganizationName.equalsIgnoreCase("WildFactory")) return new WildFactory();
        return null;
    }
}

生成器模式

此模式就是先创建一些简单的对象，然后再用这些简单的对象组装成复杂的对象，依次上推，形成更复杂的对象，其中再Swing窗口设计时常用这种模式，举个简单的例子：

代码示例：

import javax.swing.*;
import java.awt.*;

/**
 * 朱窗口类
 */
public class Test extends JFrame {
    MainPanel mainPanel=new MainPanel();
    public static void main(String[] args) {
        Test test=new Test();
        test.setDefaultCloseOperation(EXIT_ON_CLOSE);
        test.setBounds(0,0,330,200);
        Container container=test.getContentPane();
        container.add(test.mainPanel);
        test.setVisible(true);
    }
}

/**
 * 主面板类
 */
class MainPanel extends JPanel{
    JButton jButton=new JButton("QQ号：");
    JTextField jTextField=new JTextField("2650312797  加个朋友呗！");
    public MainPanel(){
        this.setLayout(null);//绝对布局
        jButton.setBounds(100,20,100,30);
        this.add(jButton);
        jTextField.setBounds(70,70,160,30);
        this.add(jTextField);
    }
}

原型模式

如果创建一个对象比较麻烦，我们可以使类实现Cloneable接口，并重写clone()方法，实现对象的复制

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        People people = new People(12, "Jack");
        People clonePeople = (People) people.clone();
        System.out.println(people.equals(clonePeople));
        System.out.println(people.toString());
        people.setName("Mike");
        System.out.println(clonePeople.toString());
        System.out.println(people.toString());
    }
}

/**
 * 可克隆的类，Object类本身并不实现接口Cloneable ，因此在类别为Object的对象上调用clone方法将导致运行时抛出异常
 * 所有数组都被认为是实现接口Cloneable ，并且数组类型T[]的clone方法的返回类型是T[]
 */
class People implements Cloneable {
    int id;
    String name;

    public People(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}