安装了jdk以后，要配置环境变量
配置环境变量
系统98:打开:C:\autoexec.bat文件
set path=c:\jdk1.4\bin
set java_home=c:\jdk1.4
set classpath=.;c:\jdk1.4\lib\dt.jar;c:\jdk1.4\lib\tools.jar;（.;已经不能少，因为它代表当前路径)
配置环境变量
系统2000或XP:
我的电脑->属性->高级->环境变量
添加以下环境变量(假定你的java安装在c:\jdk1.4）
java_home=c:\jdk1.4
classpath=.;c:\jdk1.4\lib\dt.jar;c:\jdk1.4\lib\tools.jar;（.;已经不能少，因为它代表当前路径)
path = c:\jdk1.4\bin
新开一个dos窗口，键入java和javac测试一下

1. this是指当前对象自己。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中:

public class A {

String s = "Hello";

public A(String s) {
System.out.println("s = " + s);
System.out.println("1 -> this.s = " + this.s);
this.s = s;
System.out.println("2 -> this.s = " + this.s);
}

public static void main(String[] args) {
new A("HelloWorld!");
}
}

运行结果：

s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!

在这个例子中，构造函数A中，参数s与类A的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类A的变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对参数s进行打印结果；后面两行分别是对对象A的变量s进行操作前后的打印结果。

2. 把this作为参数传递
当你要把自己作为参数传递给别的对象时，也可以用this。如：

public class A {
public A() {
new B(this).print();
}

public void print() {
System.out.println("Hello from A!");
}
}

public class B {
A a;
public B(A a) {
this.a = a;
}

public void print() {
a.print();
System.out.println("Hello from B!");
}
}

运行结果：
Hello from A!
Hello from B!

在这个例子中，对象A的构造函数中，用new B(this)把对象A自己作为参数传递给了对象B的构造函数。

3. 注意匿名类和内部类中的中的this。
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子：

public class A {
int i = 1;

public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) {
}
}
}
};
thread.start();
}

public void run() {
System.out.println("i = " + i);
i++;
}

public static void main(String[] args) throws Exception {
new A();
}

}

在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。

一、基础知识：
1、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）。
2、this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）；
3、super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时）。
如：super.变量名
super.成员函数据名（实参）
4、this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）。
二、应用实例：
class Point
{ private int x,y;
public Point(int x,int y)
{
this.x=x; //this它代表当前对象名
this.y=y;
}
public void Draw()
{
}
public Point()
{
this(0,0); //this（参数）调用本类中另一种形成的构造函数
}
}
class Circle extends Point
{
private int radius;
public circle(int x0,int y0, int r )
{
super(x0,y0); //super（参数）调用基类中的某一个构造函数
radius=r;
}
public void Draw()
{
super.Draw(); //super它引用当前对象的直接父类中的成员
drawCircle();
}
}

Java 语言中的 return 语句

众所周知，return 只能用在有返回类型的函数中，但是有返回值的函数一定要有return吗？return都可以用在函数的哪些地方呢？这是本文需要讨论的问题。



--------------------------------------------------------------------------------


例一：

class test {
public String test() {
if(true){
return "";
}
else{
return "";
}
}
}

上面这样即可通过编译，但是下面这两个例子却不能通过编译：

(一)
class test {
public String test() {
if(true){
return "";
}
}
}


(二)
class test {
public String test() {
if(isTrue()){
return "";
}
else if(!isTrue()){//两个if里的判断包括了所有的可能性,但是还是编译期error
return "";
}
}
boolean isTrue(){
return true;
}
}

结论1：
对于(一)，这是因为java编译器认定单独的if语句只在当一定条件满足情况下才执行，它认为if不会有任何情况下都能执行的能力。
对于(二)，这是因为java编译器对if else 语句能够全面囊括所有情况的能力只限定在的if...else(或if...else if...else)时，而不包括if...else if。



--------------------------------------------------------------------------------


再看例二：

class test {
public String test() {
while(true){
return "";
}
}
}
上面这样即可通过编译，但是下面这样不行：

class test {
public String test() {
while(isTrue()){
return "";
}
}
boolean isTrue(){
return true;
}
}

结论2：
这是因为编译器认为while语句有在任何情况下都能执行的能力，但是只在入参为true的情况下有该能力。



--------------------------------------------------------------------------------


再看例三：

public class test {
String test() throws Exception{

throw new Exception();//抛出异常后，跳出程序,程序中止
}
}
结论3：
如果函数中创建了异常，并抛出，则该函数可以不返回值。

常常在网上看到有人询问：如何把 java 程序编译成 .exe 文件。通常回答只有两种，一种是说，制作一个可执行的 JAR 文件包，就可以像.chm 文档一样双击运行了；而另一种回答，则是使用 JET 来进行编译。但是 JET 是要用钱买的，而且，据说 JET 也不是能把所有的 Java 程序都编译成执行文件，性能也要打些折扣。所以，使用制作可执行 JAR 文件包的方法就是最佳选择了，何况它还能保持 Java 的跨平台特性。先来看看什么是 JAR 文件包：

1. JAR 文件包

　　JAR 文件就是 Java Archive File，顾名思意，它的应用是与 Java 息息相关的，是 Java 的一种文档格式。JAR 文件非常类似 ZIP 文件??准确的说，它就是 ZIP 文件，所以叫它文件包。JAR 文件与 ZIP 文件唯一的区别就是在 JAR 文件的内容中，包含了一个 META-INF/MANIFEST.MF 文件，这个文件是在生成 JAR 文件的时候自动创建的。举个例子，如果我们具有如下目录结构的一些文件：

　　==
　　`-- test
　　　 `-- Test.class

　　把它压缩成 ZIP 文件 test.zip，则这个 ZIP 文件的内部目录结构为：

　　test.zp
　　`-- test
　　　 `-- Test.class

　　如果我们使用 JDK 的 jar 命令把它打成 JAR 文件包 test.jar，则这个 JAR 文件的内部目录结构为：

