java开发项目负责人面试题

public static void main(String[] args) {

    Sender sender = SendFactory.produceMail();

    sender.send();

}}
抽象工厂模式 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。public interface Provider {
public Sender produce();}
public interface Sender {
public void send();}
public class MailSender implements Sender {
@Override

public void send() {

    System.out.println("this is mail sender!");

}}
public class SmsSender implements Sender {
@Override

public void send() {

    System.out.println("this is sms sender!");

}}
public class SendSmsFactory implements Provider {
@Override

public Sender produce() {

    return new SmsSender();

}}
public class SendMailFactory implements Provider {
@Override

public Sender produce() {

    return new MailSender();

}}
public class Test {
public static void main(String[] args) {

    Provider provider = new SendMailFactory();

    Sender sender = provider.produce();

    sender.send();

}}
**28、建造者模式（Builder）** 工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象， 所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的 Test 结合起来得到的。public class Builder {
private List<Sender> list = new ArrayList<Sender>();

public void produceMailSender(int count) {

    for (int i = 0; i < count; i++) {

        list.add(new MailSender());

    }

}

public void produceSmsSender(int count) {

    for (int i = 0; i < count; i++) {

        list.add(new SmsSender());

    }

}}
public class Builder {
private List<Sender> list = new ArrayList<Sender>();

public void produceMailSender(int count) {

    for (int i = 0; i < count; i++) {

        list.add(new MailSender());

    }

}

public void produceSmsSender(int count) {

    for (int i = 0; i < count; i++) {

        list.add(new SmsSender());

    }

}}
public class TestBuilder {
public static void main(String[] args) {

    Builder builder = new Builder();

    builder.produceMailSender(10);

}}
**29、适配器设计模式** 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。



类的适配器模式public class Source {
public void method1() {

    System.out.println("this is original method!");

}}
public interface Targetable {
/* 与原类中的方法相同 */

public void method1();

/* 新类的方法 */

public void method2();}
public class Adapter extends Source implements Targetable {
@Override

public void method2() {

    System.out.println("this is the targetable method!");

}}
public class AdapterTest {
public static void main(String[] args) {

    Targetable target = new Adapter();

    target.method1();

    target.method2();

}}
对象的适配器模式 基本思路和类的适配器模式相同，只是将 Adapter 类作修改，这次不继承 Source 类，而是持有 Source 类的实例，以达到解决兼容性的问题。public class Wrapper implements Targetable {
private Source source;

public Wrapper(Source source) {

    super();

    this.source = source;

}

@Override

public void method2() {

    System.out.println("this is the targetable method!");

}

@Override

public void method1() {

    source.method1();

}}
public class AdapterTest {
public static void main(String[] args) {

    Source source = new Source();

    Targetable target = new Wrapper(source);

    target.method1();

    target.method2();

}}
接口的适配器模式 接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。



**30、装饰模式（Decorator）** 顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。public interface Sourceable {
public void method();}
public class Source implements Sourceable {
@Override

public void method() {

    System.out.println("the original method!");

}}
public class Decorator implements Sourceable {
private Sourceable source;

public Decorator(Sourceable source) {

    super();

    this.source = source;

}

@Override

public void method() {

    System.out.println("before decorator!");

    source.method();

    System.out.println("after decorator!");

}}
public class DecoratorTest {
public static void main(String[] args) {

    Sourceable source = new Source();

    Sourceable obj = new Decorator(source);

    obj.method();

}}
**31、策略模式（strategy）** 策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数。策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可。public interface ICalculator {
public int calculate(String exp);}
public class Minus extends AbstractCalculator implements ICalculator {
@Override

public int calculate(String exp) {

    int arrayInt[] = split(exp， "-");

    return arrayInt[0] - arrayInt[1];

}}
public class Plus extends AbstractCalculator implements ICalculator {
@Override

public int calculate(String exp) {

    int arrayInt[] = split(exp， "\+");

    return arrayInt[0] + arrayInt[1];

}}
public class AbstractCalculator {
public int[] split(String exp， String opt) {

    String array[] = exp.split(opt);

    int arrayInt[] = new int[2];

    arrayInt[0] = Integer.parseInt(array[0]);

    arrayInt[1] = Integer.parseInt(array[1]);

    return arrayInt;

}}
public class StrategyTest {
public static void main(String[] args) {

    String exp = "2+8";

    ICalculator cal = new Plus();

    int result = cal.calculate(exp);

    System.out.println(result);

}}
**32、观察者模式（Observer）** 观察者模式很好理解，类似于邮件订阅和RSS订阅，当我们浏览一些博客或wiki时，经常会看到RSS图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。其实，简单来讲就一句话：当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。public interface Observer {
public void update();}
public class Observer1 implements Observer {
@Override

public void update() {

    System.out.println("observer1 has received!");

}}
public class Observer2 implements Observer {
@Override

public void update() {

    System.out.println("observer2 has received!");

}}
public interface Subject {
/*增加观察者*/

public void add(Observer observer);

/*删除观察者*/

public void del(Observer observer);

/*通知所有的观察者*/

public void notifyObservers();

/*自身的操作*/

public void operation();}
public abstract class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();

@Override

public void add(Observer observer) {

    vector.add(observer);

}

@Override

public void del(Observer observer) {

    vector.remove(observer);

}

@Override

public void notifyObservers() {

    Enumeration<Observer> enumo = vector.elements();

    while (enumo.hasMoreElements()) {

        enumo.nextElement().update();

    }

}}
public class MySubject extends AbstractSubject {
@Override

public void operation() {

    System.out.println("update self!");

    notifyObservers();

}}
public class ObserverTest {
public static void main(String[] args) {

    Subject sub = new MySubject();

    sub.add(new Observer1());

    sub.add(new Observer2());

    sub.operation();

}}

**33、微服务架构的六种常用设计模式是什么？** 代理设计模式 聚合设计模式 链条设计模式 聚合链条设计模式 数据共享设计模式 异步消息设计模式



**34、设计模式是什么，设计模式有什么作用？** 设计模式是一套被反复使用的、多数人知晓、经过分类编目的优秀代码设计经验的总结。特定环境下特定问题的处理方法。 1）重用设计和代码 重用设计比重用代码更有意义，自动带来代码重用 2）提高扩展性 大量使用面向接口编程，预留扩展插槽，新的功能或特性很容易加入到系统中来 3）提高灵活性 通过组合提高灵活性，可允许代码修改平稳发生，对一处修改不会波及到其他模块 4） 提高开发效率 正确使用设计模式，可以节省大量的时间