BlogJava-SexTian-文章分类-java特性

面向对象的特征

chenkkkabc — Thu, 18 Jun 2009 14:16:00 GMT

1. 抽象

2. 封装

3. 继承

4. 多态

chenkkkabc 2009-06-18 22:16 发表评论

内存管理

chenkkkabc — Wed, 17 Jun 2009 04:48:00 GMT

1.Java内存管理方式
Java语言的一个优点就是通过垃圾收集器GC自动管理内存的回收，程序员不需要手动释放内存。内存管理实质上就是对内存的分配和释放问题，在Java中，程序员通过new关键字为每个对象申请内存空间（基本类型除外），所有对象都在堆中分配空间；对象的释放是由GC决定和执行的。GC为了能够准确及时的释放对象，需要监控每个对象的运行状态，包括对象的申请、引用、被引用、赋值等。一个对象被释放的根本原则就是这个对象不再被引用。
2.GC的原理
把对象想象成有向图的节点，引用关系想象成图的有向边，有向边从引用者指向被引用对象。大部分程序以mian线程开始，可以把其想象作main线程顶点开始的一棵树。根节点可达的对象都是有效对象，GC不可回收；而与根节点不可达关系的对象则被认为不被引用，可以通过GC回收。相对计数器模型，有向图模型可以很容易的发现变量循环引用的问题。
3.内存泄露
Java虽然在语言级支持垃圾回收，但是Java程序同样存在内存泄露，无用对象占用的空间不能及时释放，就造成了这段局部时间事实上的内存泄露。要及时释放内存，最好是在用完对象之后立即执行“object=null;”语句。
4.对象引用类型
有没有让System.gc()立即收效的办法呢？答案在Java提供的4种对象引用类型上：
a. 强引用
强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
b. 软引用
如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存（下文给出示例）。
软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
c. 弱引用
弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
d. 虚引用
“虚引用”顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。
虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。

chenkkkabc 2009-06-17 12:48 发表评论

枚举

chenkkkabc — Tue, 16 Jun 2009 01:01:00 GMT

chenkkkabc 2009-06-16 09:01 发表评论

脚本引擎

chenkkkabc — Mon, 15 Jun 2009 13:48:00 GMT

1.Java脚本API的好处
Java能够对脚本语言提供支持，原理上是通过将脚本语言编译成字节码来实现的。脚本API在Java应用程序和外部脚本间提供了双向可见性。这样脚本语言也能享用Java平台的诸多优势如可移植性、安全性等；并且执行效率比解释执行高出许多。Java本身也可以间接获得动态灵活性、扩展性等。

2.Java脚本API的使用步骤
Java里自带支持JavaScript。要在Java里使用脚本语言非常非常的简单，只需以下三步：
a. 创建一个ScriptEngineManager对象
b. 通过ScriptEngineManager对象创建ScriptEngine对象
c. 用ScriptEngine对象的eval()方法执行脚本

chenkkkabc 2009-06-15 21:48 发表评论

Annotation

chenkkkabc — Sun, 14 Jun 2009 05:18:00 GMT

Java注释——采用metadata机制，对某点程序代码作解释说明，将程序的元素如：类，方法，属性，参数，本地变量，包和元数据联系起来。这样编译器可以将元数据存储在class文件中。这样虚拟机和其它对象可以根据这些元数据来决定如何使用这些程序元素或改变它们的行为。

事先定义好的三种annotation类型，都位于java.lang包里：
1 Override 用来指示一个方法，它覆盖了它的基类的方法
2 Deprecated 指出某一个方法或是元素类型的使用时被阻止的
3 SupressWarnings 会关掉class、method、field与variable初始化的编译器警告

我们可以创建自定义的annotation类型，很类似于声明一个接口：
public @interface TODO {
String value();
}
编译器自动使用相同名称创建了一个成员变量value，使用时可以这么写：
@TODO(value="Finish homework")

Java提供了四种基本的meta-annotation如下，都位于java.lang.annotation包里：
1 Target 指定哪个程序单元可以有其所定义的annotation
参数类型是ElementType[]，其中ElementType定义为如下枚举