　　test.jar
　　|-- META-INF
　　|　 `-- MANIFEST.MF
　　`-- test
　　　　`--Test.class


2. 创建可执行的 JAR 文件包

　　制作一个可执行的 JAR 文件包来发布你的程序是 JAR 文件包最典型的用法。

　　Java 程序是由若干个 .class 文件组成的。这些 .class 文件必须根据它们所属的包不同而分级分目录存放；运行前需要把所有用到的包的根目录指定给 CLASSPATH 环境变量或者 java 命令的 -cp 参数；运行时还要到控制台下去使用 java 命令来运行，如果需要直接双击运行必须写 Windows
的批处理文件 (.bat) 或者 Linux 的 Shell 程序。因此，许多人说，Java 是一种方便开发者苦了用户的程序设计语言。

　　其实不然，如果开发者能够制作一个可执行的 JAR 文件包交给用户，那么用户使用起来就需要方便了。在 Windows 下安装 JRE (Java Runtime Environment) 的时候，安装文件会将 .jar 文件映射给 javaw.exe 打开。那么，对于一个可执行的 JAR 文件包，用户只需要双击它就可以运行程序了，和阅读 .chm 文档一样方便 (.chm 文档默认是由 hh.exe 打开的)。那么，现在的关键，就是如何来创建这个可执行的 JAR 文件包。

　　创建可执行的 JAR 文件包，需要使用带 cvfm 参数的 jar 命令，同样以上述 test 目录为例，命令如下：

　　jar cvfm test.jar manifest.mf test

　　这里 test.jar 和 manifest.mf 两个文件，分别是对应的参数 f 和 m，其重头戏在 manifest.mf。因为要创建可执行的 JAR 文件包，光靠指定一个 manifest.mf 文件是不够的，因为 MANIFEST 是 JAR 文件包的特征，可执行的 JAR 文件包和不可执行的 JAR 文件包都包含 MANIFEST。关键在于可执行 JAR 文件包的 MANIFEST，其内容包含了 Main-Class 一项。这在 MANIFEST 中书写格式如下：

　　Main-Class: 可执行主类全名(包含包名)

　　例如，假设上例中的 Test.class 是属于 test 包的，而且是可执行的类 (定义了 public static void main(String[]) 方法)，那么这个 manifest.mf 可以编辑如下：

　　Main-Class: test.Test <回车>

　　这个 manifest.mf 可以放在任何位置，也可以是其它的文件名，只需要有 Main-Class: test.Test 一行，且该行以一个回车符结束即可。创建了 manifest.mf 文件之后，我们的目录结构变为：

　　==
　　|-- test
　　|　 `-- Test.class
　　`-- manifest.mf

　　这时候，需要到 test 目录的上级目录中去使用 jar 命令来创建 JAR 文件包。也就是在目录树中使用?=?表示的那个目录中，使用如下命令??

　　jar cvfm test.jar manifest.mf test

　　之后在?=?目录中创建??test.jar，这个 test.jar 就是执行的 JAR 文件包。运行时只需要使用 java -jar test.jar 命令即可。

　　需要注意的是，创建的 JAR 文件包中需要包含完整的、与 Java 程序的包结构对应的目录结构，就像上例一样。而 Main-Class 指定的类，也必须是完整的、包含包路径的类名，如上例的 test.Test；而且在没有打成 JAR 文件包之前可以使用 java <类名> 来运行这个类，即在上例中 java test.Test 是可以正确运行的 (当然要在 CLASSPATH 正确的情况下)。


3. jar 命令详解

　　jar 是随 JDK 安装的，在 JDK 安装目录下的 bin 目录中，Windows 下文件名为 jar.exe，Linux 下文件名为 jar。它的运行需要用到 JDK 安装目录下 lib 目录中的 tools.jar 文件。不过我们除了安装 JDK 什么也不需要做，因为 SUM 已经帮我们做好了。我们甚至不需要将 tools.jar 放到 CLASSPATH 中。

　　使用不带任何的 jar 命令我们可以看到 jar 命令的用法如下：

　　jar {ctxu}[vfm0M] [jar-文件] [manifest-文件] [-C 目录] 文件名 ...

　　其中 {ctxu} 是 jar 命令的子命令，每次 jar 命令只能包含 ctxu 中的一个，它们分别表示：

　　-c　创建新的 JAR 文件包
　　-t　列出 JAR 文件包的内容列表
　　-x　展开 JAR 文件包的指定文件或者所有文件
　　-u　更新已存在的 JAR 文件包 (添加文件到 JAR 文件包中)

　　[vfm0M] 中的选项可以任选，也可以不选，它们是 jar 命令的选项参数

　　-v　生成详细报告并打印到标准输出
　　-f　指定 JAR 文件名，通常这个参数是必须的
　　-m　指定需要包含的 MANIFEST 清单文件
　　-0　只存储，不压缩，这样产生的 JAR 文件包会比不用该参数产生的体积大，但速度更快
　　-M　不产生所有项的清单（MANIFEST〕文件，此参数会忽略 -m 参数

　　[jar-文件] 即需要生成、查看、更新或者解开的 JAR 文件包，它是 -f 参数的附属参数
　　[manifest-文件] 即 MANIFEST 清单文件，它是 -m 参数的附属参数

　　[-C 目录] 表示转到指定目录下去执行这个 jar 命令的操作。它相当于先使用 cd 命令转该目录下再执行不带 -C 参数的 jar 命令，它只能在创建和更新 JAR 文件包的时候可用。
　　文件名 ... 指定一个文件/目录列表，这些文件/目录就是要添加到 JAR 文件包中的文件/目录。如果指定了目录，那么 jar 命令打包的时候会自动把该目录中的所有文件和子目录打入包中。

　　下面举一些例子来说明 jar 命令的用法：

　　1) jar cf test.jar test

　　该命令没有执行过程的显示，执行结果是在当前目录生成了 test.jar 文件。如果当前目录已经存在 test.jar，那么该文件将被覆盖。

　　2) jar cvf test.jar test

　　该命令与上例中的结果相同，但是由于 v 参数的作用，显示出了打包过程，如下：

　　标明清单(manifest)
　　增加：test/(读入= 0) (写出= 0)(存储了 0%)
　　增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

　　3) jar cvfM test.jar test

　　该命令与 2) 结果类似，但在生成的 test.jar 中没有包含 META-INF/MANIFEST 文件，打包过程的信息也略有差别：

　　增加：test/(读入= 0) (写出= 0)(存储了 0%)
　　增加：test/Test.class(读入= 7) (写出= 6)(压缩了 14%)

　　4) jar cvfm test.jar manifest.mf test

　　运行结果与 2) 相似，显示信息也相同，只是生成 JAR 包中的 META-INF/MANIFEST 内容不同，是包含了 manifest.mf 的内容

　　5) jar tf test.jar

　　在 test.jar 已经存在的情况下，可以查看 test.jar 中的内容，如对于 2) 和 3) 生成的 test.jar 分别应该此命令，结果如下；

　　对于 2)

　　META-INF/
　　META-INF/MANIFEST.MF
　　test/
　　test/Test.class

　　对于 3)

　　test/
　　test/Test.class

　　6) jar tvf test.jar

　　除显示 5) 中显示的内容外，还包括包内文件的详细信息，如：

　　　　 0 Wed Jun 19 15:39:06 GMT 2002 META-INF/
　　　　86 Wed Jun 19 15:39:06 GMT 2002 META-INF/MANIFEST.MF
　　　　 0 Wed Jun 19 15:33:04 GMT 2002 test/
　　　　 7 Wed Jun 19 15:33:04 GMT 2002 test/Test.class

　　7) jar xf test.jar

　　解开 test.jar 到当前目录，不显示任何信息，对于 2) 生成的 test.jar，解开后的目录结构如下：

　　==
　　|-- META-INF
　　|　 `-- MANIFEST
　　`-- test
　　　　`-- Test.class

