从接口到工厂模式

大家是不是有这样一种感觉:学了一年多Java了，甚至不懂什么接口？通过本文，你将认识接口的全貌！由于作者本人水平有限，有不足之处还望同仁指出，不胜涕零。
定义
Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
特点
网友的解释：
网友1：接口的最主要的作用是达到统一访问，就是在创建对象的时候用接口创建，【接口名】 【对象名】=new 【实现接口的类】，这样你像用哪个类的对象就可以new哪个对象了，不需要改原来的代码，就和你的USB接口一样，插什么读什么，就是这个原理。
网友2：接口是用来规范类的，它可以避免类在设计上的不一致 这在多人合作的开发中犹为重要 ， 你象一个人，把他封装一个类对象，作为一个接口实现的话，一继承就能实现人的所有的属性和方法，并且重复多次的利用，就不用每次都自己写了，而某个人的某个行为与大多数人不同的话，就可以重写这个方法，要是普通类的话只能调用的不能重写，这就是接口的好处。
引用Java核心技术的解释：接口技术主要用来 描述类具有什么功能，而并不是类的具体实现。一个类可以实现一个或多个接口，并在需要接口的地方，随时使用实现了相应接口的对象。
我的理解：给大家想举两个例子
我们生活中最常见的插座和插头。我们不需要关心插座的内部结构，只需要知道插头插上就能正常的工作。
还有USB接口，我不管你是鼠标、键盘、摄像头还是蓝牙，只要能插在USB接口上，这些设备就能正常工作。
这就是接口的功能！接口=静态常量+方法声明。静态常量和方法声明就是告诉外界函数在调用的时候我这个接口需要提供什么样参数会返回什么样的数据，而具体的业务逻辑实现由类来搞定
声明一个接口
Public interface接口名 {
常量列表
方法声明列表……
}
eg:
public interface People{
public static Date brithday ;
public static String sex;
public void eat(String things);
public Boolean work();
}
如果实现了一个已知接口，就自动继承常量，必须实现对应的方法。
eg：
public class Chinese implements People{
public void eat(String things){
}
public Boolean work(){
}
}
使用接口有哪些好处呢？比如，地球上有中国人、英国人、美国人等等。但是都少不了吃饭工作。但是，中国人、英国人、美国人的吃饭和工作方式又不一样。所以，接口就是给类定义了一种外部调用的标准，只要你符合了我这个标准了，你就可以调用！
已知实例
List是一个接口，ArrayList是一个已知的实现了List接口的类。
面向对象的应用
面向对象的核心可以理解为把生活 当中的每个东西看成一个对象，每类东西看成一个类。我们生活当中不乏各种接口。以PC为例，声音有3.5毫米的声音插口，视频有VGA接口、HDMI接口、IDV接口，串口，并口，硬盘的SATA/IDE接口，主板上有插CPU的接口，内存条的插口，PCI接口都是接口。总之一句话，能插上就能用。Java更是如此，把PC看成一个类，这个类实现了3.5毫米接口、VGA接口、HDMI接口……对于接口来说，我只需要知道有哪些方法提供什么参数返回什么值，具体怎么实现那是类的事。
Implements VS extends
Java只允许继承一个类，就像一个儿子只有一个爹（不像是C#，还可以认个干爹），你要是想认个干爹也行，用接口啊！接口可以实现多个，在Java里用接口可以实现多重继承！
软件的声明周期
一个软件从定义到废弃为止，这就是软件的生命周期。以windows为例，从1.0到现在的8.1都属于他的声明周期（真实的比我说的还要长）。如果要想给软件增添一些功能，这个软件就会变得越来越臃肿，就像一双破鞋（咦~怎么有点不对劲，淡定，淡定那是旧时代的东西，我们是新时代的人了），打的补丁多了就不想穿了想换新的。软件是纯YY的作品，不是说换就能换的，要花钱的！http://www.cnblogs.com/yinhaiming/articles/1506060.html是对软件声明周期一些较为详细的解释，如果想详细了解请参见阎宏先生写的《Java与模式》软件的可维护性与可复用性一章。熟练的运用设计模式就可以解决这些问题。甚至有人程学会了数据结构、算法、设计模式就有了软件的铁饭碗（这不就是架构师么？！啧啧啧~~~）。
设计模式简介
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。简单的说，就是让代码更精简，更有结构化！最早是由建筑学引申到软件行业的（额？不是吧！长见识了吧，世界就是这么奇葩！）
工厂模式简介
最常见的非工厂模式莫属了，我们可以理解，需要工厂生产什么产品，然后调用工厂方法提供对应的参数生产出对应的产品。
简单工厂模式
1. 目的
工厂模式就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。
2 . 简单工厂模式的结构

