创建型设计模式,顾名思义,它是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 + '\'' +
                '}';
    }
}

 

 

Logo

CSDN联合极客时间,共同打造面向开发者的精品内容学习社区,助力成长!

更多推荐