某公司面试题，用面向对象的思想写一下代码，题目很简单，我就写不好

[专注or全面]

代码题（用oop的思想编码，注意代码规范）

用java写一个微波炉，注意物品正加热时不能开门，带皮带壳食物不能被加热。

用Java写一个冰箱，注意家用冰箱多数分为冷冻柜和冷藏柜两个柜（冰箱随机）

如题，就是要用面向对象的方式写代码，我怎么看不出来怎么写，

比如第二题，我一个接口然后具体类实现接口完事，结果被鄙视，无情鄙视啊

这是某某的面试题，大家各抒己见！！！

[zeroqiooo]

学习中，oo的思想

[常遇道]

面试，就是用人单位变态的玩法，不过你的心态一定要好，平常心态一定很重要

[狂镀余光]

interface BingXiangGui
{
	void work();
	void stop();
}
//冷藏柜
class LengCang implements BingXiangGui
{
	public void work()
	{
		System.out.println("冷藏柜正在工作");
	}
	public void stop()
	{
		System.out.println("冷藏柜停止工作");
	}
}
//冷冻柜
class LengDong implements BingXiangGui
{
	public void work()
	{
		System.out.println("冷冻柜正在工作");
	}
	public void stop()
	{
		System.out.println("冷冻柜停止工作");
	}
}
class BingXiangMen
{
	public void kaiMen(BingXiangGui bxg)
	{
		bxg.work();
		bxg.stop();
	}
}
class BingXiang
{
	public static void main(String [] args)
	{
		BingXiangMen bxm=new BingXiangMen();
		LengCang lc=new LengCang();
		LengDong ld=new LengDong();
		bxm.kaiMen(lc);//lc隐式转型为bxg，向上转型
		bxm.kaiMen(ld);
	}
}

结果：
冷藏柜正在工作
冷藏柜停止工作
冷冻柜正在工作
冷冻柜停止工作

[狂镀余光]

public class weiBoLu
{
public boolean flag=false;
public void setFlagFalse()//烘拷完成，取出食物
{
flag=false;
}
public void hongKao(boolean k,boolean p)//烘拷箱
{
if(flag)
{
System.out.println("对不起！正在烘拷，不能开门");
return ;
}
else
{
if((k&&p))
{
System.out.println("对不起！带皮且带壳的食物更加不能烘拷");
return;
}
if (k||p)
{
if(k)
System.out.println("对不起！带壳的食物不能烘拷");
else
System.out.println("对不起！带皮的食物不能烘拷");
}
else
{
System.out.println("正在烘拷......");
flag=true;
}

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

weiBoLu td = new weiBoLu();

td.hongKao(false,false);//既不带皮也不带壳
td.setFlagFalse();//烘拷完成，取出食物

td.hongKao(false,false);
/*当要对

食物进行烘拷之前一定要把原烘拷箱内
* 的食物取出，否则无法烘拷，试着将下条语句注释*/
td.setFlagFalse();//烘拷完成，取出食物

td.hongKao(true,false);//带壳的食物
td.hongKao(false,true);//带皮的食物
td.hongKao(true,true);//既带皮又带壳的食物
td.hongKao(f

alse,false);//此语句可以说明上面三条语句都没有将食物放到烘拷箱内
}
}

执行结果：

正在烘拷......
正在烘拷......
对不起！带壳的食物不能烘拷
对不起！带皮的食物不能烘拷
对不起！带皮且带壳的食物更加不能烘拷
正在烘拷......

[狂镀余光]

public class weiBoLu
{
	public boolean flag=false; 
	public void setFlagFalse()//烘拷完成，取出食物
	{
		flag=false;
	}
	public void hongKao(boolean k,boolean p)//烘拷箱
	{
		if(flag)
		{
			System.out.println("对不起！正在烘拷，不能开门");
			return ;
		}
		else 
		{
			if((k&&p))
			{
				System.out.println("对不起！带皮且带壳的食物更加不能烘拷");
				return;
			}
			if (k||p)
			{
				if(k)
					System.out.println("对不起！带壳的食物不能烘拷");
				else 
					System.out.println("对不起！带皮的食物不能烘拷");
			}
			else
			{
				System.out.println("正在烘拷......");
				flag=true;
			}
			
		}
	}
	public static void main(String [] args)
	{
		weiBoLu td = new weiBoLu();
		
		td.hongKao(false,false);//既不带皮也不带壳
		td.setFlagFalse();//烘拷完成，取出食物
		
		td.hongKao(false,false);
		/*当要对食物进行烘拷之前一定要把原烘拷箱内
		 * 的食物取出，否则无法烘拷，试着将下条语句注释*/
		td.setFlagFalse();//烘拷完成，取出食物
		
		td.hongKao(true,false);//带壳的食物
		td.hongKao(false,true);//带皮的食物
		td.hongKao(true,true);//既带皮又带壳的食物
		td.hongKao(false,false);//此语句可以说明上面三条语句都没有将食物放到烘拷箱内
	}
}

[狂镀余光]

将

public boolean flag=false; 

改为

private boolean flag=false; 

执行结果：
正在烘拷......
正在烘拷......
对不起！带壳的食物不能烘拷
对不起！带皮的食物不能烘拷
对不起！带皮且带壳的食物更加不能烘拷
正在烘拷......

[laoas]

学习

[常常发懵？]

[Quote=引用 16 楼 aptweasel 的回复:]
关于冰箱的问题说的不清楚，我发表一下我对微波炉的看法，我觉得它真的能看出一个程序员的水平高低
我们来分析一下这个问题
用java写一个微波炉，注意物品正加热时不能开门，带皮带壳食物不能被加热。
1，微波炉是一个对象，它应该是一个公共对象，大家都可以用。
2，注意物品正加热时不能开门,我们可以理解，这个对象在执行时，是排它的，唯一的
3，带皮带壳食物不能被加热。这个对象不是万能的，有些事它是不可以做的。
因此，我们的对象是公共对象，它有一个开关（属性），同时有开关方法，并且是单例程序，并且有同步约束，在方法体里加一些判断， 这个过程就OK了。

[/Quote]

分析的好强啊
高人
膜拜一下

[常常发懵？]

参考16的思路，用线程写了一下这个程序，请大家点评

package JavaTest;

public class Microwave implements Runnable {