3. 一个简单例子
java 代码
1. // 产品接口
2. public interface Product {
3.
4. public void getName();
5.
6. }
7.
8. // 具体产品A
9. public class ProductA implements Product {
10.
11. public void getName() {
12. System.out.println(" I am ProductA ");
13. }
14.
15. }
16.
17. // 具体产品B
18. public class ProductB implements Product {
19.
20. public void getName() {
21. System.out.println(" I am ProductB ");
22. }
23.
24. }
25.
26. // 工厂类
27. public class ProductCreator {
28.
29. public Product createProduct(String type) {
30. if (" A ".equals(type)) {
31. return new ProductA();
32. }
33. if (" B ".equals(type)) {
34. return new ProductB();
35. } else
36. return null;
37. }
38.
39. public static void main(String[] args) {
40. ProductCreator creator = new ProductCreator();
41. creator.createProduct(" A ").getName();
42. creator.createProduct(" B ").getName();
43. }
44. }
4. 小结工厂模式的适用范围
• 在编码时不能预见需要创建哪一种类的实例。
• 一个类使用它的子类来创建对象。
• 开发人员不希望创建了哪个类的实例以及如何创建实例的信息暴露给外部程序。

抽象工厂模式
1. 抽象工厂模式可以说是简单工厂模式的扩展，它们主要的区别在于需要创建对象的复杂程度上。
在抽象工厂模式中，抽象产品可能是一个或多个，从而构成一个或多个产品族。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。
2. 抽象工厂模式的结构

3. 一个简单例子
java 代码
1. // 产品 Plant接口
2. public interface Plant {
3. }
4.
5. // 具体产品PlantA，PlantB
6. public class PlantA implements Plant {
7.
8. public PlantA() {
9. System.out.println(" create PlantA ! ");
10. }
11.
12. public void doSomething() {
13. System.out.println(" PlantA do something ");
14. }
15. }
16.
17. public class PlantB implements Plant {
18. public PlantB() {
19. System.out.println(" create PlantB ! ");
20. }
21.
22. public void doSomething() {
23. System.out.println(" PlantB do something ");
24. }
25. }
26.
27. // 产品 Fruit接口
28. public interface Fruit {
29. }
30.
31. // 具体产品FruitA，FruitB
32. public class FruitA implements Fruit {
33. public FruitA() {
34. System.out.println(" create FruitA ! ");
35. }
36.
37. public void doSomething() {
38. System.out.println(" FruitA do something ");
39. }
40. }
41.
42. public class FruitB implements Fruit {
43. public FruitB() {
44. System.out.println(" create FruitB ! ");
45. }
46.
47. public void doSomething() {
48. System.out.println(" FruitB do something ");
49. }
50. }
51.
52. // 抽象工厂方法
53. public interface AbstractFactory {
54. public Plant createPlant();
55.
56. public Fruit createFruit();
57. }
58.
59. // 具体工厂方法
60. public class FactoryA implements AbstractFactory {
61. public Plant createPlant() {
62. return new PlantA();
63. }
64.
65. public Fruit createFruit() {
66. return new FruitA();
67. }
68. }
69.
70. public class FactoryB implements AbstractFactory {
71. public Plant createPlant() {
72. return new PlantB();
73. }
74.
75. public Fruit createFruit() {
76. return new FruitB();
77. }
78. }
4. 小结
在以下情况下，应当考虑使用抽象工厂模式。
　　首先，一个系统应当不依赖于产品类实例被创立，组成，和表示的细节。这对于所有形态的工厂模式都是重要的。
　　其次，这个系统的产品有多于一个的产品族。
　　第三，同属于同一个产品族的产品是设计成在一起使用的。这一约束必须得在系统的设计中体现出来。
　　最后，不同的产品以一系列的接口的面貌出现，从而使系统不依赖于接口实现的细节。
　　其中第二丶第三个条件是我们选用抽象工厂模式而非其它形态的工厂模式的关键性条件。
//引用自ITEye地址 ：http://www.iteye.com/topic/26455。
从工厂模式到Spring IoC
Spring IoC我的理解就是一个超级工厂，Spring容器就是一个超级加工厂，所有的Bean实例由Spring容器管理，这里不再多做解释。感兴趣的可以翻阅陈雄华先生的《Spring 3.0就这么简单》
小结
我现在还清晰的记得，魔乐科技李兴华老师说的：你写的Java程序如果没用到接口，那肯定是 Shit！也许你现在理解不了我上面说的，不要紧，先保存下来等有更多知识积累的时候再拿出来看看，你肯定会有收获。我也经常和同学交流编程的学习方法，我们都是在摸着石头过河，我们都渴望有更多人来共同交流。不懂得可以先放到一边，随着时间的推移慢慢也就 懂了。（P.S.我现在还不懂什么是context，额~~~）。