设计原则名称

设计原则简介

重要性

单一职责原则

(Single Responsibility Principle, SRP)

类的职责要单一，不能将太多的职责放在一个类中

★★★★☆

开闭原则

(Open-Closed Principle, OCP)

软件实体对扩展是开放的，但对修改是关闭的，即在不修改一

个软件实体的基础上去扩展其功能

★★★★★

里氏代换原则

(Liskov Substitution Principle, LSP)

在软件系统中，一个可以接受基类对象的地方必然可以接受一

个子类对象

★★★★☆

依赖倒转原则

(Dependency Inversion Principle, DIP)

要针对抽象层编程，而不要针对具体类编程

★★★★★

接口隔离原则

(Interface Segregation Principle, ISP)

使用多个专门的接口来取代一个统一的接口

★★☆☆☆

合成复用原则

(Composite Reuse Principle, CRP)

在系统中应该尽量多使用组合和聚合关联关系，尽量少使用甚

至不使用继承关系

★★★★☆

迪米特法则

(Law of Demeter, LoD)

一个软件实体对其他实体的引用越少越好，或者说如果两个类

不必彼此直接通信，那么这两个类就不应当发生直接的相互作

用，而是通过引入一个第三者发生间接交互

★★★☆☆

编辑本段详细说明

先看下面两段程序：

程序一：
public class Variable
{
int i;
void test()
{
   int j=8;
   if(j==i)
    System.out.println("相等");
   else
    System.out.println("不相等");
}
public static void main(String[] args)
{
   Variable v=new Variable();
   v.test();
}
}

程序二：
public class Variable
{
   void test()
{
   int i;
   int j=8;
   if(j==i)
    System.out.println("相等");
   else
    System.out.println("不相等");
}
public static void main(String[] args)
{
   Variable v=new Variable();
   v.test();
}
}

----------------------------------------------------------------------------------------------------------

第一个程序很正常，编译时不会出错。第二个程序编译时会提示如下错误：

D:\Program\java\test>javac Variable.java
Variable.java:9: 可能尚未初始化变量 i
                if(j==i)
                      ^
1 错误

之所以会出现这样的错误是因为：成员变量有默认值，（被final修饰且没有static的必须显式赋值），局部变量不会自动赋值

===========================================================

类体分为两部分。变量定义部分所定义的变量被称为类的成员变量，在方法体中定义的变量和方法的参数都被称为局部变量

java中成员变量和局部变量的区别

package com;

public class MemberVariable {
 int v_int;
 float v_float;
 boolean v_boolean;
 String v_string;
 byte v_byte;
 short v_short;
 char v_char;
 long v_long;
 
 public static void main(String[] args)
 {
  MemberVariable mv = new MemberVariable();
  System.out.println("int的默认值:"+mv.v_int);
  System.out.println("float的默认值:"+mv.v_float);
  System.out.println("boolean的默认值:"+mv.v_boolean);
  System.out.println("string的默认值:"+mv.v_byte);
  System.out.println("short的默认值:"+mv.v_short);
  System.out.println("char的默认值:"+mv.v_char);
  System.out.println("long的默认值:"+mv.v_long);
 }
}
int的默认值:0
float的默认值:0.0
boolean的默认值:false
string的默认值:0
short的默认值:0
char的默认值:

因为JAVA有个属于自己的运行环境，既：JAVA虚拟机，虚拟机与平台无关，JAVA代码经过编译后，直接运行于虚拟机上，实现了跨平台。

1.为什么要使用Java虚拟机

Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行,至少需要编译成不同的目标代码。而引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息,使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时,把字节码解释成具体平台上的机器指令执行。

2.谁需要了解Java虚拟机