	public boolean isCooking = false;
	public Food food;
	public int time;

	public Microwave(Food food, int time) {
		this.food = food;
		this.time = time;
	}

	@Override
	public void run() {
		cook(food, 3000);

	}

	public synchronized void cook(Food food, int time) {
		
		System.out.println("door is closed ...");
		
		if (food.isSheel) {
			System.out
					.println("this microwave is not available for Food with sheels!");
			return;
		}

		System.out.println("cooking ....");
		
		try {
			Thread.sleep(time);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("food is OK!");

		open();

	}

	private void open() {
		System.out.println("door is opened. ");
	}

	public static void main(String[] args) {

		Microwave mw = new Microwave(new Food(false), 2000);
		new Thread(mw).start();
		new Thread(mw).start();
	}
}

class Food {
	public boolean isSheel = false;

	public Food(boolean sheel) {
		this.isSheel = sheel;
	}
}

[李雅勇的技术专栏]

这道题的目的是考面向对象，想要考察面试人员的考点我觉得：1、通过封装尽量降低解耦，2、提高可扩展性及可维护性。
所以观察题意，本人觉得先找变化点，再对其进行封装。
微波炉的例子变化点有两个，即：
微波炉的状态和微波炉中可加热的食物的判定：
先说微波炉的状态：微波炉的状态应该用状态模式，将开门、关门、加热封装成三种状态，如果以后有了新状态，如：强加热、中加热、弱加热等，可直接添加状态类而无需改动原代码。
再说微波炉中可加热的食物的判定：加热的食物可能会和加热状态耦合，之后为考题加难度可能会使不同加热方式可放入不同种类的食物等方面。此时，变化点比较复杂，所以食物不一定只有带不带壳，可能还有其他分法，为了解耦，可将不同的类的食物及不同类型加热方式封装在策略模式中。
此时，如果加入新的加热状态则只需要加入一个状态类和一个此状态的策略类。
但是这样做还是有问题的，因为如果加入一种新的食物，就需要更改所有的策略类，使所有加热状态都够判定新的食物。
微波炉例子就到这里吧，至于冰箱的例子，原文描述为：
“用Java写一个冰箱，注意家用冰箱多数分为冷冻柜和冷藏柜两个柜（冰箱随机）”
还是先找变化点，其中，每个柜的大小、开门方向或制冷量都是其属性而已，不属于变化点。
我认为变化点在以下描述中可以看出来：
冰箱有双开门或单开门：其中双开门又包括上冷藏下冷冻，也可能会是下冷藏上冷冻；而单开门可能只有冷藏，但也可能把冰柜也算在内。所以变化点之一就是冰箱的不同组合方式会是单柜或不同的上下柜。
另外，此处可以看到，有的组合了两种，有的只有一种，有的可能有特殊的保鲜柜，
将来的冰箱除了单开门和双开门，可能会加入三开门（保鲜柜）等。这时，问题不只是组合方式更加灵活，除了更加灵活的组合方式外，还有就是加入了新的冰柜类型即“保鲜柜”。
这两个变化点都可以用组合模式来完成，组合模式不仅可以让你的类组合起来更灵活，而且可以让新组件的添加独立于以前的结构。
注意：上述我所说的三个模式是GoF书中的composite组合、strategy策略和state状态。

[bb100044535]

顶上去

[李雅勇的技术专栏]

引用楼主 x_wy46 的回复:

代码题（用oop的思想编码，注意代码规范）

用java写一个微波炉，注意物品正加热时不能开门，带皮带壳食物不能被加热。

用Java写一个冰箱，注意家用冰箱多数分为冷冻柜和冷藏柜两个柜（冰箱随机）

如题，就是要用面向对象的方式写代码，我怎么看不出来怎么写，

比如第二题，我一个接口然后具体类实现接口完事，结果被鄙视，无情鄙视啊

这是某某的面试题，大家各抒己见！！！

以下是我的思考，记录下来，有兴趣可以在此加以回复讨论

这道题的目的是考面向对象，想要考察面试人员的考点我觉得：1、通过封装尽量降低解耦，2、提高可扩展性及可维护性。
所以观察题意，本人觉得先找变化点，再对其进行封装。
微波炉的例子变化点有两个，即：
微波炉的状态和微波炉中可加热的食物的判定：
先说微波炉的状态：微波炉的状态应该用状态模式，将开门、关门、加热封装成三种状态，如果以后有了新状态，如：强加热、中加热、弱加热等，可直接添加状态类而无需改动原代码。
再说微波炉中可加热的食物的判定：加热的食物可能会和加热状态耦合，之后为考题加难度可能会使不同加热方式可放入不同种类的食物等方面。此时，变化点比较复杂，所以食物不一定只有带不带壳，可能还有其他分法，为了解耦，可将不同的类的食物及不同类型加热方式封装在策略模式中。
此时，如果加入新的加热状态则只需要加入一个状态类和一个此状态的策略类。
但是这样做还是有问题的，因为如果加入一种新的食物，就需要更改所有的策略类，使所有加热状态都够判定新的食物。
微波炉例子就到这里吧，至于冰箱的例子，原文描述为：
“用Java写一个冰箱，注意家用冰箱多数分为冷冻柜和冷藏柜两个柜（冰箱随机）”
还是先找变化点，其中，每个柜的大小、开门方向或制冷量都是其属性而已，不属于变化点。
我认为变化点在以下描述中可以看出来：
冰箱有双开门或单开门：其中双开门又包括上冷藏下冷冻，也可能会是下冷藏上冷冻；而单开门可能只有冷藏，但也可能把冰柜也算在内。所以变化点之一就是冰箱的不同组合方式会是单柜或不同的上下柜。
另外，此处可以看到，有的组合了两种，有的只有一种，有的可能有特殊的保鲜柜，
将来的冰箱除了单开门和双开门，可能会加入三开门（保鲜柜）等。这时，问题不只是组合方式更加灵活，除了更加灵活的组合方式外，还有就是加入了新的冰柜类型即“保鲜柜”。
这两个变化点都可以用组合模式来完成，组合模式不仅可以让你的类组合起来更灵活，而且可以让新组件的添加独立于以前的结构。
注意：上述我所说的三个模式是GoF书中的composite组合、strategy策略和state状态。



本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/geniusli/archive/2010/01/05/5136989.aspx

[jxygjzh04]

因为我们家里面只有冰箱..就说说冰箱好了... 为什么没微波炉呢，因为我租房..为什么租房子呢，因为北京房子太贵..为什么..

跑题了跑题了..

我对冰箱考虑的思路是这样滴..我的观点不是从冰箱与冷冻柜（冷藏柜）是父类子类的关系，我就把冷冻和冷藏看做是冰箱的功能，冰箱可以做冷藏这个工作，或者冷冻的工作，或者两项都可以做。
万一以后又了什么加热的功能..那就好了..微波炉和冰箱大组合..哈哈..

又跑题了 不好意思

那么我采用的模式是装饰器的模式。

首先，先吧冰箱这个东西抽象出来。

public interface Icebox {
	public String work();
}

然后咱们造一个简单的冰箱。让这个冰箱大吼一声，我是冰箱。

public class SimpleIcebox implements Icebox {

