设计模式肝完了，还挺全！

/**
 * 拿铁、美式咖啡、卡布奇诺等均为咖啡家族的一种产品
 * 咖啡则作为一种抽象概念
 * @author 
 */
public abstract class Coffee {
    /**
     * 获取coffee名称
     * @return
     */
    public abstract String getName();
}
/**
 * 美式咖啡
 * @author Lsj
 *
 */
public class Americano extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
/**
 * 卡布奇诺
 * @author Lsj
 */
public class Cappuccino extends Coffee {
    @Override
    public String getName() {
        return "卡布奇诺";
    }
}
/**
 * 拿铁
 * @author Lsj
 */
public class Latte extends Coffee {
    @Override
    public String getName() {
        return "拿铁";
    }
}

public class AbstractFactoryTest {
   public static void main(String[] args) {
       // 抽象工厂
       String result = (new CoffeeFactory()).createProduct("Latte");
       System.out.println(result); // output:拿铁
   }
}
// 抽象工厂
abstract class AbstractFactory{
   public abstract String createProduct(String product);
}
// 啤酒工厂
class BeerFactory extends AbstractFactory{
   @Override
   public String createProduct(String product) {
       String result = null;
       switch (product) {
           case "Hans":
               result = "汉斯";
               break;
           case "Yanjing":
               result = "燕京";
               break;
           default:
               result = "其他啤酒";
               break;
       }
       return result;
   }
}
/\* \* 咖啡工厂 \*/
class CoffeeFactory extends AbstractFactory{
   @Override
   public String createProduct(String product) {
       String result = null;
       switch (product) {
           case "Mocca":
               result = "摩卡";
               break;
           case "Latte":
               result = "拿铁";
               break;
           default:
               result = "其他咖啡";
               break;
       }
       return result;
   }
}

1 class Person{
 2 private:
 3     Person(){};
 4     Person(const Person&){};
 5
 6     static Person *Singleton; //静态变量，类内声明，类外初始化, 初始化时不用static,需指定作用域
 7
 8 public:
 9     static Person *getInstance(){
10         return Singleton;
11     }
12 };
13
14 Person *Person::Singleton = new Person;
15
16 void test01(){
17
18     Person::getInstance();//外部通过接口访问单例
19     Person *p = Person::getInstance();
20     Person *p1 = Person::getInstance();
21
22     //--------------
23     //不能直接定义或new实例，只能通过调用接口
24     //Person p2;
25     //Person *p1 = new(*p); //这里调用拷贝构造函数
26     //--------------
27
28     if (p == p1){
29         cout << "两个单例的地址相同，为同一个单例" << endl;
30     }
31
32 }

package com.Model.Proxy;
//买车行为
public interface BuyCar {
    public void buycar();
}
package com.Model.Proxy;
public class People implements BuyCar {
    private int cash;
    private String vip;
    private String username;
    @Override
    public void buycar() {
        System.out.println(username + " is vip so he/she can buy any car...");
    }
    public int getCash() {
        return cash;
    }
    public void setCash(int cash) {
        this.cash = cash;
    }
    public String getVip() {
        return vip;
    }
    public void setVip(String vip) {
        this.vip = vip;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
}
// 代理类 去检测买车行为是否符合规则
class ProxyBuyCar implements BuyCar {
    private People People;
    public People getPeople() {
        return People;
    }
    public void setPeople(People people) {
        People = people;
    }
    @Override
    public void buycar() {
        if (People.getVip().equals("vip")) {
            People.buycar();
        } else if (People.getCash() >= 50000) {
            System.out.println(People.getUsername() + "buy a new car trade over...");
        } else {
            System.out.println(People.getUsername() + "people can't buy a car ");
        }
    }
}

/\* \* 传统的充电线 MicroUSB \*/
interface MicroUSB {
    void charger();
}
/\* \* TypeC 充电口 \*/
interface ITypeC {
    void charger();
}
class TypeC implements ITypeC {
    @Override
    public void charger() {
        System.out.println("TypeC 充电");
    }
}
/\* \* 适配器 \*/
class AdapterMicroUSB implements MicroUSB {
    private TypeC typeC;
    public AdapterMicroUSB(TypeC typeC) {
        this.typeC = typeC;
    }
    @Override
    public void charger() {
        typeC.charger();
    }
}
/\* \* 测试调用 \*/
public class AdapterTest {
    public static void main(String[] args) {
        TypeC typeC = new TypeC();
        MicroUSB microUSB = new AdapterMicroUSB(typeC);
        microUSB.charger();
    }
}

/\* \* 声明旅行 \*/
interface ITrip {
    void going();
}
class Bike implements ITrip {
    @Override
    public void going() {
        System.out.println("骑自行车");
    }
}
class Drive implements ITrip {
    @Override
    public void going() {
        System.out.println("开车");
    }
}
/\* \* 定义出行类 \*/
class Trip {
    private ITrip trip;
    public Trip(ITrip trip) {
        this.trip = trip;
    }
    public void doTrip() {
        this.trip.going();
    }
}
/\* \* 执行方法 \*/
public class StrategyTest {
    public static void main(String[] args) {
        Trip trip = new Trip(new Bike());
        trip.doTrip();
    }
}