显示参数和隐式参数。

class Employee

{

   . . .

   private final String name;

}

private final Date hiredate;

final应用于基本数据类型，表示值不可变，应用于类对象，表示对象的引用不可变。

一个引用不能改变作为参数的基本类型数据，但能改变对象，因为传入的参数是对象的引用，不能改变对象引用。

main()是一个程序执行的入口，系统必须先进入这个入口，也就是先要调用main()函数，才能继续程序的执行，如果main()不用static修饰，系统就没法进行调用，因为一开始系统不能创建任何对象。而加上了static后，系统就可以直接调用main()函数了，从而继续程序的执行。 

public static void swap(Employee x, Employee y) // doesn't work

{

   Employee temp = x;

   x = y;

   y = temp;

}

Employee a = new Employee("Alice", . . .);

Employee b = new Employee("Bob", . . .);

swap(a, b);

a,b的引用没有改变。

一个方法不能改变一个基本类型的参数

一个方法可以改变一个对象参数的状态

一个方法不能让对象参数引用一个新对象

默认值：数值为0，对象为null，布尔型为false

public Employee(String name, double salary)

{

   this.name = name;

   this.salary = salary;

}

This指示隐式参数，即被构造的类对象。

public Employee(double s)

{

   // calls Employee(String, double)

   this("Employee #" + nextId, s);

   nextId++;

}

This将调用同一个类的另一个构造函数。

初始化块

// static initialization block

static

{

   Random generator = new Random();

   nextId = generator.nextInt(10000);

}

可以为任何一个类添加finalize方法，finalize方法将在垃圾回收器清除对象之前被调用。因为某些对象使用了内存之外的其他资源，如文件。

内部类方法可以访问该类定义所在的作用域的数据，包括私有数据。

内部类对同一包中的其他类不可见。

使用内部类定义回调函数可以避免写大量代码。

class TalkingClock

{

   public TalkingClock(int interval, boolean beep) { . . . }

   public void start() { . . . }

   private int interval;

   private boolean beep;

   private class TimePrinter implements ActionListener

      // an inner class

   {

     Date now = new Date();

      System.out.println("At the tone, the time is " + now);

      if (beep) Toolkit.getDefaultToolkit().beep();

   }

}

内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域。内部类有一个隐式引用，其指向外围类对象。

public void actionPerformed(ActionEvent event)

{ 

   Date now = new Date();

   System.out.println("At the tone, the time is " + now);

   if (outer.beep) Toolkit.getDefaultToolkit().beep();

}

内部类的默认构造函数

public TimePrinter(TalkingClock clock) // automatically generated code
{
     outer = clock;
}

局部内部类，不能用private和public声明，start方法都不能访问它。

public void start()

{

   class TimePrinter implements ActionListener

   {

      public void actionPerformed(ActionEvent event)

      {

          Date now = new Date();

          System.out.println("At the tone, the time is " + now);

          if (beep) Toolkit.getDefaultToolkit().beep();

      }

   }

   ActionListener listener = new TimePrinter();

   Timer t = new Timer(1000, listener);

   t.start();

}

匿名内部类

public void start(int interval, final boolean beep)

{

   ActionListener listener = new

      ActionListener()

      {

         public void actionPerformed(ActionEvent event)

         {

             Date now = new Date();

             System.out.println("At the tone, the time is " + now);

             if (beep) Toolkit.getDefaultToolkit().beep();

         }

      };

   Timer t = new Timer(1000, listener);

   t.start();

}

匿名构造了不能有构造函数，而是把构造函数参数传递给超类构造函数，

new SuperType(construction parameters)
{
   inner class methods and data
}

内部类实现接口时，不能有任何参数

new InterfaceType() { methods and data }

静态内部类

class ArrayAlg

{

   public static class Pair

   {

      . . .

   }

   . . .

}

静态内部类对象除了没有对生产它的外部类对象的引用特权外，与其他的内部类完全一样。

一个方法必须声明所有可能抛出的已检查异常，而未检查异常要么不可控制(Error)，要么就应该避免(RuntimeException)

如果超类方法没有抛出异常，则子类方法也不能抛出任何异常。子类方法抛出的异常不能超过超类声明的范围。

publicinterface Iterable<T> {

    Iterator<T> iterator();

}

publicinterface Collection<E> extends Iterable<E>

Collection和Iterator是泛型接口，任何集合都可以使用其方法。Collection接口中的方法：

public static <E> boolean contains(Collection<E> c, Object obj)

{ 

   for (E element : c)

      if (element.equals(obj))

         return true;

   return false;

}

iterator方法返回一个实现了Iterator接口的对象。

publicinterface Iterator<E> {

    boolean hasNext();

    E next();

    void remove();

}

Java集合类库将接口与实现分离，Queue

publicabstractclass AbstractCollection<E> implements Collection<E>

一个集合类可以从AbstractCollection类扩展

除了Map结尾的类，其他类都实现了Collection接口。

ArrayList动态数组

ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构。

在ArrayList的前面或中间插入数据时，必须将其后的所有数据相应的后移，这样必然要花费较多时间，所以，当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能；

而访问链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

如果在编程中，两种情形交替出现，这时，可以考虑使用List这样的通用接口，而不用关心具体的实现，在具体的情形下，它的性能由具体的实现来保证。

Java中每个链表实际上是双重链表。链表是有序的。List接口和实现了该接口的LinkedList类。

interface ListIterator<E> extends Iterator<E>

ListIterator中的add方法，添加元素在迭代器之前，remove方法删除上一个被访问的元素。Set方法取代使用next或previous方法最后访问的元素。