　　8) jar xvf test.jar

　　运行结果与 7) 相同，对于解压过程有详细信息显示，如：

　　　创建：META-INF/
　　展开：META-INF/MANIFEST.MF
　　　创建：test/
　　展开：test/Test.class

　　9) jar uf test.jar manifest.mf

　　在 test.jar 中添加了文件 manifest.mf，此使用 jar tf 来查看 test.jar 可以发现 test.jar 中比原来多了一个 manifest。这里顺便提一下，如果使用 -m
参数并指定 manifest.mf 文件，那么 manifest.mf 是作为清单文件 MANIFEST 来使用的，它的内容会被添加到 MANIFEST 中；但是，如果作为一般文件添加到 JAR 文件包中，它跟一般文件无异。

　　10) jar uvf test.jar manifest.mf

　　与 9) 结果相同，同时有详细信息显示，如：

　　增加：manifest.mf(读入= 17) (写出= 19)(压缩了 -11%)


4. 关于 JAR 文件包的一些技巧

　　1） 使用 unzip 来解压 JAR 文件

　　在介绍 JAR 文件的时候就已经说过了，JAR 文件实际上就是 ZIP 文件，所以可以使用常见的一些解压 ZIP 文件的工具来解压 JAR 文件，如 Windows 下的 WinZip、WinRAR 等和 Linux 下的 unzip 等。使用 WinZip 和 WinRAR 等来解压是因为它们解压比较直观，方便。而使用 unzip，则是因为它解压时可以使用 -d 参数指定目标目录。

　　在解压一个 JAR 文件的时候是不能使用 jar 的 -C 参数来指定解压的目标的，因为 -C 参数只在创建或者更新包的时候可用。那么需要将文件解压到某个指定目录下的时候就需要先将这具 JAR 文件拷贝到目标目录下，再进行解压，比较麻烦。如果使用 unzip，就不需要这么麻烦了，只需要指定一个 -d 参数即可。如：

　　unzip test.jar -d dest/

　　2） 使用 WinZip 或者 WinRAR 等工具创建 JAR 文件

　　上面提到 JAR 文件就是包含了 META-INF/MANIFEST 的 ZIP 文件，所以，只需要使用 WinZip、WinRAR 等工具创建所需要 ZIP 压缩包，再往这个 ZIP 压缩包中添加一个包含 MANIFEST 文件的 META-INF 目录即可。对于使用 jar 命令的 -m 参数指定清单文件的情况，只需要将这个 MANIFEST 按需要修改即可。

　　3） 使用 jar 命令创建 ZIP 文件

　　有些 Linux 下提供了 unzip 命令，但没有 zip 命令，所以需要可以对 ZIP 文件进行解压，即不能创建 ZIP 文件。如要创建一个 ZIP 文件，使用带 -M 参数的 jar 命令即可，因为 -M 参数表示制作 JAR 包的时候不添加 MANIFEST 清单，那么只需要在指定目标 JAR 文件的地方将 .jar 扩展名改为 .zip 扩展名，创建的就是一个不折不扣的 ZIP 文件了，如将上一节的第 3） 个例子略作改动：

　　jar cvfM test.zip test

 

检验配置的方法:

运行：java -version

path配置不对会提示找不到java命令，classpath配置不对不会出现信息提示。

static很容易理解的，与其它非static的变量和方法区别在于它是类的一部分而不是属于类的实例

 

 

//ReadMultiFile.Java
import Java.io.*;
import Java.util.*;

