先把教材的最后一章看了再说

1. File class
四个常量:pathSeparator, pathSeparatorChar, separator, separatorChar
与常量命名惯例冲突。

2. 几乎所有的I/O类的方法会抛出java.io.IOException,在使用时必须声明或使用try块。

3. 文本IO
两个基类Reader和Writer,下面分别有InputStreamReader BufferedReader FileReader PrintWriter等子类。
基类的方法Core Java中已经看了一部分了。
PrintWriter类并不会抛出IOException

4. FileReader / FileWriter
Reader及其子类访问一个并不存在的文件会抛出IOException的子类FileNotFoundException。
判断文件结尾:input.read() == -1
FileWriter的常用构造方法:
java.io.FileWriter(java.io.File)
java.io.FileWriter(java.lang.String)
java.io.FileWriter(java.io.File, boolean append)
java.io.FileWriter(java.lang.String, boolean append)
如果文件已经存在,前面两个构造器会清除该文件的所有内容。使用后面两个构造器,并设置append为true可以防止这种情况。
也可以在写入前判断:
if (file.exites()) {
System.out.println(“File temp.txt already exites”);
System.exit(0);
}

5. InputStreamReader / InputStreamWriter
可以在byte和char之间转换。编码方式可以是默认的,也可以由用户指定。
getEncoding()方法返回当前的编码方式名(String)。由于FileReader和FileWriter是他们的子类,因此也可以使用这个方法。

6. BufferedReader / BufferWriter
使用了一个字符数组作为缓冲区,减少读写次数,以提高读写速度。
在输入时,预先读入字符;输出时,先把内容暂存在数组中,分块输出到输出流。
构造器
java.io.BufferedReader(java.io.Reader)
java.io.BufferedReader(java.io.Reader, int)
java.io.BufferedWriter(java.io.Writer)
java.io.BufferedWriter(java.io.Writer, int)
int指定了缓冲区大小,默认为8192字节。
可以用BufferedReader/Writer类“包装”任何Reader/Writer流。
String BufferedReader.readLine()方法返回一行不带有换行符的文本,没有则返回null。
void BufferWriter.newLine()方法写入一个换行符

7. PrintWriter / PrintStream
以文本形式输出对象、字符串或者数值。PrintWriter被设计用于代替PrintStream,两者的输出功能几乎相同,但是前者更高效。
System.out就是一个静态的PrintStream对象,默认为屏幕控制端,可以通过System.setOut(PrintStream)重新设置。
两者都有许多重载的print/println方法,以及和C相似的printf。
PrintWriter的构造器(并不会抛出IOException异常)
public PrintWriter(Writer out)
public PrintWriter(Writer out, boolean autoFlush)

posted @ 2007-04-22 20:24 ZelluX 阅读(536) | 评论 (0)编辑 收藏

2007-02-22 23:08:37

等看完了Thinking in Java后还是很有必要看一遍Core Java的,JDK5新增的东西Thinking in Java都没提到。

枚举类

l public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

这样已经定义了一个Size类,它是java.lang.Enum类的子类。

l 枚举类的相等判断可以直接使用==符号。

l 可以在枚举类中添加构造器、方法和数据域。构造器只能在枚举常量初始化的时候使用。

enum Size

{

SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL");

private Size(String abbreviation) { this.abbreviation = abbreviation; }

public String getAbbreviation() { return abbreviation; }

private String abbreviation;

}

l toString()方法返回枚举常量的常量名,如

Size.SMALL.toString()

返回”SMALL”

l valueOf方法则将由变量名得到枚举常量,如

Size s = (Size) Enum.valueOf(Size.class, “SMALL”);

s设置为Size.SMALL

l values()方法返回所有的枚举常量,如

Size[] values = Size.values();

l 事实上,Enum类含有类型参数,例如Size类实际上是Enum>Size<

posted @ 2007-04-22 20:24 ZelluX 阅读(377) | 评论 (0)编辑 收藏

2007-02-22 22:29:15

1. 异常抛出后,有几件事会随之发生。首先,使用new在堆上创建异常对象。然后,当前的执行路径被终止,并且从当前环境中弹出对异常对象的引用。此时,异常处理机制接管程序,并开始寻找一个恰当的地方来继续执行程序。这个恰当的地方就是异常处理程序。

