设计模式面试点汇总

/*饿汉式*/

public class Singleton implements Serializable{
    
    // 首先我们需要拥有一个私有的构造方法（为了防止其他对象调用构造方法产生新对象）
    private Singleton(){
        
        // 这里我们需要做一个判断，如果已存在单例对象,且其他对象调用构造方法，直接报错（为了预防反射获得类然后新创对象）
        if( INSTANCE != null){
            throw new RuntimeException("单例对象不可重复创建");
        }
        
        System.out.println("private Singleton");
        
    }
    
    // 饿汉式：在加载类时就直接创建单例对象，我们这里直接用static创建一个静态单例对象(随着类加载创建单例对象)
    private static final Singleton INSTANCE = new Singleton();
    
    // 由于单例对象是private，我们需要一个公共方法获得对象
    public static Singleton getInstance(){
        return INSTANCE;
    }
    
    // 其他方法
    public static void otherMethod(){
        System.out.println("otherMethod");
    }
    
    // readResolve方法，用于阻止反序列化获得新对象
    public Object readResolve(){
        return INSTANCE:
    }
    
    // 需要注意：Unsafe类破坏单例对象是无法阻止的！！！
    
}

/*枚举*/

enum Sex{
    MALE，FAMALE;
}

/*枚举饿汉式*/

public enum Singleton{
    
    // 单例对象
    INSTANCE;
    
    // getStance方法
    public static Singleton getInstance(){
        return INSTANCE;
    }
    
    // 枚举方法自带 反射 反序列化 生成对象的阻止方法
    
    // 枚举方法也不能阻止Unsafe类生成对象
    
}

/*懒汉式*/

public class Singleton{
    
    // 首先我们需要一个构造方法
    private Singleton(){
        System.out.println("private Singleton");
    }
    
    // 懒汉式：该对象创建之后不赋值，等到使用时在进行赋值
    private static Singleton INSTANCE = null;
    
    // getStance:我们在获得 STANCE 对象时再进行赋值并且反馈(注意：需要加锁处理多线程问题)
    public static synchronized Singleton getStance(){
        // 首先判断是否存在，若不存在创建并返回，若存在直接返回
        if(INSTANCE == null){
            INSTANCE = new Singleton();
        }
        return INSTANCE;
    }
    
    // 其他方法
    public static void otherMethod(){
        System.out.println("otherMethod");
    }
    
}

/*DCL懒汉式*/

// DCL:Double Check Lock 双重检查锁

public class Singleton{
    
    private Singleton(){
        System.out.println("private Singleton");
    }
    
    // 这里需要加上volatile，为了保证语句的有序性
    // 在getStance的赋值操作中INSTANCE = new Singleton()语句属于init初始化和static初始化
    // 两者之间可能出现优化状态，可能导致先进行ISNTANCE赋值，再进行init初始化
    // 但是在这个间隙线程2可能会通过INSTANCE判断,然后直接返回INSTACE，这时返回的并不是完整体的INSTANCE，可能出错
    private static volatile Singleton INSTANCE = null;
    
    // 我们将这里的锁进行更改，之前我们将getStance方法上锁，所有进程调用均需要锁处理，效率较慢
    // 实际上，我们只有第一次创建时，需要上锁处理，所以我们采用双重检查锁，判定只有未赋值时进行锁处理
    public static Singleton getStance(){
        // 首先判断是否赋值，若没赋值，进入锁赋值判断阶段
        if(INSTANCE == null){
            // 需要锁处理：这里就是并发部分
            synchronized(Singleton.class){
                // 需要二次判断，因为当线程1进行赋值操作时，线程2可能已经通过了第一次null判断，到这里还需要重新判断
				if(INSTANCE == null){
                    // 赋值操作
            		INSTANCE = new Singleton();
        		}
            }
        }
        
        
        return INSTANCE;
    }
    
    public static void otherMethod(){
        System.out.println("otherMethod");
    }
    
}

/*内部类懒汉式*/

// 属于最简洁的一种懒汉式创建方式

