显示参数和隐式参数。

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)

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

子元素和属性的区别，属性是隐式的，不出现在文档中。

Xmlns名字空间

CDATA用于对正常文本的处理。

XML模式定义语言：DTD和XML Schema

XML Schema事实上也是XML的一种应用，也就是说XML Schema的格式与XML的格式是完全相同的，而作为SGML DTD的一个子集，XML DTD具有着与XML格式完全不同的格式。这种区别会给XML Schema的使用带来许多好处：

1.       由于XML Schema本身也是一种XML，所以许多的XML编辑工具、API 开发包、XML语法分析器可以直接的应用到XML Schema，而不需要修改。

2.       作为XML的一个应用，XML Schema理所当然的继承了XML的自描述性和可扩展性，这使得XML Schema 更具有可读性和灵活性。

3.       由于格式完全与XML一样，XML Schema除了可以像XML一样处理外，也可以同它所描述的XML文档以同样的方式存储在一起，方便管理。

4.       XML Schema与XML格式的一致性，使得以XML为数据交换的应用系统之间，也可以方便的进行模式交换。

XML Schema则不同，它内置了三十七种数据类型，如long，int，short，double等常用的数据类型，XML Schema数据类型的真正灵活性来自于其对用户自定义类型的支持。使用complexType和sequence构造复杂类型。

DTD：限制并归类文档中的信息，并不限制基本类型意义上的类型，只限制元素子元素很属性的出现。是有关一个元素中可以出现何种模式的子元素的一系列规则。|表示或，+表示一个或多个，*表示零个或多个，？表示零个或一个。

DTD

1.         单个文本元素和属性不能定义，不能定于为整数。

2.         只能指定一个无序的集合，很难指定每个标签只出现一次

XML Schema可以用minOccurs和maxOccurs指定某个子元素出现的最多和最少次数。

XML Schema较DTD的优势：

1.         允许把元素中出现的文本限制为专门类型

2.         允许创建用户自定义类型

3.         允许唯一性和外键约束

4.         与名字空间结合以允许文档遵从不同模式

5.         允许使用继承来扩展复杂类型

6.         允许使用专门类型来对类型进行限制，最大最小值

XML查询转换工具：XPath，XQuery，XSLT

XPath是基于路径表达式的语言，FLWOR表达式

XQuery仿照SQL

XSLT(XSL Transformation)是由XSL(XML Stylesheet Language)扩展而来的

#PCDATA表示文本数据，empty表示没有内容，any表示任意。

<?xml version="1.0"?>