ArrayList封装了一个动态重新分配的数组。

Vector类的所有方法都是同步的。可以用两个线程安全地访问Vector对象。代码会在同步操作上浪费相当多的时间。ArrayList类的方法不是同步的。

hashCode()方法必须和equals方法相兼容。如果a.equals(b)为ture,则a和b必有相同的散列码。散列吗是通过对象实例字段产生的整数。

TreeSet是一个有序集合，插入时可以是任意顺序，输出时为排序后的顺序。红黑树。默认情况下，TreeSet假设你插入的元素实现了Comparable接口。

publicinterface Comparable<T> {

    publicint compareTo(T o);

}

PriorityQueue是一种能够在以任意顺序插入元素后，再按排序顺序读取这些元素的数据结构。优先级队列和TreeSet一样，其所持有的元素可以是实现了Comparable接口的类的对象，也可以是在构造器中提供的Comparator对象。

HashMap和TreeMap都实现了Map接口，映射表用于存放键/值对。

HashSet类，实现了基于散列表的散列集。不存在重复元素的集合。

散列映射表用于对键进行散列，树状映射表对于键的全局顺序进行排序，并组成搜索树。

框架就是一个类集合，它形成了创建高级功能的基础。框架包含许多超类，这些超类拥有非常有用的功能、策略和机制。框架用户建立的子类可以扩展类的功能，而不是重新创建基本的机制。

两个用于集合的基本接口，Collection和Map。

Set接口和Collection接口，Set不允许有重复元素。List接口提供随机访问的方法，ArrayList和LiknkedList的访问算法效率是不同的。

注释

文件头注释

文件头注释以 /*开始，以*/结束，需要注明该文件创建时间，文件名，命名空间信息。

例如：

/*

 * @(#)Boolean.java  1.51 04/05/11

 *

 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

 */

类、接口注释

类、接口的注释采用 /** … */，描述部分用来书写该类的作用或者相关信息，块标记部分必须注明作者和版本。Import语句之后，类定义之前。

例如：

/**

 * The Boolean class wraps a value of the primitive type

 * <code>boolean</code> in an object. An object of type

 * <code>Boolean</code> contains a single field whose type is

 * <code>boolean</code>.

 * <p>

 * In addition, this class provides many methods for

 * converting a <code>boolean</code> to a <code>String</code> and a

 * <code>String</code> to a <code>boolean</code>, as well as other

 * constants and methods useful when dealing with a

 * <code>boolean</code>.

 *

 * @author  Arthur van Hoff

 * @version 1.51, 05/11/04

 * @since   JDK1.0

 */

方法注释采用/** … */，描述部分注明方法的功能，块标记部分注明方法的参数，返回值，异常等信息。

/**

* Compares this <tt>Boolean</tt> instance with another.

*

* @param   b the <tt>Boolean</tt> instance to be compared

* @return  zero if this object represents the same boolean value as the

*          argument; a positive value if this object represents true

*          and the argument represents false; and a negative value if

*          this object represents false and the argument represents true

* @throws  NullPointerException if the argument is <tt>null</tt>

* @see     Comparable

* @since  1.5

*/

@param后面空格后跟着参数的变量名字（不是类型），空格后跟着对该参数的描述。

@return标记返回为空（void）的构造函数或者函数，@return可以省略。

如果返回值就是输入参数，必须用与输入参数的@param相同的描述信息。

必要的时候注明特殊条件写的返回值。

@deprecated由于某种原因而被宣布将要被废弃的方法。

@see:引用其它类的文档，相当于超链接，Javadoc会在其生成的HTML文件中，将@see标签链到其他的文档

@see package.classname#feature label

@see <a href=”…”>label</a>

@see “text”

@link标记