2. 所有标准异常类都有两个构造器,一个是缺省构造器,另一个是接受字符串的构造器。

3. 异常处理的一个好处是,使你得以先在一个地方专注于正在解决的问题,然后在别的地方处理这些代码中的错误。

4. 异常处理理论的两种基本模型:终止模型(termination)和恢复模型(resumption)JavaC++都使用前者。不过后者也可以实现,如把try块放入while中,不断进入try块,直到得到满意结果。

5. 创建自定义异常时,建议把信息写到System.err,因为System.out可能会被重定向。

6. Throwable.printStackTrace方法可以输出从方法调用处直到异常抛出处的方法调用序列,使用时可以不带参数,或者传递一个PrintStreamPringWriter类的引用。

posted @ 2007-04-22 20:24 ZelluX 阅读(314) | 评论 (0)编辑 收藏

2007-02-22 22:14:02

ArrayList

JDK5.0以后这是一个泛型类。

ArrayList>Employee< staff = new ArrayList>Employee<();

构造器:

ArrayList(Collection>? extends E< c)

ArrayList()

ArrayList(int initialCapacity)

方法:

boolean add(E e)

void add(int index, E element)

int size() 相当于数组中的length

remove(int index)

remove(Object o)

ArrayList管理了一个对象数组,如果数组已满,此时再加入元素,ArrayList会自动创建一个更大的数组,并把原来数组的内容复制到新数组中。

如果提前知道要加入多少元素,可以使用ensureCapasity(int)方法。也可以在创建ArrayList时使用ArrayList>Employee< staff = new ArrayList>Employee<(int)

如果要使ArrayList定容,使用trimToSize()方法

注意ArrayListc++vector的不同,后者赋值时是按值操作的。

访问ArrayList的元素:

设置元素:set(int index, E element) (和数组一样,index0开始编号)

注意不要在ArrayList的已初始化容量小于i时进行set操作。

ArrayList>Employee< list = new ArrayList>Employee<(100); // capacity 100, size 0

list.set(0, x); // no element 0 yet

是错误的

获取元素:get(int index)

JDK5新支持的for each循环:

for (Element e : ArrayList) {//...}

一个技巧:

先创建ArrayList并安全地添加元素

ArrayList>X< list = new ArrayList>X<();

while (. . .)

{

x = . . .;

list.add(x);

}

ArrayList转换为数组,从而方便地读取

X[] a = new X[list.size()];

list.toArray(a);

posted @ 2007-04-22 20:24 ZelluX 阅读(383) | 评论 (0)编辑 收藏


这一章又长又难,sign,挺过这一章估计就轻松点了
1. 内部类可以访问外围类的所有元素,包括private字段,原因在于内部类对象保存了一个指向外围类对象的引用。因此内部类的对象只能在与其外部类的对象相关联的情况下才能被创建。构建内部类对象时,需要一个指向其外围类对象的引用。
2. 嵌套类(nested)
如果不需要内部类对象与外围类对象有联系,可以将内部类声明为static,称为嵌套类。普通的内部类对象隐式地保存了一个引用,指向创建它的外部类对象。然而,当内部类是static时,就不是这样了。这意味着:
1)要创建嵌套类的对象,并不需要外围类的对象。
2)不能从嵌套类的对象中访问非静态的外围类对象。
嵌套类与普通内部类的另一个区别在于,普通内部类的字段与方法,只能放在类的外部层次上,所以普通的内部类不能有static数据和static字段,也不能包含嵌套类,但是嵌套类可以包含所有的这些东西(不怎么理解诶)
另外,正常情况下,不能在接口内部放置任何代码,但由于嵌套类是static的,因此可以作为接口的一部分。
在每个类中写一个main()方法,可以用来测试这个类,但这样会在编译时产生额外的内容。可以使用嵌套类防止测试代码
public class TestBed {
public TestBed() {}
public void f() { System.out.println("f()"); }
public static class Tester {
public static void main(String[] args) {
TestBed t = new TestBed();
t.f();
}
}
} ///:~
发布的时候删除TestBed$Tester.class即可
3. 引用外部类的对象
外围类名称 + ".this"
要创建非静态内部类,必须使用外围类的对象:
Parcel11 p = new Parcel11();
Parcel11.Contents c = p.new Contents();
4. 多层嵌套类
类比二层的嵌套类即可
注意这里有个名次混淆的地方,非static类也可以嵌套起来使用,但是非static类内部就不能有static类了。
5. 内部类的继承
内部类指向外围类的隐藏引用必须被初始化
class WithInner {
class Inner {}
}
public class InheritInner extends WithInner.Inner {
//! InheritInner() {} // Won't compile
InheritInner(WithInner wi) {
wi.super();
}

public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}
6. 内部类的覆盖
继承某个外围类的时候,内部类并不会发生变化,即使“重写”了内部类代码。不过可以用Thinking in Java上介绍的,明确继承某个内部类。
7. 为什么要用内部类
If I just need a reference to an interface, why don’t I just make the outer class implement that interface? The answer is “If that’s all you need, then that’s how you should do it.”
使用内部类最吸引人的原因是:
每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否已经继承某个(接口的)实现,对于内部类都没有影响。
由此可见,接口解决了部分问题,而内部类有效地实现了“多重继承”。
8. 闭包与回调 Closure & Callbacks
闭包是一个可调用的对象,它记录了一些信息,这些信息来自于创建它的作用域。由此可见内部类是面向对象的闭包。通过内部类提供闭包的功能是完美的解决方案,它比指针更灵活、安全。
9, 内部类与控制框架
太难了,跳掉。。。

