java设计模式源码

‘壹’ java中常用的设计模式有哪些请详细说明一下工厂模式。

1.单例模式（有的书上说叫单态模式其实都一样）
该模式主要目的是使内存中保持1个对象
2.工厂模式
该模式主要功能是统一提供实例对象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用
3.建造模式
该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。
4.门面模式
这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。
5.策略模式
这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。

‘贰’ Java 23 种设计模式的通俗解释，看完秒懂

以下是Java中23种设计模式的通俗解释：

1. 工厂方法模式：

   • 解释：就像请MM吃饭，你可以选择麦当劳或肯德基，两者都提供鸡翅，但具体实现不同。顾客无需关心餐厅的内部细节，只需点餐，餐厅负责提供对应的产品。这实现了客户与具体产品工厂的分离，产品修改只影响工厂。

2. 建造者模式：

   • 解释：使用翻译机为MM翻译“我爱你”，不同语言对应不同的按键组合。建造者模式就像这个翻译过程，通过一步步构建，最终完成跨语言的情感表达，且构造过程清晰明了。

3. 抽象工厂模式：

   • 解释：在麦当劳选择汉堡时，顾客只需选择想要的汉堡类型，无需记忆所有的汉堡选项和制作过程。工厂负责提供具体的汉堡产品，实现了客户与具体产品的解耦。

4. 原型模式：

   • 解释：就像用QQ上的情话原型快速复制深情话语，原型模式通过复制现有对象来创建新对象，从而简化聊天内容的准备过程。

5. 单态模式：

   • 解释：在婚姻关系中，一个老公对应多个称呼，但身份本质上是唯一的。单态模式确保一个类只有一个实例，并提供全局访问点。

6. 适配器模式：

   • 解释：为MM翻译粤语时，通过适配器将粤语翻译成普通话，使双方能够顺畅交流。适配器模式将一个类的接口转换成客户端期望的另一个接口，实现接口之间的兼容。

7. 桥梁模式：

   • 解释：问候MM时，根据不同时间段和场合使用不同的语言表达，桥梁模式将问候语的外观与实现解耦，使代码更加灵活。

8. 合成模式：

   • 解释：将T恤、裙子和包组合成一套搭配，合成模式允许将简单对象组合成复杂对象，同时保持这些对象的一致性。

9. 装饰模式：

   • 解释：为手机预设常用句子，方便发送短信。装饰模式在不改变对象自身的基础上，给对象添加新的功能，实现功能的动态扩展。

10. 门面模式：

    • 解释：相机设置为自动模式，简化操作步骤，使不熟悉摄影的人也能轻松拍照。门面模式提供一个统一的接口，用来访问子系统中的一群接口，简化客户端与子系统之间的交互。

11. 享元模式：

    • 解释：在手机中存储常用句子，根据上下文发送。享元模式通过共享对象来减少内存占用，提高系统性能，特别适用于大量细粒度对象的场景。

12. 代理模式：

    • 解释：编写程序代理MM在网聊中回答常见问题，提高交互效率。代理模式为其他对象提供一种代理以控制对这个对象的访问。

13. 责任链模式：

    • 解释：传递纸条提出求婚条件，直至找到愿意处理的人。责任链模式将请求沿着处理者链进行传递，直到有一个处理者处理该请求。

14. 命令模式：

    • 解释：通过纸条传递求婚指令，确保指令的独立性和可撤消性。命令模式将请求封装成对象，以便使用不同的请求、队列或者日志请求来参数化客户端。

15. 解释器模式：

    • 解释：《泡MM真经》作为脚本，解释泡MM的策略。解释器模式给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

16. 迭代模式：

    • 解释：求婚时逐步提出条件，通过迭代的方式简化决策过程。迭代模式是一种遍历访问集合元素的模式，能够顺序访问一个集合中的各个元素，而不暴露该对象的内部表示。

17. 调停者模式：

    • 解释：在MM之间调解财务纠纷，确保公平分配。调停者模式用一个中介对象来封装一系列对象的交互，使这些对象不需要显式地相互引用。

18. 备忘录模式：

    • 解释：记录与MM的对话，方便日后查阅，避免误解。备忘录模式在不破坏封装性的前提下，捕获并保存对象的内部状态，以便将来可以恢复到这个状态。

19. 观察者模式：

    • 解释：加入公司MM情报组，实时接收信息。观察者模式定义对象间的一种一对多的依赖关系，当一个对象改变状态时，其所有依赖者都会收到通知并自动更新。

20. 状态模式：

    • 解释：根据MM的不同状态调整约会策略。状态模式允许对象在内部状态改变时改变它的行为，对象看起来似乎修改了它的类。

21. 策略模式：

    • 解释：为不同类型的MM准备不同策略。策略模式定义了一系列的算法，并将每一个算法封装起来，使它们可以互换，策略模式让算法独立于使用它的客户端而变化。

