1.泛化关系：【继承extends】
1）.文字描述
　　一个类或者接口继承了另一个类或者接口，增加了在原有的方法和属性上增加了新的方法和属性。
2）.代码表示
　　public class A{}
　　public class B extends A{}//B继承了A中的所有的方法和属性，对于私有的方法和属性，子类只能是拥有，但无法直接使用。

2.实现关系 【实现implements】
1）.文字描述
　　一个class类实现了interface接口
2）.代码表示
　　public interface A{}
　　public class B implements A{}//类B实现了接口A，使用关键自implements，接口和接口的继承实用的是extends

3.依赖关系：【局部变量、方法的形参】
1）.文字描述
　　依赖关系表示一个类依赖于另一个类的定义，一般依赖关系在java中提现为局部变量、方法的形参，或者对静态方法的调用，这是一种弱关系。
2）.代码描述
　　public class A{}
　　public class B{
　　　　public void abc(A a){//在B类中的没有A的属性，而是以形参的方式引入
         A a1 = new A(); //在B类中的没有A的属性，而是以局部变量的方式引入
      }
　　}

4.关联关系：【成员变量】
1）.文字描述
　　一般以类的属性形式出现在关联类中，在java中关联关系一般使用成员变量来实现。又分为聚合关系和组合关系。
2）.代码描述
　　public class A{

    }

　　public class B{
　　　　A a;//成员变量引入了A类
　　}

5.聚合关系：【成员变量，不同生命周期】
1）.文字描述
　　聚合关系 has a,关联关系较弱,后期使用不会因为对象的删除而删除
2）.代码描述
　　public class A{
  
   }

　　public class B{
　　　　A a;//成员变量引入了A类
　　　　B(A a){
　　　　　　this.a = a;
　　　　}
　　}

6.组合关系：【成员变量，同生命周期】
1）文字描述
　　组合关系 contains a，关联关系较强，整体和部分是不可分割的，他们又共同的生命周期。
2）代码描述
　　public class A{
    
    }

　　public class B{
　　　　A a;//成员变量引入了A类
　　　　B(){
　　　　　　this.a = new A();
　　　　}
　　}

public class Singleton {
    private Singleton() {} //Singleton通过将构造方法限定为private避免了类在外部被实例化
    private static Singleton single=null;
    //静态工厂方法 
    public static synchronized  Singleton getInstance() {  //考虑线程安全,getInstance方法加同步
         if (single == null) {  
             single = new Singleton(); //懒汉式单例类.在第一次调用的时候实例化自己
         }  
        return single;
    }
}

public class Singleton {  
    private Singleton (){}  
    //静态内部类
    private static class LazyHolder { 
    //懒汉式单例类.在第一次调用的时候实例化自己 
       private static final Singleton INSTANCE = new Singleton();  
    }  
    public static final Singleton getInstance() {  
       return LazyHolder.INSTANCE;  
    }  
}

public class Singleton {  
    private static volatile Singleton singleton = null;

    /**
     * 构造函数修饰为private防止在其他地方创建该实例
     */
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
            }  
        }  
        return singleton; 
    }
}

public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1(); //在类初始化时，已经自行实例化 
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

/**
 * 目标对象和代理对象的共同：接口类
 */
public interface IBuyHouse {
    void buyHosue();
}

/**
 * 目标对象实现类
 */
public class BuyHouseImpl implements IBuyHouse {
    @Override
    public void buyHosue() {
        System.out.println("我要买房");
    }
}

/**
 * 代理类
 */
public class BuyHouseProxy implements IBuyHouse {
    private IBuyHouse buyHouse;

    //构造方法：传入目标对象
    public BuyHouseProxy(final IBuyHouse buyHouse) {
        this.buyHouse = buyHouse;
    }

    @Override
    public void buyHosue() {
        System.out.println("买房前准备"); // 前置扩展
        buyHouse.buyHosue();  // 执行目标对象的真正方法
        System.out.println("买房后装修");  // 后置结果扩展
    }
}

/**
 * 测试
 */