posted @ 2007-04-22 20:24 ZelluX 阅读(162) | 评论 (0)编辑 收藏

2007-02-21 20:18:22
1. Stream Zoo 的基础:四个抽象类,InputStream, OutputStream, Reader, Writer
其中后面两个使用于Unicode文本。
2. 四个接口
interface Closeable {void close() throws IOException}
interface Flushable {void flush() throws IOException}
这两个比较简单
interface Readable {int read(CharBuffer cb)}
其中CharBuffer提供了支持连续/随机读写操作的方法
Appendable接口有两个方法,用于追加单个字符或一列字符
Appendable append(char c)
Appendalbe append(CharSequence s)
CharSequence是另一个接口。
java.lang.CharSequence 1.4
char charAt(int index)
int length()
CharSequence subSequence(int startIndex, int endIndex)
String toString()
3. FileInputStream和FileOutputStream
构造方法:
FileInputStream fin = new FileInputStream("employee.dat");
File f = new File("employee.dat");
FileInputStream fin = new FileInputStream(f);
注意输入Windows文件路径的时候使用双\\,如"C:\\Windows\\a.ini",不过也可以是"c:/Windows/a.ini",不过这并不被提倡。
读入一个字节:byte b = (byte) fin.read();
3. System.getProperty 方法
public static String getProperty(String key)
返回key值对应的属性
posts - 403, comments - 310, trackbacks - 0, articles - 7
  BlogJava :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理
2007-02-21 21:21:46
Key Description of Associated Value
java.version Java Runtime Environment version
java.vendor Java Runtime Environment vendor
java.vendor.url Java vendor URL
java.home Java installation directory
java.vm.specification.version Java Virtual Machine specification version
java.vm.specification.vendor Java Virtual Machine specification vendor
java.vm.specification.name Java Virtual Machine specification name
java.vm.version Java Virtual Machine implementation version
java.vm.vendor Java Virtual Machine implementation vendor
java.vm.name Java Virtual Machine implementation name
java.specification.version Java Runtime Environment specification version
java.specification.vendor Java Runtime Environment specification vendor
java.specification.name Java Runtime Environment specification name
java.class.version Java class format version number
java.class.path Java class path
java.library.path List of paths to search when loading libraries
java.io.tmpdir Default temp file path
java.compiler Name of JIT compiler to use
java.ext.dirs Path of extension directory or directories
os.name Operating system name
os.arch Operating system architecture
os.version Operating system version
file.separator File separator ("/" on UNIX)
path.separator Path separator (":" on UNIX)
line.separator Line separator ("\n" on UNIX)
user.name User's account name
user.home User's home directory
user.dir User's current working directory

如要得到当前目录,使用String dir = System.getProperty("user.dir");

posted @ 2007-04-22 20:24 ZelluX 阅读(377) | 评论 (0)编辑 收藏

