91麻豆精品国产91久久久久久 ,国产精品第一视频,欧美日韩国产中文字幕在线

Java 正则表达�?(2) -- Metacharacters & Character Classes

Jafe — Mon, 10 Dec 2007 01:58:00 GMT

1、元字符(metacharacters):元字�W�是指那些可以代表特�D�含义的字符�Q�java.util.regex支持的元字符包括

([{\^-$|]})?*+.。注意，在某些时候这些特�D�的字符�q�不一定代表特�D�含义，例如 - 在[a-c]中是元字�W�，但在 a-c 则不表示�Ҏ��含义。不�q�上面没列出的字�W�则一定不会代表特�D�含义�?br />
2、可以对元字�W�进行�{义，主要有两�U�方法：

在元字符前面加一个反斜杠 (backslash�Q�\
�?\Q �?\E包含��h��Q�例�?\? == \Q?\E

3、Character Classes �Q�这里的class�q�不是Java中的class�Q�在正则表达式中�Q�一个character class是由一�p�d��包含在方括号中的字符�l�成�Q�它能在输入的一�p�d��字符串中匚w��一个字�W�，例如[a-d]匚w��a, b, c, d,中的��M��一个字�W�。再看下面一个例子（摘自java.sun.com�Q?br />

Character Classes
`[abc]`	a, b, or c (simple class)
`[^abc]`	Any character except a, b, or c (negation)
`[a-zA-Z]`	a through z, or A through Z, inclusive (range)
`[a-d[m-p]]`	a through d, or m through p: [a-dm-p] (union)
`[a-z&&[def]]`	d, e, or f (intersection)
`[a-z&&[^bc]]`	a through z, except for b and c: [ad-z] (subtraction)
`[a-z&&[^m-p]]`	a through z, and not m through p: [a-lq-z] (subtraction)

4、Character Classes 之间的运��：从上面的表格也可以看�?character classes包含了几个跟集合操作很相似的操作�Q�例如negation�Q�补�Q�、union(�qӞ��、intersection(交）、subtraction(差）。由上面的表��g��可以看出两个Character Classes之间的运��只需要简单地��一个Character Classes嵌入到另一个Character Classes�q��用正��的操作�W�就可以了�?br />
5、Predefined Character Classes�Q�java.util.regex.* 包含了一些预先定义的 Character Classes,在实际中可以很方便地�q�用�Q�（摘自 java.sun.com )

Predefined Character Classes
`.`	Any character (may or may not match line terminators)
`\d`	A digit: `[0-9]`
`\D`	A non-digit: `[^0-9]`
`\s`	A whitespace character: `[ \t\n\x0B\f\r]`
`\S`	A non-whitespace character: `[^\s]`
`\w`	A word character: `[a-zA-Z_0-9]`
`\W`	A non-word character: `[^\w]`

Jafe 2007-12-10 09:58 发表评论

Java 正则表达�?(1) -- java.util.regex.* 介绍

Jafe — Sun, 09 Dec 2007 11:47:00 GMT

1、Java 1.4之后的版本引�q�了一个用于处理正则表辑ּ�的包 java.util.regex.*; 该包主要包含三个�c�：

Pattern : 用来表示一个经�q�编译处理后的正则表辑ּ�。通俗一�Ҏ��_��是用一个类来表�C�Z��个正则表辑ּ��Q�这个类是从正则表达式构造得到的。这个类�q�没有public constructor, 如果惛_��C��个这个类的一个对象则必须调用该类的public static�Ҏ��Q�public static Pattern compile(String regex)或�?public static Pattern compile(String regex,int flags)。这两个�Ҏ��q�回一个Pattern型的对象�?/li>
Matcher : 解释Pattern�q�执行匹配、查扑ַ�作的�c�，跟Pattern�c�M��P��q�个�c�M��没有定义public constructor�Q�要惌��得一个Matcher对象必须调用Pattern�cȝ��Ҏ�� public Matcher matcher(CharSequence input) 来得到�?/li>
PatternSyntaxException : 一个unchecked exception。当遇到不符和Java正则表达式的语法的时候程序就会抛��个异常�?/li>

2、一个例子（摘自java.sun.com �Q?br />

package regex;

import java.io.Console;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class RegexTestHarness {
    public static void main(String [] args) {
        Console console = System.console();
        if (console == null) {
            System.err.println("No console.");
            System.exit(1);
        }
        while (true) {
            Pattern pattern = Pattern.compile(console.readLine("%nEnter your regex: "));
            Matcher matcher = pattern.matcher(console.readLine("Enter input string to search: "));
            boolean found = false;
            while (matcher.find()) {
                console.format("I found the text \"%s\"starting at " +
                        "index %d and ending at index %d. %n", matcher.group(), matcher.start(), matcher.end());
                found = true;
            }
            if (!found)
                console.format("No match found.%n");
        }
    }
}

注：�׃��q�个例子使用了JDK 1.6后才有的�Ҏ��Q�System.console(),所以这个例子在eclipse和netbeans都不能正常运行。只有在命��o行下才能正确�q�行。如果想在eclipse和nb下运行，好像可以用System.out/in来代替System.console�?br />

Jafe 2007-12-09 19:47 发表评论

Java Thread (1)

Jafe — Wed, 12 Sep 2007 13:32:00 GMT

1、开启一个新�U�程的方法，归结��h��不外乎有两种�Q?br />

�l�承�c�java.lang.Thread �Q�覆盖其中的�Ҏ�� run(); 实例化该子类�Q�例如：
public class MyThread extends Thread
{
   public void run()
  {
      // do some work
   }
}
// code to use MyThread
new MyThread().start();
定义一个实现接�?java.lang.Runnable; 的类�Q�实现该接口的方法run(); 然后��该�cȝ��一个实例作为实参传�l�Thread的构造方法。例如：
public class MyThread2 implements Runnable
{
   public void run()
  {
      // do some work
   }
}

// code to use MyThread2
Thread t = new Thread(MyThread2);
t.start();
无论用哪�U�方法最�l�得到的都是一个Thread的object�Q�当调用�Ҏ��start()�Ӟ��pȝ��创��Z��个新的线�E�来执行run() �Ҏ��Q�这个新的线�E�将一直运行知道run�Ҏ��退出。在新线�E�开始运行的同时�Q�原来的�U�程也将�l�箋执行start()之后的代码�?/span>

2、一个线�E�的生命周期�Q�每个线�E�的生命周期(lifecycle)一共有六个状�?state)�Q�这六个状态用枚�D�c�d��Thread.State的六个枚丑ָ�量来表示。分别是�Q?br />

NEW : �U�程已经被创建，但是start()�Ҏ��q�没被调用，所有的�U�程都是从这个状态开始的
RUNABLE : 该线�E�已�l�在JVM上执行了�Q�但可能�q�在�{�待操作�pȝ��U�的其他资源�Q�也��是说要么现在就在运行，要么只要操作�pȝ��调度到该�U�程时立卛_��可以执行�?/li>
BLOCKED �Q?�U�程�q�没有运行因为它必须�{�待直到获得一个锁以便�q�入一个synchronized的方法或者块�?/li>
WAITING : �U�程�q�没有运行因为它已经调用了方�?Object.wait()或�?Thread.join( ).
TIMED_WAITING �Q�线�E��ƈ没有�q�行因�ؓ它已�l�调用了Thread.sleep()或者调用了使用timeout值的Object.wait()或�?Thread.join( ).
TERMINATED : �U�程已经完成执行��d��Q�即run()�Ҏ��要么正常退出，要么抛出一个异常�?/a>

3、线�E�优先��Q�线�E�可以有不同优先�U�，Thread定义了三个优先��帔R��Q?br />

public final static int MIN_PRIORITY = 1; //最��优先��
public final static int NORM_PRIORITY = 5; //默认的优先��
public final static int MAX_PRIORITY = 10; //最大优先��

一个线�E�的优先�U�可以是1�?0中�Q何一个整敎ͼ�包括1�?0).�Ҏ�� void setPriority(int newPriority) 可以用来讄��U�程有限�U�。关于优先��需要注意的是，调度器��L��选择优先�U�最高的�U�程来执行，但是java的线�E�优先��是和操作�pȝ��相关的，例如windows XP�pȝ��?个优先��Q�java中的某些优先�U�会对应到xp�?个优先��中去。但是SUN 的linux版本的JVM上所有线�E�的优先�U�都是NORM_PRIORITY。在使用优先�U�的同时也要避免饿死的情况出现�?br /> 4、处�?uncaught exceptions: 当一个线�E�的run()�Ҏ��执行完毕或者run()�Ҏ��执行return语句�Ӟ��U�程正常中止。当run�Ҏ��抛出一个unchecked异常�Ӟ��注意�Q�run�Ҏ��是不能抛出checked异常的）�Q�线�E�也会中止�ƈ且打印出异常信息。如果你��x��获处理该异常�Q�则必须��U�程��d��一个uncaught exception handler来执行。例如：package uncaughtexception; public class MyThread implements Runnable { @Override public void run() { throw new UnsupportedOperationException(); } } package uncaughtexception; public class TestMyThread { public static void main(String [] args) { Thread aThread = new Thread(new MyThread()); aThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { @Override public void uncaughtException(Thread t, Throwable e) { System.out.println("Hello"); } }); aThread.start(); } } �q�行�l�果: Hello

Jafe 2007-09-12 21:32 发表评论

Java Enumeration (枚�D�c�d��) (5) -- Value-specific class body

Jafe — Sun, 09 Sep 2007 07:29:00 GMT

什么是Value-specific class body呢？��而言之，��是不同的枚丑ָ��?(enumeration constant)拥有自己的类定义�Q�先看一个例子（�q�个例子的行为可以用更优雅的代码来实玎ͼ�用它只是��Z��说明问题�Q?br />

ArithmeticOp.java

TestOperator.java

定义每一�?value-specific class body �Q�不知如何翻译~~)��会创徏一个该枚�D�c�d��的匿名子�c�（anonymous subclass), 对应的枚丑ָ�量将会唯一的指向该子类。这里需要注意的是，��管枚�D�c�d��不能被extends�Q�但是它却可以拥有匿名子�c�，从这个意义上来说�Q�枚丄��型�ƈ不是一个严格的final�c�R�?/li>
匿名子类��预�C�着�q�些子类没有自己的constructor�Q�你也不能在你的代码中引用一些匿名子�c�自己拥有的�Ҏ��或域�Q�见上面例子ADD中的justForAdd�Ҏ��Q�，�q�是因�ؓ每个枚�D�c�d��的枚丑ָ�量的枚�D�c�d��都是该枚丄��型的。可能这句话我表�q�的不好。�D个例子，设有�c?A, B是A的子�c�，B有一个自��q��Ҏ�� bMethod()。在代码中，我先new一个B的实例b�Q�然后再declare一个A的变量a,�q�让a指向b(a = b)�Q�这�Ӟ��管a�Q�b指向同一个对象，但你可以b.bMethod()却不能够a.bMethod()�?/li>
枚�D�c�d��可以定义abstract�Ҏ��Q�但你必��至��定义一个枚丑ָ�量来实现�q�些abstract�Ҏ��Q�否则将会��生编译错误�?/li>
�?可以看出�Q�定义value-specific class body实际上就是实现枚丄��型中的abstract�Ҏ��或者override枚�D�c�d��U�存在的�Ҏ��?br />

Jafe 2007-09-09 15:29 发表评论

Java Enumeration (枚�D�c�d��) (3) -- 自定义类�?class body)

