《基于安卓平台的程序设计：C++程序员Java速成》由会员分享，可在线阅读，更多相关《基于安卓平台的程序设计：C++程序员Java速成（123页珍藏版）》请在金锄头文库上搜索。
1、C+程序员程序员Java速成速成一、程序结构1.一个Java 程序可以由多个.java文件组成，必须有且只有一个类，含有 public static void main(String args) 成员函数，Java程序从这个函数开始执行public class HelloWorld public static void main( String args) System.out.println(Hello,World);一、程序结构2. 程序存在.java文件中。一个.java文件里可以有多个class，但是只能有一个class是public的。.java文件里 可以没有类是public的。包
2、含main的那个类也可以不是public的。3. .java文件里如果有public的class，那么文件名必须和该类名一致（大小写相关）。如果没有public类，那么文件名也必须和其中某个类（随便哪个都行）相同。4. Java程序大小写相关，甚至文件名都是大小写相关的。5. .java文件的编码必须是ANSI的.6. Java程序中的每个类，经过编译后会变成一个.class文件，文件名和类名相同。7. a.java中如果用到了文件b.java中的类，那么不做特殊处理的话， 程序运行时，应确保a.class应该和 b.class在同一个文件夹下。8. Java没有全局变量和全局函数。所有东西都
3、写在 class里面。一、程序结构1.java有boolean数据类型，没有bool类型。boolean类型的取值是true或false。boolean和int类型不能互相转换。条件表达式必须是boolean类型的，不能把0当false,非0当true2.有byte数据类型，byte类型的变量占一个字节, 取值是 -128 127。3. float常量后面要加 f 或 F，如: float y = 0.3f,x = 1.3e-4f;二、数据类型4.char类型的变量可以是Unicode字符表中的字符，包括可以是汉字，如 : char c = 好; char类型变量里，存放的是字符在 unico
4、de编码里的序号。Unicode编码一共65535个字符。字母、数字和普通标点符号在unicode里的编号正好和其ASCII码相等。不能认为char类型的变量占一个字节。二、数据类型5. long类型的变量占8个字节。long类型的常量后面要跟L或l，如: long a = 0xffffffffffaL;6. 将精度高的数值赋值给精度低的变量时，必须要进行强制类型转换，不过char类型和int类型可以互相赋值，只要赋给char类型的int值不超过65535;二、数据类型public class HelloWorld public static void main( String args) f
5、loat y = 0.3f,x = 1.3e-4f;char c = 好;long a = 0xffffffffffL;System.out.println(c);System.out.println(a);System.out.println(int)好);System.out.println(char)22900);System.out.println(int)a);/int n = 3.232; /wrongchar c1 = 65535; /ok/char c2 = 65536; /wrong输出：好109951162777522909奴971.成员变量被称为“属性”，成员函数被称为“
6、方法2.Java中没有指针，但Java对象本质上只是相当于C+中的指针，必须通过new运算符创建后才能被使用。class Test int n;public class HelloWorld public static void main( String args) Test t; /本质上相当于C+ 的 Test * t; t.n = 100; /错，t还没有初始化，对象不存在三、对象的概念正确的写法：class Test int n;public class HelloWorld public static void main( String args) Test t;t = new Te
7、st();t.n = 100;三、对象的概念3.Java 中对象用new创建后，不需要delete。Java虚拟机有垃圾回收机制，定期自动回收没用的对象。4. 对象间互相赋值会使得两个对象指向(或说是引用）相同的地方三、对象的概念class A int i; public class HelloWorld public static void main( String args) A a1 = new A(), a2 = new A();a1.i = 10; a2.i = 20;a1 = a2; a1.i = 30;System.out.println(a2.i); 输出：301.Java 中
8、的数组都是对象，有许多属性和方法。比如length属性表示数组元素个数。2.一维数组的两种定义方式（无区别）：类型 数组名 ;类型 数组名;不能在 中指定元素个数 四、数组3.数组定义后并不占有内存，也必须用new运算符创建后才能使用。创建时指定元素个数。float gpa ;gpa = new float300; /300个元素 也可以定义时直接初始化：float gpa = new float4;int a = 1,2,3,4, 5;System.out.println(a.length); /输出5四、数组一维对象数组初始化：class Student int n;Student(int
9、 v) n = v ; ;public class HelloWorld public static void main( String args) Student aStudent = new Student(3), new Student(2),new Student(4);四、数组数组new后，每个元素都是null，每个元素都需要new后才能使用class Demo int n;void ArrayDemo() Demo a = new Demo10;a1.n = 5; /上面会引发 java.lang.NullPointerException 错误a1 = new Demo();a1.
10、n = 5;四、数组4. 二维数组的每一行都可以分别初始化，而且每一行的元素个数可以不一样。二维数组的length属性代表其行数，也就是其中一维数组的个数。四、数组int a = 1,2,3 ,2,3,4,5;System.out.println(a.length); /输出 3System.out.println(a0.length); /输出 3System.out.println(a1.length); /输出 25. 二维数组的其他初始化方式: 四、数组public class HelloWorld public static void main( String args) int b
11、,c;b = new int45; c = new int4 ;c0 = new int3;c1 = new int100;System.out.println(c.length); /输出 4System.out.println(c0.length); /输出 3 System.out.println(c1.length); /输出 100System.out.println(c2.length); /运行时导致java.lang.NullPointerException 错误 6. 数组是对象，本质是指针。同类型数组之间可以互相赋值。import java.util.Arrays; /类似
12、于C+的 #incudepublic class HelloWorld public static void main( String args ) char a = h,e,k ;char b = 1,2,3,4 ;a = b; /a 和 b 指向（或称引用）同一个数组，a原来指向的数组被垃圾回收System.out.println(a.length);a0 = a; /b0也变成 aString s = Arrays.toString(b); System.out.println(s); /Arrays是Java标准类，能将数组转换成字符串 四、数组输出：4a, 2, 3, 47. Arr
13、ays是Java标准类，能将数组转换成字符串import java.util.Arrays; /类似于C+的 #incudepublic class HelloWorld public static void main( String args) int a = 12,34,29;System.out.println(Arrays.toString(a); 四、数组输出：12, 34, 298. 关于char数组char类型的的数组可以直接用println输出其全部内容char a = a,b,c;System.out.println(a); /输出 abcchar类型的数组不能如下初始化：c
14、har a = this;四、数组9. 拷贝数组System.arraycopy(srcArray,int idx1,destArray,int idx2, int len)将srcArray从下标idx1开始的len个元素拷贝到destArray从下标idx2开始的地方。destArray必须足够大。Arrays.copyOfRange(someArray,int from,int to)将 someArray从from开始到to-1的元素复制到一个新数组中并且返回。四、数组import java.util.Arrays;public class HelloWorld public stat
15、ic void main( String args) int a = 1,2,3,4 ;int b = 5,6,7,8,9;System.arraycopy(b,0,a,1,2);System.out.println(Arrays.toString(a);int c = Arrays.copyOf(b,3);System.out.println(Arrays.toString(c); int d = Arrays.copyOfRange(b,1,4);System.out.println(Arrays.toString(d);int e = Arrays.copyOfRange(b,1,9);
16、System.out.println(Arrays.toString(e);四、数组1, 5, 6, 45, 6, 76, 7, 86, 7, 8, 9, 0, 0, 0, 0输出：四、数组10. 遍历数组：除了和C+一样的遍历方式外，还有如下方式public class HelloWorld public static void main( String args) int a = 1,2,3,4;int n = 0;for(int k:a)n += k;System.out.println(n);char b = a,b,c ;for(char ch : b)System.out.prin
17、t(ch);10abc输出：import java.util.Arrays;enum Season Spring, Summer,Autum,winter public class HelloWorld public static void main( String args) Season x;x = Season.Spring;System.out.println(x);输出：Spring五、枚举类型六、类1.所有成员函数的函数体都写在 class . /此处不需要 ; 里面，不能拿出来写。2. 成员变量可以是本类的对象（因对象本质是指针）class LinklistNode int n;
18、LinklistNode next;六、类3. 静态属性称为“类变量”，非静态属性称为“实例变量”。静态方法称为“类方法”，非静态方法称为 “实例方法”。4. 同样存在 “this指针”，当然在Java里不叫指针。在类的方法内可以通过 “ this.成员名”的方式访问成员。总之，C+中的 “-”和 “:”在Java里都是“.”六、类5.写类定义时，可以对属性进行初始化。class Test int n = 4;double f = 1.3f;public class HelloWorld public static void main( String args) Test t = new Te
19、st();System.out.println(t.n);System.out.println(t.f);41.2999999523162842输出：六、类7. 构造方法没有初始化列表。要调用基类的构造方法，就写 super(.);8. 类派生使用关键字 extends六、类class A int n;A( int v) n = v; class B extends Aint v;B(int n) super(n); /没有此句，编译不过。 public class HelloWorld public static void main( String args) B b = new B(4);
20、System.out.println(b.n);六、类9. 封闭类的构造函数中不需要交代如何初始化成员对象。class A int n;A( int v) n = v; class B int v;A a;B(int n) public class HelloWorld public static void main( String args) B b = new B(4); 为什么？七、函数参数传递Java中的函数，参数都是传值的，没有传引用的。如果参数是对象，则效果和C+中参数是指针的情况一样。class A int i; A( int v) i = v; class Functions
21、static void Swap1(A a1, A a2) int tmp = a1.i; a1.i = a2.i; a2.i = tmp; static void Swap2(A a1, A a2)A tmp = a1; a1 = a2; a2 = tmp; public class HelloWorld public static void main( String args ) A a = new A(5), b = new A(10);Functions.Swap1(a,b);System.out.printf(%d,%dn,a.i,b.i);Functions.Swap2(a, b)
22、;System.out.printf(%d,%dn,a.i,b.i);输出：10,510,5八、包和import语句为避免不同的.java文件中出现名字相同的类导致冲突，Java引入了包的概念。类可以分属不同的包，不同包里的类可以重名。使用“包名.类名”形式就能避免类的命名冲突。类似于C+的“名字空间:类名”用 package语句作为 .java文件的第一条语句，指明该文件所属的包名。如果没有package语句，该文件中的类就都属于“无名包”（或叫“默认包”default package)。八、包和import语句包名可以是一个标识符，也可以是多个标识符用.连接，如：package pku;p
23、ackage pku.eecs.cs;八、包和import语句程序运行时，如果包含 main 的那个类的.class文件在当前文件夹下，则：如果文件里指定包名是 pku,那么该文件编译出来的 .class 文件就应该位于当前文件夹下的 pku子文件夹下如果文件里指定包名是 pku.eecs.cs,那么该文件编译出来的 .class 文件就应该位于当前文件夹下的 pkueecscs子文件夹下总之，包名里的一个标识符，就代表一个文件夹。也可以认为包就是一个文件夹。八、包和import语句在eclipse中，鼠标右键点击工程名(或已有的包名），在弹出的菜单上选 new - package 就可以新建
24、一个package在eclips工程里，编译出来的 .class文件都放在工程的 bin文件夹下，源程序都放在 src文件夹下.源程序文件的存放位置与包名的关系，和 .class文件存放位置与包名的关系一样。八、包和import语句多包程序的例子 - 有eclipes工程 example1八、包和import语句example1有以下文件：example1srcHelloWorld.javapublicclassHelloWorldpublicstaticvoidmain(Stringargs)gw1.PackageTestp=newgw1.PackageTest();p.PrintInfo(
25、);gw1.PackageTest2p2=newgw1.PackageTest2();p2.PrintInfo();gw2.subgw1.SubPackageTestsp=newgw2.subgw1.SubPackageTest();sp.PrintInfo();八、包和import语句example1srcgw1 PackageTest.javapackagegw1;publicclassPackageTestpublicvoidPrintInfo()System.out.println(thisisPackageTestObj);八、包和import语句example1srcgw1 Pac
26、kageTest2.javapackagegw1;publicclassPackageTest2publicvoidPrintInfo()System.out.println(thisisPackageTest2Obj);八、包和import语句example1srcgw2subgw1SubPackageTest.javapackagegw2.subgw1;publicclassSubPackageTestpublicvoidPrintInfo()System.out.println(ThisisSubPackageTestObject);Example1程序输出结果：this is Pack
27、ageTest Objthis is PackageTest2 ObjThis is SubPackageTest Object八、包和import语句用import语句引入包，可以省去在类前面写包名importgw1.*;/gw1里面的类，都不用写包名了importgw2.subgw1.*;/gw1.subgw1里面的类，都不用写包名了publicclassHelloWorldpublicstaticvoidmain(Stringargs)PackageTestp=newPackageTest();p.PrintInfo();PackageTest2p2=newPackageTest2();
28、p2.PrintInfo();SubPackageTestsp=newSubPackageTest();sp.PrintInfo();八、包和import语句 import语句也可以只引入一个类:importgw1.PackageTest;importgw2.subgw1.*;publicclassHelloWorldpublicstaticvoidmain(Stringargs)PackageTestp=newPackageTest();p.PrintInfo();gw1.PackageTest2p2=newgw1.PackageTest2();p2.PrintInfo();SubPacka
29、geTestsp=newSubPackageTest();sp.PrintInfo();八、包和import语句一个包对应于一个文件夹，但不包括该文件夹下的子文件夹。例如：importgw2.*;使得gw2文件夹下的类被import进来，但是gw2subgw1文件夹下的类，并没有被import进来。要import它们，还是需要写：importgw2.subgw1.*;九、类的可使用范围1.定义类时，前面可以加public关键字，也可以不加。加了，称为“公有类”。同一个包里的类，不论是否在同一个.java文件中，不论是否是public,都可以互相使用。2.只能使用其他包里的 public类，不能
30、使用其他包里的非 public类。十、类成员的可访问范围1. 类的成员，前面可以加 public(公有成员），private(私有成员）或protected(保护成员）。不加这三个标识符，并不缺省为私有，而是称为“友好成员”。2.一个类，可以访问同包类对象的公有、友好和保护成员，不可以访问同包类的私有成员3.一个类，可以访问异包类对象的公有成员，不能访问异包类对象的保护、私有和友好成员十、类成员的可访问范围4.子类不能访问父类的私有成员。5.友好成员和保护成员的区别是：与父类不在同一包中的子类，可以访问父类的保护成员，不能访问父类的友好成员。十、类成员的可访问范围(示例程序）packagegw
31、1;publicclassPackageTestpublicvoidPrintInfo()/友好方法System.out.println(thisisPackageTestObj);voidFriendFunc()System.out.println(inFriendFunc);privatevoidPrivateFunc()System.out.println(inPrivateFunc); protectedvoidProtectedFunc()System.out.println(inProtectedFunc);example1srcgw1 PackageTest.java十、类成员的
32、可访问范围(示例程序）packagegw1;publicclassPackageTest2publicvoidPrintInfo()System.out.println(thisisPackageTest2Obj);PackageTestt=newPackageTest();t.FriendFunc();/ok,可访问同包类对象的友好成员t.PrivateFunc();/错,不可访问同包类对象私有成员t.ProtectedFunc();/ok,可访问同包类对象保护成员t.PrintInfo();example1srcgw1 PackageTest2.java十、类成员的可访问范围(示例程序）i
33、mportgw1.*;importgw2.subgw1.*;publicclassHelloWorldpublicstaticvoidmain(Stringargs)PackageTestp=newPackageTest();p.PrintInfo();/ok，可以访问异包类对象的公有成员p.FriendFunc();/wrong,不可访问异包类对象的友好成员p.PrivateFunc();/wrong,不可访问异包类对象的私有成员p.ProtectedFunc();/wrong,不可访问异包类对象的保护成员example1srcHelloWorld.java十、类成员的可访问范围(示例程序）
34、classDerivedextendsPackageTestvoidTest()PackageTestp=newPackageTest();p.ProtectedFunc();/错,不可访问异包对象的保护成员p.FriendFunc();/wrong,不可访问异包对象的友好成员ProtectedFunc();/ok，可以调用异包基类的保护方法PrivateFunc();/wrong,不能调用基类私有方法FriendFunc();/wrong,不能调用异包基类的友好方法example1srcHelloWorld.java十一、super 关键字用“super.成员名”来访问基类的成员；在构造方法
35、中用“super(.)”调用基类构造方法如果派生类的构造方法没有调用基类的构造方法，那么等效于用“super();”调用基类的无参构造方法class A int v;A(int n) v=n; void Init() System.out.println(A.Init);class B extends A B (int n) super(n); void Init() super.Init();System.out.println(B.Init);public class HelloWorld public static void main( String args ) B b = new B
36、(5);b.Init();十一、super 关键字输出：A.InitB.Init1.假设有基类方法Function1, 返回值类型是A , 派生类中可以写同名同参数表的Funciton1, 返回值类型是可以是A,也可以是 A的派生类。2.重写基类的方法时，不能缩小方法的可访问范围。比如基类的Function1是public 的，那么派生类中重写的同名同参数表的 Function1，就不能是友好、保护或私有的。十二、派生类重写（覆盖）基类方法1.final 关键字可以修饰类、成员变量和方法中的局部变量2.final关键字修饰的类，不允许有派生类final class A A 不能有派生类。Jav
37、a 中的String类，就是final的3.final修饰成员变量和局部变量时，作用相当于C+的const，即常量4. final成员变量和局部变量必须在声明的时候初始化。十三、final 关键字5. final成员变量必须在声明时初始化或在构造函数中初始化，初始化后，其值不可改变。以下初始化方式均可：class A final int v = 4;A(int n) 或：class A final int v;A(int n) v = n;十三、final 关键字6. final局部变量也可以不初始化，但是赋值或创建一次后，就不能修改其值。7. 一个对象是final的，其含义并不是其成员变量的
38、值不能被修改，而是它不能再指向别的对象,类似于C+ 的 类型 * const 指针名;如int * const p;十三、final 关键字public class HelloWorld public static void main( String args ) final A a;final int n;n = 4;a = new A(10);System.out.printf(%d,%dn,n,a.v);n = 9; /wronga = new A(20); /wronga.v = 100; /wrong;a.k = 100; /ok;System.out.println(a.k);十三
39、、final 关键字(例程）class A final int v;int k;A(int n) v = n;去掉出错的语句后，输出:4,101001.abstract 类相当于C+中的抽象类，abstract方法相当于C+的纯虚函数。只有abstract类才能有abstract方法。和C+不同之处在于，abstract类中可以没有abstract方法。abstract class A abstract void func(); /不能写函数体 2. abstract类不能用new运算符创建对象。 十四、abstract 类和abstract方法1. 接口（interface)是Java中的重
40、要概念。接口和类有点像，但是其所有的成员变量都是public且final的（不写public和final也有一样），所有的成员函数都是abstract 且public的（不写public和abstract 也有一样）。例如：interface A int n = 5;void Func(int a,int b);int PrintInfo();可以定义接口变量，如 : A a; 但是，不能用new运算符来创建“接口对象”。十五、接口2. 接口可以派生出子接口：interface A int n = 5;void Func(int a,int b);int PrintInfo();interfa
41、ce B extends A double f = 3.0;int Count();十五、接口3. 接口可以派生出类。从接口派生类，用implements关键字，也称为类“实现”了某个接口：interface A int n = 5;void Func(int a,int b);int PrintInfo();class C implements A double c;int SomeFunc() return 0; public void Func(int a,int b) public int PrintInfo() return 1;十五、接口实现了接口的类，一定要对接口中的全部方法都重
42、写，写成public的，要写出函数体。若有接口的方法没有被重写，则这个类就必须是abstract 的。4. 可以让接口变量指向一个new出来的实现了该接口的类的对象:interface B int v = 6; void FuncB(); class E implements B public void FuncB() System.out.println(in B.FuncB); public class HelloWorld public static void main( String args ) B b = new E();b.FuncB(); 十五、接口输出:in B.FuncB5
43、. 接口也可以用public来修饰，称为“公有接口”。public 接口可以被任何类实现，非 public接口仅可以被同一个包中的类实现。public interface A 十五、接口Java中没有多继承。一个类最多只能有一个基类。但是一个类可以在继承一个基类的同时，还实现多个接口（也可以只实现多个接口而不继承任何类）。十六、“多继承”interface A int n = 5;void Func(int a,int b);int PrintInfo();interface B int v = 6;void FuncB(); class C class D extends C impleme
44、nts A,B public void Func(int a,int b) public int PrintInfo() return 0; public void FuncB() 1. Java中的方法，除了类方法(静态成员函数）外，都可以认为相当于是C+中的虚函数。十七、多态2. Java中多态的规则如下： 1) 通过基类对象，调用基类和派生类都有的同名同参数表的方法时，是多态。该基类对象如果指向的确是基类对象，那么指向的就是基类的方法，如果指向的是派生类对象，那么执行的就是派生类的方法。2) 通过接口变量，调用接口和实现了该接口的类都有的同名同参数表的方法时，是多态。被执行的是类的方法。
45、接口存在的目的，就是为了实现多态十七、多态(例程）interface IA int n = 5;void FuncIA();interface IB void FuncIB();class A void FuncA() System.out.println(in A.FuncA);class B extends A implements IA,IBvoid FuncA() System.out.println(in B.FuncA);public void FuncIA() System.out.println(in B.FuncIA);public void FuncIB() System.
46、out.println(in B.FuncIB);class C extends Bvoid FuncA() System.out.println(in C.FuncA);public void FuncIA() System.out.println(in C.FuncIA);public class HelloWorld public static void main( String args ) A a; IA ia;IB ib;a = new A(); a.FuncA();a = new B(); a.FuncA();a = new C(); a.FuncA();ia = new B()
47、; ia.FuncIA();ia = new C(); ia.FuncIA();ib = new B(); ib.FuncIB();ib = new C(); ib.FuncIB();输出：in A.FuncAin B.FuncAIn C.FuncAin B.FuncIAin C.FuncIAin B.FuncIBin B.FuncIB十八、字符串1.String类: 用来表示字符串 String s1,s2;s1 = hello;s2 = hello;System.out.println( s1 = s2 );s2 = new String(hello);System.out.println
48、( s1 = s2 );输出:truefalse十八、字符串1.String类: 用来表示字符串 String s = new String(hello);System.out.println(s.equals(hello);System.out.println(s = Hello);输出:truefalse十八、字符串1.String类: 用来表示字符串 int x;String s = 123456;x = Integer.parseInt(s);System.out.println(x);String str = String.valueOf(1233.223);System.out.p
49、rintln(str );输出:1234561233.223十八、字符串2. 字符串和字节数组byte d = abc你我他.getBytes();System.out.println(d.length);String s = new String(d,3,2);System.out.println(s);s = new String(d);System.out.println(s);出:9你abc你我他十八、字符串3. 正则表达式String regex = 1-90-9*.?0-9*;/ ? 代表出现0次或一次String str1 = 12r34a5;String str2 = 123.
50、45908;if( str1.matches(regex)System.out.println( str1 + 是数字);else System.out.println( str1 + 不是数字);String result = str1.replaceAll(D+,);/ D代表任意非数字字符,+代表出现一次或多次System.out.println(result);System.out.println(str2.matches(regex);输出：12r34a5不是数字12345true十八、字符串3.正则表达式String regex = sdpPunct+;String sentenc
51、e = This,is890 whatt word:me;String words = sentence.split(regex);for( int i = 0; i words.length; +i)System.out.println(wordsi); 输出：Thisiswhattwordme十八、字符串4. StringBuffer类 String字符串不能修改，StringBuffer可以StringBuffer str = new StringBuffer(123);str.append(456);System.out.println(str);char c = str.charAt
52、(2);System.out.println(c);str.setCharAt(0,X);System.out.println(str);str.insert(2, abc);System.out.println(str);String s1 = string obj;str = new StringBuffer(s1);String s2 = new String(str);输出：1234563X23456X2abc3456十九、图形用户界面使用图形界面，需要 import java.swing.*;十九、图形用户界面JComponent类及其派生类的对象叫“组件”Container类及其派
53、生类的对象叫“容器”容器上可以添加组件虽然组件也是容器，但许多组件一般不当做容器用，比如JButton。但JPanel会作为容器使用。窗口一般从Jframe派生对话框从Jdialog派生在一个窗口或对话框上可以添加组件各种按钮，编辑框，选择框，列表框，菜单，都是组件。十九、图形用户界面/空窗口程序import javax.swing.*;import javax.swing.JFrame.*;public class HelloWorld public static void main( String args ) JFrame window1 = new JFrame(window1);wi
54、ndow1.setBounds(60,100,180,100);window1.setVisible(true);十九、图形用户界面/空窗口程序import java.awt.*;import javax.swing.*;import javax.swing.JFrame.*;public class HelloWorld public static void main( String args ) TextWindow win = new TextWindow();win.setTitle(window with text);class TextWindow extends JFrame J
55、TextField text1,text2;JButton bt;public TextWindow() init();setBounds(100,100,236,150);setVisible(true);十九、图形用户界面void init() setLayout(new FlowLayout(); /设置布局text1 = new JTextField(uneditable);text1.setEditable(false);text2 = new JTextField(10); /10个字符宽add(text1);add(text2);bt = new JButton(Please P
56、ush);add(bt);往容器上放组件前，要设置布局。布局决定了组件的摆放方式。十九、图形用户界面十九、图形用户界面运行结果:二十、事件响应有些对象上能够发生“事件”，称为“事件源”比如按钮按下就是一个事件，按钮就是事件源列表框某项被选中就是一个事件，列表框就是事件源窗口上鼠标移动或点击就是一个事件，窗口就是事件源窗口或编辑框里用户敲击键盘也是事件，窗口或编辑框就是事件源响应事件需要:import java.awt.event.*;二十、事件响应发生事件后，程序应该要做出反应。因此需要一个“监视器”对事件源进行监视，这样，有事件发生时，监视器就能对事件做出处理。事件源通过调用一些方法，将某个
57、对象注册为自己的监视器，如文本框，可以用addActionListener(对象名)；将一个对象注册为自己的监视器。二十、事件响应能作为监视器使用的对象，必须实现某些特定的接口。比如要作为文本框的监视器的对象，必须实现 ActionListener 接口。ActionListener接口有以下方法：public void actionPerformed(ActionEvent e)在文本框中有敲回车时，文本框就会创建一个ActionEvent 对象，然后以此对象作为参数，调用监视器对象的该方法，通过该参数，就能知道具体发生的事件是什么样的，以及事件发生在哪个源上。事件有不同规定类型，Actio
58、nEvent 是其中一种二十、事件响应比如，ActionEvent 有以下方法：Object getSource(); 取得事件源对象String getActionCommand() 获取和事件有关的一个字符串所有的Java对象都是从Object对象派生而来二十、事件响应响应鼠标事件，用:addMouseListener : 添加响应鼠标点击、进出组件事件的监视器监视器需要实现 MouseListener接口addMouseMotionListener : 添加响应鼠标移动和拖动事件的监视器监视器需要实现 MouseMotionListener 接口二十、事件响应响应鼠标事件，用:Mouse
59、Listener : 有以下方法：public void mouseExited(MouseEvent arg0) ;public void mouseEntered (MouseEvent arg0) ;public void mousePressed(MouseEvent arg0) ;public void mouseReleased(MouseEvent arg0) ;public void mouseClicked(MouseEvent arg0) ;二十、事件响应响应鼠标事件，用:MouseMotionListener : 有以下方法：public void mouseMoved(
60、MouseEvent arg0) ;public void mouseDraged (MouseEvent arg0) ;二十、事件响应响应键盘事件，用:addKeyListener : 添加响应键盘敲击的监视器监视器需要实现 KeyListener接口KeyListener有以下方法：public void keyTyped(KeyEvent arg0) public void keyPressed(KeyEvent arg0)public void keyReleased(KeyEvent arg0)二十一、内部类class Out int n;Inner in;class Inner /
61、内部类String s;void PrintInfo() System.out.println( in= + Integer.toString(n) + , s= + s);二十一、内部类public class HelloWorld public static void main( String args ) Out o = new Out();/o.in = new Out.Inner(); / wrongo.n = 100;o.in = o.new Inner(); o.in.s = hello;o.in.PrintInfo();Out.Inner obj;obj = o.new Inn
62、er(); /内部类的对象一定要通过一个外部类的对象来newobj.PrintInfo();/obj = new Out.Inner(); /wrong输出：in=100, s=helloin=100, s=null二十二、静态内部类class Out int n;Inner in;static class Inner String s;void PrintInfo() /System.out.println( in= + Integer.toString(n); /wrongSystem.out.println( s= + s); 静态内部类的成员函数不能访问外部类的非静态成员二十二、静态内
63、部类public class HelloWorld public static void main( String args ) Out o = new Out();o.in = new Out.Inner(); o.n = 100;/o.in = o.new Inner(); /wrongo.in.s = hello;o.in.PrintInfo();Out.Inner obj;/obj = o.new Inner(); /wrongobj = new Out.Inner(); obj.s = hello2;obj.PrintInfo();输出：s=hellos=hello2二十三、匿名类可
64、以直接创建一个子类的对象，而不需要给出类名，这个无名子类就是匿名类。class A void PrintInfo() public class HelloWorld public static void main( String args ) A a1 = new A() void PrintInfo() System.out.println(hello);a1.PrintInfo(); 输出：hello二十三、匿名类interface A void PrintInfo();public class HelloWorld public static void main( String args
65、 ) A a1 = new A() public void PrintInfo() System.out.println(hello);a1.PrintInfo();输出：hello二十四、获取文件属性使用File类:import java.io.*;public class HelloWorld public static void main( String args ) File f1 = new File(c:tmp,test.txt);System.out.println(f1.getName() + 是可写的吗: + f1.canRead();System.out.println(f
66、1.getName() + 长度: + f1.length();System.out.println(f1.getName() + 绝对路径: + f1.getAbsolutePath();System.out.println(f1.getName() + 是否是文件夹: + f1.isDirectory(); 输出：test.txt 是可写的吗:truetest.txt 长度:23test.txt 绝对路径:c:tmptest.txttest.txt 是否是文件夹:false二十五、创建文件夹使用File类:import java.io.*;public class HelloWorld p
67、ublic static void main( String args ) File f1 = new File(c:tmptestdir);if( f1.mkdir() System.out.println(文件夹创建成功);elseSystem.out.println(文件夹创建失败或已存在); 二十六、列出目录中的文件要用File类的 list方法或listFiles方法还要用到接口 FileNameFilter的子类对象来存放要列出的文件名符合的条件，比如”*.java”等import java.io.*;class FileAccept implements FilenameFilt
68、er String extendName;public boolean accept(File dir,String name) return name.endsWith(extendName);二十六、列出目录中的文件public class HelloWorld public static void main( String args ) File dir = new File(c:tmp); FileAccept fileAc = new FileAccept();fileAc.extendName = .txt;String fileNames = dir.list(fileAc);f
69、or( String name:fileNames)System.out.println(name);dir = new File(.); /当前文件夹File fileObjs = dir.listFiles(); /列全部文件和文件夹for( File obj:fileObjs)System.out.println(obj.getName();二十七、删除文件import java.io.*;public class HelloWorld public static void main( String args ) File dir = new File(c:tmp,test.txt);d
70、ir.delete();二十八、以字节为单位读文件import java.io.*;public class HelloWorld public static void main( String args ) int b; byte tom = new byte100;try File f = new File(c:tmptest.txt);FileInputStream in = new FileInputStream(f);while( (b = in.read(tom,0,100)!= -1) String s = new String(tom,0,b);System.out.print
71、ln(s);in.close();catch( IOException e) System.out.println(file read error + e); 二十九、以字节为单位写文件import java.io.*;public class HelloWorld public static void main( String args ) byte b = 你好,are you ok.getBytes();try FileOutputStream out = new FileOutputStream(c:tmptest2.txt);out.write(b);out.write(b,2,b.
72、length - 2);out.close();catch( IOException e) System.out.println(error + e); /文件内容：你好,are you ok好,are you ok三十、以字符为单位读写文件import java.io.*;public class HelloWorld public static void main( String args ) char a = 这是15道考题答案.toCharArray();int n = 0,m = 0;try File f = new File(c:tmpsecret.txt);for(int i =
73、 0; i a.length; + i)ai = (char)(ai R); /加密FileWriter out = new FileWriter(f);out.write(a,0,a.length);out.close();FileReader in = new FileReader(f);char tom = new char10;三十、以字符为单位读写文件while(n = in.read(tom,0,10)!= -1) for(int i = 0; i n; + i)tomi = (char)(tomiR);String s = new String(tom,0,n);System.o
74、ut.println(s);in.close();catch( IOException e) System.out.println(e.toString(); 文件内容：辋晽cg送聑飊笆栚 输出结果：这是15道考题答案三十一、用缓冲流读写文件中的一行import java.io.*;public class HelloWorld public static void main( String args ) File file = new File(c:tmptest.txt);String content = line1,line 2,line 3 ;try FileWriter outOne
75、 = new FileWriter(file);BufferedWriter outTwo = new BufferedWriter(outOne);for(String str:content) outTwo.write(str);outTwo.newLine(); /换行outTwo.close();三十一、用缓冲流读写文件中的一行FileReader inOne = new FileReader(file);BufferedReader inTwo = new BufferedReader(inOne);String s = null;while(s = inTwo.readLine()
76、!= null)System.out.println(s);catch( IOException e) System.out.println(e.toString();三十二、随机流import java.io.*;public class HelloWorld public static void main( String args ) RandomAccessFile inAndOut = null;int data = 1,2,3,4,5,6 ;try inAndOut = new RandomAccessFile(c:tmptest.dat,rw);for( int i = 0;i =
77、 0; -i) inAndOut.seek(i*4);System.out.println( + inAndOut.readInt();三十二、随机流inAndOut.close();catch( IOException e) System.out.println(e.toString();输出结果：654321三十三、对象流import java.io.*;class Student implements Serializable /能被写入文件的对象所属的类，必须实现Serializable 接口String name = null;double height;Student( Strin
78、g n, double h) name = n; height = h;三十三、对象流public class HelloWorld public static void main( String args ) Student students = new Student(zhang,1.77),new Student(li,1.67) ;File file = new File(c:tmpstudents.dat);try FileOutputStream fileOut = new FileOutputStream(file);ObjectOutputStream objOut = new
79、 ObjectOutputStream(fileOut);for( int i = 0;i students.length; + i)objOut.writeObject(studentsi);objOut.close();FileInputStream fileIn = new FileInputStream(file);三十三、对象流ObjectInputStream objIn = new ObjectInputStream(fileIn);Object obj;for( int i = 0;i 2; + i) Student st = (Student) objIn.readObjec
80、t();System.out.println( st.name + : + Double.toString(st.height);objIn.close();catch( ClassNotFoundException e) System.out.println(不能读出对象);三十三、对象流catch( IOException e) System.out.println(e.toString();输出结果：zhang:1.77li:1.67三十三、对象克隆把对象写入一个byte数组流，然后再读出来，可以起到克隆对象的作用import java.io.*;class A implements S
81、erializableint va;A (int v) va = v; class B implements Serializableint vb;A a;B(int v) vb = v ; 三十三、对象克隆public class HelloWorld public static void main( String args ) B b1 = new B(10);b1.a = new A(100);try ByteArrayOutputStream out = new ByteArrayOutputStream();/数组可以作为流的来源和目的地ObjectOutputStream objO
82、ut = new ObjectOutputStream(out);objOut.writeObject(b1);ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray();ObjectInputStream objIn = new ObjectInputStream(in);B b2 = (B)objIn.readObject(); System.out.printf(%d,%d,b2.vb,b2.a.va);catch( ClassNotFoundException e) System.out.println(不能
83、读出对象);catch( IOException e) System.out.println(e.toString();输出结果：10,100三十三、模板import java.io.*;class Cone /模板double height;E bottom;public Cone( E b,double h) bottom = b; height = h;public double getVolume() / return height * bottom.getArea(); 错，只能调用从object继承或重写的方法return height * Double.parseDouble(b
84、ottom.toString(); 三十三、模板class Rectangle double w,h;public String toString() return + w * h; Rectangle( double W, double H) w = W; h = H; class Circle double r;public String toString() return + 3.14 * r * r; Circle(double R) r = R; 三十三、模板public class HelloWorld public static void main( String args )
85、Rectangle r = new Rectangle(3,4);Circle c = new Circle(10);Cone cube = new Cone(r,10);Cone cl = new Cone(c,20);System.out.println(cube.getVolume();System.out.println(cl.getVolume();输出结果：120.06280.0三十三、模板库LinkList : 链表,相当于listArrayList : 动态数组，相当于vectorStack : 栈HashMap ： 哈希表TreeSet : 相当于setTreeMap : 相当于 map