class ReadMultiFile
{
public static void main(String args[])
{
//实例化FileFilter类
FileFilter fFilter = new FileFilter(“D:\Java2\Source”,”Java”);
//创建顺序输入流
SequenceInputStream seqInput = new SequenceInputStream(fFilter);
//创建输出文件对象
FileOutputStream fOutput = new FileOutputStream(“SourceSum”);
//每次读取的字符
int bContent;
//从文件输入流中读取内容
while((bContent = seqInput.read())!=-1)
{
//写出到文件输出对象
fOutput.write(nContent);
}
//关闭顺序输入流
seqInput.close();
//关闭文件输出对象
fOutput.close();
}
}
class FileFilter implements Enumeration
{
File directory;
String extension;
String strFileList[];
Filter filter;
int nCounter;
//构造方法
FileFilter(String strDirectoryName,String extension)
{
this.extension = extension;
//创建目录对象
directory = new File(strDirectoryName);
if(directory.isDirectory())
{
//如果是目录，获取目录中所有文件
filter = new Filter(extension);
strFileList = directory.list(filter);
}
else
{
//如果不是目录，获取当前文件
strFileList = new String[1];
strFileList[0] = strDirectoryName;
}
nCounter = 0;
}
//判断枚举中十分还有元素的方法
public Boolean hasMoreElements()
{
if(nCounter<strFileList.length)
{
return true;
}
else
{
return false;
}
}
//获取枚举中下一元素的方法
public Object nextElement()
{
//如果还有元素
if( hasMoreElements())
{
nCounter++;
//返回文件输入流对象
return new FileInputStream(strFileList[nCounter-1]);
}
else
return null;
}
}




//FilterWalker.Java
import Java.io.*;
import Java.util.*;
class FilterWalker implements Observer
{
String[] patterns;
File dir;
FilterWalker (String dirname, String[] patterns)
{
dir = new File(dirname);
this.patterns = patterns;
// Start walking the file system.
FileWalker fw = new FileWalker();
fw.addObserver(this);
fw.walk(new File(dirname), false, new FileFilter());
}
class FileFilter implements Java.io.FileFilter
{
// Returns true if filename matches one of the patterns.
public boolean accept(File file)
{
if (file.isDirectory())
{
return true;
}
String s = file.getName();
if (patterns.length == 0) {
return true;
} else {
for (int i=0; i<patterns.length; i++) {
if (s.endsWith(patterns[i])) {
return true;
}
}
}
return false;
}
}
// This method is called for each file that the file walker discovers.
public void update(Observable o, Object arg) {
System.out.println(arg);
}
public static void main(String[] args) {
if (args.length < 1) {
System.err.println(
"Usage: Java Main <directory> [<pattern>...]");
} else {
// Retrieve patterns, if any.
String[] patterns = new String[args.length-1];
System.arraycopy(args, 1, patterns, 0, patterns.length);
new Main(args[0], patterns);
}
}
}
//FileWalker.Java
import Java.io.*;
import Java.util.*;
import Java.util.zip.*;
class FileWalker extends Observable
{
void walk(File dir, boolean includeDirectories, FileFilter filter)
{
if (dir.isDirectory()) {
if (includeDirectories) {
setChanged();
notifyObservers(dir);
}
File[] files = dir.listFiles(filter);
if (files != null) {
for (int i=0; i<files.length; i++) {
walk(files[i], includeDirectories, filter);
}
}
} else {
setChanged();
notifyObservers(dir);
}
}
}



//DataIOTest.Java
import Java.io.*;
public class DataIOTest
{
public static void main(String[] args) throws IOException
{
//创建数据输出流
DataOutputStream out = new DataOutputStream(new
FileOutputStream("content.txt"));
//初始化输出数据
double[] prices = { 19.99, 9.99, 15.99, 3.99, 4.99 };
int[] units = { 12, 8, 13, 29, 50 };
String[] descs = {
"Java T-shirt",
"Java Mug",
"Duke Juggling Dolls",
"Java Pin",
"Java Key Chain"
};
//数据输出
for (int i = 0; i < prices.length; i ++)
{
out.writeDouble(prices[i]);
out.writeChar(´\t´);
out.writeInt(units[i]);
out.writeChar(´\t´);
out.writeChars(descs[i]);
out.writeChar(´\n´);
}
//关闭数据输出流
out.close();
//创建数据输入流
DataInputStream in = new DataInputStream(
new FileInputStream("content.txt"));

double price;
int unit;
String desc;
double total = 0.0;
try
{
//利用数据输入流读文件内容
while (true)
{
price = in.readDouble();
in.readChar(); // throws out the tab
unit = in.readInt();
in.readChar(); // throws out the tab
desc = in.readLine();
System.out.println("You´ve ordered " +
unit + " units of " +
desc + " at $" + price);
total = total + unit * price;
}
}
//捕获异常
catch (EOFException e)
{
e.printStackTrace();
}
System.out.println("For a TOTAL of: $" + total);
//关闭数据输入流
in.close();
}
}



// DataIOException.Java
import Java.io.*;
class DataIOException
{
public static void main(String args[])
{
//利用文件输入流创建数据输入流
DataInputStream dis = new DataInputStream(
New FileInputStream(“DataIOException.Java”));
byte b;
try
{
//读文件的内容并打印出来
while(true)
{
b = dis.readByte();
System.out.println((char)b);
System.out.flush();
}
}
//捕获文件结束异常
catch(EOFException e1)
{
System.out.println(e1);
}
//捕获文件不存在异常
catch(FileNotFoundException e2)
{
System.out.println(e2);
}
//捕获文件输入输出异常
catch(IOException e3)
{
System.out.println(e3);
}
//处理其他异常
catch(Throwable anything)
{
System.out.println(anything);
}
}
}


//BufferedInputDemo.Java
class BufferedInputDemo
{
public static void main(String args[])
{
//创建与文件输入流对应的缓冲区输入流
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(“BufferedInputDemo.Java”));
int b;
try
{
//从缓冲区输入流中读数据
while((b=bis.read())!=-1)
{
System.out.println((char)b);
}
}
catch(IOException e)
{
e.printStackTrace();
}
}
}



//LineNumberDemo.Java
class LineNumerDemo
{
public static void main(String args[])
{
//定义数据输入流
DataInputStream dis;
//定义文件输入流
FileInputStream fis;
//定义缓冲区输入流
BufferedInputStream bis;
//定义行号输入流
LineNumberInputStream lnis;
String strLine;

Try
{
//创建文件输入流对象，与实际文件相连
fis = new FileInputStream(“LineNumberDemo.Java”);
//根据文件输入流对象创建缓冲区输入流
bis = new BufferedInputStream(fis);
//根据缓冲区输入流对象创建行号输入流
lnis = new LineNumberStream(bis);
//根据行号输入流创建数据输入流
dis = new DataInputStream(lnis);
//从数据输入流中读数据
while((strLine=dis.readLine())!=null)
{
//从行号输入流中取得行号
int nLineNumber = lis.getLineNumber();
//打印出行号和当前行内容
System.out.println(nLineNumer+”:”+strLine);
}
}
catch(Exception e)
{
e.printStackTrace();
}
finally
{
//关闭数据输入流
dis.close();
}
}
}



