pedestrian_I

最近忙一些琐事，一度将scjp抛到脑后，着实不该。速战速决。
今天复习一下java的一些高级语言特性……
1、static变量、方法是针对类而言，而不是对象。注意要在外部调用必须是public，而不是private，小心这个陷阱。

2、非静态变量只限于实例，并只能通过实例引用被访问。也就是说static方法中不能调用非static变量。

3、静态初始化程序
在static block中，类可以包含方法程序中不存在的代码。当类被装载时，静态代码块只执行一次。
static{}

4、static综合例子一个

1．	class MyClass {
2．	  static int statInt = 4;
3．	  static Double statDouble = 16.0;
4．	  int instInt;
5．	  double instDouble;
6．	
7．	  public static void statMethod(){
8．	    System.out.println ("statInt="+statInt+ 
9．	        ";statdouble="+statDouble);
10．	} 
11．	public void instMethod(){ 
12．	  System.out.println("instInt="+instInt+ 
13．	    ";instdouble="+instDouble); 
14．	} 
15．	public MyClass(int intArg, double doubleArg){
16．	  instInt = intArg;
17．	  instDouble = doubleArg;
18．	} 
19．	public static void main(String args[]){
20．	  MyClass instance1 = new MyClass(1,2.0);
21．	  MyClass instance2 = new MyClass(3,4.0);
22．	  
23．	  MyClass.statMethod(); //Outputs:statInt=4;
24．	         //statDouble=16.0
25．	
26．	  instance1.instMethod(); //Outputs:instInt=1; 
27．	        //instDouble=2.0 
28．	  instance1.statMethod(); //Outputs:statInt=4;
29．	        //statDouble=16.0 
30．	  
31．	  instance2.instMethod(); //Outputs:instInt=3;
32．	        //instDouble=4.0 
33．	  instance2.statMethod(); //Outputs:statInt=4;
34．	        //statDouble=16.0 
35．	}
36．	} 

5、关键字final
Final类不能被分成子类
Final方法不能被覆盖
Final变量是常数

6、被声明为final的方法有时被用于优化。编译器能产生直接对方法调用的代码，而不是通常的涉及运行时查找的虚拟方法调用。
被标记为static或private的方法被自动地final，因为动态联编在上述两种情况下都不能应用。

7、如果变量被标记为final，其结果是使它成为常数。想改变final变量的值会导致一个编译错误。
如果将引用类型（即，任何类的类型）的变量标记为final，那么该变量不能指向任何其它对象。但可能改变对象的内容，因为只有引用本身是final。

8、抽象类
声明方法的存在而不去实现它的类被叫做抽象类
可以通过关键字abstract进行标记将类声明为抽象

     public abstract class Drawing {
           public abstract void drawDot(int x, int y);
           public void drawLine(int x1, int y1,
                               int x2, int y2) {
             // draw using the drawDot() method repeatedly.
           }
         }

一个abstract类可以包含非抽象方法和变量
声明方法的存在而不是实现，以及带有对已知行为的方法的实现，这样的类通常被称做抽象类。通过用关键字abstract进行标记声明一个抽象类。被声明但没有实现的方法（即，这些没有程序体或{}），也必须标记为抽象。

9、不能创建abstract类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。
Abstract类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。

10、接口
接口是抽象类的变体。
在接口中，所有方法都是抽象的。
多继承性可通过实现这样的接口而获得。
句法是：

           public interface Transparency {
             public static final int OPAQUE=1;
             public static final int BITMASK=2;
             public static final int TRANSLUCENT=3;

             public int getTransparency();
           }

接口是抽象类的变体。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。

11、对于下述情况，接口是有用的：
声明方法，期望一个或更多的类来实现该方法。
揭示一个对象的编程接口，而不揭示类的实际程序体。（当将类的一个包输送到其它开发程序中时它是非常有用的。）
捕获无关类之间的相似性，而不强迫类关系。
描述“似函数”对象，它可以作为参数被传递到在其它对象上调用的方法中。它们是“函数指针”（用在C和C++中）用法的一个安全的替代用法。

12、高级访问控制
没有其他，记住这个表就OK了。
修饰符 同类 同包 子类 通用性
公共 是 是 是 是
受保护 是 是 是
缺省 是 是
私有 是

