设计模式之创建型模式

创建型模式

简单工厂模式
描述：通过工厂对象来决定创建哪一种产品的实例。

方式一：继承
注：子类可以向上转型 （用子类去实例化父类）

方式二：实现接口
注：实例化接口类返回所需产品

情景：
1.一个类不知道它创建的类
2.一个类希望由它的子类来指定它所创建的对象
3.希望使用者不知道究竟是哪个类进行了实例化。（如寄包裹，邮递员不知道内容）

简单工厂模式

• 一个JAVA类文件可以有多各类，但只能有一个是public经行向上转型时，属性不会经行动态绑定（隐藏），只有方法会经行动态绑定（覆盖）。
• 子类不会继承父类的构造函数，但可以通过super进行调用

public class 简单工厂模式 {
              public static void main(String[] args) {
                    
                     Factory a=new FactoryA();
                     Factory b=new FactoryB();
                     a.runMechine();
                     b.runMechine();
             }
       
}
        class Factory
       {
             
             public void runMechine()
             {
                    System.out.println("这是父类工厂");
             }
             
       }
       
        class FactoryA extends Factory
       {
             public void runMechine()
             {
                    System.out.println("这是工厂A");
             }
       }
        class FactoryB extends Factory
       {
             
             public void runMechine()
             {
                    
                    System.out.println("这是工厂B");
             }
       }
       
复制代码

简单工厂模式之接口

• 静态方法不能直接实例化内部类

public interface FactoryInterface {
       void runMechine();
}
public class 工厂接口 {
       
        @Test
        public void test()
        {
             
             //静态方法不能直接实例化内部类
             FactoryInterface a=new FactoryA();
             FactoryInterface b=new FactoryB();
             a.runMechine();
             b.runMechine();
        }
       class FactoryA implements FactoryInterface
       {
             @Override
             public void runMechine() {
                    // TODO Auto-generated method stub
                    System.out.println("这是工厂A");
             }
             
       }
       
       
       class FactoryB implements FactoryInterface
       {
             @Override
             public void runMechine() {
                    // TODO Auto-generated method stub
                    System.out.println("这是工厂B");
             }
             
       }
       
}
复制代码

抽象工厂模式\

描述：相对于简单工厂来说，抽象工厂有更多业务
抛弃继承，实现接口，进行不同业务的组合

反射：通过Java反射机制，可以在程序访问过程中已经加载到JVM中的JAVA对象的描述从而达到修改的目的。

如何通过一个接口获得黑面包和白巧克力

public interface AbstartFactory {
       void Breakmaking();
       void Chocolatmaking();
}

//黑工厂
public class FactoryA implements AbstartFactory
{
       @Override
       public void Breakmaking() {
             // TODO Auto-generated method stub
             System.out.println("制作黑面包");
       }
       @Override
       public void Chocolatmaking() {
             // TODO Auto-generated method stub
             System.out.println("制作黑巧克");
       }
       
       
       }

//白工厂
public class FactoryB implements AbstartFactory
{
       @Override
       public void Breakmaking() {
             // TODO Auto-generated method stub
             System.out.println("制作白面包");
       }
       @Override
       public void Chocolatmaking() {
             // TODO Auto-generated method stub
             System.out.println("制作白巧克");
       }
       
       
       }
//测试类
import org.junit.Test;
public class TestFactory {
       
       @Test
       public void test()
       {
             
             AbstartFactory a=new FactoryA();
             //AbstartFactory b=new FactoryB();
             
             System.out.println("需要黑面包");
             a.Breakmaking();
             System.out.println("需要白巧克力");
             try {
                    Class <?> c=Class.forName("抽象工厂模式.FactoryB");
                    a=(AbstartFactory)c.newInstance();
                    a.Chocolatmaking();
             } catch (ClassNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
             } catch (InstantiationException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
             } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
             }
             
       }
}
复制代码

单例模式\

