finalize() 方法

Java允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做finalize( )，它用来清除回收对象。

例如，你可以使用finalize()来确保一个对象打开的文件被关闭了。

在finalize()方法里，你必须指定在对象销毁时候要执行的操作。

finalize()一般格式是：

protected void finalize()
{
   // 在这里终结代码
}

关键字protected是一个限定符，它确保finalize() 方法不会被该类以外的代码调用。

当然，Java的内存回收可以由JVM来自动完成。如果你手动使用，则可以使用上面的方法。

读写文件

如前所述，一个流被定义为一个数据序列。输入流用于从源读取数据，输出流用于向目标写数据。

下图是一个描述输入流和输出流的类层次图。

读取控制台输入

BufferedReader br = new BufferedReader(new 
                      InputStreamReader(System.in));

从控制台读取多字符输入
从BufferedReader对象读取一个字符要使用read()方法，它的语法如下：
int read( ) throws IOException

从控制台读取字符串

从标准输入读取一个字符串需要使用BufferedReader的readLine()方法。

它的一般格式是：

String readLine( ) throws IOException

void write(int byteval)

三种类型的异常：

• 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
• 运行时异常： 运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
• 错误： 错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

• Exception类的层次

  
  

  捕获异常

  使用try和catch关键字可以捕获异常。try/catch代码块放在异常可能发生的地方。

  try/catch代码块中的代码称为保护代码，

  
  

  多重捕获块

  一个try代码块后面跟随多个catch代码块的情况就叫多重捕获。

  多重捕获块的语法如下所示：

   try{
      // 程序代码
   }catch(异常类型1 异常的变量名1){
      // 程序代码
   }catch(异常类型2 异常的变量名2){
      // 程序代码
   }catch(异常类型2 异常的变量名2){
      // 程序代码
   }

  来源： <http://www.w3cschool.cc/java/java-exceptions.html>

  Java 继承

  继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。

  如果类A是类B的父类，而类B是类C的父类，我们也称C是A的子类，类C是从类A继承而来的。在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类 

• 继承中最常使用的两个关键字是extends和implements。

  这两个关键字的使用决定了一个对象和另一个对象是否是IS-A(是一个)关系。

  通过使用这两个关键字，我们能实现一个对象获取另一个对象的属性。

  所有Java的类均是由java.lang.Object类继承而来的，所以Object是所有类的祖先类，而除了Object外，所有类必须有一个父类。

  通过过extends关键字可以申明一个类是继承另外一个类而来的，

  HAS-A 关系

  HAS-A代表类和它的成员之间的从属关系。这有助于代码的重用和减少代码的错误。

  例子

  public class Vehicle{}
  public class Speed{}
  public class Van extends Vehicle{
  	private Speed sp;
  } 

  Van类和Speed类是HAS-A关系(Van有一个Speed)，这样就不用将Speed类的全部代码粘贴到Van类中了，并且Speed类也可以重复利用于多个应用程序。

  在面向对象特性中，用户不必担心类的内部怎样实现。

  Van类将实现的细节对用户隐藏起来，因此，用户只需要知道怎样调用Van类来完成某一功能，而不必知道Van类是自己来做还是调用其他类来做这些工作。

  Java只支持单继承，也就是说，一个类不能继承多个类。

  Java只支持单继承（继承基本类和抽象类），但是我们可以用接口来实现（多继承接口来实现）,脚本结构如：

  public class Apple extends Fruit implements Fruit1, Fruit2{}

  来源： <http://www.w3cschool.cc/java/java-inheritance.html>
   

  重写(Override)

  重写是子类对父类的允许访问的方法的实现过程进行重新编写！返回值和形参都不能改变。即外壳不变，核心重写！

  重写的好处在于子类可以根据需要，定义特定于自己的行为。

  也就是说子类能够根据需要实现父类的方法。

  自己小结：也就是说，父类有的东西，子类可以有可以没有；如果animal b=new dog,b引用的bark方法只存在子类而不存在父类，那么就会报异常。

  Super关键字的使用

  当需要在子类中调用父类的被重写方法时，要使用super关键字。

  重载(Overload)

  重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。

  每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

  只能重载构造函数

  重写与重载之间的区别

  区别点	重载方法	重写方法
  参数列表	必须修改	一定不能修改
  返回类型	可以修改	一定不能修改
  异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
  访问	可以修改	一定不能做更严格的限制（可以降低限制）

  
  

