面试之设计模式

Posted 2021-02-09 sun-flower1314

 

1.举出一个例子，在这种情况你会更倾向于使用抽象类，而不是接口？

这是很常用但又是很难回答的设计面试问题。接口和抽象类都遵循”面向接口而不是实现编码”设计原则，它可以增加代码的灵活性，可以适应不断变化的需求。下面有几个点可以帮助你回答这个问题：

在Java中，你只能继承一个类，但可以实现多个接口。所以一旦你继承了一个类，你就失去了继承其他类的机会了。
接口通常被用来表示附属描述或行为如：Runnable、Clonable、Serializable等等，因此当你使用抽象类来表示行为时，你的类就不能同时是Runnable和Clonable(译者注：这里的意思是指如果把Runnable等实现为抽象类的情况)，因为在Java中你不能继承两个类，但当你使用接口时，你的类就可以同时拥有多个不同的行为。
在一些对时间要求比较高的应用中，倾向于使用抽象类，它会比接口稍快一点。
如果希望把一系列行为都规范在类继承层次内，并且可以更好地在同一个地方进行编码，那么抽象类是一个更好的选择。有时，接口和抽象类可以一起使用，接口中定义函数，而在抽象类中定义默认的实现。

2. 设计一个贩卖机，可以接收不同的货币，出售不同的产品？

这是一个开放设计问题，你可以作为练习，尝试着写出设计文档、代码和JUnit测试而不是只是解决这个问题，看看它花了你多少时间得到解决方案和得到需要的原形。理想情况下，这个问题应该可以在3个小时内解决，至少应该得到一个可以运行的版本。

3. 你有一个Smartphone类，可以派生如IPhone、androidPhone、WindowsMobilePhone类

它还可以是一些有着品牌的手机名称，你会怎么设计这个类系统呢。

这是另外一个设计模式练习，你可以应用你的面向对象设计技巧来得到一个设计，这个设计需要足够灵活能够支持未来产品的扩展，足够稳定能够支持在现有模型进行修改。

4. 在Java中，什么时候用重载，什么时候用重写？

对有经验的Java设计师来说，这是一个相当简单的问题。如果你看到一个类的不同实现有着不同的方式来做同一件事，那么就应该用重写（overriding），而重载（overloading）是用不同的输入做同一件事。在Java中，重载的方法签名不同，而重写并不是。

5. 设计一个ATM机？

我们所有人都使用ATM(自动柜员机)。想想你会怎么设计一个ATM？就设计金融系统来说，必须知道它们应该在任何情况下都能够如期工作。不管是断电还是其他情况，ATM应该保持 正确的状态（事务） , 想想 加锁（locking）、事务（transaction）、错误条件（error condition）、边界条件（boundary condition） 等等。尽管你不能想到具体的设计，但如果你可以指出非功能性需求，提出一些问题，想到关于边界条件，这些都会是很好的一步。

6. 你正在写一些类提供市场数据，你知道你可以不定时切换不同的厂商如Reuters、wombat或者直接的批发商， 你会如何设计你的市场数据系统。

这是一个非常有趣的设计面试问题，并且真的在一家大的投资银行问到过，如果你是用Java编码的话这是一个相当平常的场景。最主要的一点是你要有一个MarketData接口，它会有调用端需要的方法如：getBid()、getPrice()、getLevel()等等，而MarketData应该由一个MarketDataProvider通过 依赖注入（dependency injection） 组成。因此，当你修改你的MarketData 提供器（MarketDataProvider）时，调用端不会受影响，因为它们是通过MarketData接口或类的方法来访问的。

7. 在Java中，为什么不允许从静态方法中访问非静态变量？

你在Java中不能从静态上下文访问非静态数据只是因为非静态变量是跟具体的对象实例关联的，而静态的却没有和任何实例关联。你可以看我的文章为什么在静态上下文中不能访问非静态变量查看详细的讨论。

8. 在Java中设计一个并发规则的pipeline？

并发编程或并发设计这些天很火，它可以充分利用现在不断提升的高级处理器的处理能力，而Java成为一个多线程语言也从这种情况获益良多。设计一个并发系统需要记住的最关键的点是线程安全，不可变性，本地变量和避免使用static或者类变量（instance variables）。你只需要想着每一类都可以同时被多个线程同时执行，所以最好的做法就是每一个线程都处理自己的数据 ，不跟其他数据交互，并且运行时只需要最小的同步保证。这个问题可以涉及到从最初的讨论到完整的类和接口编码，但只要你记住并发中最重要的点和问题如，竞争条件（race condition）、死锁（deadlock）、内存交互问题（memory interference）、原子性、ThreadLocal变量等，你都可以回答它。

给初学者的设计模式面试问题

这些软件设计和设计模式问题大多在初学者层次时被问起，目的只是了解一下候选人(应聘者)对设计模式知道多少，如， 设计模式是什么 或者 一个特定的设计模式做什么 ?这些问题通过简单地记忆概念就可以回答，但就信息和知识而言还是有价值的。

