基本概念：1）　　Simple Factory模式属于创建型模式，2）　　简单工厂模式是由一个工厂（注意是一个！）对象决定创建出哪一种产品类的实例（例如你到肯德基说你要鸡腿，要薯条，要饮料还是，，，这时肯德基是一个工厂，客户端只需要点明自己要什么就行）3）实现方式的实质：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。
下面来看一个例子：音乐盒接口IMusicBox：
package SimpleFpublic interface IMusicBox {
public void play();}
两种不同的音乐盒播放方式：ViolinBox（小提琴）和 PianoBox（钢琴）：
package SimpleFpublic class ViolinBox implements IMusicBox {
public void play() {
System.out.println("拨放小提琴音乐^_^");
package SimpleFpublic class PianoBox implements IMusicBox {
public void play() {
System.out.println("拨放钢琴音乐:)");
下面是一个工厂MusicBoxFactory（Simple Factory的核心，在工厂中根据客户端指定的参数动态创建不同的对象）：
package SimpleFpublic class MusicBoxFactory {
public static IMusicBox createMusicBox(String name)
throws InstantiationException,
IllegalAccessException,
ClassNotFoundException{
// 这边使用的是Java的Reflection机制来产生实例
// 不过客户端不用管啦
// 以后就算改变了这边的程式，客户端程式是不用更改的
return (IMusicBox) Class.forName(name).newInstance();
下面客户端就可以利用工厂模式：（利用工厂模式，客户端只需要对工厂指定你要创建的对象的名字（参数），工厂就可以根据你指定的参数动态创建不同的对象）
package SimpleFpublic class MusicBoxDemo {
public static void main(String[] args) throws Exception {
// playMusicBox(MusicBoxFactory.createMusicBox("PianoBox"));
// playMusicBox(MusicBoxFactory.createMusicBox("ViolinBox"));
//利用工厂模式，客户端只需要对工厂指定你要创建的对象的名字（参数），工厂就可以根据你指定的参数动态
//创建不同的对象。当然，这些不同的对象就有不同的表现（在本例中通过play表示）
playMusicBox(MusicBoxFactory.createMusicBox("SimpleFactory.PianoBox"));
playMusicBox(MusicBoxFactory.createMusicBox("SimpleFactory.ViolinBox"));
public static void playMusicBox(IMusicBox musicBox) {
musicBox.play();
结果：拨放钢琴音乐:)拨放小提琴音乐^_^上面例子的关系用下图表示：
-------------------------------------------------------------------------------------------------------------------------------------------------分析：工厂角色：被客户端直接调用，根据客户端指定传入的参数，动态创建客户端需要的对象抽象产品角色：所有对象的父类（接口）具体产品角色：即工厂的创建目标，工厂创建的对象就是这些具体类的对象。可以看出，客户端只面对工厂，不用管产品的具体细节，客户只需向工厂要求你需要什么，其他的事情都交给工厂了。优点：通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责&消费&对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利。（简单地说，你到肯德基去只需要说你要鸡腿还是鸡翅就行了，不需要去管鸡腿和鸡翅是怎么做出来的，工厂为你提供了这样一个界面）不足：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；
　　工厂类负责创建的对象比较少；
　　　　客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；
　　　由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。
从上面的例子也可以看出来，工厂类往往是用反射机制来产生具体对象的。（因为不同类都继承自同一接口），故其扩展性很有限，产品种类必须是事先就知道的哪几种，什么时候你想要添加一个不是公共接口下的具体类就不行了。另外，如果你不用反射机制，也不要公共接口，在工厂中使用其他逻辑（例如判断传入的字符串）来根据用户参数创建对象也行，那样扩展性也是很糟糕的，逻辑和添加只会越来多。
阅读(...) 评论()单电、微单和单反有什么区别啊？在拍摄人物或景色、静态或动态上各有什么优势啊？6千元选购哪一款比较好？_百度知道
单电、微单和单反有什么区别啊？在拍摄人物或景色、静态或动态上各有什么优势啊？6千元选购哪一款比较好？
提问者采纳
性能与微单相似强点，建议看实物。预算充足的话就奥林巴斯E-M5，稍小的芯片对画质的影响很小，单反，可是个头不小哇，对焦也稍慢：索尼NEX系列画质不错，抓拍利器，M4&#47，只能入门的600D+18-55套机4699元。尼康J1套机3480元也很不错、奥林巴斯E-PL3套机4799元中二选一。这是选购相机前要搞明白的一个定位。万元以下只推荐微单。6000元。单电介于微单与单反之间，不然无法选择。这三个实际差不多的，喜欢哪个就是哪个。微单画质比顶级DC都好很多，600D+18-135套机也要6499元微单简单理解就是简化的单反，个人以为是一个不上不下的产品，不符合买微单便携的目的，外形与单反相似略小，但与入门单反相近但高感弱点。然而其实所谓比入门单反弱的那点是专业性的比较，非专业人士根本看不出来，买微单就是图个画质较好上的便携，而且对焦迅速;3单电相机巅峰之作，套机10699元。建议在松下GX1套机5199元
我看到你在其他题目里也提到尼康J1 2400元，套机包了什么，升到3480了？貌似体积也不大，刚好适合出游。这款你用过吗，可以详细介绍一下吗还有尼康P310与尼康J1有什么区别啊？
套机当然包含镜头呀！介绍已经够详细了！单反、微单、DC按需购买，万元以下推荐微单，单反各种配备万元以下很寒碜也就没有意思了，一般玩玩要求不高买个好点的DC如佳能S100V、松下LX5等也挺好了；E-M5、GX1、E-PL3、J1按经济能力购买，当然价格越高性能、操控、速度等越好，一分钱一分货，升级永无止境，不特别追求就不用特别在意。E-M5是好东西，但价格太高了。个人倾向于E-PL3，无他，够用、好用就可以了。
提问者评价
非常感谢啊！！我想问，你是卖数码的吗？哈哈有好店铺介绍？
其他类似问题
您可能关注的推广
其他3条回答
电子取景会造成画面的延时微单，实际就是单电单反，所拍即所见建议买单反：微单是索尼起的名字只在中国使用：单镜头反光相机：单镜头电子取景相机单电，单电与微单都是外型小巧
卡片机满足不了需求，单反又买不起好的，单电是不是一个折中的选择？
入门不用太好，入门机就好佳能550D,600D都可以单电的价格便宜不了多少
前两者唯一的优势就是：体积小、重量轻。它们之间没有什么本质区别，叫法不同。在你所说的拍摄人物、景色、静态、动态方便，前两者基本没有优势，要干活儿，还得主靠单反。6000元左右，买宾得k5吧，性价比那是相当的高。
感光元器件大小不同， 对比胶片机就是胶片大小不同。单电和微单的尺寸是一样的。 拍摄效果主要取决于镜头。 考虑便携性， 买单电或微单。 考虑画质和以后的升级， 镜头兼容性， 买单反。
单反的相关知识
等待您来回答
为您推荐：
下载知道APP
随时随地咨询
出门在外也不愁1 动态评价与静态评价的根本区别是什么?二者相比谁更有优势?优势体现在什么方面?_百度知道
1 动态评价与静态评价的根本区别是什么?二者相比谁更有优势?优势体现在什么方面?
静态评价的相关知识
等待您来回答
为您推荐：
下载知道APP
随时随地咨询
出门在外也不愁采用DHCP动态分配IP地址与静态设置IP地址相比，具体有什么优势_百度知道
采用DHCP动态分配IP地址与静态设置IP地址相比，具体有什么优势
168。（太暴力了）。，那么你可以很明白的管理网络，故障排查难.2发送大量数据包导致网络延迟增加.2。。但是这样的不足之处就是你需要花费大量时间来编辑和维护一份IP地址分配表，然后去收拾他。不好管理。。，但是每个用户都要到你这里来备案一个他的MAC地址，例如192。。。 如果是动态IP的话就和上面的正好相反了如果你用静态IP的话，那么你就可以经过查找IP分配表找到使用这个IP的人，但是你可以很轻松的就布置好一个网络。就是使用动态分配IP地址。。其实也有一个办法解决。
其他类似问题
其他4条回答
网吧等电脑客户端比较固定的场所个人感觉DHCP适合电脑客户端不固定的网络，例如宾馆等公共场所，他们不智知道网络的参数设置，可以有效的避免ARP欺骗等，所以最好用DHCP服务器自动进行分配。静态IP地址适合于办公室，固定IP后在网关侧进行双绑，这类场所由于用户的移动
DHCP动态分配IP地址减少了管理员的工作量，不用一台一台去配，如果电脑比较多的话，频繁的步骤容易导致错误，而且网络发生变化，工作站转移的话，也不用去修改IP以免不必要的错误。
你好你说的问题太笼统。静态IP管理方便，动态IP管理繁琐，动态IP如果手动绑定每台客户机，那和静态没有区别。DHCP可以和静态混合使用 比如DHCP中的保留IP 就是静态IP DHCP小型网络可以使用 大型网络 需要手动分配IP并标识，方便管理。
那就是一个一个 去输入 了
如果有几百台机子的话
工作量是很大的
而且容易有IP冲突
dhcp的相关知识
等待您来回答
为您推荐：
下载知道APP
随时随地咨询
出门在外也不愁代理模式深入（一）——静态到动态 - 信息技术提高班九期学员——卓家进
- 博客频道 - CSDN.NET
& & 周末放假，小孙睡到12点才告别周公醒来，顿时饥肠辘辘。舍长小王正准备去食堂买饭，作为一个好舍长小王主动要帮小孙带饭。小孙点了米饭、宫保鸡丁、芬达。小孙起床洗漱，然后静待舍长。小孙心理寻思道舍长果然是好舍长啊。下面我们先把这个故事抽象一下，画作类图。这个类图即代理模式。
& &定义：为其他对象提供一种代理以控制对这个对象的访问。怎么理解这句话呢？从生活的角度来说就是：用一个对象A代替另一个对象B来处理本来应该由对象B完成的事情，例如上面买饭的例子，又如通过黄牛买票等等。从代码的角度来说则是：用一个对象A来过滤、预处理对对象B的调用 。不管从哪个角度看吧，代理都需要拥有和实际对象的需要被代理的全部方法。
& & 类图如上所示了，定义也看了。接下来我们按照类图来看看代码。
& & 接口（宿舍成员）
* 宿舍成员接口
* 开发时间： 下午9:17:19
public interface DormitoryMember {
public boolean buyStapleFood(String stapleFoodName);
public boolean buyDish(String dishName);
public boolean buyDrink(String drinkName);
& & 代理（宿舍长）& &&
public class DormitoryMemberProxy implements DormitoryMember {
//持有一个被代理的对象
private DormitoryMember dormitoryM
//构造时传入被代理对象
public DormitoryMemberProxy(DormitoryMember dormitoryMember){
this.dormitoryMember=dormitoryM
//代理买主食
public boolean buyStapleFood(String stapleFoodName) {
return dormitoryMember.buyStapleFood(stapleFoodName);
//代理买菜
public boolean buyDish(String dishName) {
return dormitoryMember.buyDish(dishName);
//代理买饮料
public boolean buyDrink(String drinkName) {
return dormitoryMember.buyDrink(drinkName);
& & &实际类（小孙）
//实际的类
public class DormitoryMemberImpl implements DormitoryMember {
public boolean buyStapleFood(String stapleFoodName) {
System.out.println(&买到主食& + stapleFoodName);
}catch(Exception e){
public boolean buyDish(String dishName) {
System.out.println(&买到菜：& + dishName);
}catch(Exception e){
public boolean buyDrink(String drinkName) {
System.out.println(&买到饮料：& + drinkName);
}catch(Exception e){
& & 宿舍长去到食堂买饭，结果小孙要的芬达断货了。于是宿舍长久提着米饭和菜就回去了，小孙吃着米饭和菜没有饮料难以下咽。但是，也不好说宿舍长，舍长是好舍长啊。将就的吃了午饭。时间来的晚饭时间，小孙在英雄联盟里正杀的起劲，那又闲工夫去买饭于是这工作有落到了好舍长身上。这次小孙学聪明了交代舍长说，如果有他点的东西没有了就打个电话回来在决定买什么替代。
& &问题来了
& & 这里需求已经改变了，如果小孙要的东西没有了的话，要给小孙打电话以决定是不是买其他的或者不买。这个电话自然是宿舍长来打。所以我们要对代理类进行修改！这也就是使用代理模式的好处，我们关闭了对实际类的修改。代理类修改后的代码如下：
public class DormitoryMemberProxy implements DormitoryMember {
//持有一个被代理的对象
private DormitoryMember dormitoryM
//构造时传入被代理对象
public DormitoryMemberProxy(DormitoryMember dormitoryMember){
this.dormitoryMember=dormitoryM
//代理买主食
public boolean buyStapleFood(String stapleFoodName) {
boolean buySuccess=dormitoryMember.buyStapleFood(stapleFoodName);
if( buySuccess=false){
System.out.println(&给小孙打电话&);
//代理买菜
public boolean buyDish(String dishName) {
boolean buySuccess=dormitoryMember.buyDish(dishName);
if( buySuccess=false){
System.out.println(&给小孙打电话&);
//代理买饮料
public boolean buyDrink(String drinkName) {
boolean buySuccess=dormitoryMember.buyDrink(drinkName);;
if( buySuccess=false){
System.out.println(&给小孙打电话&);
& & 问题（1）
& & 看代码可以知道，我们要对代理类中的每一个方法都进行同样的修改。极限假设我们实现的这个接口有1000个方法，哭死都不冤枉。
& & 问题（2）
& & &极限假设，伟大的宿舍长不止帮小孙买饭，还要帮小李买衣服，还要帮小赵买电脑。换句话说宿舍长要代理不同的接口。但是这是不可能实现的，因为在代理类所持有的实际类是确定的，也就是说每一个代理类只能代理一个借口。
& & 显然很不科学，这么多的代码重复出现。有不科学的情况出现，自然就会有办法因对。最怕的是没有发现问题，没有问题就没有改进。下面我们上动态代理。
& & 首先看问题一，既然当代理调用实际类时在代理类中的预处理都是一样的那么我们要达到代码不重复的话就只要保证调用实际类之前或者之后都回掉到某个处理就好了。当然以前好像没有学过可以对很多种不同的方法都同样回掉一个函数，因为类的参数个数和类型以及返回值都是不一致的。因此，java中就为此专门有一个接口可以实现这样的功能，InvocationHandler接口。
& & 再看问题二，对于问题二我们必须将代理类和被代理类解耦，通常我们解决这类问题就是用反射。这也不例外，这里java提供的反射机制可以在运行时产生代理类，即动态代理。这篇博客已经太长了，分开来吧。先把动态代理的代码贴上。其中实际类和接口没有变化！
& & &代理类工厂& &&
import java.lang.reflect.P
//代理工厂类
public class ProxyFactory {
public ProxyFactory(Object target){
this.target=
//根据传入的实际类生成代理
public Object getInstance(){
//实例化一个继承了InvocationHandler接口的预处理对象
ProxyHandler handler=new ProxyHandler(target);
//反射得到代理类
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
handler);//handler即集中处理在动态代理类对象上的方法调用
& & &继承了InvocationHandler接口的handler类
import java.lang.reflect.InvocationH
import java.lang.reflect.M
public class ProxyHandler implements InvocationHandler {
public ProxyHandler(Object target){
this.target=
//所有代理方法的公共处理方法
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result =
result=method.invoke(target, args);
//要买的东西断货时
if(result.toString().equals(&false&)){
System.out.println(&给小孙打电话&);
& & & &修改后的客户端调用
public class Client {
public static void main(String[] args){
//真正得到的代理类在客户端强转
DormitoryMember dormitoryMember=(DormitoryMember)new ProxyFactory(new DormitoryMemberImpl()).getInstance();
dormitoryMember.buyStapleFood(&米饭&);
& & &总结：动态代理通过反射把代理类和实际类之间的耦合解开了，同时通过继承了InvocationHandler接口的handler类对代理的方法进行统一的处理。也就解决静态代理所遇到的问题。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：103279次
积分：4358
积分：4358
排名：第2928名
原创：113篇
评论：1282条
阅读：4837
阅读：4357
文章：14篇
阅读：18608
(4)(3)(4)(3)(3)(4)(3)(3)(3)(4)(4)(4)(3)(3)(2)(3)(3)(2)(3)(3)(4)(3)(2)(4)(2)(4)(2)(2)(1)(1)(2)(4)(6)(6)(4)(3)