Jafe — Sat, 08 Sep 2007 07:39:00 GMT

枚�D�c�d��其实是一个有限制的类�Q�很多类的语法都可以用在枚�D上面上，例如自定义域、方法、构造方法等。先看下面一个例子：

package custom;
public enum Prefix
{
    // These are the values of this enumerated type.
    // Each one is followed by constructor arguments in parentheses.
    // The values are separated from each other by commas, and the
    // list of values is terminated with a semicolon to separate it from
    // the class body that follows.
    MILLI("m", .001),
    CENTI("c", .01),
    DECI("d"),
    DECA("D", 10.0),
    HECTA("h", 100.0),
    KILO("k", 1000.0);  // Note semicolon

                                                                                                                                                                                                                        // semicolon

    // This is the constructor invoked for each value above.
    private Prefix(String abbrev, double multiplier)
    {
        this.abbrev = abbrev;
        this.multiplier = multiplier;
    }

    //Another constructor
    private Prefix(String abbrev)
    {
        this.abbrev = abbrev;
        this.multiplier = .1;
    }

    // These are the private fields set by the constructor
    private String abbrev;
    private double multiplier;

    // These are accessor methods for the fields. They are instance methods
    // of each value of the enumerated type.
    public String abbrev()
    {
        return abbrev;
    }