22. 模板方法模式：

    • 解释：约会过程遵循经典步骤，但具体实现根据情况调整。模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中实现。

23. 访问者模式：

    • 解释：为每个MM准备个性化的礼物。访问者模式使得在不修改对象结构的情况下，可以扩展操作集合。它为复杂对象结构中的元素提供了一种机制，通过访问者接口，可以针对对象结构中的元素执行不同的操作。

这些解释旨在以通俗易懂的方式阐述Java中的设计模式，希望能帮助读者快速理解这些概念。

‘叁’ java中设计模式中Control、View之间的调用

我觉得你弄错了C和V的关系，应该是这样的：
Control a=new Control();
View b=new View();
b.setSomeListenner(a);
然后，视图b在触发某些事件的时候，比如某个按钮被点击的时候，去调用a的相关方法。

另外楼上说的也行得通，把view当做参数传回去就行嘛。

‘肆’ java中的单例模式的代码怎么写

单例模式(Singleton) ,属于最常见的设计模式之一，大部分系统都会用到，目的是为了维护系统中唯一的一个实例。
可分为eager模式，示例代码如下：
Java代码
1.class EagerSingleton{
2. private static final EagerSingleton m_instance = new EagerSingleton();
3. private EagerSingleton(){}
4. public static EagerSingleton getInstance(){
5. return m_instance;
6. }
7.}
class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
private EagerSingleton(){}
public static EagerSingleton getInstance(){
return m_instance;
}
}
和 lazy模式，示例代码如下：
Java代码
1.class LazySingleton{
2. private static LazySingleton m_instance = null;
3. private LazySingleton(){}
4. public synchronized static getInstance(){
5. if(m_instance == null){
6. m_instance = new LazySingleton();
7. }
8. return m_instance;
9. }
10.}
class LazySingleton{
private static LazySingleton m_instance = null;
private LazySingleton(){}
public synchronized static getInstance(){
if(m_instance == null){
m_instance = new LazySingleton();
}
return m_instance;
}
}
java源码中，Runtime.getRuntime()就是单例的一个例子。
单例模式的精神就是整个系统中维护一个实例，推广开来，如果在一个系统中需要维护多个示例，那么就产生了多例模式(multiton)。
多例模式(Multiton) ,通过聚集对象了保留自身的多个示例，根据客户端的参数返回所需要的实例。
示例代码如下：
Java代码
1.class Multiton{
2. private final int INSTANCE_SIZE = 10;
3. private static Map instances = new HashMap(INSTANCE_SIZE);
4. private String name;
5. private Multiton(){}
6. private Multiton(String name){
7. this.name = name;
8. }
9. public synchronized static getInstance(String name){
10. if(instances.containsKey(name)){
11. return instances.get(name);
12. }
13. else{
14. ins = new Multiton(name);
15. instances.put(name, ins);
16. return ins;
17. }
18. }
19.}
class Multiton{
private final int INSTANCE_SIZE = 10;
private static Map instances = new HashMap(INSTANCE_SIZE);
private String name;
private Multiton(){}
private Multiton(String name){
this.name = name;
}
public synchronized static getInstance(String name){
if(instances.containsKey(name)){
return instances.get(name);
}
else{
ins = new Multiton(name);
instances.put(name, ins);
return ins;
}
}
}
[nextpage]
一个实用的例子就是KeyGenerator, 示例代码如下：
Java代码
1.class KeyGenerator{
2. private final int POOL_SIZE = 20;
3. private static Map instances = new HashMap(16);
4. private KeyInfo keyinfo;
5. private KeyGenerator(){}
6. private KeyGenerator(String keyName){
7. this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
8. }
9. public synchronized static getInstance(String keyName){
10. if(instances.containsKey(keyName)){
11. return (KeyGenerator)instances.get(keyName);
12. }
13. else{
14. keyGen = new KeyGenerator(keyName);
15. instances.put(name, keyGen);
16. return keyGen;
17. }
18. }
19. public synzhronized int getNextKey(){
20. return keyinfo.getNextKey();
21. }
22. }
class KeyGenerator{
private final int POOL_SIZE = 20;
private static Map instances = new HashMap(16);
private KeyInfo keyinfo;
private KeyGenerator(){}
private KeyGenerator(String keyName){
this.keyinfo = new KeyInfo(POOL_SIZE, keyName);
}
public synchronized static getInstance(String keyName){
if(instances.containsKey(keyName)){
return (KeyGenerator)instances.get(keyName);
}
else{
keyGen = new KeyGenerator(keyName);
instances.put(name, keyGen);
return keyGen;
}
}
public synzhronized int getNextKey(){
return keyinfo.getNextKey();
}
}