设计模式之创建型模式

设计模式之创建型模式

技术杂谈小彩虹2021-07-13 1:21:0370A+A-

设计模式之创建型模式

创建型模式

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

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

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

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

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1

联系我们