    public double multiplier()
    {
        return multiplier;
    }
}

需注意�Q�一个枚丄��型可以有多个构造器�?br />

Jafe 2007-09-08 15:39 发表评论

Java Enumeration (枚�D�c�d��) (2) -- switch语句

Jafe — Sat, 08 Sep 2007 06:43:00 GMT

当枚丄��型用在switch语句中时�Q�语法有一点点特别。看例子�Q?div style="border: 1px solid rgb(204, 204, 204); padding: 4px 5px 4px 4px; background-color: rgb(238, 238, 238); font-size: 13px; width: 98%;">package other;
import basic.Day;
public class SwitchTest
{
    public static void main(String [] args)
    {
        int FRIDAY = 5;
        System.out.println(FRIDAY);

        Day today = Day.SATURDAY;
        switch(today)
        {
        case FRIDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case SATURDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case SUNDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case MONDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case TUESDAT:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case WEDNESDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        case THURSDAY:
            System.out.println("Today is " + today.toString().toLowerCase());
            break;
        default:
            System.out.println("otherday");
        }
    }
}
注意在case标签中，Day不出玎ͼ�即case Day.FRIDAY是不合法的。而在其他地方出现时则必须用Day.FRIDAY

Jafe 2007-09-08 14:43 发表评论

Java Enumeration (枚�D�c�d��) (1) -- 基本概念

Jafe — Sat, 08 Sep 2007 06:13:00 GMT

Java 5.0新引�q�了一�U�类型：枚�D�c�d��。昨晚看了一下，语法�q�是比较复杂的，臛_��比C的枚举要复杂的很多，不过功能也强大了很多。具体语法请参见 JLS 8.9
1、定义一个功能简单的枚�D�c�d��Q�更定义一个简单的�c�d��怼��Q�例�?/font>