	public String work() {
		// TODO Auto-generated method stub
		return "我是个冰箱 , 我开始工作鸟";
	}

}

然后呢，咱们要开发一个工具，让这个冰箱有一些功能。就要先定义一个装饰器的抽象类。（具体请参考装饰器模式）

abstract class IceboxDecorator implements Icebox{
	protected Icebox icebox; // the Window being decorated 
	
	public IceboxDecorator(Icebox icebox){
		this.icebox = icebox;
	}
}

下面呢，咱们要让冰箱有什么功能呢。先冷藏吧：

public class Refrigerator extends IceboxDecorator {
	public Refrigerator(Icebox icebox){
		super(icebox);
	}
	
	public String work() {
		// TODO Auto-generated method stub
		return icebox.work() + " , 我可以冷藏" ;
	}

}

然后在冷冻。

public class Freezer extends IceboxDecorator {
	public Freezer(Icebox icebox){
		super(icebox);
	}
	
	public String work() {
		// TODO Auto-generated method stub
		return icebox.work() + " , 我可以冷冻" ;
	}

}

哈哈...快快快..试试造个冰箱吧，后面跟帖的朋友们看看你们的运气了，奖品设置：

第88888楼的朋友，奖品是：

                Icebox icebox1 = new Freezer(new SimpleIcebox());
		System.out.println(icebox1.work());

输出结果：我是个冰箱 , 我开始工作鸟 , 我可以冷冻

第888888楼的朋友，奖品是：

