Java基础知识回顾（二）

1.抽象类应用-模板方法模式（Templete）

概念：定义操作中的算法的骨架，而将一些可变部分的实现延迟到子类中。模板方法模式
使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定的步骤。

public class TempleteMode {
	// test invoke
    public static void main(String[] args) {
        Manager m = new UserManager();
        m.action("admin","admin","add");
    }

}

/**
 * 模板方法的骨架
 */
abstract class Manager{

    public void action(String name,String password,String opertor){
        if("admin".equals(name) && "admin".equals(password)){
            excute(opertor);
        } else {
            System.out.println("你没有访问权限，请联系管理员。");
        }
    }

    public abstract void excute(String opertor);

}

class UserManager extends Manager{

    @Override
    public void excute(String opertor) {
        if("add".equals(opertor)){
            System.out.println("执行了添加方法");
        }else if("del".equals(opertor)){
            System.out.println("执行了删除方法");
        }
    }
}

class RoleManager extends Manager{
    @Override
    public void excute(String opertor) {
        System.out.println("...");
    }
}

小结：核心在于定义好某种共需的模板算法。

2.接口应用-策略模式（Strategy）

概念：定义了一系列的算法，将每一种算法封装起来并可以相互替换使用，
策略模式让算法独立于使用它的客户应用独立变化。（把每一个变化的客户抽象出具体的行为）

public class StrategyMode {

    public static void main(String[] args) {
        Assemble assemble = new BizCode(new DataToNet());
        assemble.excete("小明");
    }

}

interface Behavior{
    // 定义好接口抽象算法
    void save(String data);
}

// 定义两个变化的客户实现行为抽象接口
class DataToDataBase implements Behavior{

    @Override
    public void save(String data) {
        System.out.println("将数据保存在数据库中...");
    }
}

class DataToNet implements Behavior{

    @Override
    public void save(String data) {
        System.out.println("将数据保存在网络中...");
    }
}

// 组装好抽象接口
abstract class Assemble {

    private Behavior behavior;
    public Assemble (Behavior behavior) {
        this.behavior = behavior;
    }

    public void excete(String data) {
        behavior.save(data);
        System.out.println(data +"数据保存成功。。。");
    }
}

/**
 * 业务代码
 */
class BizCode extends Assemble{

    public BizCode(Behavior behavior) {
        super(behavior);
    }
}

小结：根据不同的策略方式来执行相应的biz code. 也可通过枚举来构建

3.简单工厂模式（Factory）

概念：由一个工厂对象决定创建哪一种产品类的实例。精髓之处在于通过工厂类来获取对象，而不是直接创建对象

    public static void main(String[] args) {
//        Product product = new Appel();
//        product.doAction();
//
//        Product banner = new Banner();
//        banner.doAction();

        Product product = ProductFactory.getProduct("banner");
        product.doAction();
    }

}

// 工厂类
class ProductFactory{
    public static Product getProduct(String name){
        if("apple".equals(name)){
            return new Appel();
        } else if("banner".equals(name)){
            return new Banner();
        } else {
            return null;
        }
    }
}


interface Product {
    void doAction();
}


class Appel implements Product{

    @Override
    public void doAction() {
        System.out.println("开始生产苹果");
    }
}

class Banner implements Product{

    @Override
    public void doAction() {
        System.out.println("开始生产图像");
    }
}

小结：核心在于用工厂类来判断后构建需要的对象，使得对象创建的耦合度降低

4.适配器模式（Adapter）

概念：将一个类的接口转换成客户希望的另外一个接口（也就是说之前的接口不能满足现在的需求）
使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

public class AdapterMode {

    public static void main(String[] args) {
        PowerB b = new ElecB();
        Adapter adapter = new Adapter(b);
        work(adapter);

    }

    public static void work(PowerA a){
        a.insert();
    }
}

// 适配器组装需要适配的接口
class Adapter implements PowerA {

    private PowerB powerB;
    public Adapter(PowerB powerB){
        this.powerB = powerB;
    }

    @Override
    public void insert() {
        powerB.connect();
    }
}

interface PowerA{
    void insert();
}

interface PowerB{
    void connect();
}

class ElecA implements PowerA {
    @Override
    public void insert() {
        System.out.println("A开始工作");
    }
}

class ElecB implements PowerB{

    @Override
    public void connect() {
        System.out.println("开始连接B");
    }
}

小结：通过适配器模式可以构建接口之间无法匹配的问题，对于扩展时开放的。主要通过组装的方式构建。

5.静态代理模式（Proxy）

概念：用代理来控制需要操作的目标方法。可在操作目标方法前后进行增强自定义的逻辑。

6.内部类：在外部创建成员内部类的实例，因为成员内部类需要依赖外部类的对象

7.享元模式：将一个字节内的数据进行缓存，比如数据缓存池，Integer源码就是享元模式的实现。运用共享技术有效的支持大量细粒度的对象。

8.装饰者模式：动态的给一个对象添加一些额外的职责，就增加功能来说，Decorator模式相比生产子类更为灵活，该模式以对客户端透明的方式扩展对象的功能。

9.递归算法：递归算法是一种直接或者间接调用自身算法的过程。往往使算法的描述简洁且易于理解。(Call yourself)

调用原理图：如求5的阶层

1、递归必须要有出口。
2、递归内存消耗大，容易GC.