package basic;
public enum Day
{
MONDAY, TUESDAT, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

跟类定义一��P��枚�D�c�d��可以单独攑֜�一个文仉��Q�当一个枚丄��型用public修饰�Ӟ��它对其他包可见，否则只对同一个包中的�c�d��见，�q�和�c�d��义是一��L��?/font>

标识�W?MONDAY, TUESDAY�{�就�U�Cؓ枚�D帔R��Q�enumeration constants�Q?/font>

每一个枚丑ָ�量被隐式的声明成Day的一个public、static成员�Q�而且其类型�ؓDay�Q�亦��是说这些常量是self-typed�?br />

2、下面的定义也是合法的：

package basic;

public enum Day
{
MONDAY, TUESDAT, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY,
}

�?br />

package basic;

public enum Day
{
MONDAY, TUESDAT, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY,;
}

�?br />

package basic;

public enum Day
{
MONDAY, TUESDAT, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}

但是当枚丄��型有其他定义�Ӟ��则分�?是必��ȝ��
3、声明、��用一个枚丄��型：
�Q?�Q�在同一个包中：

BasicMainClass.java

�Q?�Q�在不同包中�Q?br />

OtherMainClass.java

4、枚丄��型的性质�Q�（摘自o'relly 出版�?Java in A Nutshell 5th)

Enumerated types have no public constructor. The only instances of an enumerated type are those declared by the enum.
Enums are not Cloneable, so copies of the existing instances cannot be created.
Enums implement java.io.Serializable so they can be serialized, but the Java serialization mechanism handles them specially to ensure that no new instances are ever created.
Instances of an enumerated type are immutable: each enum value retains its identity. (We'll see later in this chapter that you can add your own fields and methods to an enumerated type, which means that you can create enumerated values that have mutable portions. This is not recommended, but does not affect the basic identity of each value.)
Instances of an enumerated type are stored in public static final fields of the type itself. Because these fields are final, they cannot be overwritten with inappropriate values: you can't assign the DownloadStatus.ERROR value to the DownloadStatus.DONE field, for example.
By convention, the values of enumerated types are written using all capital letters, just as other static final fields are.
Because there is a strictly limited set of distinct enumerated values, it is always safe to compare enum values using the = = operator instead of calling the equals() method.
Enumerated types do have a working equals( ) method, however. The method uses = =finalso that it cannot be overridden. This working equals( ) method allows enumerated values to be used as members of collections such as Set, List, and Map. internally and is
Enumerated types have a working hashCode() method consistent with their equals( )equals(), hashCode( ) is final. It allows enumerated values to be used with classes like java.util.HashMap. method. Like
Enumerated types implement java.lang.Comparable, and the compareTo() method orders enumerated values in the order in which they appear in the enum declaration.
Enumerated types include a working toString( ) method that returns the name of the enumerated value. For example, DownloadStatus.DONE.toString( ) returns the string "DONE" by default. This method is not final, and enum types can provide a custom implementation if they choose.
Enumerated types provide a static valueOf( ) method that does the opposite of the default
toString( ) method. For example, DownloadStatus.valueOf("DONE") would return DownloadStatus.DONE.
Enumerated types define a final instance method namedordinal()that returns an integer for each enumerated value. The ordinal of an enumerated value represents its position (starting at zero) in the list of value names in the enum declaration. You do not typically need to use the ordinal( ) method, but it is used by a number of enum-related facilities, as described later in the chapter.
Each enumerated type defines a static method named values( ) that returns an array of enumerated values of that type. This array contains the complete set of values, in the order they were declared, and is useful for iterating through the complete set of possible values. Because arrays are mutable, the values( ) method always returns a newly created and initialized array.
Enumerated types are subclasses of java.lang.Enum, which is new in Java 5.0. (Enum is not itself an enumerated type.) You cannot produce an enumerated type by manually extending the Enum class, and it is a compilation error to attempt this. The only way to define an enumerated type is with the enum keyword.
It is not possible to extend an enumerated type. Enumerated types are effectively final, but the final keyword is neither required nor permitted in their declarations. Because enums are effectively final, they may not be abstract.
Like classes, enumerated types may implement one or more interfaces.

Jafe 2007-09-08 14:13 发表评论

Java 单元��试

Jafe — Wed, 22 Aug 2007 13:00:00 GMT

�׃��来自ibm developworks,转蝲要提交申��P��׃��转内容了。。�?br />
1、单元测试利�?JUnit 4
http://www.ibm.com/developerworks/cn/java/j-lo-junit4/

2、JUnit 4抢先�?br />http://www.ibm.com/developerworks/cn/java/j-junit4.html

3、深入探�?JUnit4�Q�这个似乎要先注册的�Q?br />http://www.ibm.com/developerworks/cn/edu/j-dw-java-junit4.html

4�?font size="3">TestNG �?Java 单元��试轻而易�?br />http://www.ibm.com/developerworks/cn/java/j-testng/

5�?/font>�q�求代码质量: JUnit 4 �?TestNG 的对�?br />http://www.ibm.com/developerworks/cn/java/j-cq08296/

Jafe 2007-08-22 21:00 发表评论

Java�Ҏ�� (3)

Jafe — Mon, 23 Jul 2007 07:47:00 GMT

1、AWT事�g�l�承层次

2、常用AWT事�g�c�d��列表
ActionEvent   KeyEvent
AdjustmentEvent     MouseEvent
FocusEvent     MouseWheelEvent
ItemEvent     WindowEvent

用于监听�q�些事�g的接口：

ActionListener                  MouseMotionListener
AdjustmentListener              MouseWheelListener
FocusListener                   WindowListener
ItemListener                    WindowFocusListener
KeyListener                     WindowStateListener
MouseListener

常用的适配器类�Q?br />FocusAdapter                    MouseMotionAdapter
KeyAdapter                      WindowAdapter
MouseAdapter

3、事件监听原理：
接收事�g的类必须实现监听接口�Q�这个类要用事�g源注册，然后�Q�接受所需要的事�g对象�Q��ƈ通过监听器接口中的方法对事�g作出相应的处�?br />
4、所有AWT事�g源都支持多点传送（multicast)模型�Q�即同一个事件可以发送给多个监听器对象。当时API不能保证一个给定事件源注册的一�l�监听器传送事件的�ơ序�Q�因此不要编写依赖传送次序的�E�序逻辑�?br />

Jafe 2007-07-23 15:47 发表评论

Java�l�承

Jafe — Sun, 22 Jul 2007 08:40:00 GMT

1、关键字super有两个用途：一是调用超�cȝ��Ҏ��Q�而是调用��类的构造器�?br /> super不是对一个对象的引用�Q�不能将super赋给另一个对象变量，它只是一个指�C�编译器调用��类�Ҏ��的特有关键字。super在构造器中的作用�Q?br />

public Manager(String n, double s, int year, int month, int day)
{
   super (n, s, year, month, day);
  bonus = 0 ;
}

�׃��构造器不能范围Employee�cȝ��U�有域（具体例子见本文最后面PersonTest.java�Q�，所以必��d��用Employee�cȝ��构造器对这部分�U�有域进行初始化�?/font> �Q�我们可以通过super实现对超�c�L��造器的调用�?font color="#ff0000">使用super调用构造器的语句必��L�� c�L��造器的第一条语�?/font>。如果之�cȝ��构造器没有昄��的调用超�cȝ��构造器�Q�这��自动调用超�c�默认（没有参数�Q�的构造器。如果超�c�L��有不带参数的构造器�Q��ƈ且在子类的构造器中没有显�C�地调用��类的其它构造器�Q�则Java�~�译器将报告错误�Q�这个规则对与abstract base class 也是成立的�?br />
2、关键字this有两个用途：一是引用隐式参敎ͼ�二是调用该类的其它的构造器。在调用构造器时和super很相��|��都只能作为另一个构造器的第一条语句出现�?br />
3、多态。先看例子：

Manager boss = new Manager();
Employee [] staff = new Employee[3];
staff[0] = boss;

在这个例子中�Q�变量staff[0]和boss引用同一个对�?但编译器��staff[0]看待成Employee对象.�q�意味着可以�q�样调用:
boss.setBonus(5000);
但不能这栯��?br />staff[0].setBonus(5000);//error�Q�这样会引�v一个编译错�?br />�q�是因�ؓstaff[0]声明的类型是Employee�Q�而setBonus不是Empoyee�cȝ��Ҏ��?br />
4、动态绑定：

�Ҏ��的名字和参数列表被称为方法的�{�֐��Q�signature).如果在子�c�M��定义了一个与��类�{�֐�相同的方法，那么子类中的�q�个�Ҏ��p��盖了��类中的�q�个同签名的�Ҏ��。但是，�q�回�c�d��不是�{�֐�的一部分�Q�因此在覆盖�Ҏ��的时候，一定要保证�q�回�c�d��的兼�Ҏ��。在JDK 5.0以前的版本中�Q�要求返回类型必��L��一��L��。而现在允许子�c�d��覆盖�Ҏ��q�回�c�d��定义为原�q�回�c�d��的子�c�d��。例如，假设Employee�c�L��Q?div style="border: 1px solid rgb(204, 204, 204); padding: 4px 5px 4px 4px; background-color: rgb(238, 238, 238); font-size: 13px; width: 98%;">public Employee getBuddy(){}在后面的子类Manager中，可以按照如下所�C�的�Ҏ��覆盖�q�个�Ҏ��Q?div style="border: 1px solid rgb(204, 204, 204); padding: 4px 5px 4px 4px; background-color: rgb(238, 238, 238); font-size: 13px; width: 98%;">public Manager getBuddy(){} //OK in JDK 5.0
如果�Ҏ��是private, static, final或者是构造器�Q�那么编译器��可以准��地知道应该调用那个�Ҏ��。我们将�q�种调用方式�U�Cؓ静态绑定。但是，子类不能�l�承父类private �Q�方�?更谈不上覆盖�Q�不能覆盖final修饰的方法，但可一覆盖static�Ҏ��
覆盖一个方法的时候，子类�Ҏ��不能低于��类�Ҏ��的可见性。特别是如果��类得方法是public�Q�那么子�c�L��法一定要声明为public�?br />

Jafe 2007-07-22 16:40 发表评论

Java �Ҏ�� (2)

Jafe — Sat, 21 Jul 2007 01:55:00 GMT

1、关于import:
�Q?�Q?使用 * 一�ơ只能import 一个package的类�Q�例如想�?import 包java.util中内容不能用 import java.*.*; 也不能企��N��过�q�种方式�Q?font color="#0000ff">import java.*; util.Date date = new Date();来引�?br />
�Q?�Q�static imports: 从JDK 5.0开始，可以用static�Ҏ��来import 某个�cȝ��静态方法和静态常量。例如：

ImportTest.java

static imports 的好处：例如�Q?/font>sqrt(pow(x, 2) + pow(y, 2))�?font color="#0000ff">Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)) �Q��?font color="#0000ff"> if (d.get(DAY_OF_WEEK) == MONDAY) �?if (d.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) 看�v来要整洁�Q�可��L��也丝毫不会受媄响~~

2、块作用域：�Q�参考资料：《Java2 核心技术》）
�Q?�Q�块�Q�即�W�合语句�Q�是指由一对花括号括�v来的若干条简单的Java语句。块��定了变量的作用域。一个块可以嵌套在另一个块中。例�?br />

TestBlock.java

注意k的作用域�Q�在花括号外是不能再引用k的�?br />�Q?�Q�不能在嵌套的两个块中声明同名变量。例如下面的代码�~�译时是通不�q�的�Q?br />

TestBlock.java

但是�q�样是可以的�Q?br />

TestBlock.java

3、��用内部类(inner class)的动机：

内部�c�L��法可以访问该�c�d��义所在的作用域的数据�Q�包括私有的数据
内部�c�d��以对同一个包中的其它�c�隐藏�v�?/li>
当想要定义一个回调函��C��不想�~�写大量代码时��用匿名（anonymous)内部�c�L��较便捗��（?)