//FileCopy.Java
//自定义异常
class FileCopyException extends IOException
{
public FileCopyException(String msg)
{
//调用父类的构造函数
super(msg);
}
}
//FileCopy类
public class FileCopy
{
public static void copy(String sourcename,String destname)
throw IOException
{
//创建源文件对象
File sourcefile = new File(sourcename);
//创建目标文件对象
File destfile = new File(destname);
//定义文件输入流
FileInputStream source= null;
//定义文件输出流
FileOutputStream dest = null;
byte[] buffer;
int readbytes;
try
{
//判断文件十分存在、是否为普通文件
if(!sourcefile.exists() || !sourcefile.isFile())
throw new FileCopyException("No such file:"+sourcename+"\n");
//判断是否具有写权限
if(!sourcefile.canRead())
throw new FileCopyException(sourcename+"cann’t be read\n");
//判断目标文件存在
if(destfile.exists())
{
//目标文件是普通文件
if(destfile.isFile())
{
//定义数据输入流
DataInputStream in = new DataInputStream(System.in);
String response;
if(!destfile.canWrite())throw new
FileCopyException(destname+"does not can write\n");
System.out.println("Overwrite (Yes/No) ?");
System.out.flush();
//读取输入内容
response = System.in.readline();
}
else
{
System.out.println(“不能对目录进行读写”);
}
}
else
{
System.out.println(“指定的文件不存在”);
}
//创建文件输入对象
source = new FileInputStream(sourcefile);
//创建文件输出对象
destination = new FileOutputStream(destfile);
buffer = new byte[1024];
//文件输出
for(;;)
{
readbytes = source.read(buffer);
if(readbytes==-1)break;
destination.write(buffer,0,readbytes);
}
}
finally
{
if(source!=null)
{
try
{
source.close();
}
catch(IOException e){};
}
if(destination!=null)
{
try
{
destination.close();
}
catch(IOException e){};
}
}
}
public static void main(String args[])
{
if(args.length!=2)
System.out.println("Java FileCopy <SourceFile> <DestFile>");
else
{
try
{
copy(args[0],args[1]);
}
catch(IOException e)
{
System.out.println(e.getMessage());
}
}
}

private static File parent(File f)
{
String dirname = f.getParent();
if(f.isAbsolute())
return new File(File.seperator);
else
return new File(System.getProperty("user.dir"));
}

//InOutDemo.Java
class InOutDemo
{
public static void main(String args[]) throws Exception
{
//定义字节数组
byte buffer[] = new byte[30];
//将从键盘输入的字节序列存储到字节缓冲区中
System.in.read(buffer);
//生成String对象
String strBuffer = new String(buffer);
//在标准输出中输出生成的String对象
System.out.println(strBuffer);
}
}



//FileFilterDemo.Java
import Java.io.*;
public class FileFilterDemo
{
//创建文件对象
File dir = new File(“D:\JavaSource”);
//创建文件类型过滤器
Filter filter = new Filter(“Java”);

//取得文件名字符串数组
String fileList[] = dir.list(filter);
for(int I=0;I<fileList.length;I++)
{
//获取文件对象
File tmpFile = new File(fileList[I]);
//取得文件属性
if( tmpFile.isFile() )
System.out.println(“文件”+tmpfile);
else
System.out.println(“目录”+tmpfile);
}
}
//定义文件过滤器
class Filter implements FilenameFilter
{
//扩展名
String extension;
//构造方法
Filter(String extension)
{
this.extension = extension;
}
//测试文件的扩展名是否为extension
public boolean accept(File directory,String filename)
{
return filename.endsWith(“.”+extension);
}
}




//LastModified.Java
import Java.io.*;
class LastModified
{
public static void main(String[] args)
{
try
{
File temp = File.createTempFile("jcl", ".out");
// Make sure it gets deleted when we´re done
temp.deleteOnExit();
// Print out file name and its last modified time
long mod = temp.lastModified();
System.out.println(temp + ":" + mod);
// Introduced some delay
try
{
Thread.sleep(3000);
}
catch (InterruptedException ie)
{
};
// Write something out to file
FileWriter fout = new FileWriter(temp);
fout.write("hello");
fout.close();
System.out.println(temp + ":" + temp.lastModified());
// Change modified date back to original
if (temp.setLastModified(mod))
{
System.out.println(temp + ":" + temp.lastModified());
}
else
{
System.out.println("modification time unchanged");
}
//
}
catch (IOException e)
{
e.printStackTrace();
}
}
}




//FileAttributeDemo.Java
class FileAttributeDemo
{
//main方法
public static void main(String args[])
{
FileAttributeDemo demo = new FileAttributeDemo();
}
//类构造方法
public FileAttributeDemo()
{
//路径分隔符
System.out.println(“Path Separator”+File.pathSeparator);
//路径分隔字符
System.out.println(“Path Separator character”+File.pathSeparatorChar);
//文件分隔符
System.out.println(“Separator”+File.separator);
//文件分隔字符
System.out.println(“Separator character”+File.separatorChar);
//创建文件对象
File flFile = new File(“D:\JavaSource\FileDemo.Java”);
//文件全路径名称
System.out.println(f);
//读属性
System.out.println(f.canRead());
//写属性
System.out.println(f.canWrite());
//文件长度
System.out.println(f.length());
//测试是否为普通文件
System.out.println(f.isFile());
//测试是否为目录
System.out.println(f.isDirectory());
//取得文件最后修改时间
System.out.println(f.lastModified());
//取得文件名
System.out.println(f.getName());
//取得文件所在路径
System.out.println(f.getPath());
//判断文件是否存在
System.out.println(f.exists());
}
}




//ReafFromFile.Java
import Java.io.*;
class ReadFromFile
{
public static void main(String args[])
{
System.out.println(“Please enter a directory that the file located in:”);
//构造待读取文件的目录
StringBuffer stfDir = new StringBuffer();
//从键盘获取输入字符，存储进入字符缓冲区
While((char ch = (char)System.in.read())!=’\n’)
{
stfDir.appendChar(ch);
}
//创建目录文件对象
File dir = new File(stfDir.toString());

System.out.println(“Please enter a filename that want to read:”);
//获取待读取的文件名
StringBuffer stfFilename = new StringBuffer();
//从键盘获取输入字符，存储进入字符缓冲区
While((char ch = (char)System.in.read())!=’\n’)
{
stfFilename.appendChar(ch);
}
//创建文件对象
File readFrom = new File(dir,stfFilename.toString());

//判断文件是否为目录、是否具有写权限、读权限
if(readFrom.isFile() && reafFrom.canWrite() && reafFrom.canRead())
{
//创建RandomAccessFile对象
RandomAccessFile rafFile =
new RandomAccessFile(readFrom,”rw”);
//如果未读到文件尾，则继续读取
while(rafFile.getFilePointer()<rafFile.length())
System.out.println(file.readLine());
//文件关闭
rafFile.close();
}
else
System.out.println(“File cann’t be read!”);
}
}




//WriteToFile.Java
import Java.io.*;
class WriteToFile
{
public static void main(String args[])
{
System.out.println(“Please enter a directory that the file located in:”);
//构造待读取文件的目录
StringBuffer stfDir = new StringBuffer();
//从键盘获取输入字符，存储进入字符缓冲区
While((char ch = (char)System.in.read())!=’\n’)
{
stfDir.appendChar(ch);
}
//创建目录文件对象
File dir = new File(stfDir.toString());

System.out.println(“Please enter a filename that want to read:”);
//获取待读取的文件名
StringBuffer stfFilename = new StringBuffer();
//从键盘获取输入字符，存储进入字符缓冲区
While((char ch = (char)System.in.read())!=’\n’)
{
stfFilename.appendChar(ch);
}
//创建文件对象
File readFrom = new File(dir,stfFilename.toString());

//判断文件是否为目录、是否具有写权限、读权限
if(readFrom.isFile() && reafFrom.canWrite() && reafFrom.canRead())
{
//创建RandomAccessFile对象
RandomAccessFile rafFile =
new RandomAccessFile(readFrom,”rw”);
//如果未读到文件尾，则继续读取
int ch;
StringBuffer stfContent;
while(ch!=-1)
{
//字符缓冲区清空
stfContent.setLength(0);
//接收键盘输入、构造字符缓冲区
while((ch=System.in.read())!=-1)
stfContent.appendChar(ch);
//附加Dos格式行结束标志
stfContent.append(“\r\n”);
//将字符缓冲区的内容写出
rafFile.writeBytes(stfContent.toString());
}
//文件关闭
rafFile.close();
}
}
else
System.out.println(“File cann’t be write!”);
}
}




