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