4、只有内部类可以是私有类�Q�常规类只能��h��包的可见性或公有的可见�?br />
5、JFrame 与JPane�cȝ��l�承层次�l�构

6、有时候JFrame�E�序退出时��Z��么要调用setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)?
�q�是因�ؓ在包含多个程序框架的�E�序中，不能因�ؓ用户关闭了其中一个框架就让程序退出。在默认情况下用户关闭窗口时只是��框枉��藏了��h��Q�而程序�ƈ没有�l�止�?br />
7、封装了用户�pȝ��的各个元素的颜色的SystemColor�c�M��的系�l�颜色和它们的含义：

System Colors
`desktop`	Background color of desktop
`activeCaption`	Background color for captions
`activeCaptionText`	Text color for captions
`activeCaptionBorder`	Border color for caption text
`inactiveCaption`	Background color for inactive captions
`inactiveCaptionText`	Text color for inactive captions
`inactiveCaptionBorder`	Border color for inactive captions
`window`	Background for windows
`windowBorder`	Color of window border frame
`windowText`	Text color inside windows
`menu`	Background for menus
`menuText`	Text color for menus
`text`	Background color for text
`textText`	Text color for text
`textInactiveText`	Text color for inactive controls
`textHighlight`	Background color for highlighted text
`textHighlightText`	Text color for highlighted text
`control`	Background color for controls
`controlText`	Text color for controls
`controlLtHighlight`	Light highlight color for controls
`controlHighlight`	Highlight color for controls
`controlShadow`	Shadow color for controls
`controlDkShadow`	Dark shadow color for controls
`scrollbar`	Background color for scrollbars
`info`	Background color for spot-help text
`infoText`	Text color for spot-help text

Jafe 2007-07-21 09:55 发表评论

Java Interface

