剑指架构师系列-设计模式

public class Singleton_Simple {  
      
    private static final Singleton_Simple simple = new Singleton_Simple();  
      
    private Singleton_Simple(){}  
      
    public static Singleton_Simple getInstance(){  
        return simple;  
    }  
  
}

//双锁机制
class Singleton {
	private volatile static Singleton singleton;
	public static Singleton getInstance() {
		if (singleton == null) {
			synchronized (Singleton.class) { // 由于每次调用都需要进行同步，所以可以在前面进行判断即可提高效率，同时注意使用的是Singleton.class的类锁
				if (singleton == null) {
					singleton = new Singleton();
				}
			}
		}
		return singleton;
	}
}

public class Singleton { 
    
	  private static class SingletonClassInstance { // 私有静态内部类
	    // 可能是final解决了并发的问题，基本类型声明就可，但是对象类型时，这个对象不能有状态，
	    // 如果有状态，则一定要声明为final,例如String类就是一个不可变类
	    private static final Singleton instance = new Singleton(); 
	  } 

	  public static Singleton getInstance() { 
	    return SingletonClassInstance.instance; // 只在这里调用了静态内部类，私有属性让他人无法使用这个类型
	  } 

	  private Singleton() {  } 
}

interface Iterable{
	public Iterator iterator();
}

interface Aggregate extends Iterable{
	public void add(Object obj);
	public void remove(Object obj);
	public Iterator iterator();
}

class ConcreteAggregate implements Aggregate {
	private List list = new ArrayList();

	public void add(Object obj) {
		list.add(obj);
	}

	public Iterator iterator() {
		return new ConcreteIterator(list);
	}

	public void remove(Object obj) {
		list.remove(obj);
	}
}

interface Iterator {
	public Object next();
	public boolean hasNext();
}

class ConcreteIterator implements Iterator {
	private List list = new ArrayList();
	private int cursor = 0;

	public ConcreteIterator(List list) {
		this.list = list;
	}

	public boolean hasNext() {
		if (cursor == list.size()) {
			return false;
		}
		return true;
	}

	public Object next() {
		Object obj = null;
		if (this.hasNext()) {
			obj = this.list.get(cursor++);
		}
		return obj;
	}
}

Aggregate ag = new ConcreteAggregate();
ag.add("小明");
ag.add("小红");
ag.add("小刚");
Iterator it = ag.iterator();
while (it.hasNext()) {
	String str = (String) it.next();
	System.out.println(str);
}

class Insect {
    private String name;
    public Insect(String name) {
        this.name = name;
    }
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

interface Attack {
    public void move();
    public void attack();
}

class AttackImpl implements Attack {
    private String move;
    private String attack;
 
    public Attack Impl(String move, String attack) {
        this.move = move;
        this.attack = attack;
    }
    @Override
    public void move() {
        System.out.println(move);
    }
    @Override
    public void attack() {
        move();
        System.out.println(attack);
    }
}

class Bee extends Insect implements Attack {
    private Attack attack;
 
    public Bee(String name, Attack attack) {
        super(name);
        this.attack = attack;
    }
 
    public void move() {
        attack.move();
    }
 
    public void attack() {
        attack.attack();
    }
}

// Different types of function objects:
interface Combiner<T> {
	T combine(T x, T y);
}


public class Functional {
	// Calls the Combiner object on each element to combine
	// it with a running result, which is finally returned:
	public static <T> T reduce(Iterable<T> seq, Combiner<T> combiner) {
		Iterator<T> it = seq.iterator();
		if (it.hasNext()) {
			T result = it.next();
			while (it.hasNext()){
				result = combiner.combine(result, it.next());
			}
			return result;
		}
		// If seq is the empty list:
		return null; // Or throw exception
	}


	// To use the above generic methods, we need to create
	// function objects to adapt to our particular needs:
	static class IntegerAdder implements Combiner<Integer> {
		public Integer combine(Integer x, Integer y) {
			return x + y;
		}
	}

	static class IntegerSubtracter implements Combiner<Integer> {
		public Integer combine(Integer x, Integer y) {
			return x - y;
		}
	}

	static class BigIntegerAdder implements Combiner<BigInteger> {
		public BigInteger combine(BigInteger x, BigInteger y) {
			return x.add(y);
		}
	}


	public static void main(String[] args) {
		
		// Generics, varargs & boxing working together:
		List<Integer> li = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
		
		Integer result = reduce(li, new IntegerAdder());
		print(result); // 28

		result = reduce(li, new IntegerSubtracter());
		print(result);


		// Use the prime-generation facility of BigInteger:
		List<BigInteger> lbi = new ArrayList<BigInteger>();
		BigInteger bi = BigInteger.valueOf(11);
		for (int i = 0; i < 11; i++) {
			lbi.add(bi);
			bi = bi.nextProbablePrime();
		}
		print(lbi);

		BigInteger rbi = reduce(lbi, new BigIntegerAdder());
		print(rbi);
		
	}
}