1. 什么是设计模式？你是否在你的代码里面使用过任何设计模式？

设计模式是世界上各种各样程序员用来解决特定设计问题的尝试和测试的方法。设计模式是代码可用性的延伸。

2. 你可以说出几个在JDK库中使用的设计模式吗？

装饰器设计模式（Decorator design pattern）被用于多个Java IO类中。单例模式（Singleton pattern）用于Runtime，Calendar和其他的一些类中。工厂模式（Factory pattern）被用于各种不可变的类如Boolean，像Boolean.valueOf，观察者模式（Observer pattern）被用于Swing和很多的事件监听中。

3. Java中什么是单例设计模式？用Java写出线程安全的单例

单例模式重点在于在整个系统上共享一些创建时较耗资源的对象。整个应用中只维护一个特定类实例，它被所有组件共同使用。Java.lang.Runtime是单例模式的经典例子。你可以在我的文章Java单例模式的10个问题看到更多的问题和讨论。从Java 5开始你可以使用枚举（enum）来实现线程安全的单例。

4. 使用工厂模式最主要的好处是什么？你在哪里使用？

工厂模式的最大好处是增加了创建对象时的封装层次。如果 你使用工厂来创建对象，之后你可以使用更高级和更高性能的实现来替换原始的产品实现或类，这不需要在调用层做任何修改。可以看我的文章工厂模式得更详细的解释和和了解更多的好处。

5. 在Java中，什么叫观察者设计模式（observer design pattern）？

观察者模式是基于对象的状态变化和观察者的通讯，以便他们作出相应的操作。简单的例子就是一个天气系统，当天气变化时必须在展示给公众的视图中进行反映。这个视图对象是一个主体，而不同的视图是观察者。可以在这篇文章中看到Java观察者模式的完整例子。

6. 举一个用Java实现的装饰模式(decorator design pattern)？它是作用于对象层次还是类层次？

装饰模式增加强了单个对象的能力。Java IO到处都使用了装饰模式，经典的例子就是Buffered系列类如BufferedReader和BufferedWriter，它们增强了Reader和Writer对象，以实现提升性能的Buffer层次的读取和写入。可以看这篇文章了解更多。

7. 什么是MVC设计模式？举一个MVC设计模式的例子？

8, Java中什么是表示层设计模式（FrontController design pattern）？举一个使用表示层设计模式（front controller pattern）的例子？

9. 什么是责任链模式（Chain of Responsibility）？

10. 什么是适配器模式？举用Java实现适配器模式的例子？

 

 

 

 

 

 

 

单例模式
简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例，所以不要错误的理解成多个对象。单例模式实现起来也很容易，直接看demo吧

public class Singleton {

private static Singleton singleton;

private Singleton() {
}

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

观察者模式
对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。Android中的各种Listener就使用到了这一设计模式，只要用户对手机进行操作，对应的listener就会被通知，并作出响应的处理。
观察者模式UML图
看不懂图的人端着小板凳到这里来，给你举个栗子??：假设有三个人，小美（女，28），老王和老李。小美很漂亮，很风骚，老王和老李是两个中年男屌丝，时刻关注着小美的一举一动。有一天，小美说了一句：我老公今天不在家，一个人好无聊啊～～～，这句话被老王和老李听到了，结果乐坏了，蹭蹭蹭，没一会儿，老王就冲到小美家门口了，于是进门了……………………..帕～啪啪啪啪啪～
在这里，小美是被观察者，老王和老李是观察者，被观察者发出一条信息，然后被观察者进行相应的处理，看代码：

public interface Person {
//老王和老李通过这个接口可以接收到小美发过来的消息
void getMessage(String s);
}

这个接口相当于老王和老李的电话号码，小美发送通知的时候就会拨打getMessage这个电话，拨打电话就是调用接口，看不懂没关系，先往下看

public class LaoWang implements Person {

private String name = "老王";

public LaoWang() {
}

@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
}
}

public class LaoLi implements Person {

private String name = "老李";

public LaoLi() {
}

@Override
public void getMessage(String s) {
System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
}

}

代码很简单，我们再看看小美的代码：
public class XiaoMei {
List<Person> list = new ArrayList<Person>();
public XiaoMei(){
}

public void addPerson(Person person){
list.add(person);
}

//遍历list，把自己的通知发送给所有暗恋自己的人
public void notifyPerson() {
for(Person person:list){
person.getMessage("今天家里就我一个人，你们过来吧，谁先过来谁就能得到我!");
}
}
}

我们写一个测试类来看一下结果对不对
public class Test {
public static void main(String[] args) {

XiaoMei xiao_mei = new XiaoMei();
LaoWang lao_wang = new LaoWang();
LaoLi lao_li = new LaoLi();

//老王和老李在小美那里都注册了一下
xiao_mei.addPerson(lao_wang);
xiao_mei.addPerson(lao_li);

//小美向老王和老李发送通知
xiao_mei.notifyPerson();
}
}