2007-02-20 23:33:53
from http://www.regexlab.com/zh/regref.htm
1. 其他一些代表抽象意义的特殊符号
|
左右两边表达式之间 "或" 关系,匹配左边或者右边

( )
(1). 在被修饰匹配次数的时候,括号中的表达式可以作为整体被修饰
(2). 取匹配结果的时候,括号中的表达式匹配到的内容可以被单独得到

举例:表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时,匹配结果是:成功;匹配到内容是:"go go go";匹配到的位置是:开始于6,结束于14。
2. 匹配次数中的贪婪与非贪婪
贪婪模式:
在使用修饰匹配次数的特殊符号时,有几种表示方法可以使同一个表达式能够匹配不同的次数,比如:"{m,n}", "{m,}", "?", "*", "+",具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中,总是尽可能多的匹配。
非贪婪模式:
在修饰匹配次数的特殊符号后再加上一个 "?" 号,则可以使匹配次数不定的表达式尽可能少的匹配,使可匹配可不匹配的表达式,尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式,也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候,与贪婪模式类似,非贪婪模式会最小限度的再匹配一些,以使整个表达式匹配成功。
3. 反向引用
表达式在匹配时,表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候,小括号包含的表达式所匹配到的字符串可以单独获取。在实际应用场合中,当用某种边界来查找,而所要获取的内容又不包含边界时,必须使用小括号来指定所要的范围。比如 ">td<(.*?)>/td<"。
其实,"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用,在匹配过程中也可以使用。表达式后边的部分,可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1" 引用第1对括号内匹配到的字符串,"\2" 引用第2对括号内匹配到的字符串……以此类推,如果一对括号内包含另一对括号,则外层的括号先排序号。换句话说,哪一对的左括号 "(" 在前,那这一对就先排序号。
举例:表达式 "('|")(.*?)(\1)" 在匹配 " 'Hello', "World" " 时,匹配结果是:成功;匹配到的内容是:" 'Hello' "。再次匹配下一个时,可以匹配到 " "World" "。

posted @ 2007-04-22 20:24 ZelluX 阅读(369) | 评论 (0)编辑 收藏

2007-02-20 21:13:42
看的是Core Java
1. Streams通常是文件,但也可能是网络连接,甚至是内存中的一块。
2. 读写字节
InputStream的方法
abstract int read()
读取一个byte并返回,如果到了输入源的结尾就返回-1
InputStream类也有几个非抽象的方法用于读取若干个字节或是跳过若干个字节,但都需要调用read()方法,而子类继承InputStream后也仅需要覆盖read()方法即可。(注意此时继承下来的读取若干字节的方法调用了子类的read()方法)
类似的OutputStream类的方法
abstract void write(int b)
read和write方法都可以暂停某个线程,直到字节读写完成后再继续。这就意味着如果无法及时从网络上读取信息的话,Java会使得这次调用挂起吗,此时就可以让其他的线程工作了。
available方法可以获得当前可读取的字节数,从而防止挂起:
int bytesAvailable = in.available();
if (bytesAvailable < 0)
{
byte[] data = new byte[bytesAvailable];
in.read(data);
}
对stream结束访问后,使用close方法清理空间,以防系统资源耗竭。close方法同时也清洗了输出流的缓冲区,如果没有close,最后写入的内容可能就无法送达了,不过也可以使用flush方法清洗缓冲区。
3. API
java.io.InputStream 1.0
abstract int read()
int read(byte[] b)
int read(byte[] b, int off, int len)
off参数为读取的第一个字节写入b数组的位置
long skip(long n)
返回实际跳过的字节数
int available()
void close()
void mark(int readlimit)
在当前位置做标记,如果读取量超过了readlimit,就取消标记。并不是所有stream都支持mark
void reset()
回到上一个标记处。
boolean markSupported()
java.io.OutputStream 1.0
abstract void write(int n)
void write(byte[] b)
void write(byte[] b, int off, int len)
void close()
void flush()

posted @ 2007-04-22 20:24 ZelluX 阅读(246) | 评论 (0)编辑 收藏