Java虚拟机是Java语言底层实现的基础,对Java语言感兴趣的人都应对Java虚拟机有个大概的了解。这有助于理解Java语言的一些性质,也有助于使用Java语言。对于要在特定平台上实现Java虚拟机的软件人员,Java语言的编译器作者以及要用硬件芯片实现Java虚拟机的人来说,则必须深刻理解Java虚拟机的规范。另外,如果你想扩展Java语言,或是把其它语言编译成Java语言的字节码,你也需要深入地了解Java虚拟机。

Java代码  

1. public class Employee {  
2.   
3.     public String name=null;  
4.       
5.     public Employee(String n){  
6.         this.name=n;  
7.     }  
8.     //将两个Employee对象交换  
9.     public static void swap(Employee e1,Employee e2){  
10.         Employee temp=e1;  
11.         e1=e2;  
12.         e2=temp;  
13.                 System.out.println(e1.name+" "+e2.name); //打印结果：李四 张三  
14.     }  
15.     //主函数  
16.     public static void main(String[] args) {  
17.         Employee worker=new Employee("张三");  
18.         Employee manager=new Employee("李四");  
19.         swap(worker,manager);  
20.         System.out.println(worker.name+" "+manager.name); //打印结果仍然是： 张三 李四  
21.     }  
22. }  

      上面的结果让人很失望，虽然形参对象e1,e2的内容交换了，但实参对象worker,manager并没有互换内容。这里面最重要的原因就在于形参e1,e2是实参worker,manager的地址拷贝。

      大家都知道，在Java中对象变量名实际上代表的是对象在堆中的地址(专业术语叫做对象引用 )。在Java方法调用的时候，参数传递的是对象的引用。重要的是，形参和实参所占的内存地址并不一样，形参中的内容只是实参中存储的对象引用的一份拷贝。

       如果大家对JVM内存管理中Java栈 的局部变量区 有所了解的话(可以参见《 Java 虚拟机体系结构 》)，就很好理解上面这句话。在JVM运行上面的程序时，运行main方法和swap方法，会在Java栈中先后push两个叫做栈帧的内存空间。main栈帧中有一块叫局部变量区的内存用来存储实参对象worker和manager的引用。而swap栈帧中的局部变量区则存储了形参对象e1和e2的引用。虽然e1和e2的引用值分别与worker和manager相同，但是它们占用了不同的内存空间。当e1和e2的引用发生交换时，下面的图很清晰的看出完全不会影响worker和manager的引用值。

      Java对象参数传递虽然传递的是地址(引用)，但仍然是值调用。是时候需要给引用调用和值调用一个准确的定义了。

      值调用(call by value) ： 在参数传递过程中，形参和实参占用了两个完全不同的内存空间。形参所存储的内容是实参存储内容的一份拷贝。实际上，Java对象的传递就符合这个定义，只不过形参和实参所储存的内容并不是常规意义上的变量值，而是变量的地址。咳，回过头想想：变量的地址不也是一种值吗！

      引用调用(call by reference) ： 在参数传递的过程中，形参和实参完全是同一块内存空间，两者不分彼此。实际上，形参名和实参名只是编程中的不同符号，在程序运行过程中，内存中存储的空间才是最重要的。不同的变量名并不能说明占用的内存存储空间不同。

      大体上说，两种调用的根本并不在于传递的是值还是地址(毕竟地址也是一个值)，而是在于形参和实参是否占用同一块内存空间。事实上，C/C++的指针参数传递也是值调用，不信试试下面的C代码吧！

C代码  

1. #include<stdio.h>  
2. void swap(int *a1,int *b1){  
3.     int *t=a1;  
4.     a1=b1;  
5.     b1=t;  
6. }  
7. int main(){  
8.     int x1=100;  
9.     int x2=200;  
10.         int *a=&x1;  
11.     int *b=&x2;  
12.     printf("%d %d\n",*a,*b);  
13.     swap(a,b);  
14.     printf("%d %d\n",*a,*b);  
15.     return 0;  
16. }  

         但C/C++是有引用调用的，这就是C/C++一种叫做引用的变量声明方法： int a; int &ra=a; 其中ra是a的别名，两者在内存中没有区别，占用了同一个内存空间。而通过引用(别名)的参数传递就符合引用调用的特点了。大家可以去试试

