J2SE
1.类：具有相同的特征和行为的一个抽象的集合。对象：类的实例化
2．Java命名规则a.类名：首字母大写，若由多个单词构成，每个单词首字母大写
b.变量名：首字母小写，从第二个单词字母开始大写，如intArray
c. 常量：所有字母都大写，CLASS_LOAD_PATH
d.关键字:所有字母都小写，if,int
e.方法：首字母小写，从第二个单词字母开始大写，（）是方法的标志，如changColour( );
3.构造方法的规则：a.与类同名,首字母大写;
b.无返回值也不加void,而且绝对不会有返回值;
c.在new的时候调用,是对对象进行初始化的;
e.若无自定义的构造方法,则自动生成一个default空构造方法;若有,则default自动失效.
4．a.成员变量：直接在类里面定义的变量，作用域是整个范围
b.局部变量：在方法的内部或方法的参数定义，是在定义他的{ }范围内有效。
c.若局部变量与成员变量同名，因就近原则直接用成员名调用的是局部变量，用this.变量名调用的是成员变量。class Person{ private String name;private int age;
Person(String name,int age){this.name=name; this.age=age;}}
5．外附类（wapper）：把基础类型包装成类,如Integer,String.
Eg: class integer{int i; integer(int i){ this.i=i; } }
6.equals:在外附类里是判断类值是否相同，在普通类里面等价于”= =”,判断是否是同一个对象。
= =：对于基本数据类型，是判断值是否相等，对于类类型判断是否是同一个对象。
Eg:public static void main(String args[]){Integer n1=new Integer(47);
Integer n2=new Integer(47);System.out.print(n1.equals(n2));//true
System.out.print(n1==n2);//false
7.=：基本数据类型表示赋值，对于类类型表示内存空间引用的传递。
class Number{int i;}
public class Test{ public static void main(String args[]){ Number n1=new Number();
Number n2=new Number();n1.i=9;n2.i=10; n1=n2;//n1和n2的值都为10；
n1.i=20;// 此时n1和n2都为20 }}
8．常见控制语句：public class XDay{public static void main(String args[]){
int yearis=2100;int monthis=12;DayCount db=new DayCount();
int s= db.countDays(monthis,yearis); }}
class DayCount{ int countDays(int month,int year){ int count=-1;switch(month){
case 1: case 3: case 5: case 7: case 8: case 10: case 12: count=31;break;
case 4: case 6: case 9: case 11: count=3;break;
case 2: if(year%4==0)count=29;else count=28;
if((year%100==0)&&(year%400!=0)) count=28;} return count;}}
9.从客户端输入：public class MonthCounter{public static void main(String args[]){
Integer intYearMonth1=Integer.parseInt(args[0]);
Integer intYearMonth2=Integer.parseInt(args[1]);//输入并转换为整型类
int intYear1, intYear2,; intYear1=intYearMonth1/100;intYear2=intYearMonth2/100; }}
转换为字符串类：String intYear2=String.valueof(intYearMon1);
10.一维数组：a.数据类型是一致的 b.数组大小是确定的 c.初始化：静态初始化int a[]={3,4};
动态初始化：声明：int a[];创建：a=new int[5];赋值：a[0]=1;a[1]=2;
声明+创建： Integer a[]=new Integer(2);//另开辟内存指向新空间
public class Array{public static void main(String args[]){
String a[]={"奥林","花园","在哪里"};String b[]=new String[5];
Integer c[]=new Integer[3]; c[0]=1;c[1]=2;c[2]=3;
b[3]="谁";b[4]="知道";
System.arraycopy(a,0,b,0,3);//源，头，目标，头，长度，大小写特殊
for(int i=0;i<b.length;i++) System.out.print(b[i]);
for(int j=0;j<c.length;j++)System.out.print(c[j]); }}
11．二维数组：静态初始化：int a[][]={{1,2},{2,3}};
动态初始化：声明：int a[][];创建:a=new int[2][];具体行:a[0]=new int[2];a[1]=new int[3];
赋值：a[0][0]=2;a[0][1]=3;a[1][0]=1;a[1][1]=4;a[1][2]=5;
12. Java的类的成员的初始化顺序: 首先初始化所有的成员变量,然后初始化构造方法.最后初始化普通方法,而且普通方法只有在“对象名.方法名”中才会被初始化,这就是缓式初始化.
13. 封装:a.把功能和属性包装成类.通过类的实例来实现;b.隐藏实现的细节;
c.通过包把类组织起来;d.访问权限的控制.
打包：package pac1;
public class Pac{public void display(){System.out.println("正在打包");}}
调试包：javac –d .\ Pac.java 使用包：import pac1.Pac
14.访问权限：private：只能在类的内部调用，默认friend:在类的内部和同一个包中被调用
public:类的内部，同一个包中其他类，包外的其他类都可以调用
protected: 在类的内部和同一个包中被调用,但可以在包外被继承，通过.调用内部成员
eg:class Robot{String name="liming";
protected String display(){return(name);}} //换成private就出错
class Person extends Robot{public void display2(){
System.out.println(display());}}
public class UseRobot1{public static void main(String args[]){
Person n1=new Person(); n1.display2(); }}
15．方法重载:同一个类中,方法名相同,参数不同,方法体不同;
方法重写:不同的类中,方法体不同,参数相同,方法名也相同.
方法重载的作用: 在有多个同名参数的类中,在调用时通过不同的参数来调用不同的方法.
方法重写的作用: 在继承中,子类可用方法重写,对父类进行扩充或改造.
class Flower{int petalCount = 0; String s=new String("null");
Flower(int petal){ petalCount=petal;System.out.println(petalCount);}
Flower(int petal,String ss){this(petal);s=ss; System.out.println(s);}
public static void main(String args[]) {
Flower n1=new Flower(4,"dd"); Flower n2=new Flower(5);} }
this:可以实现一个构造方法调用另一个构造方法，this(参数)；普通方法不能调用构造方法，对this的调用必须是该构造方法的第一个语句（本类的）。
16．名称遮蔽:子类中若对父类进行方法重写,出现与父类同名的属性,则会将父类中与其同名属
性遮蔽掉. 在子类中,如果要调用父类的构造方法,必须使用super(参数)调用,
若要调用父类的普通方法则用super.方法名;调用.且子类中对super的调用必须
是子类构造方法所做的第一件事.这样便可以绕过名称遮蔽。
class Test3{ int value=8; int display4(){ return value; }}
class UseTest extends Test3{int value=9;int display5(){return value;}
int display6(){return(super.value)； }}
class NiHao{ public static void main(String args[]){ UseTest n1=new UseTest();
System.out.println(n1.display5());System.out.println(n1.display6());}}
若父类没有空构造方法，若子类想初始化则子类必须有非空构造方法；则在子类构造方
法中用super(参数)对父类初始化。
class Person{ public String name;public int age;
Person(String name,int age){this.name=name;this.age=age; }}
class Student extends Person{public String school;
Student(String name,int age,String s){super(name,age); school=s;}}
public class UsePerson{public static void main(String args[]){
Student n1=new Student("nihao",18,"keda");//new的时候对构造函数初始化
System.out.println(n1.name); System.out.println(n1.school);}}
17．多态多态:相同的事物调用的是相同的方法，参数也相同，表现形式去不同
a.子类能以父类的身份出 现
b.不同的子类以共同的父类身份出现，但做事情时以自己的方式来实现
c.子类以父类身份出现，只有与父类共有的属性和功能才能被调用，自己个性化的功能就会失效。(方法可以多态进行重写，变量则不可多态，不能重写)
class Instrument{public void play(){System.out.println("instrument.play");} }
class Wind extends Instrument{ public void play(){System.out.println("wind.play");}}
class Ehu extends Instrument{public void play(){System.out.println("Ehu.play");}}
public class Music3{static void tune(Instrument i){i.play();}//类为参数，多态参数
static void tuneAll(Instrument e[]){for(int i=0;i<e.length;i++)tune(e[i]);}
public static void main(String[] args){ Instrument[] a=new Instrument[2];
int i=0; a[i++]=new Wind();a[i++]=new Ehu();tuneAll(a); } }//异类集合
18．继承:a.子类自动拥有父类非private的属性和功能;
b.子类还可以拥有自己所特有的属性和功能;
c.子类可以继承父类的属性和功能,并可以修改,以自己的方式来实现.
class Person{String name;}
class Worker extends Person{String copration="witbridge";
public String getCorp(){return copration;}}
class Student extends Person{String school="witbridge";
public String getSchool(){return school;}}
public class Display{public void method(Person e){
if(e instanceof Student){//执行期型别辩识。测试属于哪个类
Student me=(Student)e;System.out.println("this is student "+me.getSchool());}
else if(e instanceof Worker){ Worker me2=(Worker)e;//转化为类类型
System.out.println("this is worker "+me2.getCorp()); }
else{ Person me3=(Person)e;System.out.println("this is person ");}}
public static void main(String args[]){ Display t=new Display();
Worker w1=new Worker();t.method(w1);Student w2=new Student(); t.method(w2);
Person w3=new Person();t.method(w3);}}
19．final: 最终的,不可改变的.
a. 修饰变量:为常量,值不可变; b.修饰对象,数组：值可变,引用不变;
c. 修饰方法：方法不可重写，但不代表内部成员也是 final； d.修饰类：不可以被继承,更不可能被重写，也就是方法是 final的。
20．static:a. 修饰的成员为类成员,不需要实例化,就可以用类名.成员名;调用;
b. static的成员,不管产生多少实例,都指向同一个内存空间;
c. static语句块中定义的语句总会在第一次初始化时执行一次。
d. 在static的语句块中的变量在成员中也必须是static的，否则类型不匹配;要想调用成员中非static变量和方法必须采用New的方式。
class Value{int i=1;}
public class FinalData{final int i1=9;
static final int VAL_TWO=99; public static final int VAL_THREE=39;
final int i4=(int)(Math.random()*20);//值只存在一个运行周期不变
static final int i5=(int)(Math.random()*20);//值将不改变，由创建第一次实例确定
Value v1=new Value();final Value v2=new Value();static final Value v3=new Value();
final int[] a={1,2,3};public void print(String id){System.out.println(id+i4+i5);}
public static void main(String args[]){FinalData fd1=new FinalData();
fd1.v2.i++;fd1.v1=new Value();for(int i=0;i<fd1.a.length;i++)fd1.a[i]++;
fd1.print("fd1");System.out.println("creating new FinalData");
FinalData fd2=new FinalData();fd1.print("fd1");fd2.print("fd2");}}
//（this不能出现在static方法调用中）eg:class Person{public static int total=10;
Static{ int i=10;int total=100;this.total=total;}}//错误，static体中为局部变量
21．接口:特殊的抽象类.只包含常量和方法的定义,无变量和方法的实现，用implements继承；
a.接口中所有方法都是抽象的，而且默认都是public访问权限的（interface）
b.一个类要实现某接口就一定要实现此接口中所有抽象方法，否则此类必为抽象类
抽象类:a.用abstract来修饰.抽象类无方法体;但是抽象类不一定有抽象方法；但有抽象方法的一定是抽象类;只能通过子类的实例,以父类的身份出现;
b.．抽象类是不可以New的
c.非抽象类的子类继承时,必须重写其所有的抽象方法，否则自己就为抽象类.
区别: 一个具象类只能继承一个抽象类,但能继承多个接口.
接口中的成员都是static & final类型的.
Java中没有多重继承,但可以通过接口,来实现多重继承机制
interface Interface{public void f();void g();}
abstract class First implements Interface{public void f(){
System.out.println("first.f();");}}//通过继承都重写了，所以Second就不用abstract;
class Second extends First{public void g(){System.out.println("second.g();");}}
public class Demo{public static void main(String args[]){//子类访问权限不能小于父类
Interface f=new Second();f.f();f.g();}}//抽象类不能呢new,只能以父类身份出现
22. 利用参数查找类：import java.lang.*; interface Common{ int time(int a,int b,int c);}
class Car implements Common{ public int time(int a,int b,int c){return(a*b/c);}}
class Plane implements Common{ public int time(int a,int b,int c){return(a+b+c);}}
public class ComputeTime{ public static void main(String args[]){
try{ int A = Integer.parseInt(args[1]);int B = Integer.parseInt(args[2]);
int C = Integer.parseInt(args[3]);int v,t;
Common d = (Common)Class.forName(args[0]).newInstance();//向上转型，是不安全的
v = d.time(A,B,C);t= 1000/v;
System.out.println("运行速度:"+v);System.out.println("时间:"+t+"小"); }
catch(Exception e){System.out.println("class not found");}}}
23．集合：把性质相似的事物汇集成一个整体，集合框架：用来操作集合的标准体系结构。
--ArrayList(有序的数组类) --HashMap（非同步）
--List接口 --Vector（线程同步）
Collection --LinkList Map（散列表） --Hashtable
--Set接口 -- WeakHashMap
24.ArrayList:a.可以添加重复的对象b.可以有null. c.线程非同步（可同时被多个调用）
import java.util.*;
public class ArrayListDemo {List a1=new ArrayList();public ArrayListDemo(){
a1.add("a");a1.add("b");a1.remove("a");}//添加对象和移出对象
public void display(){int n=a1.size();System.out.println("list大小为"+n);
for(int i=0;i<n;i++){System.out.print(a1.get(i).toString());}}//为objec自动调用
public void insertElement(int index,Object obj){a1.add(index, obj);}
public void removeElement(int index){ a1.remove(index);}
public void setElement(int index,Object obj){ a1.set(index,obj);}
public static void main(String args[]){ArrayListDemo ald=new ArrayListDemo();
ald.insertElement(2, "xx");ald.display();ald.removeElement(3);ald.display();
ald.setElement(1, "toto");ald.display();}}
25．HashMap：a.可以有空键也可以有空值，但是空键只能有一个，空值可以多个；线程非同步；
b.不能通过get找出键和值的一一映射，只能通过containsKey判断值是否存在；
import java.util.*; class Counter{ int i=1;
public String toString(){ return Integer.toString(i); }}//Object被String等类继承
public class TestHashMap {public static void main(String args[]){
HashMap hm=new HashMap();for(int i=0;i<10;i++){
Integer r=new Integer((int)(Math.random()*20));//random产生的是double型的
if(hm.containsKey(r)) ((Counter)hm.get(r)).i++;
else hm.put(r,new Counter());} System.out.println(hm);}}
26．Hashtable:a.任何非空对象b. 线程同步；import java.util.HashMap;
public class DemoHashTable {public static void main(String args[]){
Hashtable number=new Hashtable ();//表都是通过put添加值的
number.put("one",1);number.put("two",2);number.put("two",new Integer(3));
Integer n=(Integer)number.get("two"); System.out.println("two="+n);}}
27．迭代器Iterator:Collection有迭代器可以实现显示全部循环编列集合，而Map没有迭代器，通过values方法将Map转为Collection接口。import java.util.*;
public class TestIterator {public static void main(String args[]){
ArrayList h=new ArrayList();h.add("1st");h.add(new Double(4.0));
Iterator it=h.iterator();//iterator为List接口下的方法，返回类型为Iterator;
while(it.hasNext()){System.out.println(it.next());}//hasNext,next为迭代器方法
Set s=new HashSet();s.add("1st");s.add(new Integer(3));//Set接口输出无序且无重复值；
Iterator is=s.iterator();while(is.hasNext()){System.out.println(is.next());}}}
28.线程：进程中的一个单一的连续控制流程。a.Java至少有两个线程（主线程+垃圾回收线程）
b.进程：多个线程，使用系统中的运行资源。
public class Thread extends Object implements Runnable(Runnable只有一个run()方法)。
class MyThread extends Thread{ public void run(){System.out.println(getName());}}
public class MultiThread{public static void main(String args[]){
MyThread mt=new MyThread();mt.start();//线程自动运行
System.out.println(“main”+Thread.currentThread().getName());}}
29．具备线程能力：继承Runnable接口，还得传递给Thread,不过可以方便实行多接口继承。
class Runner1 implements Runnable{public void run(){
for(int i=0;i<30;i++){ System.out.println("no."+i);}}}
public class TestThread1 {public static void main(String[] args) {
Runner1 r=new Runner1();Thread t=new Thread(r); t.start()；}}
30．多个线程同时启动，交替抢占CPU运行，具体运行由当前CPU效率来决定。
Sleep方法可以让线程休眠，synchronized关键字可以使线程变成同步。
class One{synchronized void display(int num){ System.out.println("one同步方法"+num);
try{Thread.sleep(2000); System.out.println("线程完成");}
catch(Exception ex){System.out.println("线程中断");}}}
class Two implements Runnable{int number; One one; Thread t;
public Two(One one_num,int n){one=one_num;number=n;t=new Thread(this);t.start();}
public void run(){ one.display(number); } }
public class TestSynchronized {public static void main(String args[]){
One one=new One();int tag=10;Two s1=new Two(one,tag++);Two s2=new Two(one,tag++);
try{s1.t.join();s2.t.join();}//Thread.join();等待该线程终止。
catch(Exception ex){System.out.println("中断");}}}
31.输入输出流：a.Stream 字节流处理,InputStream输入流，read()方法读入字节，实现类FileInputStream 处理文件；OutputStream输出流，write()方法写出字节
b.Reader字符流的处理，被InputStreamReader和OutputStreamReader继承。
import java.io.*; public class CopyFile {public static void main(String args[]){
try{ FileInputStream fis=new FileInputStream("CopyFile.java");
FileOutputStream fos=new FileOutputStream("temp.txt"); int read=fis.read();
while(read!=-1){ fos.write(read); read=fis.read();}//实现循环走动
fis.close();fos.close();}//输出不关闭可以无限输入，输出不关闭不能刷新
catch(IOException e){System.out.println(e);}}}
32．public class CopyFile1 {public static void main(String args[]){
try{ File f=new File("filename.txt");//File文件和目录路径名的抽象表现形式
FileReader fr=new FileReader(f);//继承了InputStreamReader,用于读取字符流
BufferedReader br=new BufferedReader(fr);//继承Reader从字符输入流中读取文本缓冲字符
String line=br.readLine();//读取文本行，返回String,read(返回int)读取单个字符
while(line!=null){System.out.println("读的数据"+line);line=br.readLine();}
br.close();}catch(Exception ex){ex.printStackTrace();}}}
33.高速读取，高速写入：public class InputOutput {public static void main(String[] args){
try{File fname=new File("newfile.txt");FileReader fr=new FileReader(fname);
BufferedReader br=new BufferedReader(fr);//可以通过new InputStreamReader(System.in)
FileWriter fw=new FileWriter("copynewfine.txt");
BufferedWriter bw=new BufferedWriter(fw); String line=br.readLine();
while(line!=null){bw.write(line);bw.newLine();line=br.readLine();}控制关闭
br.close();bw.close();} catch(Exception ex){ex.printStackTrace();}}}
34.如果用read读，int i=in.read();必须System.out.print((char)i);否则输出16位字节内存地址。
35．异常：程序在正常情况下运行，出现正常的情况而使程序终止。捕获异常使程序可正常进行
a.Error JVM系统内部错误；b.Exception:程序内部错误。
c.语法结构try{ } catch{ } finally{ 无条件执行，通常情况下用于释放资源 close }
36.catch(Exception e)信息：e.printStackTrace();打印异常路径，名称
e.toString();打印异常名和信息；e.getMessage();打印异常信息。
37.自定义异常：throws为抛出给谁去处理异常，throw为产生异常。
class UseException extends Exception{public UseException(String s) { super(s);}}
public class Test{ public static void main(String args[]) throws UseException{
try {String a[]={"a","b","c"};for(int i=0;i<4;i++){System.out.println(a[i]);}}
catch(Exception e){throw new UseException("数组超过界限了！");}}}
38．JDK 5.0新特性
a.自动拆装箱：拆：对象—>基本数据类型；装：基本数据类型-à对象
public class AutoBoxDemo { //避免把值类型数据保存到集合中 需要装箱(add()只接受对象)
public static void Show(Integer intObject){ System.out.println(intObject);}
public static void show1(){Show(new Integer(8));}public static void show2(){Show(90);}
public static void main(String args[]){show1();show2();}}
b.增强的循环：有利于防止数组下标越界；确保安全性，因为使数组内数据类型一致
public class For5 {public static void main(String args[]){
int a[]={1,2,3,4};for(int aa:a){System.out.println("数组值是"+aa);}}}
c. 泛型:本质就是参数化类型。即允许创建一个类，接口，方法时所操作的数据类型是一个参数。操作参数化类型的类，接口，方法被泛型.
c.1:类型安全:泛型的主要目标是提高 Java类型安全 ，在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。而在之前必须在运行期动态进行容器内对象的检查及转换；
c.2:消除强制类型转换:消除源代码中的许多强制类型转换。这使得代码更加可读，减少出错；
c.3:潜在的性能收益:编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。
c.4:擦除: Java 语言中的泛型基本上完全在编译器中实现，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。这种实现技术称为擦除(erasure）(编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除)
public class GenDemo { public static void main(String args){
Gen<Integer> iob; iob=new Gen<Integer>(33);
iob.showType();int v=iob.getOb(); System.out.println("value"+v);
Gen<String> strOb=new Gen<String>("test");
strOb.showType();String str=strOb.getOb(); System.out.println("value"+str);}}
class Gen<T>{T ob;Gen(T o){ob=o;}T getOb(){return ob;}// 泛型类声明，由参数决定
void showType(){System.out.println("type of t is"+ob.getClass().getName());}}
不需要类型转化：import java.awt.*; import java.util.*;
public class TestList {public static void main(String args[]){test();test1();}
public static void test(){List list=new ArrayList();list.add("中国");
list.add("上海");for(Iterator item=list.iterator();item.hasNext;){
String s=(String)item.next();System.out.println(s);}}
public static void test1(){List<String> list=new ArrayList<String>();
list.add("你好");list.add("hello");for(String s:list){System.out.println(s);}}}
d. 通配符 ？变量的泛型声明和方法的参数的泛型声明有很大差别!import java.util.*;
public class Type {public static void main(String args[]){
List<String> list=new ArrayList<String>();list.add("1");list.add("2");
for(String s:list){System.out.println(s);}
List<Number> list2=new ArrayList<Number>();list2.add(new Integer(1));
list2.add(225);prt1(list2);prt2(list2);
List<Integer> list3=new ArrayList<Integer>();list3.add(new Integer(1));
list3.add(9); prt2(list3); }// prt1(list3);错误，类型不匹配
private static void prt1(List<Number> list){for(Number n:list){打印n;}}
private static void prt2(List<? extends Number>list){for(Number n:list){ 打印n;}}}
39.GUI程序设计：import java.awt.*;
public class TestFrame {public static void main(String args[])
{ Frame f=new Frame("第一个窗口");f.setSize(170,100); f.setVisible(true);}}
利用适配器创建GUI：import java.awt.*;import java.awt.event.*;
public class TestAdapter {public static void main(String args[]){
Frame f=new Frame("gui");f.setSize(170,100);MyLis m=new MyLis ();
f.addWindowListener(m);f.setVisible(true);}}
class MyLis extends WindowAdapter{public void wClo(WindowEvent e){System.exit(0);}}
40．NetBeans中 适配器WindowAdapter类：
总接口：EventListener-à子接口：WindowListener,WindowFocusListener等——>
被WindowAdapter类全部继承，其中的所有关闭，激活等方法需要的重写就可以。
GUI设计原理：容器（JFrame,Jwindow等）-à使用add()添加控件类(JLable,JTextField)
-à调用Event事件响应相应的方法—>在IDE内部由Listener负责监听Event
Eg:在NetBeans中构建Swing:
private void jListSportValueChanged(javax.swing.event.ListSelectionEvent evt) {
String sport=(String)this.jListSport.getSelectedValue();
this.jLabelMessage.setText("你选择了"+sport);}
private void jTextFieldAddressActionPerformed(java.awt.event.ActionEvent evt) {
String address=this.jTextFieldAddress.getText();
if(address!=null&&!address.equals("")){
this.jLabelMessage.setText("你输入了"+address);// TODO 将在此处添加您的处理代码：
}else{this.jLabelMessage.setText("你没有输入任何内容！");}}
private void jRadioButtonDislikeItemStateChanged(java.awt.event.ItemEvent evt) {
this.jLabelMessage.setText("你选择了讨厌单选按钮！");}
private void jCheckBoxBaggioItemStateChanged(java.awt.event.ItemEvent evt) {
if(this.jCheckBoxBaggio.isSelected()){this.jLabelMessage.setText("你喜欢巴桥了！");}
else{this.jLabelMessage.setText("你不喜欢巴桥了！");}}
private void jButtonEnterActionPerformed(java.awt.event.ActionEvent evt) {
this.jLabelMessage.setText("你按下了确定按纽！"); }
总结：JLable主要方法：setText();JTextField通过Action事件主要方法：getText();
JRadioButton和CheckBox通过Item事件主要方法：isSelected();
JList通过ListSelection事件主要方法：getSelectedValue();
JSplitPane类将容器分成几部分，拥有HORIZONTAL_SPLIT和VERTIVAL_SPLIT等属性值。