public abstract class Duck{

    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;
    
    public Duck(){
    }
    
    public abstract void dispaly();
    
    public void performQuack(){
        quackBehavior.quack();
    }
    
    public void performFly(){
        flyBehavior.fly();
    }
    
    public void swim(){
        System.out.println("all ducks float,even decoys");
    }
}

public class Bduck extends Duck{

    public Bduck(){
        quackBehavior = new Quack();
        flyBehavior = new FlyWithWings();
    }

    public void setFlyBehavior( FlyBehavior fb){
        flyBehavior = fb;
    }
    
    public void setQuackBehavior( QuackBehavior qb){
        quackBehavior = qb;
    }
    
    public void display(){
        System.out.println("i am Bduck");
    }
    
}

public class Test{

    public static void main(String[] args){
        Duck d = new Bduck();
        d.performFly();
        d.setFlyBehavior(new FlyRocketPowered());
        d.performFly();
    }
}

1.单例模式的饿汉式[可用]
public class Singleton {
 
    private static Singleton instance=new Singleton();
    private Singleton(){};
    public static Singleton getInstance(){
        return instance;
    }
}
访问方式

Singleton instance = Singleton.getInstance();

2.单例模式懒汉式双重校验锁[推荐用]
class Singleton{
    private volatile static Singleton instance = null;

    private Singleton() {
         
    }
    public static Singleton getInstance() {
        if(instance==null) {
            synchronized (Singleton.class) {
                if(instance==null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}
访问方式

Singleton instance = Singleton.getInstance();

3.内部类[推荐用]

public class Singleton{
 
    
    private Singleton() {};
    
    private static class SingletonHolder{
        private static Singleton instance=new Singleton();
    } 
    
    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

访问方式

Singleton instance = Singleton.getInstance();

需要实例化时，调用getInstance方法，才会装载SingletonHolder类，从而完成Singleton的实例化。

4.枚举形式
public enum Singleton {

    INSTANCE;

    public void doSomething() {
        System.out.println("doSomething");
    }

}
调用方法：

public class Main {

    public static void main(String[] args) {
        Singleton.INSTANCE.doSomething();
    }

}

直接通过Singleton.INSTANCE.doSomething()的方式调用即可。方便、简洁又安全。

懒汉式单例

//交通工具
public abstract class Vehicle {
    //实现由子类决定
    public abstract void run();
}
//食物
public abstract class Food {
    public abstract void printName();
}
//武器
public abstract class Weapon {
    //
    public abstract void shoot();
}

//抽象工厂
public abstract class AbstractFactory {
    //生产 交通工具
    public abstract Vehicle createVehicle();
    //生产 武器
    public abstract Weapon createWeapon();
    //生产食物
    public abstract Food createFood();
}

//哈利波特的魔法工厂
public class MagicFactory extends AbstractFactory {
//交通工具：扫把
    public Vehicle createVehicle(){
        return new Broom();
    }
    
    //武器：魔法棒
    public Weapon createWeapon(){
        return new MagicStick();
    }
    //食物：毒蘑菇
    public Food createFood(){
        return new MushRoom();
    }
}

//默认的工厂
public class DefaultFactory extends AbstractFactory{
@Override
    public Food createFood() {
        return new Apple();
    }
@Override
    public Vehicle createVehicle() {
        return new Car();
    }
@Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

public class Car extends Vehicle{
    @Override
    public void run() {
        System.out.println("冒着烟奔跑中...");
    }
}
//扫帚
public class Broom extends Vehicle{
@Override
    public void run() {
        System.out.println("扫帚摇着尾巴呼呼呼...");
    }
}
//食物：毒蘑菇
public class MushRoom extends Food {
@Override
    public void printName() {
        System.out.println("mushroom");
    }
}
public class Apple extends Food {
    @Override
    public void printName() {
        System.out.println("apple");
    }
}
public class AK47 extends Weapon{
public void shoot(){
        System.out.println("哒哒哒....");
    }
}
//武器：魔法棒
public class MagicStick extends Weapon {
    @Override
    public void shoot() {
        System.out.println("fire hu hu hu ...");
    }
}

//换一个工厂，只需要改动这一处，就可以了，换一个工厂，就把生产的系列产品都换了
        AbstractFactory factory =  new DefaultFactory(); //new DefaultFactory();
        //换一个工厂
        Vehicle vehicle = factory.createVehicle();
        vehicle.run();
        Weapon weapon = factory.createWeapon();
        weapon.shoot();
        Food food = factory.createFood();
        food.printName();

public abstract class CaffeineBeverageWithHook{
    void prepareRecipe(){
        boilWater();
        brew();
        poureInCup();
        if( customerWantsCondiments() ){
            addCondiments();
        }
    }
    abstract void brew();
    
    abstract void addCondiments();
    
    void boilWater(){
        System.out.println("Boiling water");
    }
    void pourInCup(){
        System.outn.println("Pouring into cup");
    }
    
    //这就是钩子，子类可以覆盖这个方法，但不见得要这么做。
    boolean customerWantsCondiments(){
        return true;
    }
}

钩子控制了咖啡因饮料是否执行某部分算法。
public class CoffeeWithHook extends CaffeineBeverageWithHook{
    public void brew(){
        System.out.println("Dripping Coffee through filter");
    }
    public void addCondiments(){
        System.out.println("Adding sugar and milk");
    }
    
    //覆盖这个钩子。提供自己功能，让用户自己输入是否添加调料
    public boolean customerWantsCondiments(){
        String answer = getUserInput();
        
        if(answer.toLowerCase().startWith("y")){
            return true;
        }else{
            return false;
        }
    }
    
    private String getUserInput(){
        ...........
    }
}
模板方法和钩子的使用实际体现了【好莱坞原则】：你别调我，我会去调用你的。

我们允许底层组件将自己挂钩到系统上，但是高层组建会决定什么时候和怎样使用这些底层组建。

依赖倒置原则让我们尽量依赖抽象，避免依赖具体实现。

好莱坞原则是在创建框架或组件上的一种技巧，好让底层组建能够被挂钩进行计算。不会让高层组建依赖底层组建。

CaffeineBeverageWithHook 是我们的高层组建，他能够控制冲泡的算法，只有需要子类实现某个算法时，才会调用子类。
客户端代码也只依赖抽象类，而不依赖具体的Tea和coffee,减少了整个系统的依赖。
不存在子类直接调用抽象类的情况。【避免依赖腐败】，你依赖我，我依赖你，最后搞不清。

public class Duck implements Comparable<Duck> {
    String name;
    int weight;
  
    public Duck(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }
 
    public String toString() {
        return name + " weighs " + weight;
    }
  
    public int compareTo(Duck otherDuck) {
 
  
        if (this.weight < otherDuck.weight) {
            return -1;
        } else if (this.weight == otherDuck.weight) {
            return 0;
        } else { // this.weight > otherDuck.weight
            return 1;
        }
    }
}

public class DuckSortTestDrive {

    public static void main(String[] args) {
        Duck[] ducks = { 
                        new Duck("Daffy", 8), 
                        new Duck("Dewey", 2),
                        new Duck("Howard", 7),
                        new Duck("Louie", 2),
                        new Duck("Donald", 10), 
                        new Duck("Huey", 2)
         };

        System.out.println("Before sorting:");
        display(ducks);

        Arrays.sort(ducks);
 
        System.out.println("\nAfter sorting:");
        display(ducks);
    }

    public static void display(Duck[] ducks) {
        for (Duck d : ducks) {
            System.out.println(d);
        }
    }
}