void swap(int &a1,int &b1);的运行结果。

   我们首先用一段代码来证实一下为什么Java的对象参数传递 是地址传递。

一、什么是log4j
Log4j 是Apache的一个开放源代码项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件、甚至是套接口服务器、NT的事件记录器、UNIX Syslog守护进程等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

二、日志简介
日志指在程序中插入语句以提供调试信息。使用日志能够监视程序的执行。例如，用户利用日志可以获得关于应用程序故障的完整信息。用户可以将调试语句（如 System.out.println）插入到程序中以获得详细的调试信息。

三、项目中为什么要用log4j
大家在编程时经常不可避免地要使用到一些日志操作，比如开发阶段的调试信息、运行时的日志记录及审计。调查显示，日志代码占代码总量的4％。通常大家可以简单地使用System.out.println()语句输出日志信息，但是往往会有一些判断，比如：
 
if (someCondition)
{
  System.out.println("some information.");
}

这些判断造成正常的程序逻辑中混杂了大量的输出语句。而在开发阶段写下的这些判断仅为了调试的语句，在开发完成时需要查找并移除。部署运行后，尤其是在一些企业应用系统中，还经常需要进一步调试，这时就遇到了更大的麻烦。所以，我们需要一套完备的、灵活的、可配置的日志工具log4J就是优秀的选择。

四、log4j组件
Log4j 由 logger、appender 和 layout 三个组件组成。可以通过同名的 Java 类访问 Log4j 的这三个组件。

Logger - 在执行应用程序时，接收日志语句生成的日志请求。它是一种重要的日志处理组件， 可以通过 log4j API 的 logger 类对其进行访问。它的方法有：debug、info、warn、error、fatal 和 log。这些方法用于记录消息。
Appender - 管理日志语句的输出结果。执行日志语句时，Logger 对象将接收来自日志语句的记录请求。此请求是通过 logger 发送至 appender 的。然后，Appender 将输出结果写入到用户选择的目的地。对于不同的日志目的地，提供不同的 appender 类型。这些 appender 包括：用于文件的 file appender、用于数据库的 JDBC appender 和用于 SMTP 服务器的 SMTP appender。
Layout - 用于指定 appender 将日志语句写入日志目的地所采用的格式。appender 可以用来格式化输出结果的各种布局包括：简单布局、模式布局和 HTML 布局。

迭代器（Iterator）

　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

　　Java中的Iterator功能比较简单，并且只能单向移动：

　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

　　(2) 使用next()获得序列中的下一个元素。

　　(3) 使用hasNext()检查序列中是否还有元素。

　　(4) 使用remove()将迭代器新返回的元素删除。

　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

迭代器应用：
 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */

序号 方 法 说 明 
1  class getClass 返回此Object的类 
2  int hashCode() 返回此Object的hash码 
3  boolean equals(Object obj) 判断此Object是否与指定的Object对象相等 
4  void copy(Object obj) 把此Object拷贝到指定的Object对象中 
5  Object clone() 克隆此Object对象 
6  String toString() 把此Object对象转换成String类的对象 
7  void notify() 唤醒一个等待的线程 
8  void notifyAll() 唤醒所有等待的线程 
9  void wait(int timeout) 使一个线程处于等待直到timeout结束或被唤醒 
10  void wait() 使一个线程处于等待直到被唤醒 
11  void enterMonitor() 对Object加锁 
12  void exitMonitor() 对Object开锁

参考地址：http://edu.codepub.com/2009/1018/16461_3.php

内置对象是不需要声明，直接可以在JSP中使用的对象，JSP有以下几种内置对象：
request request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
response response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）
out out 对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
pageContext pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
session session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
application applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
config config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
page page表示从该页面产生的一个servlet实例。