语法：{@link package.class#member label}

Label为链接文字。

package.class#member将被自动转换成指向package.class的member文件的URL。

@since

类注释标记。

标明该类可以运行的JDK版本

JDBC编程的基本概念

用于JDBC编程的类都包含在java.sql和javax.sql包中

java.sql.DriverManager类用于选择数据库驱动程序和创建新的数据库连接。

只有在驱动管理器中注册过的驱动程序才可以被激活。

"jdbc.drivers"属性包含一系列驱动程序的类名。驱动管理器会在启动时注册这些驱动。

System.setProperty("jdbc.drivers", "oracle.jdbc.driver.OracleDriver")

程序运行在Servlet引擎容器中时要通过加载驱动程序类来手动加载驱动程序，如Class.forName("oracle.jdbc.driver.OracleDriver");

调用DriverManager.getConnection方法获得java.sql.Connection对象

驱动管理器遍历当前所有已经注册过的驱动程序，….

创建一个java.sql.Statement对象

Statement stat = conn.createStatement();

调用Statement类中的executeUpdate方法执行字符串中的SQL语句。

当执行查询操作时可通过executeQuery方法返回一个java.sql.ResultSet对象，来每次一行地迭代遍历所有查询结果。执行SELECT查询时必须使用executeQuery方法。

ResultSet rs = stat.executeQuery("SELECT * FROM Books")

每一个Connection对象都可以创建一个或一个以上的Statement对象，同一个Statement对象可以用于多个不相关的命令和查询。但是，一个Statement对象最多只能打开一个结果集。

当使用完ResultSet、Statement、Connection对象时，应立即调用close()方法关闭连接对象。这些对象都使用了规模较大的数据结构，自行回收而不是等垃圾回收。

4.5 执行查询操作

预备语句（Prepared Statement） java.sql.PreparedStatement

返回一个含预编译语句的PreparedStatement对象，sql语句可以包含一个或多个?指明的占位符。

void setXxx(int n, Xxx x)

(Xxx is a type such as int, double, String, Date, etc.) sets the value of the nth parameter to x.

参数：第一个参数指的是需要赋值的宿主变量的位置，第二个参数指的是赋予宿主变量的值

4.6 可滚动和可更新的结果集

PreparedStatement stat = conn.preparedStatement(command,type,concurrency);

参数type的值：TYPE_FORWARD_ONLY(结果集不能滚动) TYPE_SCROLL_INSENSITIVE(结果集可以滚动，但对数据库变化不敏感) TYPE_SCROLL_SENSITIVE(结果集可以滚动，且对数据库变化敏感)

参数concurrency的值：CONCUR_READ_ONLY(结果集不能用于更新数据库) CONCUR_UPDATABLE(结果集可以用于更新数据库)

4.7 元数据

在SQL中描述数据库或其组成部分的数据称为元数据。包括三个类别：关于数据库的元数据（java.sql.DatabaseMetaData）、 关于结果集的元数据（java.sql.ResultSetMetaData）、关于预备语句参数的元数据 （java.sql.ParameterMetaData）

4.8 行集

适用于无需始终保持与数据库连接的应用或者将结果集移动到复杂应用的其他层。javax.sql.RowSet

RowSet接口继承了resultset接口

一个被缓存的行集包含了一个结果集中所有的数据。javax.sql.CachedRowSet

CachedRowSet接口继承了resultset接口

4.9 事务

当所有语句都顺利执行之后，事务可以被提交，否则，如果其中某个语句遇到错误，那么事务将被回滚。默认情况下，数据库的连接处于自动提交模式。一旦提交成功就无法进行回滚操作。

//You turn off autocommit mode with the command

conn.setAutoCommit(false);

//Now you create a statement object in the normal way:

Statement stat = conn.createStatement();

Call executeUpdate any number of times:

stat.executeUpdate(command1);

stat.executeUpdate(command2);

stat.executeUpdate(command3);

. . .

//When all commands have been executed, call the commit method:

conn.commit();

//However, if an error occurred, call

conn.rollback();

//Then, all commands until the last commit are automatically reversed. You typically issue a //rollback when your transaction was interrupted by a SQLException.

使用保存点（save point）可以让事务只需回滚到保存点，而非事务的开始。java.sql.Savepoint

Statement stat = conn.createStatement(); // start transaction; rollback() goes here

stat.executeUpdate(command1);

Savepoint svpt = conn.setSavepoint(); // set savepoint; rollback(svpt) goes here

stat.executeUpdate(command2);

if (. . .) conn.rollback(svpt); // undo effect of command2

. . .

conn.commit();

//When you are done with a save point, you should release it:

stat.releaseSavepoint(svpt);

批量更新

Statement stat = conn.createStatement();

//Now, instead of calling executeUpdate, you call the addBatch method:

String command = "CREATE TABLE . . ."

stat.addBatch(command);

while (. . .)

{

   command = "INSERT INTO . . . VALUES (" + . . . + ")";

   stat.addBatch(command);

}

//Finally, you submit the entire batch:

int[] counts = stat.executeBatch();

4.10 高级连接管理

Java名字和目录接口（JNDI）定位数据源。javax.sql.DataSource接口

4.11 LDAP概述

LDAP（Lightweight Directory Access Protocol,轻量级目录访问协议），通常主要应用于目录存储，且该目录包含了如用户名、密码和权限之类的数据。适用于应用数据遵从树状结构，且读操作多于写操作。

LDAP数据库将所有数据存储在一个树状结构中，树中的每一项包含：

1、0个或0个以上属性，每个属性都有一个ID和一个值。

2、一个或一个以上的对象类，一个对象类定义了该元素上的一组属性。

3、一个专有名称，专有名称是一组描述路径的属性序列，该路径将该条目与树的根连接在一起。

CORBA与SOAP都是完全独立于语言的。CORBA的接口定于语言是IDL，SOAP是WSDL。

远程方法调用

存根：

1.       被使用的远程对象的标识符；

2.       被调用的方法的描述；

3.       编组后的参数。

服务端接受对象：

1.       反编组参数；

2.       定位要调用的对象；

3.       调用所需方法；

4.       捕获返回值或该调用产生的异常，并对它编组；

5.       将返回值编组，打包送给客户端存根。

远程对象的所有接口都必须继承Remote接口，java.rmi.remote。接口中的所有方法也必须抛出RemoteException异常。

基本的RMI类

服务器类通常继承自java.rmi.server.RemoteServer类。RemoteServer是一个抽象类，仅仅定义了服务器对象与其远程存根之间通信的基本机制。UnicastRemoteServer是一个实体类，继承自RemoteServer。

服务器程序使用自举注册服务来注册对象，然后客户端可以获取这些对象的存根。

// server

ProductImpl p1 = new ProductImpl("Blackwell Toaster");

Context namingContext = new InitialContext();//建立一个命名context来访问RMI注册表

namingContext.bind("rmi:toaster", p1);//将rmi:toaster与p1对象绑定。

// client

Product p = (Product) namingContext.lookup("rmi://yourserver.com/toaster");//返回url对应的远程对象。

默认情况下，服务器是localhost，端口为1099。

可获得所有URL中带有rmi：的服务器对象的列表。

NamingEnumeration<NameClassPair> e = namingContext.list("rmi:");

只要实现Serializable接口的类都可以被复制。

远程对象是作为存根通过网络传递的，而非远程对象是通过复制。

DOM(Document Object Model)解析器读入的是一个完整的XML文档，然后将其转化为一个树形结构。适合数据量不大的解析。

Document对象是XML文档的树形结构在内存中的表现。

要读入一个文档，首先要一个DocumentBuilder对象，你可以从DocumentBuilderFactory工厂中得到。

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

DocumentBuilder builder0020= factory.newDocumentBuilder();

File f = "xx.xml";
Document doc = builder.parse(f);
或是用一个url
URL u = ......
Document doc = builder.parse(u);
还可以是任意的输入流
InputStream in = .......
Document doc = builder.parse(in);

它有实现Node接口以及其它子接口的类对象构成。

可以调用getDocumentElement方法来分析文档内容，它将返回跟元素
Element root = doc.getDocumentElement();

String getTagName()返回元素的标签名。

NodeList getChildNodes()得到该元素的子元素，它将返回一个NodeList集合。

String getAttribute()返回属性值。

trim()把实际数据前后的空白字符删掉。

org.w3c.dom.Node

DTD和XML schema包含了用于解释文档是如何构成的规则。

SAX解析器是在解析XML输入的构件时就报告事件，但不会以任何方式存储文档，有事件处理器决定是否要建立数据结构，实际上，DOM解析器是在SAX解析器基础上建立起来的。

SAX解析时，需要一个处理器来解析，要实现ContentHandler 接口，他定义了很多回调方法。

startElement和endElement 在每当遇到起始或结束时各调用一次。
characters每当遇到字符时调用，
startDocument和endDocument分别在文档开始和结束时各调用一次。

SAXParserFactory saxfactory = SAXParserFactory.newInstance();

SAXParser parser = saxfactory.newSAXParser();

parser.parse(source, handler); //source是要处理的文件，handler处理器的一个子类

defaultHandler实现了四个接口。

ContentHandler

DTDHandler

EntityResolver

ErrorHandler

public class DefaultHandler

implements EntityResolver, DTDHandler, ContentHandler, ErrorHandler

事件处理

将ColorAction作为ButtonPanel类的内部类，ColorAction就自动拥有访问外部类的权限。

将组件变成事件监听器，panel本身作为事件监听器

Object source = event.getSource()返回发生事件的对象引用。

String command = event.getActionCommand()

getSystemLookAndFeelClassName()获取系统观感

UIManager.setLookAndFeel(String className)设置观感

Java中实现一个接口的任何类都必须实现其中的所有方法。

Public interface WindowsListener

Public class WindowsAdapter implements WindowsListener

匿名内部类

EventObject类有一个子类AWTEvent，它是所有AWT事件类的父类。Swing组件将生成其他事件类型的事件对象；它们都直接扩展于EventObject，而不是AWTEvent。

Java使用一个线程在后台进行垃圾回收。

Sleep()是Thread类的一个静态方法，暂停当前线程活动。会抛出InterruptedException异常。

实现Runnable接口

public interface Runnable{

    public abstract void run();

}

Thread t = new Thread(Runnable r);

当你用new操作符创建一个线程时。还没有调用thread.start()，处于新生状态。

t.start;

调用了thread.start()方法之后。线程就变成了Runnable状态了。

Thread的start方法会创建一个新的线程来执行run方法，启动这个线程，将引发调用run()方法。

Thread(Runnable target)构造一个新的线程来调用指定target的run()方法。

当interrupt方法在一个线程上被调用时，该线程的中断状态将被置位。

调用静态的Thread.currentThread方法来取得当前的线程。然后调用它的isInterrupted方法。

如果一个线程被阻塞了，就无法检查中断状态了。就会产生InterruptedException异常。例如sleep或者wait，这时候程序是在等待的，所以不可能去检查currentThread().isInterrupted()是否返回true。

当sleep方法抛出一个InterruptedException异常时，它同时也会清除中断状态。

Thread接口：
void interrupt()
发送一个中断请求给一个线程。中断状态被设为true。如果正在被sleep调用阻塞，抛出一个InterruptedException。

static boolean interrupted()
检查当前线程是否已经被中断了。调用这个方法会把当前的现成中断状态设置成false. currentThread

boolean interrupted()
检查一个线程是否已经被终止了。

static Thread currentThread()
返回当前线程的Thread对象。

线程组

ThreadGroup g = new ThreadGroup(String groupName);

Thread t = new Thread(g, threadName);

未捕获异常处理器

锁对象

同步synchronized关键字，ReentrantLock类

Private Lock mylock = new ReentrantLock();

Mylock.lock;

Try{

...

}finally{

Mylock.unlock;

}

条件对象

Condition newCondition()返回该锁相关的一个条件对象；

void await()将该线程放到条件的等待集；直到条件被改变时，再次激活等待线程。

void signalAll()解除该条件的等待集中所有线程的阻塞状态。

Synchronized方法，即线程必须先获得对象的锁，才能调用该方法。

publicfinalnativevoid notify();

publicfinalnativevoid notifyAll();

解除在该对象上调用wait的线程的阻塞状态。

public final native void wait(long timeout) throws InterruptedException;

对象的集合

数组

数组标识符其实只是一个引用，指向在堆（heap）中创建的一个真实对象，这个（数组）对象用以保存指向其他对象的引用。

java.util. Arrays它有一套 static方法，提供操作数组的实用功能。

要保存基本类型，则只能用数组。

如果你复制对象数组，那么只是复制了引用——不会出现两份对象的拷贝。这被称作浅复制、浅拷贝（shallow copy）

Collection:一组独立的元素，通常有某种规则应用于其上。List必须保持元素特定的顺序，而 Set不能有重复元素。

Map:一组成对的键值对（key-value）对象。Map可以返回所有键组成的Set，所有值组成的 Collection，或其键值对组成的Set。

Java的容器类有两种基本类型，区别在于容器中每个位置保存的元素个数。Collection每个位置只能保存一个元素。包括List，它以特定的顺序保存一组元素；Set，元素不能重复。ArrayList 是一种List，而HashSet是一种Set。将元素添入任意Collection都可使用 add()方法。

Map保存的是键值对，（Map也被称作关联数组）使用方法put()为Map添加元素，它需要一个键与一个值作为参数。

Java容器的“缺点”，在将对象加入容器的时候就丢失了类型信息。容器只保存Object型的引用，这是所有类的基类，因此容器可以保存任何类型的对象。

将ArrayList看作是“能够自动扩展的数组”。

迭代器是一个对象，它的工作是遍历并选择序列中的对象。

1. 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。

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

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

4. 使用remove()将上一次返回的元素从迭代器中移除。

点线方框表示接口，虚线方框表示抽象类，实线方框表示普通的（具体的）类。点线箭头代表特定的类实现一个接口（若是抽象类，则表示部分实现了接口）。实线箭头表示一个类可以生成箭头所指向类的对象。

三种容器：Map，List和Set，它们各有两到三个实现版本。常用的容器用黑色粗线框表示。

与持有对象有关的接口是Collection，List，Set和Map。

接口的优美之处（或者说目的）在于，如果你决定改变当前的实现，只需要在创建的位置做些修改即可。

List x = new LinkedList();

List x = new ArrayList();

典型情况是你会生成一个“具体类”的对象，然后将它向上转型为对应的接口，在代码中使用接口操作它。

Collection的功能方法：

可以通过Set或List执行的所有操作。

两种List：一种是基本的ArrayList，允许对元素进行快速随机访问，但是向 List 中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList，而不是用来插入和移除元素，因为那比LinkedList开销要大很多；另一种是更强大的LinkedList，对顺序访问进行了优化，向List中间插入与删除的开销并不大，随机访问则相对较慢。LinkedList 可以当作堆栈、队列和双向队列使用。

次序是List最重要的特点；它保证维护元素特定的顺序。一个List可以生成ListIterator，使用它可以从两个方向遍历List，也可以从List中间插入和移除元素。

Set具有与Collection完全一样的接口，实际上Set就是Collection，只是行为不同。存入Set 的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。

HashSet为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。

运行期类型识别（RTTI，run-time type identification）：当你只有一个指向对象的基类的引用时，RTTI机制可以让你找出这个对象确切的类型。

两种方式：一种是传统的 RTTI，它假定我们在编译期和运行期已经知道了所有的类型；另一种是反射机制（reflection），它允许我们在运行期获得类的信息。

多态机制，Shape对象实际上执行什么样的代码，是由引用指向的具体对象是Circle,Square 或者Triangle而决定的。

类型信息在运行期的表示是由 “Class 对象”的特殊对象完成的，它包含了与类有关的信息。Class 对象正是被用来创建类的“常规”对象的。每个类都有一个 Class 对象。编写并且编译了一个新类，就会产生一个 Class 对象，保存在一个同名的.class 文件中。想生成这个类的一个对象，运行这个程序的 Java 虚拟机首先检查这个类的Class对象是否已经加载。如果尚未加载，JVM 就会根据类名查找.class 文件，并将其载入。Java 程序并不是一开始执行，就被完全加载的。一旦某个类的 Class 对象被载入内存，它就被用来创建这个类的所有对象。

Class.forName("Gum");这是Class类（所有Class对象都属于这个类型）的一个static 成员。Class对象就和其他对象一样，我们可以获取并操作它的引用（这也就是类加载器的工作）。forName()是取得Class 对象的引用的一种方法。对forName()的调用是为了它产生的“副作用”：如果类Gum还没有被加载就加载它。

Gum.class; 在编译期就会受到检查。

TYPE域是一个引用，指向对应的基本数据类型的 Class 对象。

RTTI形式包括：

1. 经典的类型转换，由RTTI确保类型转换的正确性，如果你执行了一个错误的类型转换，就会抛出一个ClassCastException异常。

2. 代表对象类型的Class对象。通过查询Class对象可以获取运行期所需的信息。

Java 是通过Class对象来实现RTTI机制的。

Class.forName()方法，在获取Class的引用时，并不需要生成该Class类型的对象。仅仅是获取引用。而如果你有了一个类型的对象，那么你可以通过调用getClass()来获取Class的引用，这是根类Object提供的方法。它返回Class 的引用，用来表示对象的实际类型。

Class.getInterfaces()方法返回Class对象的数组，这些对象代表的是某个Class对象所包含的接口。

如果你有一个Class对象，可以通过getSuperclass()获取它的直接基类，返回一个Class的引用，这意味着在运行期，你可以找到一个对象完整的类层次结构。

Class的newInstance()方法创建一个新的对象的方法。“尽管我不知道你的准确类型是什么，但还是请正确地创建你自己。”

反射（Reflection）运行期的类信息

在编译期，编译器必须知道你要通过RTTI 来处理的所有类。

java.lang.reflect包含了Field，Method以及Constructor类（每个类都实现了 Member 接口）。这些类型的对象是由JVM在运行期创建的，用以表示未知类里对应的成员。

匿名对象的类信息就能在运行期被完全确定下来，而在编译期不需要知道任何事情。

通过反射与一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类，在做其它事情之前，必须加载那个类的 Class 对象。那个类的.class 文件对于JVM 来说必须是可获取的，要么在本地机器上，要么可以通过网络取得。

RTTI和反射之间真正的区别只在于，对 RTTI 来说，编译器在编译期打开和检查.class 文件。而对于反射机制来说.class文件在编译期间是不可获取的，所以是在运行期打开和检查.class 文件。

异常

异常能使错误处理代码变得更有条理，只需在一个地方处理错误。把“描述做什么事”的代码和“出了问题怎么办”的代码相分离。先在一个地方专注于正在解决的问题，然后在别的地方处理这些代码中可能发生的错误。

异常情形，在当前环境下无法获得必要的信息来解决问题。

Java将使用 new在堆上创建异常对象。当前的执行路径被终止，并且从当前环境中弹出异常对象的引用。异常处理机制接管程序，异常处理程序继续执行程序。

所有标准异常类都有两个构造器：一个是缺省构造器；另一个是接受字符串作为参数，用来把相关信息放入异常对象的构造器。

创建一个代表错误信息的对象，并且将它从当前环境中“抛出”，这样就把错误信息传播到了“更大”的环境中，称为“抛出一个异常”。

因为异常返回的“地点”与普通方法调用返回的“地点”完全不同。异常将在一个恰当的异常处理程序中得到解决。

“终止模型”，一旦异常被抛出，程序无法返回到异常发生的地方继续执行。

自定义异常

class SimpleException extends Exception {}，让编译器为你产生缺省构造器。对异常来说，最重要的部分就是类型的名称。System.err打印到控制台的标准错误流。

异常说明使用了附加的关键字 throws，后面接一个所有潜在异常类型的列表，可以声明方法将抛出异常，实际上却不抛出。

通过捕获异常类型的基类Exception，捕获所有类型的异常。

String getMessage( )

String getLocalizedMessage( )

用来获取详细信息，或用本地语言表示的详细信息。

String toString( )

返回对 Throwable的简单描述，要是有详细信息的话，也会把它包含在内。

void printStackTrace( )  

输出到标准输出流，打印Throwable和Throwable的调用栈轨迹。调用栈显示了“把你带到异常抛出地点”的方法调用序列。

重新抛出异常

重抛异常会把异常抛给上一级环境中的异常处理程序。同一个 try 块的后续 catch 子句将被忽略。

Throwable类被用来表示任何可以作为异常被抛出的类。

Throwable对象可分为两类：Error编译期和系统错误；Exception 是可以被抛出的基本类型。

异常的基本的概念是用名称代表发生的问题，并且异常的名称应该可以望文生意。

运行期异常RuntimeException，属于错误将被自动捕获。只能在代码中忽略 RuntimeException（及其子类）类型的异常，其它类型异常的处理都是由编译器强制实施的。

异常被设计用来处理运行期错误，这些错误往往是由你的代码控制能力之外的因素导致的。

finally当你要把除内存之外的资源恢复到它们的初始状态时，就要用到 finally子句。

编译器会对异常说明做强制要求，但异常说明本身并不属于方法原型的一部分，方法原型是由方法的名字与参数的类型组成的。因此，你不能根据异常说明的不同来重载方法。

一个出现在基类方法的异常说明中的异常，不一定会出现在派生类方法的异常说明里。

并不要求抛出的异常同处理程序所声明的异常完全匹配。派生类的对象也可以匹配处理程序中声明的基类。，catch(Annoyance e)会捕获 Annoyance以及所有从它派生的异常。

异常处理的一个重要目标就是把错误处理的代码同错误发生的地点相分离。

异常使用指南：

1． 在恰当的级别处理问题。（在你知道该如何处理的情况下才捕获异常）。

2． 解决问题并且重新调用产生异常的方法。

3． 进行少许修补，然后绕过异常发生的地方继续执行。

4． 用别的数据进行计算，以代替方法返回的期望值。

5． 把当前运行环境下能做的事情尽量作完，然后把相同的异常重抛（rethrow）到

更高层。

6． 把当前运行环境下能做的事情尽量作完，然后把不同的异常抛(throw)到更高

层。

7． 终止程序。

8． 进行简化。（如果异常把问题搞得太复杂，那用起来会非常痛苦也很烦人。）

9． 让类库和程序更安全。（这既是在为调试做短期投资，也是在为程序的健壮性做

长期投资。）

1.寄存器(register).位于CPU中,所以它是存取速度最快的存储区.但是由于CPU中寄存器的数量是非常有限的,所以寄存器的使用是由CPU按需进行分配.编程的时候我们没有必要去对它进行直接控制.并且在程序中也没办法找到到底什么时候使用了寄存器的依据.
2.栈(stack).它位于随机存取存储器(RAM)中,并通过由CPU直接支持的栈指针(stack pointer)来进行操作.栈指针通过向下移动来分配新的存储空间,并通过向上移动来释放存储空间.这是仅次于寄存器的另一种高速有效地分配存储空间的方式.在创建程序期间,Java编译器必须知道存储在栈上的所有数据的准确大小和它们的生命周期.这样它才能够产生代码来让栈指针上下地移动.但这种约束限制了代码的灵活性,所以当某些Java存储区在栈上的时候——特别是,对象引用(object reference)――而Java对象本身并不被存储在栈上.

3.堆(heap).这是存储Java所有对象的内存池(同样在RAM区域中).堆的优点是,它不像栈一样,编译器并不需要知道它应该从堆中分配多大的存储空间,或者存储空间应该在堆上存在多久.因此,在堆上分配多大的存储空间具有很大的灵活性.无论你何时需要创建对象,你只需要简单的在代码中使用关键字 new来创建它就行了.在这段代码被执行时候就在堆(heap)上面分配相应的存储空间.当然,为这样的灵活性也需要付出一定的代价:在堆上分配存储空间比在栈上分配存储空间要更加耗时(如果你能够在Java中像在C++一样,在stack上创建对象的话).

4.静态存储区(static storage).”静态(static)”在这里表示”在一个固定的位置”(尽管它同样在RAM中).静态存储区包括:对于程序的整个运行期间都有效的 数据.你能够使用关键字static来指定特殊的对象为静态的.但是Java对象自身却从来不放置在静态存储区中.

5.常量存储区(constant storage).常量通常被直接放置在程序代码当中.这是安全的。

基本类型存放在堆栈中，每种基本类型所占存储空间的大小都是确定的。基本类型具有包装器类，可以在堆中创建一个非基本对象，用来表示对应的基本类型。

基本成员默认值
若类的某个成员是基本数据类型，即使没有进行初始化，Java也会确保它获得一个默认值。如下表所示：
基本类型            默认值
boolean             false
char                   ‘\u0000’ (null)
byte                   (byte)0
short                  (short)0
int                       0
long                   0L
float                    0.0f
double                0.0d

然而上述确保初始化的方法并不适用于“局部”变量（即并非是某个类的属性）。因此，如果在某个方法中有这样定义：
int x;
那么变量x得到的可能是任意值，而不会被自动初始化为零。

Static的数据和方法不会与包含它的类的任何对象实例关联在一起。非static数据和方法必须知道它们一起运作的特定对象。

通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。

Java中，类构造器由编译器调用，无返回值。如果没有写构造器，编译器会自动创建一个构造器，如果写了构造器，编译器就不会自动创建缺省构造器。

this编译器把所操作对象的引用作为第一个参数传递给成员函数。在方法内部获得当前对象的引用。this关键字只能在方法内部使用，表示对调用方法的那个对象的引用。

static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来却可以。

“this通常指代当前对象，super通常指代父类”。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this 来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数。如果你想引用父类的某种东西，则super。

最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。

在构造函数中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。在构造器中，this只能调用一个构造器，且必须将构造器调用置于最起始处。super后加参数的是用来调用父类中具有相同形式的构造函数。this后加参数则调用的是当前具有相同参数的构造函数。

final成员：当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对 于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能 选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。

如果不加访问权限，则默认为包访问权限，即包内的类对其有访问权限。

protected：继承访问权限。基类通过protected把访问权限赋予派生类而不是所有类，
另外，protected也提供包访问权限，也就是说，相同包内的其他类可以访问protected元素。

对于类访问权限来说，
仅有两个选择：包访问权限或public。
类既不可以是private的，也不可以是protected的，但内部类是个特例，一个内部类可以是private或protected的。

名称屏蔽：如果java的基类拥有某个已被多次重载的方法名称，那么在导出类中重新定义该方法名称并不会屏蔽其在基类中的任何版本（这一点于C++不同）。因此，无论是在该层或者它的基类中对方法进行定义，重载机制都可以正常工作。这句话的意思是指：如果基类有方法 void method（） String method（int i），那么在导出类中定义 int method（char a） 并不会吧基类的方法给屏蔽，基类的重载方法是可以用的。导出类同样可以重载。

类的复用有两种方法：组合（composition）和继承

组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形，一般在新类中嵌入一个现有类的private对象。但有时，允许类的用户访问新类中的组合部分是极具意义的。如果成员对象自身都隐藏了具体实现，那么将它声明为public也是安全的。

组合一般是将现有类型作为新类型底层实现的一部分来加以复用，而继承复用的是接口，由于导出类具有基类的接口，所以它可以向上转型至基类。

向上转型

新类是现有类的一种类型。

向上转型中子类将能看到父类被覆盖字段

在子类继承父类之后，如果子类与父类有同名的字段和方法，那么子类中的子段会代替或隐藏父类的子段，说明子类字段覆盖了超类字段，但可以通过super关 键字去访问超类字段。但是，在我们将子类对象向超类转型的时候就会发生这个奇怪的现象，子类对象居然可以看到父类曾经被覆盖掉的字段！

一定要注意：当把子类转换成超类时，子类可以见到或访问被隐藏的同名变量。Java允许名字重复的原因是，允许将来把新的字段加到超类中，而不影响已经使用了该名字的现有子类，子类将会继续使用自己的字段副本。除非让子类以超类对象的形式出现，方法可以覆盖，但是字段不能被覆盖。注意：最好不要隐藏超类中的字段名。
所以我们在进行向上转型的时候一定要注意：不要访问子类中那些“覆盖”掉父类的字段（它并没有真正覆盖掉，在向上转型的时候就可以访问的到），要么将子类字段改名（在你知道父类代码的情况下），要么通过方法来访问字类字段（方法即使同名也肯定能覆盖掉）。

在向上转型的过程中，类接口中唯一可能发生的事情是丢失方法，而不是获取它们。

是否需要从新类向基类进行向上转型，如果必须向上转型，则继承是必要的。

final数据

1. 它可以是一个永不改变的“编译期常量（compile-time constant）”。

2. 它可以是一个在运行期被初始化的值，而你不希望它被改变。

在编译期常量的情况下，编译器可以将该常量值带入任何可能用到它的计算式中。就是说，可以在编译期执行计算式，减轻了一些运行期的负担。这类常量必须是基本类型。

一个既是static又是final的域只占有一份不能改变的存储空间。

对于原始类型，final使数值恒定不变，而用于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法对它进行改变以指向另一个对象。然而，对象其自身却是可以被修改的，Java并未提供使任何对象恒定不变的途径。

Java允许生成空白final（Blank final），所谓空白final是指被声明为final但又未给定初值的数据成员。无论什么情况，编译器都确保空白 final在使用前必须被初始化。但是，空白final在关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却又保持其恒定不变的特性。

Java允许你以在参数列表中以声明的方式将参数指明为final。这意味着你无法在方法中更改参数引用所指向的对象。你可以读参数，却无法修改参数。

使用final方法的原因有两个。第一个原因是把方法锁定，以预防任何继承类修改它的意义。这是出于设计的考虑：你想要确保在继承中方法行为保持不变，并且不会被重载。

使用final方法的第二个原因是效率。如果你将一个方法指明为final，就是同意编译器将针对该方法的所有调用都转为内嵌（inline）调用。C++中的内联函数，空间换时间

类中所有的private方法都被隐含是final的。由于你无法取用private方法，所以你也无法重载之。如果你试图重载一个private方法（隐含是final的），看起来是奏效的，而且编译器也不会给出错误信息。覆盖只有在某方法是基类的接口的一部分时才会出现。如果某方法是private，它就不是基类的接口的一部分。

当你将某个类的整体定义为final时（通过将关键字final置于它的定义之前），你就声明了你不打算继承该类，而且也不允许别人这样做。Final类禁止继承，所以final类中所有的方法都隐式指定为final。

每个类的编译代码都存在于它自己的独立的文件中。该文件只在需要使用程序代码时才会被加载。一般来说，你可以说：“类的代码在初次使用时才加载。”这通常是指知道类的第一个对象被构建时才发生加载，但是当访问static数据成员或是static方法时，也会发生加载。

初次使用之处也是静态初始化（static初始化）发生之处。所有的static对象和static代码段都会在加载时依程序中的顺序（即，你定义类时的书写顺序）依次初始化。当然，static只会被初始化一次。

用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初 始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

多态通过分离“做什么”和“怎么做”，从另一个角度将接口和实现分离开来。

“封装”通过合并特征和行为来创建新的数据类型。“实现隐藏”则通过将细节“私有化”把接口和实现分离开来。多态的作用则是消除类型之间的耦合关系。

多态方法调用允许一种类型表现出与其他相识类型之间的区别，只要他们都是从同以基类导出而来的。这种区别是根据方法行为的不同而表现出来的，虽然这些方法都可以通过同一个基类来调用。

向上转型可能会缩小接口，但不会比基类接口更窄。

前期绑定：若在程序执行前进行绑定（如果有的话，由编译器和链接程序实现）后期绑定：在运行时根据对象的类型进行绑定。也称动态绑定或运行时绑定

c语言都是前期绑定，java除了static方法和final方法外，其他所有的方法都是后期绑定,final可以有效地"关闭”动态绑定。

基类为自它那里继承而来的所有导出类建立一个公用接口，导出类通过覆盖这些定义，来为每种特殊类型提供单独的行为。

从通用的基类继承出的新的数据类型，从而新添一些新的功能，而那些操纵基类的接口的方法不需要任何改动就可以运用于新类。这正是“可扩展性”的程序的一般特征。

多态，将改变的事物与未变的事务分离开来。

只有非private方法才可以被覆盖；但是还需要密切注意覆盖private方法的现象，这时编译器不会报错，但是也不会按照我们所期望的来指向。

如果一个类包含一个或多个抽象方法该类必须被限定为抽象的。也可以创建一个没有任何抽象方法的抽象类，仅是为了组织产生这个类的任何对象。

如果想从一个抽象类继承，并想创建该新类的对象，那么就必须为基类中的所有的抽象方法提供方法定义。如果不这样做，那么导出类便也是抽象类，且编译器将强制我们用abstract关键字来限定这个类。

对象调用构造器的顺序：

1.调用基类构造器。这个步骤会不断地反复递归下去，首先是构造这种层次结构的根，后是下一层导出类，等到那个，知道最低层的导出类。

2.按声明顺序调用成员的初始化方法

3.调用导出类构造器的主体

清理的时候应该首先对其导出类进行清理，然后才是基类。这是因为导出类的清理可能会调用基类中的某些方法，所以需要使基类中的构件仍起作用而不应该过早地销毁它们。

初始化实际的过程是：

1.         在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零

2.         按前面所述调用基类构造器

3.         按声明的顺序调用成员的差距是花方法

4.         调用导出类的构造器主体

这样做有一个优点，那就是所有东西都至少初始化成零（或者某些特殊数据类型中与:零等价的值），而不是仅仅留作垃圾。其中包含通过“组合”而嵌入一个类内 部的对象引用，其值是null。所以如果忘记为该引用进行初始化，就会在运行时出现异常。查看输出结果时，会发现其他所有的东西的值，都是会是零，这通常也 正是方法问题的证据。

编写构造器时有一条准则：用尽可能简单的方法使对象进入正常状态；如果可以的，避免调用其他的方法。在构造器内唯一能够安全调用的方法是基类中的final方法（也适合于private）。这些方法不能被覆盖。

导出类中接口的扩展部分不能被基类访问，因此，向上转型，不能调用新方法。

向上转型会丢失具体类型信息，但向上转型是安全的。

在java中，所有的类型转换都会得到检查。所以即使我们知识进行一次普通的加括号形式的类型转型，在进入运行期仍会对其检查，以便保证它的确是我们希望的那种类型。否则，会返回一个ClassCastException异常。运行时类型识别RTTI。