//SetFileLength.Java
import Java.io.*;
class SetFileLength.Java
{
public static void main(String[] args)
{
if (args.length != 2)
{
System.err.println(
"usage: Java Main <new filename> <size in bytes>");
System.exit(-1);
}
long size = 0;
try
{
size = Long.parseLong(args[1]);
}
catch (NumberFormatException e)
{
System.err.println(
"usage: Java Main <new filename> <size in bytes>");
System.exit(-1);
}

try
{
RandomAccessFile raf = new RandomAccessFile(args[0], "rw");
raf.setLength(size); // extend file to be specified size
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}




//FileIODemo.Java
import Java.io.*
class FileIODemo
{
//main方法
public static void main(String args[])
{
FileIODemo aFileIODemo = new FileIODemo();
}
//构造方法
public FileIODemo
{
try
{
//利用系统输入设备作为文件输入流
FileInputStream fin = new FileInputStream(System.in);
//创建输出文件input.txt
FileOutputStream fout = new FileOutputStream( new File(“input.txt”));
int nKeyIn;

for(int n=0;n<10;n++)
{
//从标准输入设备读取10个字符输入
nKeyIn = fin.read();
//向文件输出流中写出输入的字符
fout.write(data);
}
//关闭输出流
fout.close();

//创建文件输入流为文件input.txt
FileInputStream fin = new FileInputStream(new File(“input.txt”));
//文件输出流为系统标准输出
FileOutputStream fout = new FileOutputStream(System.out);
while(fin.available()>0)
{
//从文件中读字符
data = fin.read();
//写出文件输出流
fout.write(data);
}
//关闭输入流
fin.close();
//关闭输出流

fout.close();
}
//捕获文件异常
catch(FileNotFoundException e)
{
e.printStackTrace();
}
//捕获输入输出异常
catch(IOException exp)
{
exp.printStackTrace();
}
}
}




//PipedIODemo.Java
import Java.io.*;
class PipedIODemo
{
public static void main(String args[])
{
try
{
//创建管道输入流
PipedInputStream pin = new PipedInputStream();
//创建管道输出流
PipedOutputStream pout = new PipedOutputStream();
//输入与输出流相连
pout.connect( pin);
//启动管道输入线程
new PipeSender(pout,”sendString”).start();
//启动管道输出线程
new PipeReciver(pin,”receiveString”).start();
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
//管道输入类
class PipeSender extends Thread
{
PipedOutputStream pout;
File fFile;
//构造函数
PipeSender(PipedOutputStream out,String file)
{
fFile = file;
pout = out;
}
public void run()
{
//创建输入文件对象
FileInputStream fin = new FileInputStream(fFile);
int n;
try
{
//读文件
while((n=fin.read())!=-1)
{
//向管道中写入
pout.write(n);
}
pout.close();
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
//管道接收类
class PipeReciver extends Thread
{
PipedInputStream pin;
File fFile;
//构造方法
PipeReciver (PipedInputStream in,String file)
{
fFile = file;
pin = in;
}
public void run()
{
//输出文件对象
FileOutputStream fout = new FileOutputStream(fFile);
int n;
try
{
//从管道中读数据
while((n=pin.read())!=-1)
{
//向文件输出对象中写数据
fout.write(n);
}
}
catch(IOException e)
{
e.printStackTrace();
}
}
}

//InOutDemo.Java
class InOutDemo
{
public static void main(String args[]) throws Exception
{
//定义字节数组
byte buffer[] = new byte[30];
//将从键盘输入的字节序列存储到字节缓冲区中
System.in.read(buffer);
//生成String对象
String strBuffer = new String(buffer);
//在标准输出中输出生成的String对象
System.out.println(strBuffer);
}
}

//ExceptionDemo.java
class ExceptionDemo
{
public static void main(String args[])
{
for(int n=0;n<4;n++)
{
try
{
switch(n)
{
case 0:
char c = “123456”.charAt(100);
break;
case 1:
int[] a = null;
a[0] = 10;
break;
case 2:
int[] b = new int[10];
b[15] = 15;
break;
case 3:
int nNull = 0;
int c = 10/nNull;
break;
}
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
}
}




// ExecutionOrder.java
public class ExecutionOrder
{
public static void main(String args[])
{
System.out.println("1");
try
{
System.out.println("2");
if( true)
//抛出用户定义的异常
throw new InstanceException();
System.out.println("3");
}
//捕获该异常
catch(InstanceException e)
{
System.out.println("4");
}
System.out.println("5");
}
}
class InstanceException extends Exception
{
public InstanceException()
{
super();
}
}




//Demo.java
import java.io.*;
class IOExceptionDemo
{
public IOExceptionDemo()
{
try
{
int a = 0;
int b = 10;
int c = b/a;
}
catch(ArithmeticException e)
{
System.out.println("arithmetic exception");
}
finally
{
System.out.println("Entering finally statement. This must be executed");
}
}
}
public class Demo
{
public static void main(String args[])
{
IOExceptionDemo aIOExceptionDemo = new IOExceptionDemo();
}
}




//UserExceptionDemo.java
class UserExceptionDemo
{
//抛出异常的方法
void doSomeThing()
{
int a = 0;
int b = 10;
//产生异常的条件判断
if(a !=0)
{
System.out.println(“Normal”);
}
else
{
//抛出异常
throw new UserDefineException();
}
}
public static void main(String args[])
{
//实例化
UserExceptionDemo aUserExceptionDemo = new UserExceptionDemo();
//调用类实例的方法
aUserExceptionDemo.doSomeThing();
}
}
//用户定义的异常，由Exception类派生
class UserDefineException extends ArithmeticException
{
//Exception message
System.out.println(“Exception occured”);
}



// ListOfNumbersDeclared.java
import java.io.*;
import java.util.Vector;

class ListOfNumbers
{
private Vector victor;
private static final int size = 10;

//构造方法
public ListOfNumbers ()
{
//创建向量类
victor = new Vector(size);
//向向量中增加元素
for (int i = 0; i < size; i++)
victor.addElement(new Integer(i));
}
//成员方法，抛出两种类型的异常
public void writeList() throws IOException, ArrayIndexOutOfBoundsException
{
//文件IO处理
PrintStream out = new PrintStream(
new FileOutputStream("OutFile.txt"));
//取得向量元素
for (int i = 0; i < size; i++)
out.println("Value at: " + i + " = " + victor.elementAt(i));
//关闭输出流
out.close();
}
}

public class ListOfNumbersDeclared
{
public static void main(String[] args)
{
//实例化对象
ListOfNumbers list = new ListOfNumbers();
try{
//调用方法
list.writeList();
}
catch( Exception e)
{
//打印出异常的栈跟踪
e.printStackTrace();
}
}
}

1：类的基本概念
　　Java程序的基本单位是类，类是对象的实例，或者说对象是类定义的的数据类型的变量。你建立类之后，就可用它来建立许多你需要的对象。Java把每一个可执行的成分都变成类。
　　类的定义形式如下：
　　class classname extends superclassname
　　{
　　　　.....

　　}
　　这 里，classname和superclassname是合法的标识符。关键词extends用来表明classname是superclassname派生的子类。有一个类叫做Object，它是所有Java类的根。如果你想定义Object的直接子类，你可以省略extends子句，编译器会自动包含它。下面是一个简单的类的定义。
　　在类定义的开始与结束处必须使用花括号。你也许想建立一个矩形类，那么可以用如下代码：
　　public class Rectangle
　　{
　　　　......

　　}

2：类的基本组成
　　一个类中通常都包含数据与函数两种类型的元素，我们一般把它叫作属性和成员函数，在很多时候我们也把成员函数称为方法(method)。将数据与代码通过类紧密结合在一起，就形成了现在非常流行的封装的概念。自然，类的定义也要包括以上两个部分。

class <classname>

<member data declarations>
<member function declarations>

3：类的实例创建
　　矩形类Rectangle中，也许你想把矩形的相关信息写入类，如：width,height，当然你还可以写入其它信息，但或许长和宽对简单的矩形来说已足够了。现在，类的定义如下所示：
　　public class Retangle
　　{
　　int width,height;
　　}
　　当你创建了自己的类之后，通常需要使用它来完成某种工作。你可以通过定义类的实例－－对象来实现这种需求。
　　对象是通过new来创建，实现成员函数如下：Rectangle myrect=new Rectangle，当然，此时对象myrect并没有做任何什么事；它只保存了矩形的长和宽的信息。有了对象以后，我们怎样使用对象内部的数据呢？下面是几个例子：
myrect.width=10;
myrect.height=20;
　　类的成员函数也是用“.”运算符来被引用的。

１.String类和StringBuffer类

它们都是处理字符串的类,但是它们有一个最大的区别,那就是,String对象是存储你不能改动的文本字符
串,相反,如果你希望改动,则应使用StringBuffer类作为替换.
eg1:
......
//omit some code
String s1="You are hired!";
System.out.println(s1.replace(′h′,′f′));//用f把字串中的h替换了
System.out.println(s1);
......
//omit some code
运行结果:
You are fired!
You are hired!
结果分析:
从结果,明显可知,s1的值并没有被改变,而第一行结果只是屏幕内容的替换.
eg2:
......
//omit some code
StringBuffer s2=new StringBuffer("Hello from Java!");
s2.replace(6,10,"to");
System.out.println(s2);
......
//omit some code
运行结果:
Hello to Java!
结果分析:
显然,s2的值已改变.

２.位逻辑与条件逻辑

首先声明, 为了与位逻辑更好区分开来,我把通常所说的逻辑取了个别名叫做条件逻辑.
它们都有各自的操作符,位逻辑操作符有:&(与运算),^(异或运算),|(或运算);条件逻辑操作符有:&&(并
且),||(或者).
位逻辑运算通常是针对两个数而言,实行位操作;而条件逻辑运算是针对两个条件表达式而言,实行条件操
作.其实,位逻辑操作符一样可以实现条件操作,但是此时有一个重要的区别:用位操作符时,不管操作符两边的
条件表达式成不成立,它都要通通进行运算判断,而条件逻辑操作符不一样了,如果通过左侧的操作数就可以进
行它们需要的判断,那么它就不会再计算右侧的操作数了,这种情况叫短路.废话少说!且看下例.
eg1:
......
//omit some code
double value=0;
if(value!=0 && 1/value<1000){
System.out.println("The value is not too small.");
}
else{
System.out.println("The value is too small.");
}
......
//omit some code
运行结果:
The value is too small.
结果分析:
照理说应会出现除数为0的错误,但是我刚才说了,由于条件逻辑操作符是短路操作符,显然,value!=0不
成立,立即就可作出判断应执行else后的语句,所以它就不再会运算判断1/value<1000了.如果不懂请再看一
例:
eg2:
......
//omit some code
double int1=0,int2=1,int3=1;
if(int1!=0 & (int2=2)==1){}
System.out.println("int2="+int2);
if(int1!=0 && (int3=2)==1){}
System.out.println("int3="+int3);
......
//omit some code
运行结果:
int2=2.0
int3=1.0
结果分析:
我想不用我分析了,你应该懂了吧.

３.实例变量与类变量

可以通过两种方法在类中存储数据───作为实例变量和类变量.实例变量是特定于对象的,如果你有两个对
象(即一个类的两个实例),每一个对象中的实例变量独立于另一个对象中的实例变量的;另一方面,两个对象的
类变量均指向相同的数据,并因此面保存相同的值,换句话说,类变量被类中的所有对象共享.差点忘了,它们在
形式上的区别,类变量在声明时比实例变量多一个static.
eg:
class data
{
public int intdata=0;//显然,intdata在这儿是实例变量
}
public class exam
{
public static void main(String[] args)
{
data a,b;
a=new data();
b=new data();
a.intdata=1;
System.out.println("b.indata="+b.intdata);
}
}
运行结果:
b.intdata=0
结果分析:
可以看出,a.intdata的值虽然变了,但并没有影响b.intdata.但是如果在data类中声明intdata时,在其前
面加上static就变成类变量了(即:public static int intdata=0;),则此时运行结果会变为:
b.intdata=1
这次a.intdata值的改变可把b.intdata影响了,事实上,对象a和b的类变量均指向相同的数据,所有值一
样,这就是类变量的作用.

４.实例方法,类方法,构造器方法

我们通常所说的方法系指实例方法,就像c语言中的函数一样,其具体方法我就不用说了,在这里我主要是
用它来区分类方法和构造器方法.类方法与实例方法最大的区别是:在形式上类方法多一个static,在用法上,
不必创建对象就可直接调用类方法(而实例方法却一定要先创建对象,再通过对象调用).
eg:
class add
{
static int addem(int op1,int op2)
{
return op1+op2;
}
}
public class xxf
{
public static void main(String[] args)
{
System.out.println("addem(2,2)="+add.addem(2,2));
} //直接用类名作为对象调用类方法
}

注: 也可按通常的方法,即先创建对象,再调用方法,不过,这时static就无任何意义了.
再说说构造器方法,它是用来初始化对象中的数据的一种方法,创建很容易,只需在类中加上一个与这个类
同名的方法,不需要在前面加任何访问说明符或者返回类型,另外,构造器也一样可以向方法一样传递参数.
eg:
class data
{
private String data1;//事先声明

data(String s)
{
data1=s; /*通过接收数据来初始化变量.(注:不能在构造器内
声明变量,事先在外就要声明.)*/
}

public String getdata()
{
return data1;
}
}

public class xxf
{
public static void main(String[] args)
{
System.out.println((new data("I love you")).getdata());/*通过传递参数调用构造器新建一
个对象,再通过对象调用方法得到数据*/
}
}

５.接口与类

类是对一类特定对象的规格说明,我们可以类定义创建对象,通过创建对象来组合所有属于该类的组件,而
接口不能这样做.而接口实质上就是一个常量和抽象方法的集合,要使用一个接口,就需要在类中实现这个接
口,然后作为类定义的一部分,编写接口中声明的每一个方法,接口中的方法永远是public,abstract,接口中的
常量永远是public static和final,因此不需要为它们说明属性.
因为在Java中不支持多重继承,但是,可以用接口来实现类似的功能,这是接口的重要作用之一.
eg:
interface anyone //定义一个接口
{
final double PI=3.1416;
void setNumber(int number);
int getNumber();
}
interface anyother //定义另一个接口
{
void setString(String str);
String getString();
}

class xxf implement anyone,anyother //定义一个类,并使用两个接口
{
int number;
String str;
public xxf(){}
void setNumber(int number)
{
this.number=number;
}
void setString(String str)
{
this.str=str;
}
void int getNumber(){}//可以为一个空实现.
void String getString(){}
}
//在类中必须实现接口中声明的所有方法.(当然也可不必,但是要用到适配器类或用抽象类)