public enum ElementType {
    TYPE, // Class, interface, or enum (but not annotation)
    FIELD, // Field (including enumerated values)
    METHOD, // Method (does not include constructors)
    PARAMETER, // Method parameter
    CONSTRUCTOR, // Constructor
    LOCAL_VARIABLE, // Local variable or catch clause
    ANNOTATION_TYPE, // Annotation Types (meta-annotations)
    PACKAGE    // Java package
}

不使用时所有程序单元都适用
2 Retention 指出是否编译器要丢掉一个annotation，或者是否将一个annotation保存在class文件里
参数是RetentionPolicy类型，定义如下

public enum RetentionPolicy {
    SOURCE, // Annotation is discarded by the compiler
    CLASS, // Annotation is stored in the class file, but ignored by the VM
    RUNTIME    // Annotation is stored in the class file and read by the VM
}

3 Documented 指出被定义的annotation应该被视为所注释的程序单元的公开API之一
4 Inherited 被应用于目标为class的annotation类型上，指出此被注释的类型是能够通过继承得到的

最后，来谈一下annotation的反射。java.lang.reflect包里的AnnotatedElement接口可以直接拿来访问被annotated的方法，具体的还是看例子吧~

chenkkkabc 2009-06-14 13:18 发表评论

事件处理机制

chenkkkabc — Sat, 13 Jun 2009 06:22:00 GMT

chenkkkabc 2009-06-13 14:22 发表评论

Derby

chenkkkabc — Fri, 12 Jun 2009 06:23:00 GMT

chenkkkabc 2009-06-12 14:23 发表评论

JDBC

chenkkkabc — Tue, 09 Jun 2009 07:28:00 GMT

JDBC：Java Database Connectivity，Java数据库连接，可以方便的访问数据库接口。
JDBC驱动程序有四种类型：
1JDBC-ODBC桥，通过ODBC数据源连接
2通过网络库连接的纯Java驱动
3通过中间件服务器
4直接与数据库相连的纯Java驱动，厂商提供

JDBC包括java.sql和javax.sql两个包。数据库应用开发的基本步骤如下：
1.建立数据源，安装相应数据库
2.装载驱动程序，Class.forName("~~~")
3.建立连接，DriverManager.getConnection()
4.建立语句对象，createStatement()
5.书写具体的SQL，executeQuery("")、executeUpdate("")
6.数据处理，next()、getString
7.获取元数据，getMetaData()
8.关闭对象，close()，应该按照ResultSet - Statement - Connection的顺序关闭
9.异常处理与警告

本文采用JDBC-ODBC桥的方式连接Access数据库，将数据库文件test.mdb放到C:\Users\chen\workspace\JavaTest目录下，账户名Administrator，密码abc。数据库包括两张表，格式如下：

try {
            // 装入驱动程序
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            // 设置登陆超时时间
            DriverManager.setLoginTimeout(5);
            String url = "jdbc:odbc:driver={MicroSoft Access Driver (*.mdb)};DBQ=C:\\Users\\chen\\workspace\\JavaTest\\test.mdb";
            // 建立一条连接
            Connection conn = DriverManager.getConnection(url, "Administrator",
                    "abc"); // 设置打开数据库的用户名和密码
            Statement s = conn.createStatement();
            ResultSet rs = s.executeQuery("SELECT * FROM Store_Information");
            ResultSetMetaData metadata = rs.getMetaData();
            int count = metadata.getColumnCount();
            System.out.print("columns:");
            for (int i = 1; i <= count; i++)
                System.out.print(" " + metadata.getColumnName(i));
            System.out.println("\nstore_name in Store_Information:");
            while (rs.next())
                System.out.println(rs.getString("store_name"));
            rs.close();
            s.close();
            PreparedStatement ps = conn
                    .prepareStatement("SELECT * FROM Geography");
            rs = ps.executeQuery();
            System.out.println("store_name in Geography:");
            while (rs.next())
                System.out.println(rs.getString("store_name"));
            rs.close();
            ps.close();
            conn.close();

        } catch (ClassNotFoundException e1) {
            System.err.println(e1);
        } catch (SQLException e2) {
            System.err.println(e2);
        }

