Java简明教程

2021-09-28 03:08:56

Java与C++比较概况

C++	Java
class Foo { // 声明 Foo 类 public: int x; // 成员变量 Foo(): x() { // Foo 的构造函数Constructor for Foo, } // 初始化 x int bar(int i) { // 成员函数 bar() return *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 = ; // 修改 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 = ; // 修改 c 指向的对象	c.x = 5; // 修改 c 指向的对象
a.bar(); // 对 a 调用 Foo::bar() c->bar(); // 对 *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 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 Character chObj1 = new Character('a'); char ch2 = Character.toUpperCase('b');
byte [1字节] byte a = 35;	Byte Byte.MIN_VALUE - Byte.MAX_VALUE Byte b1 = new Byte("23");
short [2字节] short a = 870;	Short Short.MIN_VALUE - Short.MAX_VALUE Short s1 = new Short("315");
int [4字节] int a = 56; // 十进制 int b = 0210; // 八进制 int c = 0x2ff; // 十六进制	Integer Integer.MIN_VALUE - Integer.MAX_VALUE Integer intObj = new Integer(56); int intVal = intObj.intValue();
long [8字节] long m = 356; long n = 86L;	Long Long.MIN_VALUE - Long.MAX_VALUE Long s1 = new Long("-98166");
float [4字节] float f = 3.5f;	Float 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 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);

        }

    }

}

码农公寓

相关文章