Jafe — Fri, 25 May 2007 16:16:00 GMT

1、一个Interface的方所有法讉K��权限�Q�visibility)自动被声明�ؓpublic,��却的说�Q�一个Interface的所有方法只能是public的，你可以显式声明一个方法是public�Q�不推荐),但是不能声明它是private或protected.但是当一个类实现某个接口�Q�定义接口的�Ҏ��Ӟ��必须且只能声明�ؓpublic�Q�否则编译将通不�q��?br />
2、接口不能实现方法（implement method),只能声明。接口可以只定义帔R��但不声明��M��Ҏ��?br />
3、Interface不能有实例域�Q�instance fields)或静态方法（static method),但可以定义常�?define constants),帔R��自动设�ؓpublic static final�Q�可以通过�c�d��直接引用帔R��Q�例�?br />

ImplementClass.z

可以通过接口命和帔R��名直接访问常量：

FirstInterface.z

4、一�?font color="#000000">非抽�?/font>�c?font color="#ff0000">�Q�注意是非抽象类�Q�）实现一个接口时�Q�必��d��现接口的所有方法，抽象�c�d��不必实现所有方法�?br />
5、不能��用new操作�W�实例化一个接口，但可以声明一个接口变量，该变量必��d��用（refer to)一个实现该接口的类的对象。可以��?instanceof ��查一个对象是否实��C��某个特定的接口。例如：

if(anObject instanceof Comparable){}

6、接口可以被另一个接口��承（但是final好像不能修饰interface�Q�编译通不�q�，以后慢慢研究~~)

7、标记接口（tagging interface, marker interface)没有�Ҏ��Q��用它的唯一目的是可以用instanceof �q�行�c�d��查（Horstmann说了�Q�不鼓励用这�U�技�?^_^�Q?br />
8�?font size="3">�Ҏ��的名字和参数列表被称为方法的�{�֐��Q�signature)�Q�实��C��个接口以为着要用完全相同的签名实现每个方法。因此实现接口方法时�Q�一定要保证�q�回�c�d��的兼�Ҏ��?/font>允许实现�cȝ��实现�Ҏ��q�回�c�d��定义为原�q�回�c�d��的子�c�d��。这个跟�l�承中子�c�覆盖父�c�L��法很�怼��?br />
8、例子：

FirstInterface.java

SecondInterface.java

ImplementClass.java

Main.java

�q�行�l�果�Q?br />20
21
22
I love you!
I love you!
9、匿名内部类(anonymous inner class):
注意一个特别的例子

AnonymousInnerClass.java

而java.util.Comparator的定义�ؓ

Comparator.java
/*
* @(#)Comparator.java    1.26 06/04/21
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/

package java.util;

/**
* A comparison function, which imposes a total ordering on some
* collection of objects.  Comparators can be passed to a sort method (such
* as {@link Collections#sort(List,Comparator) Collections.sort} or {@link
* Arrays#sort(Object[],Comparator) Arrays.sort}) to allow precise control
* over the sort order.  Comparators can also be used to control the order of
* certain data structures (such as {@link SortedSet sorted sets} or {@link
* SortedMap sorted maps}), or to provide an ordering for collections of
* objects that don't have a {@link Comparable natural ordering}.

*
* The ordering imposed by a comparator c on a set of elements
* S is said to be consistent with equals if and only if
* c.compare(e1, e2)==0 has the same boolean value as
* e1.equals(e2) for every e1 and e2 in
* S.

*
* Caution should be exercised when using a comparator capable of imposing an
* ordering inconsistent with equals to order a sorted set (or sorted map).
* Suppose a sorted set (or sorted map) with an explicit comparator c
* is used with elements (or keys) drawn from a set S. If the
* ordering imposed by c on S is inconsistent with equals,
* the sorted set (or sorted map) will behave "strangely." In particular the
* sorted set (or sorted map) will violate the general contract for set (or
* map), which is defined in terms of equals.

*
* For example, suppose one adds two elements {@code a} and {@code b} such that
* {@code (a.equals(b) && c.compare(a, b) != 0)}
* to an empty {@code TreeSet} with comparator {@code c}.
* The second {@code add} operation will return
* true (and the size of the tree set will increase) because {@code a} and
* {@code b} are not equivalent from the tree set's perspective, even though
* this is contrary to the specification of the
* {@link Set#add Set.add} method.

*
* Note: It is generally a good idea for comparators to also implement
* java.io.Serializable, as they may be used as ordering methods in
* serializable data structures (like {@link TreeSet}, {@link TreeMap}). In
* order for the data structure to serialize successfully, the comparator (if
* provided) must implement Serializable.

*
* For the mathematically inclined, the relation that defines the
* imposed ordering that a given comparator c imposes on a
* given set of objects S is:


 *       {(x, y) such that c.compare(x, y) <= 0}.
 *

The quotient for this total order is:


 *       {(x, y) such that c.compare(x, y) == 0}.
 *

*
* It follows immediately from the contract for compare that the
* quotient is an equivalence relation on S, and that the
* imposed ordering is a total order on S. When we say that
* the ordering imposed by c on S is consistent with
* equals, we mean that the quotient for the ordering is the equivalence
* relation defined by the objects' {@link Object#equals(Object)
* equals(Object)} method(s):


 *     {(x, y) such that x.equals(y)}.

*
* This interface is a member of the
* docRoot}/../technotes/guides/collections/index.html">
* Java Collections Framework.
*
* @param  the type of objects that may be compared by this comparator
*
* @author  Josh Bloch
* @author  Neal Gafter
* @version 1.26, 04/21/06
* @see Comparable
* @see java.io.Serializable
* @since 1.2
*/