装饰者模式
对已有的业务逻辑进一步的封装，使其增加额外的功能，如java中的IO流就使用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的效果。
举个栗子，我想吃三明治，首先我需要一根大大的香肠，我喜欢吃奶油，在香肠上面加一点奶油，再放一点蔬菜，最后再用两片面包加一下，很丰盛的一顿午饭，营养又健康，那我们应该怎么来写代码呢？
首先，我们需要写一个Food类，让其他所有食物都来继承这个类，看代码：

public class Food {
private String food_name;
public Food() {
}

public Food(String food_name) {
this.food_name = food_name;
}

public String make() {
return food_name;
};
}

代码很简单，我就不解释了，然后我们写几个子类继承它：

//面包类
public class Bread extends Food {

private Food basic_food;

public Bread(Food basic_food) {
this.basic_food = basic_food;
}

public String make() {
return basic_food.make()+"+面包";
}
}

//奶油类
public class Cream extends Food {

private Food basic_food;

public Cream(Food basic_food) {
this.basic_food = basic_food;
}

public String make() {
return basic_food.make()+"+奶油";
}
}

//蔬菜类
public class Vegetable extends Food {

private Food basic_food;

public Vegetable(Food basic_food) {
this.basic_food = basic_food;
}

public String make() {
return basic_food.make()+"+蔬菜";
}

}

 

这几个类都是差不多的，构造方法传入一个Food类型的参数，然后在make方法中加入一些自己的逻辑，如果你还是看不懂为什么这么写，不急，你看看我的Test类是怎么写的，一看你就明白了

public class Test {
public static void main(String[] args) {
Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
System.out.println(food.make());
}
}

 

看到没有，一层一层封装，我没从里往外看：最里面我new了一个香肠，在香肠的外面我包裹了一层奶油，在奶油的外面我又加了一层蔬菜，最外面我放的是面包，是不是很形象，哈哈?? 这个设计模式简直跟现实生活中一摸一样，看懂了吗？
我们看看运行结果吧
运行结果
一个三明治就做好了～～～

适配器模式
将两种完全不同的事物联系到一起，就像现实生活中的变压器。假设一个手机充电器需要的电压是20V，但是正常的电压是220V，这时候就需要一个变压器，将220V的电压转换成20V的电压，这样，变压器就将20V的电压和手机联系起来了。

public class Test {
public static void main(String[] args) {
Phone phone = new Phone();
VoltageAdapter adapter = new VoltageAdapter();
phone.setAdapter(adapter);
phone.charge();
}
}

// 手机类
class Phone {

public static final int V = 220;// 正常电压220v，是一个常量

private VoltageAdapter adapter;

// 充电
public void charge() {
adapter.changeVoltage();
}

public void setAdapter(VoltageAdapter adapter) {
this.adapter = adapter;
}
}

// 变压器
class VoltageAdapter {
// 改变电压的功能
public void changeVoltage() {
System.out.println("正在充电...");
System.out.println("原始电压：" + Phone.V + "V");
System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
}
}

 

工厂模式
简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

// 抽象产品类
abstract class Car {
public void run();

public void stop();
}

// 具体实现类
class Benz implements Car {
public void run() {
System.out.println("Benz开始启动了。。。。。");
}

public void stop() {
System.out.println("Benz停车了。。。。。");
}
}

class Ford implements Car {
public void run() {
System.out.println("Ford开始启动了。。。");
}

public void stop() {
System.out.println("Ford停车了。。。。");
}
}

// 工厂类
class Factory {
public static Car getCarInstance(String type) {
Car c = null;
if ("Benz".equals(type)) {
c = new Benz();
}
if ("Ford".equals(type)) {
c = new Ford();
}
return c;
}
}

public class Test {

public static void main(String[] args) {
Car c = Factory.getCarInstance("Benz");
if (c != null) {
c.run();
c.stop();
} else {
System.out.println("造不了这种汽车。。。");
}

}

}

1

工厂方法模式：有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品

// 抽象产品角色
public interface Moveable {
void run();
}

// 具体产品角色
public class Plane implements Moveable {
@Override
public void run() {
System.out.println("plane....");
}
}

public class Broom implements Moveable {
@Override
public void run() {
System.out.println("broom.....");
}
}

// 抽象工厂
public abstract class VehicleFactory {
abstract Moveable create();
}

// 具体工厂
public class PlaneFactory extends VehicleFactory {
public Moveable create() {
return new Plane();
}
}

public class BroomFactory extends VehicleFactory {
public Moveable create() {
return new Broom();
}
}

// 测试类
public class Test {
public static void main(String[] args) {
VehicleFactory factory = new BroomFactory();
Moveable m = factory.create();
m.run();
}
}

 

 

抽象工厂模式：与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品

/抽象工厂类
public abstract class AbstractFactory {
public abstract Vehicle createVehicle();
public abstract Weapon createWeapon();
public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
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 Test {
public static void main(String[] args) {
AbstractFactory f = new DefaultFactory();
Vehicle v = f.createVehicle();
v.run();
Weapon w = f.createWeapon();
w.shoot();
Food a = f.createFood();
a.printName();
}
}

 

 忘记摘自那个博客了 侵删