public class ProxyTest {
    public static void main(String[] args) {
        IBuyHouse buyHouse = new BuyHouseImpl(); // 目标对象
        // buyHouse.buyHosue(); // 创建目标对象直接调用目标方法
        BuyHouseProxy buyHouseProxy = new BuyHouseProxy(buyHouse); // 创建代理对象,把目标对象传给代理对象,建立代理关系
        buyHouseProxy.buyHosue(); // 执行的是代理的方法，代理对象内部调用目标对象方法，并执行代理类内添加的扩展功能
    }
}

/**
 * 实现方式1：代理工厂类
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;

    public ProxyFactory(Object target){
        this.target=target;
    }

    //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("买房前准备");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("买房后装修");
                        return returnValue;
                    }
                }
        );
    }
}

/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IBuyHouse buyHouse = new BuyHouseImpl();  
        // 创建代理对象, 传入目标对象，内存中动态生成的代理对象 
        IUserDao proxy = (IUserDao) new ProxyFactory(buyHouse).getProxyInstance();
        // 执行代理对象方法时, 会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
        proxy.buyHosue();
    }
}


/**
 * 实现方式2：
 */
public class DynamicProxyHandler implements InvocationHandler {
    //维护一个目标对象
    private Object object;

    public DynamicProxyHandler(final Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("买房前准备");
        Object result = method.invoke(object, args);
        System.out.println("买房后装修");
        return result;
    }
}

/**
 * 测试类2
 */
public class DynamicProxyTest {
    public static void main(String[] args) {
        IBuyHouse buyHouse = new BuyHouseImpl();
        BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(IBuyHouse.class.getClassLoader(),
            new Class[]{IBuyHouse.class},
            new DynamicProxyHandler(buyHouse));
        proxyBuyHouse.buyHosue();  // 执行代理对象方法时, 会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入
    }
}

Cglib子类代理实现方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在内存中动态构建子类
3.代理的类不能为final,无法被继承
4.目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

/**
 * Cglib动态代理类
 */
public class CglibProxy implements MethodInterceptor {
    //维护目标对象
    private Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    public Object getInstance() {
        //1.工具类 
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(this.target.getClass());
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.创建子类(代理对象)
        return enhancer.create();
    }

    @Override
    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("买房前准备");
        //执行目标对象方法
        Object result = methodProxy.invoke(object, args);
        System.out.println("买房后装修");
        return result;
    }
}

/**
 * 测试类
 */
public class CglibProxyTest {
    public static void main(String[] args){
        IBuyHouse buyHouse = new BuyHouseImpl();
        //传入目标对象，创建代理对象
        BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) new CglibProxy(buyHouse).getInstance();
        buyHouseCglibProxy.buyHosue(); //执行代理对象的方法
    }
}

/**
 * 策略角色(抽象/接口)类： Strategy
 * 用来约束一系列具体的策略算法
 * 也可以是abstract抽象父类，策略实现子类对其继承
 */
public interface IStrategy {
    /**
     * 必要方法：抽象算法接口，策略实现类中进行多态实现
     */
    void algorithm();
}

/**
 * @Description 具体策略实现类A： ConcreteStrategy
 **/
public class ConcreteStrategyA implements IStrategy {
    @Override
    public void algorithm() {
        System.out.println("Strategy A");
    }
}

/**
 * @Description 具体策略实现类B： ConcreteStrategy
 **/
public class ConcreteStrategyB implements IStrategy {
    @Override
    public void algorithm() {
        System.out.println("Strategy B");
    }
}

/**
 * @Description 策略上下文
 * 负责和具体的策略实现交互，通常策略上下文对象会持有一个真正的策略实现对象，策略上下文还可以让具体的策略实现从其中获取相关数据，回调策略上下文对象的方法
 **/
public class StrategyContext {
    private IStrategy mStrategy;

    public StrategyContext(IStrategy strategy) {
        this.mStrategy = strategy;
    }

    public void algorithm() {
        this.mStrategy.algorithm();
    }
}

/**
 * 测试StrategyContext 
 **/
public class StrategyTest {
    public static void main2(String[] args) {
        //选择一个具体策略
        IStrategy strategyA = new ConcreteStrategyA();
        //来一个上下文环境
        StrategyContext context = new StrategyContext(strategyA);
        //客户端直接让上下文环境执行算法
        context.algorithm();

        IStrategy strategyB = new ConcreteStrategyB();
        context = new StrategyContext(strategyB);
        context.algorithm();
    }
}