public interface Comparator<T> {
    /**
     * Compares its two arguments for order.  Returns a negative integer,
     * zero, or a positive integer as the first argument is less than, equal
     * to, or greater than the second.

     *
     * In the foregoing description, the notation
     * sgn(expression) designates the mathematical
     * signum function, which is defined to return one of -1,
     * 0, or 1 according to whether the value of
     * expression is negative, zero or positive.

     *
     * The implementor must ensure that sgn(compare(x, y)) ==      * -sgn(compare(y, x)) for all x and y.  (This
     * implies that compare(x, y) must throw an exception if and only
     * if compare(y, x) throws an exception.)

     *
     * The implementor must also ensure that the relation is transitive:
     * ((compare(x, y)>0) && (compare(y, z)>0)) implies
     * compare(x, z)>0.

     *
     * Finally, the implementor must ensure that compare(x, y)==0
     * implies that sgn(compare(x, z))==sgn(compare(y, z)) for all
     * z.

     *
     * It is generally the case, but not strictly required that
     * (compare(x, y)==0) == (x.equals(y)).  Generally speaking,
     * any comparator that violates this condition should clearly indicate
     * this fact.  The recommended language is "Note: this comparator
     * imposes orderings that are inconsistent with equals."
     *
     * @param o1 the first object to be compared.
     * @param o2 the second object to be compared.
     * @return a negative integer, zero, or a positive integer as the
     *            first argument is less than, equal to, or greater than the
     *           second.
     * @throws ClassCastException if the arguments' types prevent them from
     *            being compared by this comparator.
     */
    int compare(T o1, T o2);

    /**
     *
     * Indicates whether some other object is "equal to" this
     * comparator.  This method must obey the general contract of
     * {@link Object#equals(Object)}.  Additionally, this method can return
     * true only if the specified object is also a comparator
     * and it imposes the same ordering as this comparator.  Thus,
     * comp1.equals(comp2) implies that sgn(comp1.compare(o1,      * o2))==sgn(comp2.compare(o1, o2)) for every object reference
     * o1 and o2.

     *
     * Note that it is always safe not to override
     * Object.equals(Object).  However, overriding this method may,
     * in some cases, improve performance by allowing programs to determine
     * that two distinct comparators impose the same order.
     *
     * @param   obj   the reference object with which to compare.
     * @return  true only if the specified object is also
     *        a comparator and it imposes the same ordering as this
     *        comparator.
     * @see Object#equals(Object)
     * @see Object#hashCode()
     */
    boolean equals(Object obj);
}

我敢开始看觉得奇怪，好像在匿名内部类中没有实现方法boolean equals(Object obj);后来仔细一惻I��其实所有的�c�都是Object的子�c�，而Object正好有该�Ҏ��的实玎ͼ�所以，即��没有实现该方法也是合法的�?br />

Jafe 2007-05-26 00:16 发表评论

Java �U�M��操作

Jafe — Tue, 22 May 2007 09:17:00 GMT

�U�M��操作要注意的问题是高�Q�低�Q�位是补0�q�是�?和对char, byte, short型的操作�Q?br />�Q?�Q?lt;< : (left-shift), 最低位�?
�Q?�Q?gt;> : �Q�signed right-shift), 右移�q�程使用�W�号位扩展（sign extension)�Q�即如果�W�号��Zؓ1则高位补1�Q��?�?则补0�Q�也��是逻辑右移
�Q?�Q?gt;>> : (unsigned right-shit),右移�q�程使用零扩展（zero extension),��x��高位一律补0�Q�也��是��术右移
�Q?�Q? �U�M��操作的数据类型可以是byte, char, short, int, long型，但是对byte, char, short�q�行操作时会先把它们变成一个int型，最后得��C��个int型的�l�果�Q�对long型操作时得到一个long型结果，不可以对boolean型进行操作�?br />�Q?�Q�移位操作符可以和＝合�ƈ��h��Q�即 <<= �?>>= �?>>>=。例�?a >>= 2; 表示��a右移两位后的值重新赋�l�a。当时在使用�q�三个操作符�?byte, char, short型数据进行操作时要注意，例如有一下代码片�D�：

public class ShiftTest
{
    public static void main(String [] args)
    {
        byte a;
        byte b;
        byte c;
        a = 127;
        b = 127;
        c = 127;
        a <<= 2;
        System.out.println(a);
        System.out.println(b <<= 2);
        System.out.println(c << 2);
    }
}

�q�行�l�果是：
            -4
          -4
             508
�q? 说明了在操作a <<= 2 执行�q�程是这��L��Q�先��?byte型的�?127变成int型，左移2位得�? 508�Q�然后把508赋给byte型变量a时只是简单地"折断"(truncate)得到�?4。编译时�~�译器不会提�C�Z��可能损失�_�ֺ��Q�实际上在本例中��? 实是损失�_�ֺ�了）�Q�但是如果你把a <<= 2�Ҏ�� a = a << 2;�~�译器就会提�C�可能损��q��度了�?img src ="http://www.aygfsteel.com/JafeLee/aggbug/119177.html" width = "1" height = "1" />

Jafe 2007-05-22 17:17 发表评论

Java �Ҏ�� (1)

Jafe — Mon, 21 May 2007 08:30:00 GMT

1�?/font>Java�q�算�W�优先��Q?br />

Operator Precedence
Operators	Associativity
`[] . ()` (method call)	Left to right
`! ~ ++ -- +` (unary) `�?/tt> (unary) () (cast) new`	Right to left
`* / %`	Left to right
`+ -`	Left to right
`<< >> >>>`	Left to right
`< <= > >= instanceof`	Left to right
`== !=`	Left to right
`&`	Left to right
`^`	Left to right
`\|`	Left to right
`&&`	Left to right
`\|\|`	Left to right
`?:`	Right to left
`= += -= *= /= %= &= \|= ^= <<= >>= >>>=`	Right to left