13、降 级
降级就是过时的构造函数和方法调用。
过时的方法和构造函数由具有更标准化的命名规则的方法所取代。
当升迁代码时，用-deprecation标志来编译代码：
javac -deprecation MyFile.java

14、==运算符与equals()方法
这个应该是说的最多的一个
equals()和==方法决定引用值是否指向同一对象
equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

15、toString()方法
被用来将一个对象转换成String
被用来将一个基本类型转换成String
对象类定义缺省的toString()方法，它返回类名称和它的引用的地址（通常情况下不是很有用）。许多类覆盖toString()以提供更有用的信息。例如，所有的包装类覆盖toString()以提供它们所代表的值的字符串格式。甚至没有字符串格式的类为了调试目的常常实现toString()来返回对象状态信息。

16、内部类
允许一个类定义被放到另一个类定义里
把类在逻辑上组织在一起
可访问它们所嵌套的类的范围

17、为什么需要内部类？
java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。
一个内部类的对象能够访问创建它的对象的实现――包括私有数据；
对于同一个包中的其他类来说，内部类能够隐藏起来；
匿名内部类可以很方便地定义回调；
使用内部类可以非常方便地编写事件驱动的程序。

18、内部类属性
类名称只能用在定义过的范围中，除非用限定的名称。
内部类的名称必须与所嵌套的类不同。
内部类可以被定义在方法中。
任何变量，不论是本地变量还是正式参数，如果变量被标记为final，那么，就可以被内部类中的方法访问。
内部类可以被定义为abstract。
只有内部类可以被声明为private或protected，以便防护它们不受来自外部类的访问。访问保护不阻止内部类使用其它类的任何成员，只要一个类嵌套另一个。
一个内部类可以作为一个接口，由另一个内部类实现。
被自动地声明为static的内部类成为顶层类。这些内部类失去了在本地范围和其它内部类中使用数据或变量的能力。
内部类不能声明任何static成员；只有顶层类可以声明static成员。因此，一个需求static成员的内部类必须使用来自顶层类的成员。
内部类有常常被用作创建事件适配器的方便特征。

19、包装类
用来将基本数据元素看作对象，包装类可以被用作：
基本数据类型 包装类
boolean Boolean
byte Byte
char Char
short Short
int Int
long Long
float Float
double Double
Java编程语言不把基本数据类型看作对象。例如，在基本格式本身当中，数字、布尔及字符型数据都被看作是为了提高效率。Java编程语言提供包装类来将基本数据元素看作对象。这样的数据元素被包裹在创建于它们周围的对象中，每个Java基本数据类型在Java.lang包中都有一个相应的wrapper class。每个包装类对象封装一个基本值。
可以通过将被包裹的值传递到合适的构造函数中来构造包装类对象。例如：
int pInt = 500;
Integer wInt = new Integer(pInt);

20、收集API
收集（或容器）是代表一个对象组的单个对象，被认为是它的元素。
收集类Vector,Bits,Stack,Hashtable,LinkedList等等都被支持。
收集API包括将对象保持为下述情况的界面：
收集-没有具体顺序的一组对象
设定-没有复制的一组对象
列表-有序对象组，允许复制

21、反射API
可以用作
构造新类实例和新数组
访问并修改对象和类的字段
调用对象和类中的方法
访问并修改数组的元素
只要安全策略允许，这些操作是可能的。在需要运行时检索并处理信息的情况下，反射API是有用的。例如，如果正在编写一个Java软件解释程序或调试程序，可以使用它。

22、反射API特征
定义类和方法的核心反射API的主要特征如下：
Java.lang.Class类提供方法，该方法可获得有关类及其字段、构造函数以及方法的信息。
Java.lang.reflect.Field提供方法，该方法设定/获得有关类中的字段的信息。
Java.lang.reflect.Method提供方法，该方法访问并调用类中的方法，并获得它们的签名。
Java.lang.reflect.Array能使数组对象自省。
Java.lang.reflect.Constructor提供反射访问到构造函数。

23、反射API安全模型
Java安全管理器一个类接一个类地控制对核心API的访问。
当下述情况发生时，标准的Java编程语言访问控制得到加强：
Field被用来获得或设定一个字段值
Method被用来调用一个方法
Constructor被用来创建并初始化一个新的类的实例