　　<!DOCTYPE note [

　　<!ELEMENT note (to,from,heading,body)>

　　<!ELEMENT to (#PCDATA)>

　　<!ELEMENT from (#PCDATA)>

　　<!ELEMENT heading (#PCDATA)>

　　<!ELEMENT body (#PCDATA)>

　　]>

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的访问算法效率是不同的。

Image对象是一个包装了本地资源的Java结构，不能被Java的垃圾回收器管理。加载图像而不卸载，会导致内存泄漏。

Eclipse使用ImageDescriptor来描述Image，ImageDescriptor可以通过getImageDescriptor()方法来获得。

创建编辑器的上下文操作，targetID="#TextEditorContext"，为eclipse默认文件编辑器的上下文菜单标识符。实现类必须实现IEditorActionDelegate接口。

Java编辑器对应的ID为：#TextEditorContext和 #CompilationUnitEditorContext，定义好targetID，就把我们的插件id指向视图菜单的id了。这样Java编辑器就会添加我们的菜单项了。

targetID用来与特定的编辑器，查看器，菜单绑定。

命令与键绑定，和操作相关联。命令只是操作的声明，操作的具体实现细节由操作本身来完成。将命令从操作实现中分离出来。

Org.eclipse.ui.commands扩展点 定义命令

Org.eclipse.ui.bindings扩展点 与命令和键绑定

视图的实现类都必须实现org.eclipse.ui.IViewPart接口，一般都会集成org.eclipse.ui.ViewPart类。

视图的行为由一个实现了org.eclipse.ui.IViewPart接口的类定义

IStructuredContentProvider结构化内容提供者负责从输入对象中提取对象，把它传递给表格查看器进行显示。AddressViewContentProvider实现IStructuredContentProvider（内容与查看器的绑定）和 AddressManagerListener接口（监听模型变化）。

AddressViewContentProvider通过AddressManager获取模型来提供显示

AddressViewContentProvider实现AddressManagerListener的addressesChanged方法。

LableProvider标签提供者将获取内容提供者返回的一个表格行对象，并提取要显示到的列上的值。

ITableLabelProvider接口要求实现getColumnText和getColumnImage两个主要的方法，getColumnText返回指定单元格的显示文本，getColumnImage返回指定单元格的显示图标。

根据对表格列的判断来显示相应区域的文本和图像。

public String getColumnText(Object element, int columnIndex)，其中element表示单元格所在行的对象，columnIndex表示单元格所在的列，返回显示的文本。

public Image getColumnImage(Object element, int columnIndex)，其中element表示单元格所在行的对象，columnIndex表示单元格所在的列，返回此单元格的显示图标。

ViewerSorter查看器排序器用于对内容提供者提供的元素进行排序，继承ViewerSorter类。

一个视图仅可以有一个内容提供者，一个标签提供者和一个排序器，但过滤器可以有很多个。

ViewerFilter类用于确定显示内容提供者返回的哪些行对象，不显示哪些行对象。

获取当前选中项，先查找视图，找到该视图后，调用getSelection()得到当前选择项，然后马上转换为IStructuredSelection，以后的操作就是统一的了，因为有IStructuredSelection接口。如果是在action中遇到这种需求，就将event调用getSelection()，然后转换为IStructuredSelection，后续操作相同。

Eclipse的每个视图（View）都有自己的菜单和工具条，View通过与自己相关的IViewSite对象与这些东西打交道，确切的说，是通过这个IViewSite对象的IActionBars对象来管理，ActionBars对象负责菜单、工具条和状态栏。

makeActions是创建操作，必要的IAction对象，这些对象可用在菜单、工具条里。

hookContextMenu是把刚刚创建的IAction对象放进与View相关的MenuManager里。

当触发了menu事件时，重新填充（fillContextMenu）

setRemoveAllWhenShown(true)的作用是清空以前显示的菜单项。不把removeAllWhenShow置为true的话，每点一下右键你就会看到菜单项多出一倍来。

用MenuManager可以创建出一个Menu对象，然后我们用表格的setMenu方法将表格控件与Menu控件联系在一起就好了。

getSite().registerContextMenu(menuMgr, viewer)这是context menu能不能显示的关键。一个视图中可以有多个context menu，而每一个context menu都必须注册给workbench。这需要通过调用org.eclipse.ui.IWorkbenchPartSite.registerContextMenu(MenuManager menuManager, ISelectionProvider selectionProvider)或者（当有多个注册的context menu时）org.eclipse.ui.IWorkbenchPartSite.registerContextMenu(String menuId, MenuManager menuManager, ISelectionProvider selectionProvider) 增加的参数menuId用于区分不同的context menu。

上下文菜单比工具栏多一步创建上下文菜单。

属性视图支持所有实现IResource接口的资源。

一个视图（View）希望得到另外一个视图显示的内容，或者选择的内容。在Eclipse中，比较标准的做法是通过ISelectionProvider和ISelectionListener来完成的。

Eclipse为了解决这个问题，提供了所谓的Site，以及ISelectionService机制，来处理视图之间的简单的交互。简单的说，ViewSite提供了一个交互的中心点，其它View向ViewSite提供选择事件，或者向其注册监听器，而事件的触发与转发则由ViewSite()来完成。只需在View中实现ISelectionListener接口，就可以监听其他Workbench部分发生的选择事件。

向Workbench注册监听器

getSite().getPage().addSelectionListener(this);

向特定WorkbenchID注册监听器

getSite().getPage().addSelectionListener(String WorkbenchID, ISelectionListener);

并实现selectionChanged方法来处理监听器捕获到的事件。

一个ISelectionProvider如果希望被别的View进行监听的话，则应该向其Site()进行注册。

getViewSite().setSelectionProvider(viewer);

IPropertySource的实现类必须为每个显示在属性视图中的项创建一个属性描述符。

ComboBoxPropertyDescriptor可以在属性视图的单元格中显示复选框，但必须为其定义标签提供者和一组String数组为显示内容。getText的参数是getPropertyValue的返回值，这个返回值必须是整数。在ComboBoxPropertyDescriptor中，每个项是按照它们的索引号来区分的。在initProperties中，将类别名用整数表示。

Integer item = (Integer)element;

表格查看器添加状态栏支持，则表格查看器添加监听器ISelectionChangedListener。

“插件是为系统提供功能的代码和/或数据的结构化包。可以以代码库（带有公共 [应用程序接口] API 的 Java 类）、平台扩展甚至文档的形式来提供功能。插件可以定义扩展点、定义良好的位置，其他插件可以在这些位置添加功能。”

Eclipse使用OSGi作为插件系统的基础。动态添加新插件和停止现有插件的能力。以动态方式管理组件生命周期的一个健壮的系统。

OSGi是基于Java的框架，旨在用于需要长运行时间、动态更新和对运行环境破坏最小的系统。

OSGi规范定义了绑定包生命周期的基础架构和绑定包的交互方式。这些规则通过使用特殊 Java类加载器来强制执行。

在一般Java应用程序中，CLASSPATH中的所有类都对所有其他类可见。相反，OSGi类加载器基于OSGi规范和每个绑定包的manifest.mf文件中指定的选项来限制类交互。

在3.1之前版本的Eclipse中，在每个插件的plugin.xml文件中定义插件依赖关系以及扩展和扩展点。在使用OSGi的新版本Eclipse中，依赖关系信息被分解到manifest.mf文件中，而 plugin.xml文件只包含扩展和扩展点的XML定义。

插件级的依赖关系改为需要显式导出和导入包的依赖关系。插件开发人员必须进行专门选择来使插件中的功能可供外部使用。该限制允许内部包保留在内部，避免插件暴露不必要的类。

Eclipse的扩展和扩展点 可插拔

每一个希望被别的模块扩展的模块，都必须声明一系列的扩展点，即插座；希望在这个模块上扩展功能的模块，需要按照扩展点的什么来编写扩展，即插头。扩展点提供服务，扩展是要服务。

延迟装载，只有在一个插件被其他模块调用的时候，才装载到内存中。

通过将扩展的声明和实现分离，eclipse实现类延迟装载。

扩展点和扩展的声明都是通过XML文件完成的，即清单文件MANIFEST.MF，描述了一个插件能够做什么，而JAVA代码则具体完成这些功能。系统启动时，只需搜索清单文件，建立一张索引表，知道有哪些插件以及能够提供什么服务。当eclipse第一次启动时，eclipse运行时会遍历plugins文件夹中的目录，扫描每个插件的清单文件信息，并建立一个内部模型来记录它所找到的每个插件的信息。

RCP包括基于OSGi的运行时框架Equniox，基于SWT/JFace的图形模块，eclipse平台的UI和Runtime模块。基于Eclipse的应用程序所需的最小插件集称为Eclipse Rich Client Platform（RCP）

Platform Runtime 平台运行库是内核，它在启动时检查已安装了哪些插件，并创建关于它们的注册表信息。即在eclipse运行时发现和管理插件。为降低启动时间和资源使用，它在实际需要任何插件时才加载该插件。除了内核外，其他每样东西都是作为插件来实现的。

Workspace 工作区是负责管理用户资源的插件。这包括用户创建的项目、那些项目中的文件，以及文件变更和其他资源。工作区还负责通知其他插件关于资源变更的信息，比如文件创建、删除或更改。

Workbench 工作台为Eclipse提供用户界面。它是使用标准窗口工具包（SWT）和一个更高级的 API（JFace）来构建的；SWT 是 Java 的 Swing/AWT GUI API 的非标准替代者，JFace 则建立在 SWT 基础上，提供用户界面组件。

插件可以扮演双重角色，其他插件服务的使用者和其他插件服务的提供者。

manifest.mf

Bundle-Activator

该类用于启动和停止绑定包。该类扩展 org.eclipse.core.runtime.Plugin，实现了 BundleActivator 接口。

Bundle-Version

该属性指定绑定包的版本号。包导入和必需的绑定包规范可以包括绑定包版本号。

Export-Package

该属性指定要公共暴露给其他插件的所有包。

Import-Package

该属性指定要从必需插件中显式导入的所有包。默认情况下，必须为要启动的绑定包解析所有包。还可以将包导入指定为可选项，以支持包不存在的情况。显式导入的类在 Require-Bundle 插件中的包之前解析。

Require-Bundle

该属性指定要在给定绑定包中导入使用的绑定包及其已导出的包。指定的绑定包在显式包导入之后解析。

----------------------            --------------------
|plugin A            |            |plugin B          |
|   ---------------  | contibute  |  --------------  |
|   | ext point p | <--------------- | extension  |  |
|   ---------------  |_           |  --------------  |
|         ||         | |          |        ||        |
|   ---------------  | |implement |  --------------  |
|   | interface I | <--|------------ | class  C   |  |
|   ---------------  | |          |  --------------  |
---------------------- |          ----------/ -------
                       |  create, call       |
                       ----------------------|

你可以把extension point想为接口, 而我们扩展这些extension,其实就是实现了这个接口

假设plugin A定义了一个extension point,  plugin B定义了一个extension,是基于plugin A的这个extension point的,它的实现类是class C,那eclipse启动后, 会读取每个plugin的配置plugin.xml,然后发现plugin B有一个基于ext point p的扩展,那它就会用interface I作为对象, 然后实例化一个class C, 就等于实现了这个extension

eclipse的内部实现
IPluginRegistry registry = Platform.getPluginRegistry();
IExtensionPoint extensionPoint = registry.getExtensionPoint(xpid); //通过扩展点ID获得扩展点
IExtension[] extensions = extensionPoint.getExtensions(); //获得该扩展点的所有扩展
// For each extension ...
for (int i = 0; i < extensions.length; i++) {
    IExtension extension = extensions[i];
    IConfigurationElement[] elements = extension.getConfigurationElements(); //获得扩展点配置元素
    configurationElement[j].createExecutableExtension(“Class”); //为每个回调对象创建实例

    ……
}
eclipse就是注册每一个extension和extension point，然后用extension point来实例化它对应的那个extension。

发生事件并向其它对象请求处理的对象被称为“事件对象”，而处理事件的对象被称为“回调对象”。回调对象由扩展者插件定义，由宿主插件创建实例。