• Java 多态

  ---

  多态是同一个行为具有多个不同表现形式或形态的能力。

  多态性是对象多种表现形式的体现。

  比如我们说"宠物"这个对象，它就有很多不同的表达或实现，比如有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物"，服务员给我小猫、小狗或者蜥蜴都可以，我们就说"宠物"这个对象就具备多态性。

  java 封装

  ---

  在面向对象程式设计方法中，封装（英语：Encapsulation）是指，一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。

  封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

  要访问该类的代码和数据，必须通过严格的接口控制。

  封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

  适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

  
  
  来源： <http://www.w3cschool.cc/java/java-encapsulation.html>
   

  Java 接口

  ---

  接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

  接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

  除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

  接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在Java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

  接口与类相似点：

  • 一个接口可以有多个方法。
  • 接口文件保存在.java结尾的文件中，文件名使用接口名。
  • 接口的字节码文件保存在.class结尾的文件中。
  • 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
  接口与类的区别：
  
  • 接口不能用于实例化对象。
  • 接口没有构造方法。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量，除了static和final变量。
  • 接口不是被类继承了，而是要被类实现。
  • 接口支持多重继承。
  • 
    
    来源： <http://www.w3cschool.cc/java/java-interfaces.html>
     

    接口的实现

    当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

    类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

    接口的继承

    一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

    标记接口

    最常用的继承接口是没有包含任何方法的接口。

    标识接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

    标识接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

    Java Bitset类

    一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。这和位向量（vector of bits）比较类似。

    这是一个传统的类，但它在Java 2中被完全重新设计。

    BitSet定义了两个构造方法。

    第一个构造方法创建一个默认的对象：

    BitSet()

    第二个方法允许用户指定初始大小。所有位初始化为0。

    
    BitSet(int size)

    BitSet中实现了Cloneable接口中定义的方法如下表所列：

    序号	方法描述
    1	void and(BitSet bitSet) 对此目标位 set 和参数位 set 执行逻辑与操作。
    2	void andNot(BitSet bitSet) 清除此 BitSet 中所有的位，其相应的位在指定的 BitSet 中已设置。
    3	int cardinality( ) 返回此 BitSet 中设置为 true 的位数。
    4	void clear( ) 将此 BitSet 中的所有位设置为 false。
    5	void clear(int index) 将索引指定处的位设置为 false。
    6	void clear(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 false。
    7	Object clone( ) 复制此 BitSet，生成一个与之相等的新 BitSet。
    8	boolean equals(Object bitSet) 将此对象与指定的对象进行比较。
    9	void flip(int index) 将指定索引处的位设置为其当前值的补码。
    10	void flip(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的每个位设置为其当前值的补码。
    11	boolean get(int index) 返回指定索引处的位值。
    12	BitSet get(int startIndex, int endIndex) 返回一个新的 BitSet，它由此 BitSet 中从 fromIndex（包括）到 toIndex（不包括）范围内的位组成。
    13	int hashCode( ) 返回此位 set 的哈希码值。
    14	boolean intersects(BitSet bitSet) 如果指定的 BitSet 中有设置为 true 的位，并且在此 BitSet 中也将其设置为 true，则返回 ture。
    15	boolean isEmpty( ) 如果此 BitSet 中没有包含任何设置为 true 的位，则返回 ture。
    16	int length( ) 返回此 BitSet 的"逻辑大小"：BitSet 中最高设置位的索引加 1。
    17	int nextClearBit(int startIndex) 返回第一个设置为 false 的位的索引，这发生在指定的起始索引或之后的索引上。
    18	int nextSetBit(int startIndex) 返回第一个设置为 true 的位的索引，这发生在指定的起始索引或之后的索引上。
    19	void or(BitSet bitSet) 对此位 set 和位 set 参数执行逻辑或操作。
    20	void set(int index) 将指定索引处的位设置为 true。
    21	void set(int index, boolean v)  将指定索引处的位设置为指定的值。
    22	void set(int startIndex, int endIndex) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为 true。
    23	void set(int startIndex, int endIndex, boolean v) 将指定的 fromIndex（包括）到指定的 toIndex（不包括）范围内的位设置为指定的值。
    24	int size( ) 返回此 BitSet 表示位值时实际使用空间的位数。
    25	String toString( ) 返回此位 set 的字符串表示形式。
    26	void xor(BitSet bitSet) 对此位 set 和位 set 参数执行逻辑异或操作。 来源： <http://www.w3cschool.cc/java/java-bitset-class.html>

    
    

    Java Vector 类

    Vector类实现了一个动态数组。和ArrayList和相似，但是两者是不同的：

    • Vector是同步访问的。
    • Vector包含了许多传统的方法，这些方法不属于集合框架。

    Vector主要用在事先不知道数组的大小，或者只是需要一个可以改变大小的数组的情况。

    Vector类支持4种构造方法。

    第一种构造方法创建一个默认的向量，默认大小为10：

    Vector()

    第二种构造方法创建指定大小的向量。

    Vector(int size)

    第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目。

    Vector(int size,int incr)

    第四中构造方法创建一个包含集合c元素的向量：

    Vector(Collection c)

    实例

    下面的程序说明这个集合所支持的几种方法：

    import java.util.*;
    
    public class VectorDemo {
    
       public static void main(String args[]) {
          // initial size is 3, increment is 2
          Vector v = new Vector(3, 2);
          System.out.println("Initial size: " + v.size());
          System.out.println("Initial capacity: " +
          v.capacity());
          v.addElement(new Integer(1));
          v.addElement(new Integer(2));
          v.addElement(new Integer(3));
          v.addElement(new Integer(4));
          System.out.println("Capacity after four additions: " +
              v.capacity());
    
          v.addElement(new Double(5.45));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Double(6.08));
          v.addElement(new Integer(7));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Float(9.4));
          v.addElement(new Integer(10));
          System.out.println("Current capacity: " +
          v.capacity());
          v.addElement(new Integer(11));
          v.addElement(new Integer(12));
          System.out.println("First element: " +
             (Integer)v.firstElement());
          System.out.println("Last element: " +
             (Integer)v.lastElement());
          if(v.contains(new Integer(3)))
             System.out.println("Vector contains 3.");
          // enumerate the elements in the vector.
          Enumeration vEnum = v.elements();
          System.out.println("\nElements in vector:");
          while(vEnum.hasMoreElements())
             System.out.print(vEnum.nextElement() + " ");
          System.out.println();
       }
    }

    以上实例编译运行结果如下：

    Initial size: 0
    Initial capacity: 3
    Capacity after four additions: 5
    Current capacity: 5
    Current capacity: 7
    Current capacity: 9
    First element: 1
    Last element: 12
    Vector contains 3.
    
    Elements in vector:
    1 2 3 4 5.45 6.08 7 9.4 10 11 12

    来源： <http://www.w3cschool.cc/java/java-vector-class.html>
     

    Java Stack 类

    栈是Vector的一个子类，它实现了一个标准的后进先出的栈。

    堆栈只定义了默认构造函数，用来创建一个空栈。 堆栈除了包括由Vector定义的所有方法，也定义了自己的一些方法。

    Stack()

    除了由Vector定义的所有方法，自己也定义了一些方法：

    序号	方法描述
    1	boolean empty()  测试堆栈是否为空。
    2	Object peek( ) 查看堆栈顶部的对象，但不从堆栈中移除它。
    3	Object pop( ) 移除堆栈顶部的对象，并作为此函数的值返回该对象。
    4	Object push(Object element) 把项压入堆栈顶部。
    5	int search(Object element) 返回对象在堆栈中的位置，以 1 为基数。

    实例

    下面的程序说明这个集合所支持的几种方法

    import java.util.*;
    
    public class StackDemo {
    
       static void showpush(Stack st, int a) {
          st.push(new Integer(a));
          System.out.println("push(" + a + ")");
          System.out.println("stack: " + st);
       }
    
       static void showpop(Stack st) {
          System.out.print("pop -> ");
          Integer a = (Integer) st.pop();
          System.out.println(a);
          System.out.println("stack: " + st);
       }
    
       public static void main(String args[]) {
          Stack st = new Stack();
          System.out.println("stack: " + st);
          showpush(st, 42);
          showpush(st, 66);
          showpush(st, 99);
          showpop(st);
          showpop(st);
          showpop(st);
          try {
             showpop(st);
          } catch (EmptyStackException e) {
             System.out.println("empty stack");
          }
       }
    }

    以上实例编译运行结果如下：

    stack: [ ]
    push(42)
    stack: [42]
    push(66)
    stack: [42, 66]
    push(99)
    stack: [42, 66, 99]
    pop -> 99
    stack: [42, 66]
    pop -> 66
    stack: [42]
    pop -> 42
    stack: [ ]
    pop -> empty stack

    
    
    来源： <http://www.w3cschool.cc/java/java-stack-class.html>

    Java Map 接口

    Map接口中键和值一一映射. 可以通过键来获取值。

    • 给定一个键和一个值，你可以将该值存储在一个Map对象. 之后，你可以通过键来访问对应的值。
    • 当访问的值不存在的时候，方法就会抛出一个NoSuchElementException异常.
    • 当对象的类型和Map里元素类型不兼容的时候，就会抛出一个 ClassCastException异常。
    • 当在不允许使用Null对象的Map中使用Null对象，会抛出一个NullPointerException 异常。
    • 当尝试修改一个只读的Map时，会抛出一个UnsupportedOperationException异常。

    序号	方法描述
    1	void clear( )  从此映射中移除所有映射关系（可选操作）。
    2	boolean containsKey(Object k) 如果此映射包含指定键的映射关系，则返回 true。
    3	boolean containsValue(Object v) 如果此映射将一个或多个键映射到指定值，则返回 true。
    4	Set entrySet( ) 返回此映射中包含的映射关系的 Set 视图。
    5	boolean equals(Object obj) 比较指定的对象与此映射是否相等。
    6	Object get(Object k) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
    7	int hashCode( ) 返回此映射的哈希码值。
    8	boolean isEmpty( ) 如果此映射未包含键-值映射关系，则返回 true。
    9	Set keySet( ) 返回此映射中包含的键的 Set 视图。
    10	Object put(Object k, Object v) 将指定的值与此映射中的指定键关联（可选操作）。
    11	void putAll(Map m) 从指定映射中将所有映射关系复制到此映射中（可选操作）。
    12	Object remove(Object k) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
    13	int size( ) 返回此映射中的键-值映射关系数。
    14	Collection values( ) 返回此映射中包含的值的 Collection 视图。 来源： <http://www.w3cschool.cc/java/java-map-interface.html>

    
    

    Java Properties 接口

    Properties 继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。

    Properties 类被许多Java类使用。例如，在获取环境变量时它就作为System.getProperties()方法的返回值。

    Properties 定义如下实例变量.这个变量持有一个Properties对象相关的默认属性列表。

    Properties defaults;

    Properties类定义了两个构造方法. 第一个构造方法没有默认值。

    Properties()

    第二个构造方法使用propDefault 作为默认值。两种情况下，属性列表都为空：

    Properties(Properties propDefault)

    除了从Hashtable中所定义的方法，Properties定义了以下方法：

    序号	方法描述
    1	String getProperty(String key)  用指定的键在此属性列表中搜索属性。
    2	String getProperty(String key, String defaultProperty) 用指定的键在属性列表中搜索属性。
    3	void list(PrintStream streamOut)  将属性列表输出到指定的输出流。
    4	void list(PrintWriter streamOut) 将属性列表输出到指定的输出流。
    5	void load(InputStream streamIn) throws IOException  从输入流中读取属性列表（键和元素对）。
    6	Enumeration propertyNames( ) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
    7	Object setProperty(String key, String value)  调用 Hashtable 的方法 put。
    8	void store(OutputStream streamOut, String description)  以适合使用  load(InputStream)方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。 来源： <http://www.w3cschool.cc/java/java-properties-class.html>