实验结果

columns: id store_name sales dates
store_name in Store_Information:
Los Angeles
San Diego
Los Angeles
Boston
store_name in Geography:
Boston
New York
Los Angeles
San Diego

源代码下载

chenkkkabc 2009-06-09 15:28 发表评论

正则表达式

chenkkkabc — Mon, 08 Jun 2009 14:56:00 GMT

首先推荐一个入门教程：http://unibetter.com/deerchao/zhengzhe-biaodashi-jiaocheng-se.htm
下面简要罗列一些关键内容：
0.正则表达式
记录文本规则的代码
作用：A数据有效性验证 B查找、替换
1.元字符

代码	说明
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

2.字符转义
\\、\.、\*
3.重复

代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

4.字符类
[aeiou]、[.?!]
5.分枝条件
a|b，自左向右测试，满足条件停止
6.分组
()，又叫子表达式
7.反义

代码/语法	说明
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

8.后向引用
分组拥有组号，按照左括号出现顺序排列
用于重复搜索前面某个分组匹配的文本，\1代表分组1匹配的文本
9.零宽断言/负向零宽断言
(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp
(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp
(?!exp)也叫零宽度负预测先行断言，它断言自身出现的位置的后面不能匹配表达式exp
(? 10.注释
(?#comment)

分类	代码/语法	说明
捕获	(exp)	匹配exp,并捕获文本到自动命名的组里
	(?exp)	匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
	(?:exp)	匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言	(?=exp)	匹配exp前面的位置
	(?<=exp)	匹配exp后面的位置
	(?!exp)	匹配后面跟的不是exp的位置
	(?	匹配前面不是exp的位置
注释	(?#comment)	这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

11.贪婪与懒惰
默认贪婪，加?变懒惰

代码/语法	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

最先开始的匹配拥有最高的优先权，比贪婪/懒惰要高
12.平衡组/递归匹配
(?'group') 把捕获的内容命名为group,并压入堆栈(Stack)
(?'-group') 从堆栈上弹出最后压入堆栈的名为group的捕获内容，如果堆栈本来为空，则本分组的匹配失败
(?(group)yes|no) 如果堆栈上存在以名为group的捕获内容的话，继续匹配yes部分的表达式，否则继续匹配no部分
(?!) 零宽负向先行断言，由于没有后缀表达式，试图匹配总是失败
13.处理选项

名称	说明
IgnoreCase(忽略大小写)	匹配时不区分大小写。
Multiline(多行模式)	更改^和$的含义，使它们分别在任意一行的行首和行尾匹配，而不仅仅在整个字符串的开头和结尾匹配。(在此模式下,$的精确含意是:匹配\n之前的位置以及字符串结束前的位置.)
Singleline(单行模式)	更改.的含义，使它与每一个字符匹配（包括换行符\n）。
IgnorePatternWhitespace(忽略空白)	忽略表达式中的非转义空白并启用由#标记的注释。
ExplicitCapture(显式捕获)	仅捕获已被显式命名的组。

14.其他问题

代码/语法	说明
\a	报警字符(打印它的效果是电脑嘀一声)
\b	通常是单词分界位置，但如果在字符类里使用代表退格
\t	制表符，Tab
\r	回车
\v	竖向制表符
\f	换页符
\n	换行符
\e	Escape
\0nn	ASCII代码中八进制代码为nn的字符
\xnn	ASCII代码中十六进制代码为nn的字符
\unnnn	Unicode代码中十六进制代码为nnnn的字符
\cN	ASCII控制字符。比如\cC代表Ctrl+C
\A	字符串开头(类似^，但不受处理多行选项的影响)
\Z	字符串结尾或行尾(不受处理多行选项的影响)
\z	字符串结尾(类似$，但不受处理多行选项的影响)
\G	当前搜索的开头
\p{name}	Unicode中命名为name的字符类，例如\p{IsGreek}
(?>exp)	贪婪子表达式
(?-exp)	平衡组
(?im-nsx:exp)	在子表达式exp中改变处理选项
(?im-nsx)	为表达式后面的部分改变处理选项
(?(exp)yes\|no)	把exp当作零宽正向先行断言，如果在这个位置能匹配，使用yes作为此组的表达式；否则使用no
(?(exp)yes)	同上，只是使用空表达式作为no
(?(name)yes\|no)	如果命名为name的组捕获到了内容，使用yes作为表达式；否则使用no
(?(name)yes)	同上，只是使用空表达式作为no

介绍完了正则表达式，下面看看如何在Java语言中使用。java.util.regex包提供了对正则表达式的支持。

public class RegularExpressionTest {

    public static void main(String[] args) {
        // IP address test
        Pattern pattern = Pattern
                .compile("((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)");
        Matcher matcher = pattern.matcher("192.168.018.1");
        System.out.println(matcher.matches());

        // Split strings
        pattern = Pattern.compile("/+");
        String[] results = pattern.split("Test1/Test2//Test3///Test4");
        for (String str : results)
            System.out.println(str);
    }
}

源代码

chenkkkabc 2009-06-08 22:56 发表评论

Java Varargs

chenkkkabc — Tue, 02 Jun 2009 08:19:00 GMT

Java Varargs可以方便方法的重载，允许你指定可以采用多个同类型参数的方法，而不需要事先确定参数的数目，由此实现可变参数。Varargs形式如同 TYPE...name，只能位于参数列表的最后，name可以看做一个TYPE数组，可以包括TYPE及其子类型，通过for/in可以方便的访问每个参数。参数传递的方式可以是单个的元素，也可以是数组，但不能是元素和数组的混合形式。

本文采用Java可变参数实现了一个求最大值的函数，代码如下

    // 求最大值
    public static int max(int values) throws IllegalArgumentException {
        // 无参时抛出异常
        if (values.length == 0)
            throw new IllegalArgumentException("Argument number can't be zero");
        int max = Integer.MIN_VALUE;
        for (int i : values)
            if (max < i)
                max = i;
        return max;
    }

测试方法main

    public static void main(String args) {
        try {
            System.out.println(max(3, 7, 2));
            System.out.println(max(new int[] { 9, 4, 5 }));
            // 以下无法通过编译，不能为混合形式
            // System.out.println(max(new int[] { 1, 7, 4 }, 3));

            System.out.println(max(new Integer(1), new Integer(5))); // 自动拆箱
            System.out.println(max(7, new Integer(3)));

            // Integer[] is = {3,4,5,6};
            // 以下无法通过编译，不能自动转换Integer[]到int[]
            // System.out.println(max(is));

            System.out.println(max()); // 此时有IllegalArgumentException抛出
        } catch (IllegalArgumentException iae) {
            System.out.println(iae);
        }
    }

运行结果

7
9
5
7
java.lang.IllegalArgumentException: Argument number can't be zero

可以从此处下载源代码

有些时候，我们可能要避免自动化的将Object...转化成Object[]，比如说我们要将一个Object[]类型的对象objectArray作为Object传进带Object...参数的方法，为了避免objectArray被拆散为许多单个的object，我们必须要这么写：
new Object[] {objectArray}，或者强转(Object)objectArray。

chenkkkabc 2009-06-02 16:19 发表评论

访问控制修饰符

chenkkkabc — Sun, 31 May 2009 14:20:00 GMT

封装将数据和处理数据的方法连接起来，同时，封装也提供另一个重要属性：访问控制。通过访问控制可以防止对象滥用，保证数据的完整性。
以下是修饰范围表。

	public	protected	默认(friendly)	private
类（非内部类）	√	X	√	X
成员变量	√	√	√	√
方法	√	√	√	√

public：所有类可以访问，接口访问权限
protected：包内所有类以及其子类可以访问，继承访问权限
default：包内所有类可以访问
private：类外任何类不可访问

chenkkkabc 2009-05-31 22:20 发表评论

嵌套类

chenkkkabc — Thu, 21 May 2009 09:45:00 GMT

1 嵌套类定义
在一个类的内部定义另一个类，这种类称为嵌套类。

2 嵌套类的分类
嵌套类根据加不加static修饰符可分为两类：静态嵌套类和非静态嵌套类，后者又叫内部类，可再细分成三类。
顶级类 top-level classes
a.嵌套顶级类 nested top-level classes
b.成员内部类 instance inner classes
c.本地内部类 local inner classes
d.匿名内部类 anonymous inner classes

3 嵌套类的好处
a.令源代码更清晰。
b.减少命名冲突。
c.控制框架：一个“应用程序框架”是指一个或一系列类，它们专门设计用来解决特定类型的问题。为应用该框架，我们可从一个或多个类继承，并覆盖其中的部分方法。我们在覆盖方法中编写的代码用于定制由那些框架提供的常规方案，以解决实际问题。“控制框架”属于应用程序框架的一种特殊类型，受到对事件响应的需要的支配；主要用来响应事件的一个系统叫作“事件驱动的系统”。内部类可以在单独一个类里表达一个控制框架应用的全部实施细节，从而完整地封装与那个实施有关的所有东西。内部类用于表达多种不同类型的action()，以便解决实际的问题。除此以外，若使用了private内部类，实施细节会完全隐藏起来，可以安全地修改。因为能方便地访问外部类的任何成员，内部类使我们具体的实施变得更加巧妙。

4 嵌套类的共性
a.嵌套类是独立的类，编译后会生成相应.class文件，但之前有顶级类的类名和$。
b.嵌套类是顶级类的一部分，可以自由的访问顶级类的成员，不论是否为private的，同理，顶级类也可以访问嵌套类的private成员。
c.嵌套类的成员及方法可以与顶级类重名，在类内会被覆盖。
d.嵌套类也可继承和被继承，但要注意作用域规则。

5 嵌套顶级类
从技术上讲，嵌套顶级类不属于内部类。因为内部类和外部类共享一种实例关系，而嵌套顶级类只是位于一个类的内部，并没有以上共享关系。
静态的含义是，为创建一个嵌套顶级的对象，我们不需要一个顶级类对象。不能从嵌套顶级类的一个对象中访问一个顶级类对象。
与静态方法相似，嵌套顶级类只能访问顶级类的static（静态）成员及方法。

class TLC1 {
    private static String s1 = "tlc1:static string";
    String s2 = "tlc1:non-static string";

    // 嵌套顶级类
    static class NTLC {
        private String ns1 = "ntlc:string";
        private static String ns2 = "ntlc:static string";

        public void f() {
            System.out.println(s1); // 可访问private
            // ! System.out.println(s2); 不能访问顶级类的非static成员
        }
    }

    public void f() {
        System.out.println(new NTLC().ns1); // 可访问private
        System.out.println(NTLC.ns2);
    }
}

main里的验证代码：

        TLC1.NTLC ntlc1 = new TLC1.NTLC();
        TLC1.NTLC ntlc2 = new TLC1.NTLC();
        System.out.println(ntlc1 == ntlc2); // 返回false
        ntlc1.f();
        new TLC1().f();

运行结果：

false
tlc1:static string
ntlc:string
ntlc:static string

6 成员内部类
成员内部类内不允许有任何静态声明，能够访问成员内部类的唯一方式就是通过顶级类（外部类）对象。
a.从外部类的非静态方法访问
实质上是通过外部类的this引用实现的。
b.从外部类的静态方法访问
由于静态方法没有this引用，必须先创建一个外部类对象，然后调用.new创建成员内部类对象进行访问。
c.从其他类访问
先创建外部类对象，再调用.new创建成员内部类对象。
d.从内部类中访问外部类对象
可以使用Outer.this来访问。

class TLC2 {
    private String s = "tlc2:string";

    // 成员内部类
    class IIC {
        private static final String is1 = "iic:static final string";
        // ! static String is2 = "iic:static string"; static必须同时是final的
        private String is3 = "iic:string";

        public void f1() {
            System.out.println(s);
            System.out.println(TLC2.this); // 访问外部类对象
        }
        // ! static void f2(){} 不能声明静态函数
    }

    public void f1(){
        new IIC().f1();
    }
    public static void f2(){
        TLC2 tlc2 = new TLC2();
        tlc2.new IIC().f1();
    }
}

main代码：

        TLC2 tlc2 = new TLC2();
        tlc2.f1();
        tlc2.f2();
        TLC2.IIC iic = tlc2.new IIC();
        iic.f1();

结果：

tlc2:string
day090521.TLC2@1bab50a
tlc2:string
day090521.TLC2@c3c749
tlc2:string
day090521.TLC2@1bab50a

对于普通的类，可用的修饰符有final、abstract、strictfp、public和默认的包访问。
但是成员内部类更像一个成员变量和方法，可用的修饰符有：final、abstract、public、protected、private、默认、strictfp和static。
一旦用static修饰，它就变成静态嵌套类了囧。

7 本地内部类
本地内部类定义在方法中，类似于本地变量（局部变量）。所以可以用于修饰本地内部类的只有final和abstract。
本地内部类只能在定义该内部类的方法或块内实例化，不可以在外部对其实例化。
本地内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象不能使用它们。
静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即只能访问外部类的静态成员。

class TLC3 {
    private String s = "tlc3:string";

    public void f(boolean b) {
        String s1 = "tlc3:f:string";
        final String s2 = "tlc3:f:final string";
        if (b) {
            // 本地内部类
            class LIC1 { // 块内可见
                private String ls;

                LIC1(String str) {
                    this.ls = str;
                }

                public void f() {
                    System.out.println(s);
                    // ! System.out.println(s1); 只能使用final类型的外部对象
                    System.out.println(s2);
                    System.out.println(ls);
                }
            }
            // ! new LIC(); 只能有一个构造函数
            System.out.println(new LIC1("lic1:string").ls);

            final class LIC2 extends LIC1 {
                LIC2() {
                    super("lic2:string");
                    super.f();
                }
            }
            new LIC2();
            // ! class LIC3 extends LIC2{} final类不可继承
        } else {
            class LIC1 {
            }
        }
        // ! new LIC2(); 超出作用域
    }
}

main代码：

new TLC3().f(true);

结果：

lic1:string
tlc3:string
tlc3:f:final string
lic2:string

上面的代码会生成TLC3$1LIC1.class和TLC3$2LIC1.class，可看出命名规则：外部类名+$+数字编号+内部类名，以防内部类重名。

8 匿名内部类
a.用于实现一个接口
b.用于扩展拥有非默认构造函数的一个类
c.用于执行字段初始化
d.通过实例初始化进行构建（匿名内部类不可拥有构造函数）

class TLC4 {
    // 匿名内部类
    public Contents f1() {
        return new Contents() {
            @Override
            public String get() {
                return "tlc4:f1:anonymous:string";
            }
        };
    }

    public void f2(AC ac) {
        ac.f1();
        ac.f2();
    }

    public AC f3(final int i) {
        return new AC(i) {
            // 初始化
            {
                if (i == 1)
                    System.out.println("i==1 is true");
            }

            @Override
            public void f1() {
                System.out.println("tlc4:f3:anonymous:f1");
            }
        };
    }
}

abstract class AC {
    private int i;

    public AC(int i) {
        this.setI(i);
    }

    abstract public void f1();

    public void f2() {
        System.out.println("AC:f2");
    }

    public void setI(int i) {
        this.i = i;
    }

    public int getI() {
        return i;
    }
}

interface Contents {
    String get();
}

main代码：

        TLC4 tlc4 = new TLC4();
        System.out.println(tlc4.f1().get());
        tlc4.f2(new AC(3) {
            @Override
            public void f1() {
                System.out.println("anonymous:f1 i:" + this.getI());
            }
        });
        tlc4.f3(1);

执行结果：

tlc4:f1:anonymous:string
anonymous:f1 i:3
AC:f2
i==1 is true

9 链接到外部类
创建自己的内部类时，那个类的对象同时拥有指向封装对象（这些对象封装或生成了内部类）的一个链接。内部类的一个对象只能与封装类的一个对象联合创建。

10 小结
java嵌套类内容很多，很纷杂。要记清其种类以及每种相应的规则，做到胸有成竹。本文完整源代码下载。

chenkkkabc 2009-05-21 17:45 发表评论