如果你读过我在我的 blog 里写的 abstract 方法总结的话，获取会对接口会接受的更快些。因为他们之间有一定的联系，同是抽象出一个方法（接口是抽象一个标准方法），让继承 / 使用的类去定义这种方法。不同的是，如果使用接口的方法，就必须在使用接口的类中全部把他定义出来，因为类使用了一个标准，就必须遵守这个标准。

还是介绍一下接口，接口是用 interface 来定义的，和类一样，可以有成员，有方法，不过，它的方法不能被定义。缺省的修饰符是 public abstract , 接口可以向类一样继承，例如

interface f1{

         void deMethod();  // public and abstract;

         public abstract void deMethod1(); // public and abstract

}

interface f2 extends f1{

         void deMethod2();

}

继承后接口 f2 就含有 3 个标准

void deMethod();

void deMethod1();

void deMethod2();

使用接口的时候用 implements . 使用了接口的类，不得将定义的方法访问控制低于接口的访问控制，接口的方法不能为 native,static,final,synchronized,priavte,protected. 所以使用接口的类一般控制访问应该设为 public.

可能你还不了解 “标准”。下面我将以一个简单的例子来做解答

电脑里的有显卡，主板，显示器， CPU 等，为什么他们可以由几个不同的厂商生产呢？其实就是因为在他们生产之间准备一种标准，让彼此只要遵守这个标准就 OK 拉，显示器厂商不会去关心 CPU 是什么型号，他只管接收显卡发射的图像并让自己显示出来就可以了，显卡同样不会去关心主板是谁生产的，它只遵守把能插在主板上并把用户的图像显示出去就可以了，于是大家干活起来越来越轻松，这就是标准带来的好处。

我们来定义一个显卡，一个主板。你将可以看到接口使用的好处

interface Video{        // 定义一个简单的显卡标准，主要负责显示和获得显卡厂家名字

         void display();

         String getName();

}

class VideoCard implements Video{   // 使用这个标准来定义

         private String name;

         public void display(){

                   System.out.println("VideoCard Working....");

         }

         public String getName(){

                   return name;

         }

         public void setName(String name){

                   this.name = name;

         }

}

class MainBoard{

         Video v;// 主板组合一个显卡标准

         void setVideoCard(Video v){

                   this.v = v;

         }

         void run(){     // 主板运行

                   v.display();// 由于显卡标准规定，主板调用显卡标准的输出方法

                   System.out.println("VideoCard is " + v.getName());// 由于显卡标准规定，主板调用显卡获取名字方法

                   System.out.println("mainBoard Working...");

         }

}

public class Computer{ // 配置一台电脑

         public static void main(String [] args){

                   VideoCard v = new VideoCard();  // 买一块显卡

                   v.setName(" 创新显卡 ");

                   MainBoard m = new MainBoard();

                   m.setVideoCard(v);// 装到主板上

                   m.run();

         }

}

这么一来。接口的作用得到充分利用。

抽象的类是不可实例化的例如

public abstract class Test{

}

他可以含有抽象的方法

public abstract class Test{

       public abstract void defMethod();

}

抽象的方法是要让子类继承下去再定义它的，让抽象的概念得以设计。例如当一种面向对象设计遇到一种方法有多种设计的时候，可以在基类暂且不设计他，把设计的工作交给子类去完成，但子类设计时，要么继续继承他超类的抽象概念，要么就把抽象的方法定义出来。

例如

abstract class Test2 extends Test{

       ……..

}

仍然不定义超类的抽象方法，继续把这种抽象概念交给 Test2 的子类去完成。

class Test2 extends Test{

       public void deMethod(){

}

}

继承 Test, 让抽象的概念得到设计。虽然在 {} 里没有任何语句，但这也表示我们为他做了一种设计，一种什么也不做的定义。如果要定义可以写在 {} 里。

总结：

在类中没有方法体的方法，就是抽象的方法。

含有抽象方法的类，即为抽象类。

如果一个子类没有实现抽象基类中所有的抽象方法，则子类也可以成为一个抽象的类。

我们可以将一个没有任何抽象方法的类声明为 abstract, 避免由这个类产生任何的对象。

今天小试了一下数据结构，感受颇深。

Vector 类
适合传统的数组。特点：无须在创建的时候设计特定大小。自动增加和减小。通过索引来获得对象，类似String类摸板。利用空间交换实现动态连续内存空间。

Stack 类
C++标准的堆栈先进后出列应用。

Disctionary
一个抽象类，利用键值与数据进行关联。访问通过键值来获得相应的存储对象，因为它是抽象类，所以只是一个消息映射框架。

