Java简明教程
Java与C++比较概况
| C++ | Java |
|---|---|
class Foo { // 声明 Foo 类 public: int x; // 成员变量 Foo(): x(0) { // Foo 的构造函数Constructor for Foo, } // 初始化 x int bar(int i) { // 成员函数 bar() return 3*i + x; } }; |
class Foo { // 定义类 Foo public int x = 0; // 成员变量, // 以及其值的初始化 public Foo() { // Foo的构造函数 } public int bar(int i) {// 成员方法 bar() return 3*i + x; } } |
Foo a; // 声明 a 为一个 Foo 类的对象值, // 使用其缺省的构造函数 // 如果你想要用其他的构造函数, // 你可以用 "Foo a(args);" |
Foo a; // 声明 a 为一个 Foo 类的对象的引用 a = new Foo(); // 使用缺省的构造函数初始化 // 如果你想要用其他的构造函数, // 你可以用 "Foo a = new Foo(args);" |
Foo b = a; // 拷贝 a 的内容到一个新的 Foo 类的变量 b 当中; // 另一种可以选择的语法是 "Foo b(a)" |
Foo b = a.clone(); // 拷贝所有a这个实例的成员到b,当且仅当, // Foo 实现了一个 public 的 clone() 方法, // 并且 clone() 返回一个新的这个对象的拷贝 |
a.x = 5; // 修改 a 对象 |
a.x = 5; // 修改 a 对象 |
cout << b.x << endl; // 输出 0,因为 b 和 a 是两个对象 |
System.out.println(b.x); // 输出 0,因为 b 和 a 是两个对象 |
Foo *c; // 声明 c 为指向一个 Foo 类对象的指针(初始值是 // 未定义的;可能指向任何地方) |
Foo c; // 声明 c 为一个指向 Foo 对象的指针 // (如果 c 是一个类的成员,那么初始值为空; // 如果 c 是一个局部变量那么你在使用之前必须 // 对它进行初始化) |
c = new Foo(); // 将 c 绑定为一个新的 Foo 对象的引用 |
c = new Foo(); // 将 c 绑定为一个新的 Foo 对象的引用 |
Foo *d = c; // 将 d 绑定为和 c 同一个对象的引用 |
Foo d = c; // 将 d 绑定为和 c 同一个对象的引用 |
c->x = 5; // 修改 c 指向的对象 |
c.x = 5; // 修改 c 指向的对象 |
a.bar(5); // 对 a 调用 Foo::bar() c->bar(5); // 对 *c 调用 Foo::bar() |
a.bar(5); // 对 a 调用 Foo.bar() c.bar(5); // 对 c 调用 Foo.bar() |
cout << d->x << endl; // 输出 5,因为 d 引用的对象和 c 一样 |
System.out.println(d.x); // 输出 5,因为 d 引用的对象和 c 一样 |
-- 来自于wiki - Comparison of Java and C++ en 中文
Java具有如下一些特性：
1. Java中基本数据为值类型，数组、枚举、类、接口均为引用类型。
2. Java中没有全局变量、全局函数、没有struct，没有union，所有东西必须写入类中。
3. Java用包代替了命名空间，用import关键字来导入外部包进行使用。
4. Java所有对象都从Object类单根继承，支持接口多继承。
5. Java没有预处理过程（不存在宏）、没有goto语句、没有指针、没有析构函数，不支持函数缺省参数，不支持运算符重载。
Java基本类型及其包装类
|
boolean [1字节] boolean flag = false; |
Boolean bObj1 = Boolean.TRUE; Boolean bObj2 = new Boolean(false); |
|
char [2字节 16位Unicode] char ch1 = 'a'; char ch2 = '\141'; // 8进制,'a' char ch3 = '\u0061'; // 16进制,'a' char ch4 = '\n'; char ch5 = '中'; |
Character chObj1 = new Character('a'); char ch2 = Character.toUpperCase('b'); |
|
byte [1字节] byte a = 35;
|
Byte.MIN_VALUE - Byte.MAX_VALUE Byte b1 = new Byte("23");
|
|
short [2字节] short a = 870;
|
Short.MIN_VALUE - Short.MAX_VALUE Short s1 = new Short("315");
|
|
int [4字节] int a = 56; // 十进制 int b = 0210; // 八进制 int c = 0x2ff; // 十六进制 |
Integer.MIN_VALUE - Integer.MAX_VALUE Integer intObj = new Integer(56); int intVal = intObj.intValue(); |
|
long [8字节] long m = 356; long n = 86L; |
Long.MIN_VALUE - Long.MAX_VALUE Long s1 = new Long("-98166");
|
|
float [4字节] float f = 3.5f;
|
Float.MIN_VALUE - Float.MAX_VALUE Float.NEGATIVE_INFINITY - Float. POSITIVE_INFINITY 0.0f/0.0f Float.NaN |
|
double [8字节] double d1 = 2.56; double d2 = 2.3e-2 |
Double.MIN_VALUE - Double.MAX_VALUE Double.NEGATIVE_INFINITY- Double. POSITIVE_INFINITY 0.0/0.0 Double.NaN |
基本类型的大小固定，与平台无关，因此Java没有像C++那样提供sizeof关键字来获取类型和对象的大小。
另外，Java不提供无符号的数据类型（unsigned）。
右移位运算符>>>
与逻辑右移位运算符功能类似，只是在左端末尾插入零值。>>则会在移位的同时插入符号位（即算术移位）
int n1 = -1; //n1=0xFFFFFFFF int n2 = n1>>1; //n2=0xFFFFFFFF int n3 = n1>>>1; //n3=0x7FFFFFFF
函数参数传递
Java函数参数没有指针传递、引用传递，只有值传递。
值类型参数会产生一个值类型副本，引用类型参数会产生一个引用类型副本（注意：引用类型间赋值不会产生新的对象，因此不会触发拷贝构造函数调用）
因此，想通过函数来实现两个数值变量或对象的交换是不行的，如下：
/***** AppMain.java *****/ public class AppMain { public static void fun(int n, Integer o) { n = 1; o = new Integer(1); } public static void swapInt(int a, int b) { int c = a; a = b; b = c; } public static void swapInteger(Integer oa, Integer ob) { Integer oc = oa; oa = ob; ob = oc; } public static void main(String[] args) { int n1 = 0; Integer on1 = new Integer(0); System.out.println("n1="+n1 + ", on1="+on1);//n1=0, on1=0 fun(n1, on1); System.out.println("n1="+n1 + ", on1="+on1);//n1=0, on1=0 int n2 = 1; Integer on2 = new Integer(1); System.out.println("n1="+n1 + ", n2="+n2); //n1=0, n2=1 System.out.println("on1="+on1 + ", on2="+on2);//on1=0, on2=1 swapInt(n1, n2); swapInteger(on1, on2); System.out.println("n1="+n1 + ", n2="+n2); //n1=0, n2=1 System.out.println("on1="+on1 + ", on2="+on2);//on1=0, on2=1 } }
其实，通过函数来实现两个数值变量或对象的交换也是有办法的（包裹：将要交换的数值变量或对象包裹到一个数组或类中）
/***** AppMain.java *****/ public class AppMain { public static void swapIntTrue(int[] a, int[] b) { int c = a[0]; a[0] = b[0]; b[0] = c; } public static void swapIntegerTrue(Integer[] oa, Integer[] ob) { Integer oc = oa[0]; oa[0] = ob[0]; ob[0] = oc; } public static void main(String[] args) { int n1 = 0; int n2 = 1; Integer on1 = new Integer(0); Integer on2 = new Integer(1); int nArray1[] = new int[1]; int nArray2[] = new int[1]; nArray1[0] = n1; nArray2[0] = n2; System.out.println("n1="+n1 + ", n2="+n2);//n1=0, n2=1 swapIntTrue(nArray1, nArray2); n1 = nArray1[0]; n2 = nArray2[0]; System.out.println("n1="+n1 + ", n2="+n2);//n1=1, n2=0 Integer onArray1[] = new Integer[1]; Integer onArray2[] = new Integer[1]; onArray1[0] = on1; onArray2[0] = on2; System.out.println("on1="+on1 + ", on2="+on2);//on1=0, on2=1 swapIntegerTrue(onArray1, onArray2); on1 = onArray1[0]; on2 = onArray2[0]; System.out.println("on1="+on1 + ", on2="+on2);//on1=1, on2=0 } }
自动封装(Autoboxing)&自动拆封(Autounboxing)
/***** AppMain.java *****/ public class AppMain { public static int autoBoxing(Integer o) { int sum = 2 + o;//自动拆封 return sum; } public static Integer autoUnBoxing(int n) { Integer o = new Integer(n); o += 2;//自动封装 return o; } public static void main(String[] args) { Integer oRet = autoBoxing(1);//参数与返回值均自动封装 int nRet = autoUnBoxing(oRet);//参数与返回值均自动拆封 } }
数组
// ----------------- 一维数组 ------------------ int nScores[] = {1,2,3,4,5,6,7,8,9,0}; String[] strContents = {"How", "Are", "You","?"}; float fDistances[] = new float[3]; // ----------------- 二维数组 ------------------ int nMatrix[][] = { {0, 1, 2}, {3, 4, 5}, {6, 7, 8} }; double[][] codes = new double[5][5]; long[] secs[] = new long[2][]; secs[0] = new long[3]; secs[1] = new long[4]; // ----------------- 数组长度 ------------------ int nWeek[] = {1, 2, 3, 4, 5, 6, 7}; int nLength = nWeek.length; // nLength = 7 // ----------------- 数组拷贝 ------------------ int nScores[] = {1,2,3,4,5,6,7,8,9,0}; int nScores2[] = new int[12]; System.arraycopy(nScores, 0, nScores2, 2, 8); // nScores2 = { 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 0, 0,}
Arrays为数组的公用工具类，里面有大量静态成员函数供数组使用。
注释
// 单行注释 /* 块注释 */ /** doc注释（会被javadoc辨别）*/
package与import
package是Java提供的一种封装机制，可将一组类和接口封装在一个package中，缺省访问符修饰的类/接口、变量、方法在package内可见。package有效地管理类名空间，可防止类名冲突。
package语句作为Java源文件的第一条语句，指明该文件中定义的类/接口所在的包
package com.JavaApp; // 该源文件需要放在src/com/JavaApp目录中
如果源文件中没有package语句，则为无名包，该源文件存放在src/目录中
为了防止在使用类时带上长长的包路径，可使用import将包路径导入到当前源文件中
import java.applet.Applet; import java.awt.*;
for、break、continue增强
void breakTest() { int sum = 0; int[] code = {0,1,2,3,4,5}; // 针对数组、集合、枚举的for循环形式 JDK1.5之后增加 for (int e : code) { sum += e; if (sum >30) { break; } } L1:for(int i=0; i<100; i++) { L2:for(int j=0; j<100; j++) { if (i==50 && j==80) { // 跳出L1层循环 break L1; } } } } void continueTest() { int sum = 0; while(sum<1000) { if (++sum>100) { continue; } } C1:for(int i=0; i<100; i++) { C2:for(int j=0; j<100; j++) { if (i==50 && j==80) { // 继续C1层循环 continue C1; } } } }
字符串（16位unicode）
String 处理不变的字符串，任何对String的改变都会引发新的String对象的生成
String s1 = "hello"; // 静态创建字符串对象 String s2 = new String("你好"); // 动态创建字符串对象 int ns1Len = s1.length(); // ns1Len = 5 int ns2Len = s2.length(); // ns2Len = 2 String s3 = "hello"; String s4 = new String("你好"); String s5 = "Hello"; if (s1==s3) // true -s1与s3是否指向同一个对象 { System.out.println("yes!! s1==s3"); } if (s2==s4) // false -s2与s4是否指向同一个对象 { System.out.println("yes!! s2==s4"); } if (s1.equals(s5)) // false -s1与s5的字符串内容是否完全一致 { System.out.println("yes!! s1,s5 has same string value."); } if (s2.equals(s4)) // true -s2与s4的字符串内容是否完全一致 { System.out.println("yes!! s2,s4 has same string value."); } if (s1.equalsIgnoreCase(s5)) // true -忽略大小写，s1与s5的字符内容是否一致 { System.out.println("yes!! s1,s5 has same string value when ignore case."); } if (s2.equalsIgnoreCase(s4)) // true -忽略大小写，s2与s4的字符内容是否一致 { System.out.println("yes!! s2,s4 has same string value when ignore case."); }
String类的"="、"+"、"+="，看似运算符重载，实际只是java编译器做了一点手脚，对String的运算符做了特殊处理。
String s = "Hello "; s += "World!"; // 编译器转换成s = (new StringBuilder()).append(s).append("World!").toString();
StringBuffer 处理可变字符串（线程安全），不可被继承（final）
StringBuilder 处理可变字符串（线程不安全，拥有更高的性能），不可被继承（final），JDK1.5引入
StringBuffer与StringBuilder在使用上几乎没有区别
StringBuffer sb1 = new StringBuffer("Hello "); sb1.append("World!"); String str1 = sb1.toString(); // Hello World! StringBuilder sb2 = new StringBuilder("Hello "); sb2.append("World!"); String str2 = sb2.toString(); // Hello World!
成员权限控制
---------------------------- 访问修饰符 ---------------------------
# 当前类 同一package 子类 其他package
public √ √ √ √
protected √ √ √ ×
缺省 √ √ × ×
private √ × × ×
---------------------------------------------------------------------
类
访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称1, 接口名称2
1、每个类文件仅能有一个public class，可以存在多个其他的缺省class
2、public class的名称（包含大小写）必须和其类文件同名
3、一个类文件(*.java)中可以不存在public class
4、top class不能是private和protected（注：内部类可以）
修饰符：
final 当前类不能被继承
abstract 抽象类，不能被实例化；抽象类中不一定包含抽象方法，但包含了抽象方法的类一定要声明为抽象类
static 静态类；只有内部类才能定义为静态类
内部类
1、内部类拥有top class的所有特性
2、内部类可以是public、缺省、protected、private的
3、内部类可以访问其外部类的成员变量、方法，及所在外部类的其它内部类
静态类
1、只有内部类才能声明为static，也可以说是静态内部类
2、只有静态内部类才能拥有静态成员，普通内部类只能定义普通成员
3、静态类跟静态方法一样，只能访问其外部类的静态成员
4、如果在外部类的静态方法中访问内部类，这时候只能访问静态内部类
其他类中使用内部类
1、访问内部类，必须使用：外部类.内部类
2、静态内部类可以直接new
3、普通内部类必须绑定在其外部类的实例上
class A
{ static class Ainner1 {} class Ainner2 {} } class B { public test() { A.Ainner1 m1 = new A.Ainner1(); A m = new A(); A.Ainner2 m2 = m.new Ainner2(); } }
[静态] 成员变量
class A { // 调用顺序 【1】 public static int MAX_SIZE = 100; static final int WTN_TOTAL = 500; // static常量类型，定义时必须进行初始化 public int m_nVar = 9; final boolean m_switch = false; // 常量类型，定义时进行初始化 final int m_nVarConst; // final空白（只声明，不赋值），可在构造函数中为不同对象赋不同的值 protected String m_strName = "A"; private boolean m_bSex; float m_fDis = 8.0f; transient short m_shFlag = 10; // 告诉编译器，在类对象序列化的时候，此变量不需要持久保存 public static volatile boolean m_bRet; // 多线程时，要求编译器优化时保证对此变量的修改能够被正确的处理 // 调用顺序 【2】 // 类成员变量初始化器，可以有多个，按照先后顺序执行，但仅被初始化一次（当JVM加载类时执行） static { MAX_SIZE = 240; } static { } // 成员变量初始化器；运行于父类构造函数之后，自身构造函数之前 { m_nVar = 100; m_strName = "AA"; m_bSex = false; m_fDis = 12.0f; } // 调用顺序 【3】 public A() { MAX_SIZE = 200; m_nVar = 99; m_strName = "a"; m_bSex = true; m_fDis = 10.0f; // final空白，必须在构造函数中赋初值 m_nVarConst = 0; } public A(int nVar) { // final空白，必须在构造函数中赋初值 // 可在构造函数中为不同对象赋不同的值 // 一旦被赋值，就不可再改变 m_nVarConst = nVar; } // 参数nVar1不可在函数体中被修改 public void fun1(final int nVar1, int nVar2) { // nSum被赋值后不能被修改 final int nSum = nVar1 + nVar2; // static int nResult = 100; -- 非法，java不允许static局部变量 } }
[静态] 成员函数
class B { int m_nVar = 0; static short m_shVar = 10; // 无参构造函数 public B() { m_nVar = 1; } // 有参构造函数 public B(int nVar) { m_nVar = nVar; } // 拷贝构造函数 public B(B other) { this.m_nVar = other.m_nVar; } // finalize方法调用时机 // 1、显式的调用finalize方法 // 2、程序退出时为每个对象调用一次finalize方法 // 3、JVM按照某种策略（如内存不够）来进行垃圾回收时调用finalize；程序员可通过调用System.gc()来建议JVM进行垃圾回收 protected void finalize() { } // final类成员函数，不能被子类重写 // 在其函数体内，只能访问类成员变量和类成员函数，不能使用this、super等关键字 public final static void sFunc1() { m_shVar = 5; } // 类成员函数；在其函数体内，只能访问类成员变量和类成员函数，不能使用this、super等关键字 public static void sFunc2(int nVar) { m_shVar += nVar; } // final成员函数，可被子类继承，但不能被重写 public final void func1(int nVar) { m_shVar = (short)nVar; m_nVar = nVar; } // 成员函数 public void func2(int nVar) { m_shVar = (short)nVar; m_nVar = nVar; // 调用参数不定成员函数 fun3(); fun3(1); fun3(1,2); fun3(1,2,3); fun3(new int[]{1,2}); } // 参数不定成员函数 // 1、如果存在fun3()、fun3(int)等函数，在调用fun3时，优先匹配定长参数的函数 // 2、可变参数必须为函数参数列表中的最后一项 public void fun3(int... an) { for(int i=0;i<an.length;i++) { System.out.println(an[i]); } } // java native方法及JNI实例 // 用native定义的方法没有实现，而大多数情况下该方法的实现是用C、C++编写的 // JNI提供了运行时加载一个native方法的实现，并将其于一个Java类关联的功能 public native void displayHelloWorld(); /*1、synchronized关键字的作用域有二种： 1）对象实例范围。synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法 （如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。 然而，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 2）类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static方法 （如果一个类有多个synchronized static方法，只要一个线程访问了其中的一个synchronized static方法，其它线程不能同时访问这个类中任何一个synchronized static方法）。 它可以对类的所有对象实例起作用。 2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。 用法是: synchronized(B.class){区块}，它的作用域是类B； synchronized(this){区块}，它的作用域是当前this对象； synchronized(String obj){区块}，它的作用域是当前String对象； 3、synchronized关键字不能被继承的，也就是说，基类的synchronized f()方法在继承类中并不自动是synchronized f()，而是变成了f()。 继承类需要显式的指定为synchronized方法。*/ // synchronized static 方法 public static synchronized void synFunc1() { } // synchronized方法 public synchronized void synFunc2() { } // synchronized块 public void synFun3(String strVar) { // 获得当前类锁。有线程访问时以下同步代码块时，其它线程的访问都被暂时阻塞 synchronized(B.class) { System.out.println("syn class!"); } System.out.println("Hello..."); // 获得当前strVar对象锁。有线程访问时以下同步代码块时，其它线程的访问都被暂时阻塞 synchronized(strVar) { System.out.println("syn var obj!"); } System.out.println("World..."); // 获得当前this对象锁。有线程访问时以下同步代码块时，其它线程的访问都被暂时阻塞 synchronized(this) { System.out.println("syn this!"); } } } // 抽象函数 abstract class C { // 不能将static方法、final方法或者类的构造器方法声明为abstract public abstract void aFunc(); public int func(int a, int b) { return a+b; } } // 抽象类不能实例化，被其他类继承后，必须实现抽象类中的抽象函数 class D extends C { public void aFunc() { } }
类继承
class CParent { String m_strName = "Parent"; int m_nParentAge; public CParent(int nAge) { m_nParentAge = nAge; } public void fun1() { } public void fun2() { } } class CChildren1 extends CParent { // CParent中的m_strName变量被隐藏 String m_strName = "Children"; int m_nChildrenAge; public CChildren1(int nAge) { // 由于父类没有缺省参数的构造函数，必须在构造函数中显示构造父类 super(nAge); } // 重写CParent中的fun1方法 // 1.重写的方法（子类）不能比被重写的方法（父类）有更严格的访问权限 // 2.重写的方法（子类）不能比被重写的方法（父类）产生更多的异常 public void fun1() { // this用来引用当前对象，super用来引用当前对象的父类 // 强制调用CParent的fun1方法 super.fun1(); // 强制访问CParent的m_strName String str1 = super.m_strName; // 访问自己的m_strName String str2 = this.m_strName; // 访问自己的m_strName时，可以不带上this String str3 = m_strName; } } class CChildren2 extends CParent { public CChildren2(int nAge) { super(nAge); } } class CGrandChildren1 extends CChildren1 { public CGrandChildren1(int nAge) { super(nAge); } } public class AppMain { // instanceof可以判定一个对象是否属于某个类的实例 // 在判定时应循序特殊到一般的原则，先判断子类，再判断父类 static int GetClassType(CParent obj) { if (obj instanceof CGrandChildren1) { return 11; } else if (obj instanceof CChildren1) { return 1; } else if (obj instanceof CChildren2) { return 2; } return 0; } public static void main(String[] args) { CParent c1 = new CChildren1(0); CParent c2 = new CGrandChildren1(0); int nClsType = GetClassType(c1); // 返回1 nClsType = GetClassType(c2); // 返回11 // 将c1强制转成CChildren1类型，这个过程叫造型 /* 如果c1为CChildren1类型时，代码不会有问题；若不是，系统会抛出ClassCastException的异常 因此，在造型之前使用instanceof进行判断是明智之举 */ CChildren1 cc = (CParent)c1; } }
接口
访问修饰符 interface 接口名称 extends 接口名称1, 接口名称2
访问修饰符：public 缺省
与类一样，public接口必须定义到自己独立的源文件中或类的内部，缺省接口可定义在任何位置
1、interface中数据成员均为公共类常量，具有public、static、final属性
2、interface中方法成员均为公共抽象方法，具有public、abstract属性
3、在接口继承关系中，如果子接口中定义了与父接口同名的常量和相同的方法，则父接口中的常量将被隐藏，方法被重写
interface E { int MAX_SIZE = 100; String NAME = "E"; void inter(); void interE(); } // 接口F必须写到F.java中 public interface F extends E { String NAME = "F"; // 接口E的NAME被隐藏 void inter(); // 接口E的inter()方法被重写 void interF(); } // 使用接口E，在new时重写接口E的方法 public static void main(String[] args) { E e = new E() { public void interE() { } }; }
枚举
枚举从JDK1.5才引进；与类一样，public枚举必须定义到自己独立的源文件中或类的内部，其他类型的枚举可定义在任何位置。
枚举具有类的绝大数特性，但也有一些特殊之处：
1、枚举常量具有public、static、final属性
2、枚举的构造函数必须为private
3、无法在外部或枚举内部new一个枚举对象
4、不支持类继承，支持接口多继承
public enum Week {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday}; //////////////////////////////////////////////////////////////////////// enum Currency { Penny(1), Nickle(5), Dime(12), Quarter(100); private int m_nValue; private Currency(int nVal) { m_nValue = nVal; } int GetValue() { return m_nValue; } } //////////////////////////////////////////////////////////////////////// interface IBase1 { void fun1(); } interface IBase2 { void fun2(); } enum Planet implements IBase1, IBase2 { Mercury (3.303e+23, 2.4397e6), Venus (4.869e+24, 6.0518e6), Earth (5.976e+24, 6.37814e6), Mas (6.421e+23, 3.3972e6), Jupiter (1.9e+27, 7.1492e7), Saturn (5.688e+26, 6.0268e7), Uranus (8.686e+25, 2.5559e7), Neptune (1.024e+26, 2.4746e7); private final double m_mass; private final double m_radius; Planet(double mass, double radius) { m_mass = mass; m_radius = radius; } public void fun1() { } public void fun2() { } } //////////////////////////////////////////////////////////////////////// public static void main(String[] args) { Currency usCoin = Currency.Dime; switch (usCoin) { case Currency.Penny: System.out.println("Penny"); break; case Currency.Nickle: System.out.println("Nickle"); break; case Currency.Dime: System.out.println("Dime"); break; case Currency.Quarter: System.out.println("Quarter"); break; } if (Currency.Quarter == usCoin) { System.out.println("Quarter coin"); } for(Currency coin: Currency.values()) { System.out.println("coin: " + coin); } }
异常
所有的异常类必须从Throwable派生，异常分为两大类：一类是unchecked异常（橙色部分）：
1、Error类异常由JVM生成并抛出（如：动态链接错误），我们不能在编程层面上解决Error，所以应该直接退出程序。
2、RuntimeException(及其衍生类)是Java程序自身造成的，RuntimeException完全可以通过修正Java程序避免。这类异常，Java编译器不强制要求程序员对其捕获和处理。
另外一类就是checked异常（淡蓝色部分）：
Java编译器要求程序员必须捕获或声明所有的这类非运行时异常（如：文件找不到造成的IOException）。
/******************* 自定义异常 *******************/ class ExceptionSelf1Base extends Exception { private String m_strExpInfo; ExceptionSelf1Base(String strVal) { m_strExpInfo = strVal; } public String toString() { return "Exception: " + m_strExpInfo; } } class ExceptionSelf2Base extends Exception { private int m_nExpInfo; ExceptionSelf2Base(int nVal) { m_nExpInfo = nVal; } public String toString() { return "Exception: " + m_nExpInfo; } } class ExceptionSelf1 extends ExceptionSelf1Base { public ExceptionSelf1(String strVal) { super(strVal); } } /******************* 抛出异常 *******************/ class ExceptionTest { // 需要通过throws关键字声明函数内的所有抛出的checked异常 public void throwExp(int nMode) throws ExceptionSelf1,ExceptionSelf1Base,ExceptionSelf2Base { if (nMode < 0) { ExceptionSelf1Base e1 = new ExceptionSelf1Base("nMode < 0"); throw e1; } else if (nMode < 100) { ExceptionSelf2Base e2 = new ExceptionSelf2Base(100); throw e2; } ExceptionSelf1 e = new ExceptionSelf1("nMode >= 100"); throw e; } } /******************* 异常处理 *******************/ public class AppMain { public static void main(String[] args) { ExceptionTest expTest = new ExceptionTest(); try { expTest.throwExp(100); } // 捕捉异常时，需要按照特殊到一般的顺序进行捕捉 catch (ExceptionSelf1 e) { } catch (ExceptionSelf1Base e) { } catch (ExceptionSelf2Base e) { } catch (Exception e) { } // finally为非必需的块 // 进入try块后，无论发生还是不发生异常，finally块中的代码都要被执行，提供了统一的出口 finally { } } }
泛型
泛型从JDK1.5才引进；经常被称为参数化类型，它能够像方法一样接受不同类型的参数。
泛型中的通配符：
(1) 泛型中可以使用"?"通配符作为参数，表示该泛型可以接受任意类型的数据
(2) 上届通配符：只允许类A或类A的子类作为参数传入；表示方式：泛型类型<? extends A>
(3) 下届通配符：只允许类A或类A的父类作为参数传入；表示方式：泛型类型<? super A>
如果想从一个数据类型里获取数据，使用 ? extends A 通配符
如果想把对象写入一个数据结构里，使用 ? super A 通配符
如果既想存又想取，那就不要用通配符
/***** AppMain.java *****/ import java.util.*; public class AppMain { public static void main(String[] args) { //ArrayList<?> gList1 = new ArrayList<?>();//编译错误，通配符修饰的泛型不能用来直接创建对象 ArrayList<String> gStrList2 = new ArrayList<String>(); gStrList2.add("1"); ArrayList<?> gList2 = gStrList2; Object objVal = gList2.get(0); //通配符修饰的泛型可以读取数据到Object类型 //gList2.add("2"); //编译错误，【?】通配符修饰的泛型不能写入任何类型数据 //ArrayList<? extends Number> geList1 = new ArrayList<? extends Number>();//编译错误，通配符修饰的泛型不能用来直接创建对象 ArrayList<Integer> geIntList2 = new ArrayList<Integer>(); geIntList2.add(1); List<? extends Number> geList2 = geIntList2; Object objVa2 = geList2.get(0); //通配符修饰的泛型可以读取数据到Object类型 Number nVal = geList2.get(0); //【上届通配符】修饰的泛型可以读取数据到Number类型 //geList2.add(new Integer(2)); //编译错误，【上届通配符】修饰的泛型不能写入任何类型数据 //ArrayList<? super Integer> gsList1 = new ArrayList<? super Integer>();//编译错误，通配符修饰的泛型不能用来直接创建对象 ArrayList<Integer> gsIntList2 = new ArrayList<Integer>(); gsIntList2.add(1); List<? super Integer> gsList2 = gsIntList2; Object objVal3 = gsList2.get(0); //通配符修饰的泛型可以读取数据到Object类型 //Integer nVal2 = gsList2.get(0); //编译错误，【下届通配符】修饰的泛型不能读取数据到除Object类型中 gsList2.add(2); //【下届通配符】修饰的泛型可以写入Integer及其父类类型数据 /*** 自定义泛型 ***/ //Gencs<CString,String,String> gen1 = new Gencs<Float,String,String>();//编译错误，参数1必须为Number或其子类 Gencs<Integer,String,String> gen2 = new Gencs<Integer,String,String>(); Gencs<Float,String,String> gen3 = new Gencs<Float,String,String>(); gen3.setX(3.0f); Float fGen3 = gen3.getX(); Object oGen3 = gen3.getX(); //Integer iGen3 = gen3.getX();//编译错误，返回值为Float类型 //gen3.setX(3);//编译错误，必须传入Float类型参数 } } class Gencs<X extends Number, Y, Z> { private X m_x; //static Y m_y; //编译错误，不能用在静态变量中 public X getX() { return m_x; } public void setX(X x) { m_x = x; } public void fun() { //Z z = new Z();//编译错误，不能创建对象 } }
集合
注：点框的为接口、虚线框的为抽象类、实线框的为功能类（右下角的Collections为公用工具类，里面含有大量静态成员函数供集合使用）
集合只能容纳对象，不能容纳基本数据类型；元素通过实现Comparable接口、或提供一个实现Comparator接口的比较算法类来定义比较的规则。
List集合是有序集合（放入的顺序与存储的顺序一致），集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。
Set集合是无序集合（放入的顺序与存储的顺序不一致），集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问。
Map集合中保存key-value对形式的元素，其key对象是不允许重复的（换个角度说：key对象的合集就是一个Set集合），访问时只能根据每项元素的key来访问其value；插入时如果key存在，则替换原来的value对象。
对象重复的含义：
(1) 两个对象e1和e2，如果e1.equals(e2)为true，则认为e1和e2重复，否则认为两个对象不重复
(2) 默认两个对象是否相等的equals方法是判断两个对象变量引用值是否指向同一个地址空间，我们可以重写equals方法来自定义重复的含义
ArrayList线程不安全；Vector线程安全（如果是单线程程序，推荐使用ArrayList）
ArrayList通过数组实现，LinkedList通过链表实现（不涉及到插入、删除等操作，推荐使用ArrayList）
与HashSet相比，TreeSet会对容器内的元素进行排序；同理，相比HashMap，TreeMap也会对容器内的元素进行排序
HashMap线程不安全，键与值都可以为null；Hashtable线程安全，键与值不能为null（如果是单线程程序，推荐使用HashMap）
/***** AppMain.java *****/ import java.util.*; public class AppMain { public static void main(String[] args) { /* ArrayList */ List list = new ArrayList(); list.add(new Integer(1)); list.add("2"); list.add(new Short((short)3)); ListIterator iList = list.listIterator(); while(iList.hasNext()) { System.out.println(iList.next()); } /* HashSet */ Set hSet = new HashSet(); hSet.add("1"); hSet.add(new Integer(2)); hSet.add("3"); Iterator iHSet = hSet.iterator(); while(iHSet.hasNext()) { System.out.println(iHSet.next()); } /* TreeSet */ Set tSet = new TreeSet(); tSet.add("1"); //tSet.add(new Integer(2)); //运行时错误，TreeSet会对元素进行排序，因此需要实现插入元素间相互比较的Comparable接口 tSet.add("3"); Iterator iTSet = tSet.iterator(); while(iTSet.hasNext()) { System.out.println(iTSet.next()); } /* HashMap */ HashMap hm = new HashMap(); hm.put(null, 0); hm.put("1", null); hm.put(new Integer(2), "2"); hm.put("3", new Float(3.0f)); Set sHm = hm.keySet(); Iterator iHm = sHm.iterator(); while(iHm.hasNext()) { Object k = iHm.next(); Object v = hm.get(k); System.out.println(k + "=" + v); } /* Hashtable */ Hashtable ht = new Hashtable(); // ht.put(null, 0); //运行时错误 // ht.put("1", null); //运行时错误 ht.put(new Integer(2), "2"); ht.put("3", new Float(3.0f)); Enumeration e = ht.keys(); while(e.hasMoreElements()) { Object k = e.nextElement(); Object v = ht.get(k); System.out.println(k + "=" + v); } /* TreeMap */ TreeMap tm = new TreeMap(); tm.put("1", new Long(1)); tm.put("2", new Double(2.0)); // tm.put(new Integer(3), "3"); //运行时错误，TreeMap会按照Key进行排序，因此Key需要实现插入元素间相互比较的Comparable接口 Set sTm = tm.keySet(); Iterator iTm = sTm.iterator(); while(iTm.hasNext()) { Object k = iTm.next(); Object v = tm.get(k); System.out.println(k + "=" + v); } } }
以上的示例为非泛型实现的集合，现在已不推荐使用了。（由于使用集合中的元素时，必须进行造型操作，效率低；而且造型操作可能在程序运行时出现问题）
泛型实现的集合在定义容器时，同时定义容器中对象的类型，这就使得容器内的元素只能是该对象类型或其子对象类型。
泛型实现的集合拥有与非泛型实现的集合同样的特性，一致的外部接口。（ArrayList LinkedList HashSet TreeSet HashMap TreeMap Hashtable）
/***** AppMain.java *****/ import java.util.*; public class AppMain { public static void main(String[] args) { /* ArrayList */ List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3"); ListIterator<String> iList = list.listIterator(); while(iList.hasNext()) { System.out.println(iList.next()); } /* HashSet */ Set<Integer> hSet = new HashSet<Integer>(); hSet.add(1); hSet.add(new Integer(2)); hSet.add(new Integer(3)); Iterator<Integer> iHSet = hSet.iterator(); while(iHSet.hasNext()) { System.out.println(iHSet.next()); } /* TreeSet */ Set<String> tSet = new TreeSet<String>(); tSet.add("1"); //tSet.add(new Integer(2)); //编译时错误 tSet.add("3"); Iterator<String> iTSet = tSet.iterator(); while(iTSet.hasNext()) { System.out.println(iTSet.next()); } /* HashMap */ HashMap<String, Integer> hm = new HashMap<String, Integer>(); hm.put(null, 0); hm.put("1", null); hm.put("2", new Integer(2)); hm.put("3", new Integer(3)); Set<String> sHm = hm.keySet(); Iterator<String> iHm = sHm.iterator(); while(iHm.hasNext()) { String k = iHm.next(); Integer v = hm.get(k); System.out.println(k + "=" + v); } /* Hashtable */ Hashtable<String, Integer> ht = new Hashtable<String, Integer>(); //ht.put(null, 0); //运行时错误 //ht.put("1", null); //运行时错误 ht.put("2", new Integer(2)); ht.put("3", 3); Enumeration<String> e = ht.keys(); while(e.hasMoreElements()) { String k = e.nextElement(); Integer v = ht.get(k); System.out.println(k + "=" + v); } /* TreeMap */ TreeMap<String, Integer> tm = new TreeMap<String, Integer>(); tm.put("1", 1); tm.put("2", new Integer(2)); // tm.put(new Integer(3), 3); //编译时错误 Set<String> sTm = tm.keySet(); Iterator<String> iTm = sTm.iterator(); while(iTm.hasNext()) { String k = iTm.next(); Integer v = tm.get(k); System.out.println(k + "=" + v); } } }