public class Singleton{
    
    // 构造方法
    private Singleton(){
        System.out.println("private Singleton");
    }
    
    // 内部类，用于存储单例对象（static内部类会随着类加载而加载，其单例性由JVM控制）
    private static class Holder{
        // 内部元素只有当类使用时被创建
        static Singleton INSTANCE = new Singleton();
    }
    
    // get方法调用内部类的INSTANCE
    public static Singleton getInstance(){
        return Holder.INSATNCE;
    }
    
    public static void otherMethod(){
        System.out.println("otherMethod");
    }
    
}

/*饿汉式Runtime*/

public class Runtime {
    
    // 单例对象，直接创建
    private static Runtime currentRuntime = new Runtime();

    // 直接返回单例对象
    public static Runtime getRuntime() {
        return currentRuntime;
    }
    
}

/*枚举饿汉式NaturalOrderComparator*/

class Comparators {
    private Comparators() {
        throw new AssertionError("no instances");
    }

    /**
     * Compares {@link Comparable} objects in natural order.
     *
     * @see Comparable
     */
    enum NaturalOrderComparator implements Comparator<Comparable<Object>> {
        INSTANCE;

        @Override
        public int compare(Comparable<Object> c1, Comparable<Object> c2) {
            return c1.compareTo(c2);
        }

        @Override
        public Comparator<Comparable<Object>> reversed() {
            return Comparator.reverseOrder();
        }
    }
}

/*DCL懒汉式System.Console*/

class System{
    
    // Console
    private static volatile Console cons = null;
    
    // Console双检索
    public static Console console() {
         if (cons == null) {
             synchronized (System.class) {
                 cons = sun.misc.SharedSecrets.getJavaIOAccess().console();
             }
         }
         return cons;
     }
    
}

/*内部类懒汉式Collections*/

class Conllections{
    
    // emptyNavigableMap对象
    public static final <K,V> NavigableMap<K,V> emptyNavigableMap() {
        return (NavigableMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
    }

    /**
     * @serial include（内部类）
     */
    private static class EmptyMap<K,V>
        extends AbstractMap<K,V>
        implements Serializable
    {
        private static final long serialVersionUID = 6428348081105594320L;

        public int size()                          {return 0;}
        public boolean isEmpty()                   {return true;}
        public boolean containsKey(Object key)     {return false;}
        public boolean containsValue(Object value) {return false;}
        public V get(Object key)                   {return null;}
        public Set<K> keySet()                     {return emptySet();}
        public Collection<V> values()              {return emptySet();}
        public Set<Map.Entry<K,V>> entrySet()      {return emptySet();}

        public boolean equals(Object o) {
            return (o instanceof Map) && ((Map<?,?>)o).isEmpty();
        }

        public int hashCode()                      {return 0;}

        // Override default methods in Map
        @Override
        @SuppressWarnings("unchecked")
        public V getOrDefault(Object k, V defaultValue) {
            return defaultValue;
        }

        @Override
        public void forEach(BiConsumer<? super K, ? super V> action) {
            Objects.requireNonNull(action);
        }

        @Override
        public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
            Objects.requireNonNull(function);
        }

        @Override
        public V putIfAbsent(K key, V value) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean remove(Object key, Object value) {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean replace(K key, V oldValue, V newValue) {
            throw new UnsupportedOperationException();
        }

        @Override
        public V replace(K key, V value) {
            throw new UnsupportedOperationException();
        }

        @Override
        public V computeIfAbsent(K key,
                Function<? super K, ? extends V> mappingFunction) {
            throw new UnsupportedOperationException();
        }

        @Override
        public V computeIfPresent(K key,
                BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            throw new UnsupportedOperationException();
        }

        @Override
        public V compute(K key,
                BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            throw new UnsupportedOperationException();
        }

        @Override
        public V merge(K key, V value,
                BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
            throw new UnsupportedOperationException();
        }

        // Preserves singleton property
        private Object readResolve() {
            return EMPTY_MAP;
        }
    }
    
}