文章目录??设计模式????工厂设计模式????单例模式????方式1：饿汉式????方式2：懒汉式????单例模式两种方式的优缺点????方式3：静态内部类写法（懒汉式）??设计模式什么是设计模式：一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。简单理解：特定问题的固定解决方法。好处：使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、重用性。在Gof的《设计模式》书中介绍了23种设计模式
工厂设计模式工厂模式主要负责对象创建的问题。开发中有一个非常重要的原则“开闭原则”，对拓展开放、对修改关闭。可通过反射进行工厂模式的设计，完成动态的对象创建。(通过类对象)
代码：
package com.wlw.chapter12_reflex.demo02_factory;// 父类public interface Usb { void service();}package com.wlw.chapter12_reflex.demo02_factory;//子类public class Mouse implements Usb { @Override public void service() { System.out.println(“鼠标开始工作了”); }}package com.wlw.chapter12_reflex.demo02_factory;//子类public class Fan implements Usb { @Override public void service() { System.out.println(“风扇开始工作了”); }}package com.wlw.chapter12_reflex.demo02_factory;//子类public class Upan implements Usb { @Override public void service() { System.out.println(“U盘开始工作了”); }}package com.wlw.chapter12_reflex.demo02_factory;//子类 键盘public class KeyBoard implements Usb { @Override public void service() { System.out.println(“键盘开始工作了”); }}package com.wlw.chapter12_reflex.demo02_factory;public class Mouse2 implements Usb { @Override public void service() { System.out.println(“鼠标2开始执行”); }}package com.wlw.chapter12_reflex.demo02_factory;//工厂类public class UsbFactory { /* Usb是接口（父类），其他为子类（商品），如果增加一个子类（商品）， 我就需要更改UsbFactory里的方法，违背了开闭原则，需要优化 反射优化：通过类对象来实例化 ,再增加一个子类（商品）话，就在属性文件中添加这个子类的全名称 利用流和Properties获取后传给creatUsb()方法 */ public static Usb creatUsb(String type){ //传入的是每个子类的全名称 ,通过类对象来实例化 Usb usb = null; Class<?> class1 = null; try { class1 = Class.forName(type); usb = (Usb)class1.newInstance(); } catch (Exception e) { System.out.println(e.getMessage()); } return usb; } /*public static Usb creatUsb(int type){ Usb usb = null; if(type == 1){ //1 表示鼠标 usb = new Mouse(); }else if(type == 2){ //2 表示风扇 usb = new Fan(); }else if(type == 3){ //3 表示U盘 usb = new Upan(); }else if(type == 4){ usb = new KeyBoard(); } return usb; }*/}package com.wlw.chapter12_reflex.demo02_factory;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.Properties;import java.util.Scanner;// 客户程序public class Demo { public static void main(String[] args) throws Exception { System.out.println(“===========请选择你想要购买的商品：1鼠标 2风扇 3U盘 4键盘 5鼠标2=======================”); Scanner input = new Scanner(System.in); String choice = input.next(); //1 = com.wlw.chapter12_reflex.demo02_factory.Mouse //2 = com.wlw.chapter12_reflex.demo02_factory.Fan //3 = com.wlw.chapter12_reflex.demo02_factory.Upan //4 = com.wlw.chapter12_reflex.demo02_factory.KeyBoard //可以通过 属性文件来 保存这些值 Properties properties = new Properties(); FileInputStream fis =new FileInputStream(“usb.properties”); properties.load(fis); fis.close(); Usb usb = UsbFactory.creatUsb(properties.getProperty(choice)); if(usb != null){ System.out.println(“购买成功”); usb.service(); }else { System.out.println(“购买失败，你购买的商品不存在”); } }}单例模式单例（Singleton）：只允许创建一个该类的对象。方式1：饿汉式类加载时创建，天生线程安全class Singleton{ private static final Singleton instance = new Singleton();//静态常量 private Singleton(){} public static Singleton getInstance(){ return instance; }}
代码:
package com.wlw.chapter12_reflex.demo03_singleton;/** * 饿汉式单例 * (1)首先创建一个常量 * (2)构造方法改成私有的。类外那不能创建对象 * (3)通过一个公开的方法。返回这个对象 */public class Singleton { private static final Singleton instance = new Singleton();//静态常量 private Singleton(){} public static Singleton getInstance(){ return instance; }}package com.wlw.chapter12_reflex.demo03_singleton;public class TestSingleton { public static void main(String[] args) { for (int i = 0; i < 3; i++) { new Thread(new Runnable() { @Override public void run() { System.out.println(Singleton.getInstance().hashCode()); } }).start(); } }}/*执行结果： 三次的对象都是一样的154337064115433706411543370641*/方式2：懒汉式使用时创建，线程不安全，加同步class Singleton{ private static Singleton instance = null; private Singleton(){} public static synchronized Singleton getInstance(){ if(instance == null){ instance = new Singleton(); } return instance; }}
代码:
package com.wlw.chapter12_reflex.demo03_singleton;/** * 懒汉式单例 * (1)首先创建一个对象，赋值为null * (2)构造方法改成私有的。类外那不能创建对象 * (3)通过一个公开的方法。返回这个对象() （需要同步：同步方法 和 同步代码块） */public class Singleton2 { private static Singleton2 instance = null; private Singleton2(){} /*public static synchronized Singleton2 getInstance(){ //同步方法 if(instance == null){ instance = new Singleton2(); } return instance; }*/ public static Singleton2 getInstance(){ if(instance == null){ //这一句是为了提高执行效率，不用每次都判断锁 synchronized (Singleton2.class){ //同步代码块 if(instance == null){ instance = new Singleton2(); } } } return instance; }}package com.wlw.chapter12_reflex.demo03_singleton;public class TestSingleton2 { public static void main(String[] args) { for (int i = 0; i < 3; i++) { new Thread(new Runnable() { @Override public void run() { System.out.println(Singleton2.getInstance().hashCode()); } }).start(); } }}/*执行结果： 三次的对象都是一样的136588860813658886081365888608*/单例模式两种方式的优缺点饿汉式：优点：线程安全缺点：声明周期太长，浪费空间懒汉式：优点：声明周期短，节省空间优点：有线程安全问题（可通过同步方法与同步代码块来改善）方式3：静态内部类写法（懒汉式）线程安全，使用时创建class Singleton{ private Singleton(){} private static class Holder{ static Singleton s = new Singleton(); } public static Singleton instance(){ return Holder.s; }}
代码:
package com.wlw.chapter12_reflex.demo03_singleton;// 静态内部类写法public class Singleton3 { private Singleton3(){} private static class Holder{ // 静态内部类不使用是不会执行的 static Singleton3 instance = new Singleton3(); } public static Singleton3 getInstance(){ return Holder.instance; }}package com.wlw.chapter12_reflex.demo03_singleton;public class TestSingleton3 { public static void main(String[] args) { for (int i = 0; i < 3; i++) { new Thread(new Runnable() { @Override public void run() { System.out.println(Singleton3.getInstance().hashCode()); } }).start(); } }}/*执行结果： 三次的对象都是一样的136588860813658886081365888608*/
勇于接受自己的不完美，认清自己不足的地方，