2007-02-20 13:52:16
1. 接口
在某些OOP语言中使用关键字protocol完成类似的功能。
字段隐式为final和static,方法隐式为public
2. 多重继承
一个非抽象类必须实现接口的所有方法,但实现的方法可以从父类中继承下来。
如interface1定义了两个方法f1()和f2(),father类定义了方法f1(),child类继承father类并实现接口interface1,它仅需要实现方法f2()即可。
3. 接口和抽象类的选择
如果知道某个事物应该成为一个基类,那个第一选择应该是使他成为一个接口。
4. 接口组合时的名字冲突
在打算组合的不同接口中使用相同的方法名常常会造成代码可读性的混乱,要尽量避免这种情况。
5. 群组常量
接口可以放便地用来创建常量组,就像C++中的enum枚举类型。
public interface Months {
int
JANURARY = 1; FEBRUARY = 2; //...
}
但这样不具备类型安全,如果需要类型安全,就需要构建一个final类
public final class Month {
private static Test monitor = new Test();
private String name;
private Month(String nm) { name = nm; }
public String toString() { return name; }
public static final Month
JAN = new Month("January"),
FEB = new Month("February"); //...
public static final Month[] month = {
JAN, FEB //...
};
public static final Month number(int ord) {
return month[ord - 1];
}
}
通过Month.number(int)获得Month类,由于每个月份的对象都仅存在一个,所以可以通过==或equals()判断是否相等。
枚举类也可以通过org.apache.commons.lang.enum包实现
6. 嵌套接口
内部接口可以被声明为private,而且可以被public类实现
As a new twist, interfaces can also be private, as seen in A.D (the same qualification syntax is used for nested interfaces as for nested classes). What good is a private nested interface? You might guess that it can only be implemented as a private inner class as in DImp, but A.DImp2 shows that it can also be implemented as a public class. However, A.DImp2 can only be used as itself. You are not allowed to mention the fact that it implements the private interface, so implementing a private interface is a way to force the definition of the methods in that interface without adding any type information (that is, without allowing any upcasting).
这段不是很理解。。。
另外,当实现某个接口时,并不需要实现嵌套在内部的任何接口。
7. 内部类与向上转型
内部类的真正好处在于,由于内部类--某个接口的实现--可以对其他人完全隐藏,他人所能得到的仅仅是一个基类或者接口的引用,而通过那个引用甚至不能找出该引用的最终类型,这样具体地实现就被完全隐藏了。
8. 在方法和作用域中的内部类
这么做的两个理由:
1)你实现了某类型的接口,于是可以创建并返回对其的引用。
2)你要解决一个复杂的问题,需要创建一个类来辅助你的解决方案,但有不希望这个类公共可用。
这种内部类只能在相应作用域内使用,除此以外,在编译等方面和普通的类一样。
9. 匿名内部类
很有用的一个方法,在用Netbeans开发界面的时候就发现它的事件响应代码就是用这个生成的。
startItem.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
startItemActionPerformed(evt);
}
});
注意最后的分号。
如果匿名内部类要使用外部的对象,参数必须设置为final,否则就会产生编译错误。
那么如何产生类似构造器的行为呢?由于匿名,因此不可能存在构造器,但通过instance initialization,可以达到构造的效果。
public class AnonymousConstructor {
private static Test monitor = new Test();
public static Base getBase(int i) {
return new Base(i) {
{
System.out.println("Inside instance initializer");
}

public void f() {
System.out.println("In anonymous f()");
}
};
}
}
这里i不需要声明为final,因为在内部类中并没有被直接使用。
当然由于不支持重载,这类构造方法只能有一个

posted @ 2007-04-22 20:24 ZelluX 阅读(231) | 评论 (0)编辑 收藏

2007-02-19 23:27:29
连连看马马虎虎完成了,用的是Netbeans。然后准备熟悉下Eclipse,写个扫雷。
1. 控件的重绘太重要了,每次修改后都要repaint()一下。
2. 交换两个按钮后忘了重新setLocation,结果发现按钮位置没变。。。
3. 菜单项设置快捷键
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_MASK))
4. javac filename 产生的.class文件在当前目录下
javac -d dir filename 产生的.class文件在dir目录的包名目录中
5. 还没弄明白的一个问题:
Board.drawLines方法中,明明getGraphics().setColor了,为什么画线的时候颜色没变呢?

posted @ 2007-04-22 20:24 ZelluX 阅读(246) | 评论 (0)编辑 收藏

仅列出标题
共39页: First 上一页 30 31 32 33 34 35 36 37 38 下一页 Last