使用场景：资源共享的情况
描述：单例模式自行实例化且实例化一次 构造函数必须是私有的
类别：懒汉单例模式和饥汉单例模式

• 懒汉单例模式：在调用资源时，如果没有进行实例化的话，就进行一次实例化。为了避免重复线程干扰要标记临界区或者借助锁机制。(双重校验的方式)
• 饥汉单例模式：在没有调用时就已经自行实例化了。 注：对象属性和get方法都要用static标记

public class SingleA
{
       
       public static SingleA singleA=null;
       private SingleA()
       {
             System.out.println("这是懒汉单例模式");
       }
       
       
       public static synchronized SingleA getSingleA() {
             
             
             if(singleA==null)
             {
             singleA=new SingleA();
             
             }
             
             return singleA;
       }
       
}

public class SingleB
{
       public static SingleB singleB=new SingleB();
       
       private SingleB()
       {
             System.out.println("这是饥汉单例模式");
       }
       public static SingleB getSingleB() {
             return singleB;
       }
       
       
}

//测试类
import org.junit.Test;
public class 单例模式 {
       @Test
       public void test()
       {
             SingleA.getSingleA();
             SingleB.getSingleB();
             
       }
       
}
复制代码

建造模式\

描述：相同的成员函数，执行顺序不同结果不同（化学实验步骤不同结果不同）
如：用其他类，起到流程监控执导的作用。

public interface Student {
       void learnMath();
       void learnEnglish();
}

public class StudentA implements Student{
       @Override
       public void learnMath() {
             // TODO Auto-generated method stub
             System.out.println("A类学生学数学");
       }
       @Override
       public void learnEnglish() {
             // TODO Auto-generated method stub
             System.out.println("A类学生学英语");
       }
}

public class StudentB implements Student{
       @Override
       public void learnMath() {
             // TODO Auto-generated method stub
             System.out.println("B类学生学数学");
       }
       @Override
       public void learnEnglish() {
             // TODO Auto-generated method stub
             System.out.println("B类学生学英语");
       }
}


public class teacher {
       private static Student a=new StudentA();
       private static Student b=new StudentB();
       private static teacher t=new teacher();
       
       public static void main(String[] args) {
             
             System.out.println("指导A类学生");
             t.conductA();
             System.out.println("指导B类学生");
             t.conductB();
             
       }
       
       //指导A类学生 先学数学后学英语
       public static void conductA()
       {
             a.learnMath();
             a.learnEnglish();
       }
       
       //指导B类学生  先学英语后学数学
       public static void conductB()
       {
             b.learnEnglish();
             b.learnMath();
             
       }
       
       
}
复制代码

原型模式

原理：依托一个已经实例化的对象去创建另一个可以经行定制的对象。避免多次new浪费资源。
场景：进一批货，填表很多信息已经相同。避免重新实例化，使用set注入参数。
注：直接使用等号复制，是一种引用，对新的对象经行修改会对先前的对象产生印象。

• 数组可以用system.arraycopy()进行复制
• 可以在clone（）方法类就行修改

public class Student implements Cloneable {
       public String name;
       public String sex;
       
       
       public Student(String name, String sex) {
             
             this.name = name;
             this.sex = sex;
       }
       public String getName() {
             return name;
       }
       public void setName(String name) {
             this.name = name;
       }
       public String getSex() {
             return sex;
       }
       public void setSex(String sex) {
             this.sex = sex;
       }
       
       
       @Override
       public String toString() {
             return "Student [name=" + name + ", sex=" + sex + "]";
       }
       protected Object clone()
       {
             try {
                    return super.clone();
             } catch (CloneNotSupportedException e) {
                    // TODO Auto-generated catch block
                    
                    e.printStackTrace();
                    return null;
             }
       }
       
}

public class Test {
       
       @org.junit.Test
       public void test001()
       {
             Student s=new Student("luo","1");
             System.out.println(s);
             Student a=(Student)s.clone();
             a.setName("li");
             System.out.println(a);
             System.out.println(s);
       }
}
复制代码