                Icebox icebox2 = new Refrigerator(new SimpleIcebox());
		System.out.println(icebox2.work());

输出结果：我是个冰箱 , 我开始工作鸟 , 我可以冷藏

第8888888楼的朋友，奖品是：

                Icebox icebox3 = new Freezer(new Refrigerator(new SimpleIcebox()));
		System.out.println(icebox3.work());

输出结果：我是个冰箱 , 我开始工作鸟 , 我可以冷藏 , 我可以冷冻

童鞋们...可以尝试加一个加热的功能..让我们的冰箱还可以加热...

[color=#FF0000]哎..帖子都好几页了..不知道有没有人能看到我的回复，能看的话招呼一声，就是批评也行，我就知道我没白忙活！[/color]

[jxygjzh04]

FML...发现这个帖子是去年了...

[tuo_bing]

呵呵，楼上的，我看到了，没白忙。。。

[lyn0032]

不出现类似状态机或者变量标记的一个实现机制？

[jing43]

[Quote=引用 16 楼 aptweasel 的回复:]
关于冰箱的问题说的不清楚，我发表一下我对微波炉的看法，我觉得它真的能看出一个程序员的水平高低
我们来分析一下这个问题
用java写一个微波炉，注意物品正加热时不能开门，带皮带壳食物不能被加热。
1，微波炉是一个对象，它应该是一个公共对象，大家都可以用。
2，注意物品正加热时不能开门,我们可以理解，这个对象在执行时，是排它的，唯一的
3，带皮带壳食物不能被加热。这个对象不是万能的，有些事……
[/Quote]
有道理！
我觉得还可以丰富一下，
1，进微波炉要带参数（放入方法），微波炉才可以判断食物有没有带壳
2，有一个执行方法，只能用单线程（进了必需要出才能再进），执行完后有一个返回值，
3，还有一个查询方法，随时可以取得微波炉的参数，如加热多少度了，加热多久了，有没有食物在里面，可不可操作

[cssdn001]

带皮的是不是用throw抛出错误？

[mengli0641]

mark and up

[caopeiming]

学习中~~~~