Servlet API中的几个对象
JSP提供了八个内部对象，而其中的五个内部对象对应于Servlet API中的七个对象，这也就使得我们正常理解并熟练使用Servlet中的这七个对象显得尤其重要。这五个JSP的内部对象和Servlet API中的对象的对应关系是：
request对象对应于：javax.servlet.http.HttpServletRequest和javax.servlet.ServletRequest
response对象对应于：javax.servlet.http.HttpServletResponse和javax.servlet.ServletResponse
session对象对应于：javax.servlet.http.HttpSession
application对象对应于：javax.servlet.ServletContext
config对象对应于：javax.servlet.ServletConfig
javax.servlet.http.HttpServletRequest
这是一个接口，在我们提到接口之前，还是让我们来复习一下Java中接口的一个初步的解释：
接口在语法上与类相似，但是接口没有实例，使用接口，只是指定类必须做什么而不是如何做。
/*重点如下*/
HttpServletRequest接口用来处理一个对Servlet的HTTP格式的请求信息。
javax.servlet.ServletRequest
这也是一个接口，这个接口定义一个Servlet引擎产生的对象，通过这个对象，Servlet可以获得客户端请求的数据。这个对象通过读取请求体的数据提供包括参数的名称、值和属性以及输入流的所有数据。而javax.servlet.http.HttpServletRequest也只是该接口的一个扩展，也就是说，该接口的所有方法也可以被javax.servlet.http.HttpServletRequest所使用。
javax.servlet.http.HttpServletResponse接口
该接口用来描述一个返回到客户端的HTTP回应。
javax.servlet.ServletResponse接口
该接口用来定义一个Servlet引擎产生的对象，通过这个对象，Servlet对客户端的请求作出响应。这个响应应该是一个MIME实体，可能是一个HTML页、图象数据或其他MIME的格式。javax.servlet.http.HttpServletResponse接口是该接口的扩展。
javax.servlet.http.HttpSession接口
该接口用来描述一个session，至于什么是session我想在这里就没必要说了吧。
javax.servlet.ServletContext接口
该接口用来定义了一个Servlet的环境对象。也可是认为这是多个客户端共享的信息，它与session的区别在于应用范围的不同，session只对应于一个用户。
javax.servlet.ServletConfig接口
该接口定义了一个对象，通过这个对象，Servlet引擎配置一个Servlet。每一个ServletConfig对象对应着一个唯一的Servlet。
javax.servlet.http.Cookie类
这个类描述了一个cookie，cookie的作用其实与session很类似，只是cookie保存在客户端，session保存在服务器端

首先保证类中有唯一的一个构造器，而且是private的，私有的，就是除了在该类中其他地方都不可以访问的。
其次有一个私有的private该类型的变量，这个变量可以在声明的的时候就实例化，也可以在构造器中调用的时候再实例化，但是，在构造器中实例化时要先判断：
private A a;
public A(){
if(a == null)
a= new A();
}
这样就可以保证只有一个A的实例，
淡然最重要的是要有个public的返回A类型变量的方法，用来返回这个唯一的变量
public A returnA(){
return a;
}
这样就可以了，实际上就三方面：
1，一个私有的构造器
2，一个私有的该类类型的变量
3，必须有一个共有的返回类型为该类类型的方法，用来返回这个唯一的变量 

ArrayList的定义：
public class ArrayList<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

        ArrayList<Integer> a = new ArrayList<Integer>();
        a.add(3);
        a.add(4);
        for (Iterator<Integer> iterator = a.iterator(); iterator.hasNext();) {   
            int number = iterator.next();   
            System.out.println(number);   
        } 

Vector定义：
public class Vector<E>extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

Vector 类可以实现可增长的对象数组。与数组一样，它包含可以使用整数索引进行访问的组件。但是，Vector 的大小可以根据需要增大或缩小，以适应创建 Vector 后进行添加或移除项的操作。Vector是同步的。

public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, Serializable

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。此实现不是同步的