初识设计模式

public class LazyMan {
private LazyMan() {
 }

private static LazyMan lazyMan;

/**
        * 线程不安全
     * @return
     */
    public static LazyMan getInstance() {
    if (lazyMan==null){
        lazyMan=new LazyMan();
    }
    return lazyMan;
    }

    /**
     * 双重校验锁
     * @return
     */
    public static LazyMan getInstanceTwo(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan=new LazyMan();
                }
            }
        }
        return lazyMan;
    }
}

/**
 * 单例模式中的饿汉式
 * 单例模式的饿汉式[可用]
 * (1)私有化该类的构造函数
 * (2)通过new在本类中创建一个本类对象
 * (3)定义一个公有的方法，将在该类中所创建的对象返回
 * <p>
 * 优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。
 * 缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它
 * 也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。
 *
 * @Author sunjl
 * @Date 2022/7/11 16:23
 * @Version 1.0.0
 */
public class EvilMan {
    private EvilMan() {
    }

    private static EvilMan evilMan = new EvilMan();

    public static EvilMan getInstace() {
        return evilMan;
    }
    /**
     * 2. 单例模式的饿汉式变换写法[可用]
     * 基本没区别
     */
    private static EvilMan evilManTwo=null;
    
    static {
        evilMan=new EvilMan();
    }
    public static EvilMan getInstanceTwo(){
        if (evilMan==null){
            evilMan=new EvilMan();
        }
        return evilManTwo;
    }
}

public static synchronized Singleton getInstance(){
       　　 if(instance == null){
　　　　　//什么时候用就什么时候new
            　　instance = new Singleton();
       　　 }
}
java

/**
 * 简单工厂模式实现
 *
 * @Author sunjl
 * @Date 2022/7/12 15:05
 * @Version 1.0.0
 */
public class SimpleRoujiaMoFactory {
    abstract class SJL {
    }

    public class SJL1 extends SJL {
        public SJL1() {
            System.out.println("创建实例1");
        }
    }

    public class SJL2 extends SJL {
        public SJL2() {
            System.out.println("创建实例 2");
        }
    }

    public class SJL3 extends SJL {
        public SJL3() {
            System.out.println("创建实例 3");
        }
    }


    public SJL creatFactory(int type) {
        SJL sjl = null;
        switch (type) {
            case 1:
                sjl = new SJL1();
                break;
            case 2:
                sjl = new SJL2();
                break;
            case 3:
                sjl=new SJL3();
                break;
        }
        return sjl;
    }
}
java

    public static void main(String[] args) {
        SimpleRoujiaMoFactory simpleRoujiaMoFactory = new SimpleRoujiaMoFactory();
        simpleRoujiaMoFactory.creatFactory(2);
    }
java

/**
 * 抽象创建工厂
 * 注意，我们在这里采用了泛型（Generic），通过定义泛型对createHuman的输入参数产
 * 生两层限制：
 * ● 必须是Class类型；
 * ● 必须是Human的实现类
 *
 * @Author sunjl
 * @Date 2022/7/12 19:16
 * @Version 1.0.0
 */

public abstract class AbstractHumanFactory {
    public abstract <T extends Human> T creatHuman(Class<T> c);
}
java

/**
 * 创建工厂
 *
 * @Author sunjl
 * @Date 2022/7/12 19:21
 * @Version 1.0.0
 */
public class HumanFactory extends AbstractHumanFactory {
    @Override
    public <T extends Human> T creatHuman(Class<T> c) {
        Human human = null;
        //通过newInstance创建新的类的实例
        try {
            human = (T) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) human;
    }
}
java

/**
 * 实现方法
 *
 * @Author sunjl
 * @Date 2022/7/12 19:40
 * @Version 1.0.0
 */
public class NvWa {
    public static void main(String[] args) {
        HumanFactory humanFactory = new HumanFactory();
        BlackHuman blackHuman = humanFactory.creatHuman(BlackHuman.class);
        blackHuman.getColor();
        blackHuman.talk();
    }
}
java

/**
 * 实现逻辑方法
 *
 * @Author sunjl
 * @Date 2022/7/12 19:04
 * @Version 1.0.0
 */
public class BlackHuman implements Human {
    @Override
    public void getColor() {
        System.out.println("一个黑人");
    }

    @Override
    public void talk() {
        System.out.println("黑人之话，");
    }
}
java

/**
 * 可理解为产品方法，逻辑方法判断
 *
 * @Author sunjl
 * @Date 2022/7/12 19:02
 * @Version 1.0.0
 */
public interface Human {
    void getColor();
    void talk();
}
java

	@SuppressWarnings("rawtypes")
	Class cls = Class.forName("java.lang.String");
	System.out.println(cls);
java

		String str = "csdn";
		Class cls2 = str.getClass();
		System.out.println(cls2); 
java

		Class cls1 = String.class;
		System.out.println(cls1);
java