BitSet 类
这个类很有用。它存储的是boolean类型值。按位来提取位值。只需要使用索引来引用每一位。优点：自动增大。
例如：
创建一个4布尔位字段位组    BitSet  conbit = new BitSet(4),在构造函数里申请4个boolean数组,利用JAVA默认的变量初始化。4个boolean数组全部为false,在利用BitSet类的set(int )方法修改相应位组的值为true;
例如修改位组2为true:
conbit.set(2);
获得位组大小:
conbit.size();//返回一个int型
在通过get(int) 方法获得逻辑值:
boolean flag = conbit.get(2);
System.out.println("the array's size is " + conbit.size() + " b[2] value is " + conbit.get(2));

Vertor 类
实现了可扩展的对象数组，必须解决新元素加入时，什么时候进行扩展和扩展多少。（说来说去就是Oracle的数据库分配问题。库容量绝对不能小于数据库当前容量大小。它必须进行时刻的空间划分。以便存储更多数据，这种空间增长值都是用户自定义和系统默认的）
新术语：向量的大小（size）指它当前存储元素的数目；向量的容量（capacity）是被分配来存储元素的内存量，他总是大于或等于向量的大小。

构造函数
Vertor v = new Vertor(10);            一次分配足够的内存空间。以支持10个元素。但是如果要超过10个元素的话可以使用下面的构造函数

Vertor v = new Vertor(10,5);       首先分配10个元素的内存空间，等存储10个元素后有新元素要加入时。将自动申请5个元素空间。增长值越小，内存管理的效率越大，但每次执行的开销越大。增长值越大，执行开销减小，但多的空间使得内存浪费。

申请好元素空间后利用add方法将元素加入到向量里去。
v.add("Tiwen");

lastElement()方法可以检索最后一个加入的字符串；get(int)方法通过索引来返回字符串。
String s = (String)v.get(0);  Vertor设计是处理Object类。返回类型时要强制转换

添加/插入方法  add(int,String)  int为要添加/插入字符串索引号。如果当前 v 存储了3个字符串，现在要执行 v.add(0,"new");   原先的3个字符串将全部在向量数组里后移一位。让字符串 "new" 成为第一个。

删除 remove(int)  通过索引号来对向量进行删除,全部删除可以使用 clear() 方法

修改 set(int,String) 通过索引号来修改指定的字符串

查找
1，以字符串形式查找
v.contains("Tiwen")  它将返回一个boolean值。true 存在，false 不存在
2，返回一个索引号
v.indexOf("Tiwen")     返回一个int值 ， -1 表示不存在
3，索引号
v.get(int)   返回当前索引的字符串

修改位组大小
v.setSize(int)   如果要修改的大小大于 v 现有元素大小将申请多的空间，如果小于将释放掉 v 多出来的元素

前面提到的空间容量总是会大于或等于存储容量，如果想在空间容量完全等于实际存储容量情况下可以使用trimToSzie()来截掉多的没有使用的空间

查看容量
capacity()  将返回一个int值

堆栈 Stack类
继续沿袭C++先进后出的存储方式，美国西部牛仔，通常使用左轮手枪，可以把枪膛当作一个空栈，装子弹时总是最后装的一棵子弹最先被发射出去，而最先装的子弹是最后一个发射出去，堆栈的设计就是这样的运作模式。

首先打开一个空的枪膛
Stack s = new Stack();

开始给枪膛装入子弹(push方法是添加)
s.push("one");
s.push("two");
s.push("three");
s.push("four");
s.push("five");

好的，开两枪吧(这个类也是把元素作为Object对象处理，要实行强制转换)
String s1 = (String)s.pop();
String s2 = (String)s.pop();
s1 is five
s2 is four

枪膛里少了2个子弹,这就是先进后出的方式。
注意最外一个也就是最后一个加入的字符串的位置编号始终是0，位置号是从这里开始计算的

peek() 方法可以访问到栈底第一元素的值，但元素不出列,这个函数也要强制转换

search(String) 返回一个要查找的字符串在栈中存放的位置号。这个位置号是从栈顶（最外层）开始计算的。

empty() 判断栈是否为空，返回一个boolean值

哈希表 Hashtable 类
它是一个从Dictionary派生而来的，实现了接口Map，特点：利用字符串作为键值，与另一组对象关联。达到一种消息映射。
与向量一样，哈希表也有容量（分配的内存量），哈希表通过表的当前大小同容量和负载系数的乘积进行比较来分配内存，如果哈希表的大小超过了这个乘积，哈希表将通过重新散列（rehash）来增加容量。
构造函数
1，默认构造函数
Hashtable hash = new Hashtable();

2，指定容量构造
Hashtable hash = new Hashtable(20);

3，指定容量和负载系数的构造
Hashtable hash  = new Hashtable(20,0.6F);//负载数在0.0-1.0

清除元素
clear() 可以清楚掉实例的哈希表的所有键值和关联对象

添加
put(String,Object)   String 提供一个键值名称，Object是关联的对象

对象查找
hash.contains(Object)   返回一个boolean值。
键值查找
hash.contains(String)  返回一个boolean值。

当哈希表需要增大空间容量时会进行散列。散列会获得多的空间容量，这都跟它的存储方式有关
hash.rehash();