设计模式之创建型模式

设计模式之创建型模式
强烈推介IDEA2020.2破解激活,IntelliJ IDEA 注册码,2020.2 IDEA 激活码

设计模式之创建型模式

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

方式一:继承
注:子类可以向上转型 (用子类去实例化父类)
这里写图片描述

方式二:实现接口
注:实例化接口类返回所需产品
这里写图片描述

情景:
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);
       }
}

在这里插入图片描述

本文来源蹊源的奇思妙想,由架构君转载发布,观点不代表Java架构师必看的立场,转载请标明来源出处:https://javajgs.com/archives/14735

发表评论