注意�Q?br />

&& || ! 的操作数只能用于boolean �?Boolean
& | 的操作数既可以用于boolean(Boolean)或者整�?不仅仅是int型）�Q�但两个操作数的�c�d��必须一�?/li>
~不能用于boolean(Boolean)型，但可以用于整形，大概是�ؓ了和 ! 区别开来吧
& | 没有短�\计算�?br />

2�?/font>

Java Integer Types
Type	Storage Requirement	Range (Inclusive)
`int`	4 bytes	�?,147,483,648 to 2,147,483,647 (just over 2 billion)
`short`	2 bytes	�?2,768 to 32,767
`long`	8 bytes	�?,223,372,036,854,775,808 to 9,223,372,036,854,775,807
`byte`	1 byte	�?28 to 127

char 2 bytes 0 to 65535

3�?/font>

Floating-Point Types
Type	Storage Requirement	Range
`float`	4 bytes	approximately �u3.40282347E+38F (6�? significant decimal digits)
`double`	8 bytes	approximately �u1.79769313486231570E+308 (15 significant decimal digits)

4、final 实例域（final instance field)�Q�可以将实例域定义�ؓfinal�Q�构建对象时必须初始化这样得域，也就是说�Q�必��ȝ��保在每一个构造器执行之后�Q�这个域的��D��讄��。但是，静态常量必��d��声明的同时也被初始化�?br />
5、for each 循环�Q?br />for (variable : collection) statment
例如�Q�for (int element : a)
System.out.println(element);
该代码片�D�|��印数�l�a的每一个元素，一个元素占一�?br />
6、合法的Java标识�W�：可以以下划线、字母或��元�W�号$开��_��后面可以跟下划线、数字、字母、美元符受��?.42以后的java标识�W�也可以包含汉字�Q�包括开头�?br />

Jafe 2007-05-21 16:30 发表评论

Jafe — Sun, 20 May 2007 10:27:00 GMT

    虽然接触Java已经快一�q�了�Q�也�pȝ��的学�q�Java语法�Q�不�q�很多概念到现在都搞不清楚，现在军_��重新把这些模�p�的概念重新温习一遍，今天��q��ȝ��一下抽象类�Q�abstract class)�?br />
1、��用abstract�cȝ��动机�Q�可以参�?Cay S. Horstmann, Gary Cornel 写的书�?strong>Core Java�?2 Volume I - Fundamentals, Seventh Edition 》（��Z��|�嗦一下，该书是偶见过最好的Java入门书） “Classes, Superclasses, and Subclasses ”一节，定义一个abstract class的格式是�Q�修饰符�Q�public, private, etc)+abstract+�c�d�� 或�?/font> abstract + 修饰�W?+ �c�d��?/span>

2、如果一个类臛_��存在一个抽象方�?abstract method)�Q�则它自�w�必��d��明成一个抽象类。但一个类可以被声明成一个抽象类即��它没有�Q何抽象方法。声明一个abstract method的格式是�Q?/font>修饰�W�（public, private, etc)+abstract+�q�回�c�d�� + �Ҏ��?或�?/font> abstract + 修饰�W?+ �q�回�c�d�� + �Ҏ��名�?/span>

3、一个抽象类可以有数据域和非抽象�Ҏ��Q�concrete data and concrete methods)�?/span>

4、当一个子�cȝ��承某个抽象类�Ӟ��它可以有两个选择�Q?br />    (1)    部分实现或完全不实现父类的所有抽象方法，但此时子�c�d��d��明�ؓ抽象�c�R�?br />    (2)    实现父类所有的抽象�Ҏ��Q�此时之�c�M��比声明�ؓ抽象�c�R�?br />
5、抽象类不能被实例化�Q�be instantiated)�Q�但可以实例化非抽象子类�Q�concrete subclass)�?br />   可以声明抽象�c�d��量，但该变量必须指向一个非抽象子类.看下面一个例子：

   1.  Person [] people = new Person[2];
   2. people[0] = new Employee();
   3. people[1] = new Student();
   4. for (Person p : people)
   5.    System.out.println(p.getName() + "," + p.getDescription());

注意代码中的一个调�?p.getDescription().可能有�h会担心这里调用了一个没定义的方法。但是， �׃��不能构造抽象类Person的对象，所以p永远不会调动Person对象�Q�而是只会调用诸如Employee或Student�q?/font>��L��具体子类�Ҏ��?/font>注意�Q�如果没有定义Person中抽象方法getDescription()但是通过p调用getDescription()则会产生�~�译错误�Q�编译器只允许调用在�c�M��声明的方法�?/font>

6、摘自《Core Java 2》的一个例子：

PersonTest.java

参考资料：

Core Java 2 Volume I - Fundamentals, Seventh Edition

by Cay S. Horstman, Gary Cornell

Jafe 2007-05-20 18:27 发表评论

91麻豆精品国产91久久久久久 ,国产精品第一视频,欧美日韩国产中文字幕在线

Java 正则表达�?(2) -- Metacharacters & Character Classes

Java 正则表达�?(1) -- java.util.regex.* 介绍

Java Thread (1)

Java Enumeration (枚�D�c�d��) (5) -- Value-specific class body

Java Enumeration (枚�D�c�d��) (3) -- 自定义类�?class body)

Java Enumeration (枚�D�c�d��) (2) -- switch语句

Java Enumeration (枚�D�c�d��) (1) -- 基本概念

Java 单元���试

Java�Ҏ�� (3)

Java�l�承

Java �Ҏ�� (2)

System Colors

Java Interface

Java �U�M��操作

Java �Ҏ�� (1)

Operator Precedence

Java Integer Types

Floating-Point Types

Java 单元��试