java2学习笔记

来源：互联网发布：利用我的世界学编程编辑：程序博客网时间：2024/06/05 18:02

java2学习笔记

设置环境变量
在环境变量中的PATH中设置%JAVA_HOME%/BIN;

JDK开发环境工具
工具主要存放在/bin下，共13个工具，26个EXE文件。

JAVA编译器JAVAC.EXE:将.JAVA文件转换成字节码.CLASS文件。对源程序中的每个类定义都会生成一个单独的类文件。
格式：javac[options] File.java ,其中：option可有
           1、-classpath<path> 指定javac的搜索类的路径序列如:c:/>javac -classpath c:/my/lib;c:/home welcome.java
           2、-d 指定编译器生成的类文件存放目录的根目录如：c:/>javac -d c:/classes welcome.java
           3、-g 编译器产生调试表，包括对应的源代码行号及变量信息。如：c:/>javac -g welcome.java
           4、-verbose 编译的同时输出一些相关信息，包括：代码名称、类名、用时等。如：c:/>javac -verbose welcome.java

JAVA解释器java.exe:直接执行java程序
格式：java[options]classname[arguments]，其中arguments是参数，options可有：
        1、-classpath 2、-D<name>=value:允许用户在运行时改变属性值。 3、-verify 使用校验 4、-help 打印帮助。

JAVA调试器jdb.exe

C头文件及存根文件生成器JAVAH.exe:可以从类文件生成C语言的头文件和C源代码文件，能跟C交互。
格式：javah [options]classname,其中otions可有：
       1、-o 输出文件名outputfile，将生成文件合成到outputfile文件中。
       2、-stubs 指令javah从java字节码文件生成C源文件。

反编译器javap.exe,格式：javap [options]classname,其中otions可有：
       1、-l 显示行号和局部变量表如：javap -l welcome
       2、-b 保持向后兼容。
       3、-J flag 直接将flag的内容送到运行系统。
       4、-s 显示内部类型标识。
       5、-verbose 显示栈的大小，方法参数和局部变量等信息。

APPLET浏览器APPLETVIEWER.EXE:运行java小应用程序。格式：appletviewer [options]htmlfilename。

API文档生成器javadoc.exe:可根据java源程序生成API文档。
格式：javadoc [options][packagelsource.java]*,文档注释以/**开头 ×/结束，文档性标签：@

压缩工具jar.exe:格式：jar[options][manifest] destination inputfile [inputfiles],
    其中：manifest file声明文件，destination jar file 目标文件 imput-file 要压缩的文件
   用法：jar{ctxu}[vfm0Mi][jar-文件][manifest-文件][-C目录]文件名。。。
     其中：-c 创建新文档 -t 列出存档列表 -x 展开所有文件 -u 更新文档 -v 生成详细输出到标准输出上
           -f 指定文件名 -m 包含标明信息 -o 只存储方式，未压缩 -M 不产生清单（manifest）文件 -i 产生索引 -C改变到指定目录。
    如： jar cvf classes.jar Foo.class Bar.class 将两个文件存到classes.jar中
         jar cvfm classes.jar mymanifest -C foo/ 将foo/下的所有文件存到classes.jar中

   代码转换器native2ascii.exe:将本地编码转换为unicode字符。格式：native2ascii [options][inputfile[outputfile]]

   检查器extcheck.exe:用来检测jar包中是否有冲突。格式：extcheck[-verbose]<jar file>

   远程对象编译器rmic.exe:生成客户端和服务器端。格式：rmic<options><class names>

   远程对象激活器rmid.exe:启用激活系统守护进程。格式：rmid<options>[-dir]

   远程对象注册器rmiregistry.exe：启用注册服务。格式：rmiregistry<options><port>

   jarsigner：为java归档文件jar产生签名。格式：jarsigner[options] jar-file alias

   keytool:密钥和证书管理。keytool[options]

   程序Welcome:用javac、java
     public class Welcome
     {
     public static void main(String arg[])
     {
         System.out.println("Welcome to java!");
     }
     }
   小应用程序WelcomeApplet.java：
   import java.applet.*;
import java.awt.*;
public class WelcomeApplet extends Applet
{
   public void paint(Graphics g)
   {
     g.drawString("welcome to java!",10,50);
   }
}
和Applet.html
<html>
<title>WelcomeApplet</title>
<body>
<Applet code="WelcomeApplet" width=200 height=300>
</Applet>
</body>
</html>
然后用Appletviewer Applet.html来运行。

------------------------------------------------------------------
java类和对象
   方法的重载：就是在一个类中定义有多个名称相同的成员方法，每个方法参数、返回值都可不同，调用时JVM自动根据调用形式在定义中匹配合适的成员方法。
   构造方法：特殊的方法，是对象被创建时初始对象的成员方法，具有和所在类名完全一样的名字，定义后会自动调用，没有返回值，返回值的类型就是类本身。构造方法也可以重载。
     如果构造方法省略，java会自动调用默认的构造方法（default constructor）格式如下：public classname(){},默认的没有任何参数，不执行任何操作。
   类的实例化：将类实例化就生成对象，在java中用new对类实例化，格式：type objectName=new type([paramlist]),其中：type：对象的类型名，objectName：对象名称，new：为对象分配内存空间，实例化一个对象，paramlist：参数表。
   this变量：可以在任何方法中引用当前对象。
   java的类库在：JDK下的jre/lib下的rt.jar文件。
   类成员修饰符：private:只可以在同一类中，private protected：可以在同一类中和该类的子类中；protected：可以在同一类中和该类的子类及同一包中，public：甚至在其他包中都可以。
     程序位于两个包，要用import包括进来。
     static修饰的变量或方法不需要实例化，格式：类名.变量名/方法名。
     static修饰的变量称为类变量，被所有对象共享，只有一个备份。
     static修饰的方法是类方法，它不能访问实例变量，也不能用this。
     final修饰符用于定义类、成员变量、成员方法的非继承性。修饰变量则说明该变量是常量，可以访问不能修改。如：private final int INCREMENT=5

   两个特殊的方法：构造方法和main方法。
     构造方法是对从这个类新创建的对象分配内存空间和初始化。构造方法的名字是init，由编译器隐含提供，不允许程序员使用。不带入口参数的构造方法是默认的构造方法。
     构造方法的调用规则：1、创建对象时，可以调用此类的父类的构造方法。2、如果一个类的构造方法中第一个语句没有用super来调用其父类的构造方法，这编译器也会默认用super（）调用父类的不带参数的构造方法，如果父类没有不带参数的构造方法，编译就会出错。3、如果某构造方法的第一句用this调用本类中的另一个构造方法，那么java就不会默认这个构造方法调用父类的构造方法。4、一个构造方法用this调用本类中的另一个构造方法，而被调用的构造方法又是调用父类的构造方法而又没有super语句，那么java会默认他含有super语句，此时，如果父类没有不带参数的构造方法，编译时就会出错。
     main方法：在java的每个应用程序（Application）中，必须有main方法，java解释器运行时首先寻找main方法，然后以此为程序的入口点运行。而applet中由于没有main方法，所以只能用带java功能的浏览器和Appletview来运行。在java中，一般只有一个main，如果有多个main，只有第一个为入口点。
   内部类：就是在某个类的内部嵌套定义一个类。有如下特性：1、可以声明为private或prtected.2、可定义为abstract。3、不能与包含他的类名相同。4、可以使用包含他的类的变量，也可使用内部类所在方法的局部变量。5、内部类如果被声明为static，就变成了顶层类，就不能再使用局部变量。

   对象的创建、使用和清除：
     创建和使用：java用new创建对象。格式：type objectName=new type([paramlist]);访问形式为：objectName.member,objectName.memberFunction()
     对象的克隆：从现存的对象复制出完全一样的副本，用clone实现，从Object类继承下来。注意：首先检查该对象是否能被克隆，如果对象实现了Cloneable接口，就可以被克隆，否则就会抛出一个异常CloneNotSupportException。Object本身没有实现Cloneable接口，因此他的子类必须实现该接口才能被克隆。克隆出来的对象是同一种类型。
     用finalize清除对象：java运行时系统通过垃圾收集周期性的无用对象使用的内存完成对象的清除。用finalize()（包含在java.lang.Object）撤销无用对象.finalize方法只能在java垃圾收集前调用。当一个对象超过作用域时，就不能调用finalize方法。应自行设计对象的释放程序，以保证释放的可靠性。

   对象的比较：1、用＝＝，表示两个引用是否指向同一对象。2、用equals。两个字符串只要内容一样，则==和equals返回true，但用String类的构造方法创建的两个字符串s1和s2==返回的是false。对于同一类对象==和equals返回都是false，这是因为同一类的不同个体是不同的。而使用obj1=obj2后，比较返回true，此时，两个引用指向同一对象。

   类的继承和多态性。继承实现代码复用，所有类都是通过Object类继承来。多态性是指用相同的名字定义一系列方法，参数和返回值不同。
     继承：用extends说明，格式：[ClassModifier]class ClassName [extends SuperClass][implemen interface]{}
     方法覆盖：当子类的成员变量与父类的变量同名时，父类隐藏，当子类的方法与父类的方法同名，参数列表、返回值类型相同时，父类方法隐藏。继承规则：1、子类继承父类中公共类和保护类的成员变量。2、如果父类定义了没有访问约束的变量、方法，子类可以访问。3、子类不能继承父类中被声明为私有的变量。
     super：实现父类成员的访问，包括子类隐藏了父类的变量、方法。
     抽象类和抽象方法：将常规操作抽象为继承结构中的较高级别。java中，用abstract修饰不能在类内实现的方法，称为抽象方法，含有抽象方法的类必须声明为abstract，叫抽象类(不一定包含抽象类，只能用于派生子类)。
     抽象方法：abstract returnType methodName(parameter1[,parameter2,parameter3...])
     抽象类：abstract class className extends parent implements interface1[interface2,interface3...]
     多态性
     java的垃圾回收：是java提供的自动内存回收功能

   接口、包
     接口：是方法定义和常量值的集合，是特殊的抽象类，用interface指明一个类必须作什么，但不明确怎么作，没有变量和方法的实现。在类的构造过程中可以实现多个接口。在类对接口的实现中，必须实现接口中所有方法。利用实现多种接口，可以实现多继承功能。
     定义：[public]interface interfaceName[extends superInterface]{}。如果定义为public，则任何类均能访问该接口。默认的只有相同包中类可以访问该接口定义。其中extends表示有父接口，可以有多个父接口。
     接口体包括常量定义，具有public、final、static属性。接口对方法只声明，没有方法体。方法只有public和abstract属性。
     接口的实现：[ClassModifier]class ClassName[extends SuperClassName][implement interface]{},其中implement interface为需要实现的接口，不同的接口用逗号分开。
     类必须实现接口中的所有方法。实现是相对的，既可以为接口中的方法提供实现代码，也可以不提供代码（必须将方法的框架完整写出）。接口也可继承，用extends。如果一个类实现的是一个继承其他接口的接口，则该类必须实现这个接口和其父接口的所有方法。
     包：是为每个java类提供一个命名空间。声明：package packageName;如：package p1.p2表示该类在p1下的p2下。import用于包含所需的类。

数组和字符串类型
一维数组：定义：type arrayName[];type[] arrayName;在数组声明中不用指定数组中元素的个数。尽管声明了数组类型的变量，但实际上该数组的内存空间并不存在，每个元素值为Null,必须用new申请。
   数组初始化：用new为动态申请过程，格式：arrayName=new type[size].如果知道元素的个数，可以在定义时直接申请数组内存空间，如：int a[]={1,1,1};
   访问数组：下标起始为0，最后一个长度(length)减一
多维数组：定义：二维数组 type arrayName[][];或type[][] arrayName;
   动态申请：arrayName=new type[size1][size2],静态初始化：int nArray3={{1,2,3,4}{2,3}{4,5,6}}.
   访问：a[m][n]

   字符串类型：java把字符串作为对象处理，类String和StingBuffer都可以表示一个字符串。
    初始化：String s="hello";StringBuffer sf=new StringBuffer("hello");
    访问和修改字符串：
      常用方法：
      string：
        1、length()返回个数；
        2、charAt(int index)返回串中index上的字符，index在0~length-1；
        3、indexOf()和lastIndexOf()分别返回ch在串中出现的第一个和最后一个的位置。还有indexOf(String str,int fromIndex)和lastIndexOf(String str,int fromIndex);
        4、getChars(int srcbegin,int end,char buf[],int dstbegin):从字符串中提取从srcbegin到end的字符放在buf[]中。
        5、subString([int beginIndex,int endIndex]):取指定位置的字符串。
        6、toUpperCase()和toLowerCase：转换大小写
        7、concat(String str):把当前字符串对象与str连接起来。
        8、replace(char oldChar,char newChar):将出现的特定字符转换成指定字符。
        9、compareTo(Object o):将字符串与一个java对象比较，如果不是字符串对象则产生异常。compareTo(String anotherString),comparToIgnoreCase(String str):不分大小写。返回0表示相等。
        10、copyValueOf(char[] data,int offset,int count):字符数组到字符串间的转换。
        11、getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin)字符串到字符数组间的转换。
        12、endsWith(String suffix):判断字符串是否由指定的suffix为结束，真为ture
        13、equals(Object o)equalsIgnoreCase(String anotherstring):判等。
      StringBuffer：
        append:添加到字符串缓冲区的后面；insert：插入；toString:转换成字符串；delete(int start,int end):删除；SetLength(int newLength)：设置长度；reverse：反转。capacity:获得剩余长度，整数。＋：连接。

     StringTokenizer类：用于分析字符串，目的将字符串分解的方法封装。
      StringTokenizer(String str,String delim,boolean return Tokens),解析时字符串必须包括一个用于解析的分隔符。默认的为空格、制表符、换行符、回车符。也可以通过delim自定义。
      方法：1、countTokens()返回分隔符的数量。2、hasMoreTokens()判断是否还有分隔符、nextToken()下一个、nextToken(String delim)
    字符串与其他数据类型的转换：
      其他对象转成字符串：toString()
      字符串转成其他对象：可以调用Integer、Double等类的valueOf转换。i=Integer.parseInt(s1);

异常处理
java通过面向对象的方法处理。如果发生了异常，用此方法生成代表该异常的一个对象，并把它交给运行时的系统，这叫作抛出(throw)异常。系统从生成异常的方法开始进行回溯，直到找到包含相应异常处理的方法为止，叫做异常捕获(catch)。try{}catch{}
main()方法是有参数的，参数是一个字符串数组，如：public static void main(String[]args){}
异常处理类：Throwable类是最顶层类，包含两个直接类:Error(不由应用程序直接处理，需交给操作系统处理)和Exception（是java程序处理或抛出的对象）
常用异常对象：
    1、算数异常ArithmeticException：除0，或0取模等。
    2、空指针NullPointerException：访问一个没有定义的对象或只定义没有实例化的对象的变量或方法，或访问一个空数组的元素时。
    3、类型转换异常ClassCastException:在类型转换过程中，无法转换导致异常；
    4、数组超界异常ArrayIndexIndexOutOfBoundException：试图范围数组的一个非法元素。
    5、指定数组下标为负值异常NegativeArraySizeException：对于动态创建的数组，如果指定的数组长度为负。如a[-1]=1;
    6、数据格式异常NumberFormatException：试图将数值直接转换成字符串，如：str=(String)n;
    7、内存溢出异常：OutOfMemeoryException：程序中申请的内存空间太大，内存不够，如：int[]nArray=new int[100000];
    8、没有找到类定义异常NoClassDefFoundException:根据包路径没有找到指定类。
    9、非法线程状态异常IllegalThreadStateException：由于将线程的状态进行非法改变引起。
异常处理：try{//可能出现异常的代码}
            catch(ExceptionType1 e){exception handing code throw(e)//异常处理}
            finally{//最终处理方法}
   用throw抛出异常，可以同时抛出多个异常。
   异常捕获：当程序抛出异常后，由产生异常的程序代码位置跳转到异常捕获语句，进行程序异常处理，异常处理结束后，将跳出捕获处理嵌套，执行其他部分，而不是从异常语句后执行。
   finally语句：无论try指定的程序是否异常，finally都要执行。
   异常也有嵌套处理。用户也可自定义异常，必须时Throwable的子类，推荐以Exception为父类。

输入/输出及文件操作
流（Stream）:指计算机各部件间的数据流动，有输出流(output stream)和输入流(input stream)。数据流是java 发送和接收数据的一个通道。java流类都封装在java.io包中，其中InputStream和OutputStream是java.io包中的两个抽象类，分别是其他输出、输入流类的超类，他们不能被实例化，但可以通过子类建立对象实体，他们都是从java.lang.object类继承来的。

java还提供了系统的输入、输出描述符，它们在System类中被定义，System.in对应于输入流；System.out对应于输出流，System.err对应于标准错误输入设备；三个分别定义在java.lang.System包中，编译时自动装载，可以使用InputStream stdin=System.in;

java中输入、输出处理的类构造层次：在io包中有：
    FileInputStream:对应于文件系统的输入；Output表示输出，下同
    PipedInputStream:用于进行管道方式的；
    ByteArrayInputStream:用于读写内存数据；
    StringBufferInputStream：用于从StringBuffer中读取字符数据；
    SequenceInputStream:用于将多个输入流连接到一个输出流。没有output
    FilterInputStream:为过滤流提供了统一接口，使得在数据输入输出时进行数据处理。
    DataInputStream:用于进行与计算机无关的数据读写；
    BufferedInputStream:在进行数据读写时将数据保存在数据缓冲区中，提高读写速度。
    LineNumberInputStream：可以在数据读写中记录读取的行数，没有output
    PushBackInputStream：包含一个字节的缓冲区，使得在读取数据时预读下一个字符。
    PrintStream:提供输出方法
    File类中封装了用于本地文件处理的方法
    FileDescriptor：提供文件描述处理
    RandomAccessFile:用于在磁盘中进行文件的随机读写
    StreamTokenizer用于把流中的内存分解为记号(Token)，通常用于文本文件的解析
    DataInput和DataOutput是接口。
文件处理：File类，java.io.File,成员变量包括：Static String PathSeparator和Static Char PathSeparatorChar;构造函数：File(String parent,String child) 如：File("c:/java",test.java); 和
File(String parent,String child) 如：File("java",test.java); 和File(String Pathname) 如：File("c:/java/test.java");

Reader与Writer类：处理字符流(character stream),即纯文本文件。而InputStream和OutputStream类处理位流(bit Stream),即二进制文件。通常不直接使用这两个类，而是根据其子类来创建实例对象。
FileReader和FileWriter类：继承Reader与Writer类，使用前先调用其构造方法创建相应的对象，然后调用相应的read()或write()方法。write不覆盖，追加。
BufferedReader和BufferedWriter类：继承Reader与Writer类，用来读取写缓冲区的数据。在使用BufferedReader类，必须先创建FileReader类对象，其有两个构造方法：BufferedReader(Reader in),BufferedReader(Reader in,int size),
如：BufferedReader br=new BufferedReader(new FileReader("c://java//test.txt"));BufferedWriter类类似。

RandomAccessFile类：文件处理中，功能齐全、文件访问方式众多的类。用于进行随意位置、任意类型的文件访问，支持文件的任意读取而不是顺序读取。构造函数为：RandomAccessFile(File file,String mode);RandomAccessFile(String name,String mode)；分别提供文件对象和字符串对象参数来指定文件名和目录树位置，而mode表示创建的随机读写文件的操作状态，如：r,rw;
在创建了一个随机文件对象后，该文件即打开状态，此时，文件的指针处于文件的开始位置，可通过seek(long pos)方法设置文件指针的当前位置，快速定位。而后通过RandomAccessFile类中的相应read()和write()方法。操作完成后，调用close()关闭。

InputStream和OutputStream类：两个抽象类，是其他流类的超类，不能被实例化，只有子类建立真正的对象实体。常用的子类：
    FileInputStream和FileOutputStream类:处理“位为主”的输入输出工作，对文件中的数据流是顺序读写而不是利用文件指针随机定位读写。
PipedInputStream和PipedOutputStream类：提供利用管道方式进行输入和输出管理的类，是InputStream和OutputStream类的直接子类，这两个类必须结合使用，其中：管道输入流作为管道的接受端、管道的输出流作为管道的发送端。
SequenceInputStream类：是InputStream的直接子类，功能是将多个输入流连接在一起，形成单一的输入流，没有对应的输出数据流存在。顺序输入流由多个输入流构成，当一个流读取数据遇到EOF时，SequenceInputStream将自动转向输入流，直到构成读取最后一个输入流遇到EOF.

过滤流：FilterInputStream和FilterOutputStream类，它必须连接到输入、输出流中，其方法是在构造方法的参数中指定。如：FilterInputStream(InputStream in)
    DataInputStream和DataOutputStream类是FilterInputStream和FilterOutputStream类的子类，实现了DataInput和DataOutput接口，用于进行与操作系统类型无关的数据输入输出操作。
    BufferedInputStream和BufferedOutputStream类：用于进行缓冲区数据的读取操作。
      重要成员变量：protected byte[] buf：字节数组buf表示与缓冲区输入流相对应的字节缓冲区。
                    protected int pos:整形变量pos表示缓冲区中的当前位置。
                    protected int count:整形变量count表示缓冲区中的字节数量。
    LineNumberInputStream类：提供对文本输入数据流加行号，编号从0开始，没遇到一个换行符，行号加1。

java图形用户界面(Graphics User Interface)简称GUI
java提供AWT和Swing两个包进行图形用户界面编程。AWT是Swing的基础，Swing是带丰富组件的GUI工具包，组成JFC(Java Foundation Class)的用户界面的核心部分，是AWT的替代品。
AWT包(Abstract Window Toolkit):提供基本的组件，主要有图形界面、事件处理对象、图形和图像、布局管理器等。java.awt包中的Component类几乎是所有图形界面的父类。
容器组件：容器类(Container)是Component类的子类，主要有Panel、Window、Frame、Dialog。
    用Frame建立窗口：Frame是Window类的子类，构造方法：Frame([String strCaption Text])创建一个指定了窗口标题的窗口框架。
      通常在编程时，不直接使用Frame类创建窗口，而是定义它的子类来完成窗口的创建功能。
        如：用public class extends Frame
              { public frame2(String str)
                  { super(str);   }
    对话框(Dialog)组件：用来与用户的交互,与框架窗体(Frame)的区别是：不能自动实现菜单、倚赖其他窗口、有模式(model)和非模式(modeless),模式让程序相应对话框内的事件，而非模式则可相应其他窗体的事件。
     构造方法：Dialog(Frame ParentWindow[,String strTitle],boolean modal):当modal为true时创建模式对话框。
   文件对话框(Filedialog)类
     构造方法：FileDialog(Frame frmParent[,String title [,int mode]]):当mode为FileDialog.SAVE时，则为保存文件对话框，否则为打开文件对话框。常用方法：String getFile()获得文件名，GetDirectory()获得路径。
   按钮（Button）组件：Button([String strCaption])
   标签组件(Label):Label([String strCaption[,int alignment]]) 创建一个指定字符串，并按一定方式对齐,其中alignment的0左对齐1居中2右对齐。方法：setText()，setAlignment();
   复选框（Checkbox）组件：在CheckboxGroup类管辖的所有Checkbox中，只能有一个Checkbox处于on状态。Checkbox([String strCaption[,CheckboxGroup,boolean state]])。方法：setLabel()，setCheckboxGroup,setState,setVisible,setBounds等。
   滚动条组件(Scrollbar):Scrollbar([int orientation[,int s,int v,int min,int max]])方法setOrientation
   Textfield和TextArea组件：单行和多行文本。rows:int表示文本域中能够显示文本的行数。getRows和setRows().方法：TextField([String strText,int column]);其中column表示最多能输入字符数目。
   菜单组件(Menu):包含菜单栏(MenuBar),菜单(Menu),菜单项(MenuItem)
     Frame类是AWT中唯一自动实现MenuContainer类的类，将菜单放入Frame中，只需要调用Frame类的setMenuBar()就能够放在窗口。
     要创造菜单，首先创建一个MenuBar,然后在它上面创建Menu组件，Menu(String strMenuName);再为每个Menu创建若干个MenuItem组件，MenuItem(String strMenuItemName);如果将菜单项设为不可用，调用setEnabled(boolean bEnabled)方法；还有CheckboxMenuItem类可以创建一个可选择的菜单项CheckboxMenuItem(String strLabelName,boolean bState);快捷菜单：(Popup Menu)
   列表(List)和下拉列表(Choise)等组件与上类似。
   FlowLayout布局管理器：自左至右，从上而下，默认为居中对齐，构造方法：FlowLayout([int align[,int hgap,int vgap]]);其中：align对齐方式有FlowLayout.LEFT[.CENTER.RIGHT],hgap行间距，vgap列间距
   BorderLayout布局管理器：分为North、South、West、East、Center5块，方法：BorderLayout([int hgap,int vgap])
   CardLayout布局管理器：卡片式方式，每个部件看成一张卡片，在一个显示区域可加入多个卡片，但每次只有一个可见。构造方法：CardLayout([int hgap,int vgap])；void first(Container)显示第一加入到CardLayout的组件，还有last,next,previous,show(Container,String)
   GridLayout布局管理器：基于网格的方式，构造方式：GridLayout([int rows,int cols[,int hgap,int vgap]]);
   GridBagLayout布局管理器：在GridBagLayout基础上允许一个部件占用多个显示单元。构造方法：GridBagLayout()

Swing:JComponent类是所有Swing组件的基类，JComponent继承自java.awt.Container类。
   JFrame是java.awt.Frame的子类。
   JLabel：JLabel([String,Icon,int horizontalAlignment]);setToolTipText设置提示信息。
   JButton、JCheckBox、JradioButton
     JButton([String,Icon]),是AbstractButton子类，无论何时激活按钮，都可调用按钮动作监听器ActionListener的actionPerformer()方法。
     JCheckBox是从JToggleButton类派生出来，JCheckBox([String,Icon,boolean])
     JRadioButton和JCheckBox几乎相同，JRadioButton([String ,Icon,boolean])
   JTextField、JTextArea、JPasswordField
   JList:可单选、单间隔选和多间隔选,唯一可以修改数据的方法是setListData()
   JComboBox：可编辑，通过设置setEditable(true),支持键选取。
   用户界面风格。默认是跨平台的java风格，可以通过java的javax.swing包中的UIManager类中的setLookAndfeel方法设置，可有1、java风格(cross)，可在任何平台显示，2、系统风格(system)，与系统有关，3、motif风格，任何平台，某些构件为立体，4、苹果风格(mac)

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
JDBC:Java DataBase Connectivity缩写，即java数据库连接接口
JDBC是一组由java类、接口组成的API（Application Programming Interface,应用程序接口）
在两层结构中，JDBC通常位于应用程序层，客户机直接发起数据查询请求。在三层中，客户机和服务器间增加了一个中间服务器，JDBC通常成为服务层。
JDBC驱动的四种类型，1、JDBC-ODBC桥，将JDBC的调用转换成ODBC的调用，需要多层转换，效率较差。
                      2、java到本地API:native-API partly-java使用java程序直接调用数据库提供的客户端链接库。
                      3、网络纯java驱动：通过3层方式JDBC的调用会通过网络传人中间层的服务器，中间层负责和数据库通信。
                      4、本地协议纯java驱动：将JDBC的调用转换成为数据库所提供的本地协议，客户端可直接和数据库通信。
JDBC中主要的接口和类：JDBC API提供的类和接口在java.sql包中定义
    java.sql.DriverManager类是JDBC的管理器，作用与java程序和驱动之间，用于管理、跟踪和建立连接。
    java.sql.Date和Time类是java.util.Date的子类：public Date(long date)或public Date(int year,int month,int day)
    java.sql.PreparedStatement是Statement接口的子接口，代表一个预编译的SQL语句。
    java.sql.CallableStatement是PreparedStatement接口的子接口
与数据库建立连接，建立连接后，用户得到一个java.sql.Connection类的对象，对数据库的操作都是基于这个对象。
    1、加载驱动程序。有两种方式：a，在JDBC的java.sql.DriverManager类初始化过程中，通过设置java属性中的sql.driver来指定驱动程序列表。b，在程序中用Class.forName()方法加载指定的驱动程序。如：Class.forName("sun.jdbc.odbc.jdbcodbcDriver")
    2、创建连接：通常，连接是通过构造数据库的URL对象，并由DriverManager的getConnection方法建立。构成方式为：jdbc:subProtocol:subName:其中jdbc是表示当前通过java的数据库连接访问数据库；subProtocol表示通过某种驱动支持的数据库连接机制；subname表示当前连接机制下的具体名称。如：String url='jdbc:odbc:student';Connection con=DriverManager.getConnection(url);通常还需要用户名和密码：DriverManager.getConnection(url,'userID','passwd');
执行查询语句：在java中，定义了3种类型的Statement;1、Statement用于执行简单的，没有参数的SQL语句。2、PreparedStatement:Statement类的子类，用于执行带In和Out参数的语句。3、CallableStatement PreparedStatement类的子类，用于执行存储过程。Connection类的creatStatement方法用于建立一个Statement对象，如下：Statement stmt=con.createStatement()
   处理查询结果：使用executQuery方法执行，返回一个ResultSet类对象：ResultSet rs=stmt.executeQuery("SELECT * FROM DUAL");更新可以用executeUpdate(String sql)
   JDBC提供了流方式来读取记录中存储内容较大的数据。JDBC API提供了3个获取流的方法，区别在返回数据类型的不同：getBinaryStream()返回原始数据库记录的二进制数据；getAsciiStream()返回ASCII字符；getUnicodeStream()返回两个自己编码的Unicode字符。

java与XML编程
XML(Extensibel Markup Language)可扩展标记语言。不管使用XML的是哪种平台或程序，它都可以用来描述信息，与其他标记语言不同，XML与使用他的程序无关。另外，XML允许用户创建自己的标签和这些标签的语法。
XML文档可以从数据处理指令<?xml version="1.0"?>开始，知道使用XML1.0版本。XML元素必须有一个打开和关闭标签，即使是空元素，如：<DOCUMENT></DOCUMENT>。XML中属性的格式为：attributename="value",可为每个元素指定附加的数据。
XML解析器：XML应用常基于一个XML解析器而创建的，它为用户提供一个接口。解析器可读入一个文档并分析其结构的代码。有以下几类： 1、验证或非验证解析器：XML文档如果使用一个DTD(Document Type Definition),并符合DTD中的规则将被称为有效文档。符合基本标记规则的XML文档被称为格式正确文档。如果不是格式正确要报错，验证解析器在解析XML文档的同时进行验证，需要相当大的开销；非验证解析器则忽略所有的验证错误。
   2、文档对象模型（DOM）是W3C的正式推荐。DOM不是一种实现，支持DOM的XML解析器必须实现DOM所定义的接口。常用接口：org.w3c.dom.Node:DOM中的主要的数据类型;Nodelist:节点集合；Document:一个完整的XML文档；Attr：表示元素的某个属性；Element:表示一个元素；Text：表示字符数据；NamedNodeMap:表示一个可以有名称引用的节点集合。
   3、XML简单应用程序编程接口：SAX处理XML的方式与DOM API不同，他不是将DOM树解析和表现为输出。使用SAX解析器，可以在文档的开始接收事件，也可以接收文档中的元素。
   使用DOM处理XML文档。创建DOMParser类的实例变量parser,然后调用该类的parser方法并传递XML文件名称。
     如：DOMParser parser=new DOMParser();
         parser.parser("weather.xml");
         Document dom=parser.getDocument();
     然后获得文档的根和元素：NodeList nList=dom.getElementsByTagName("Houston");
                              for(int i=0;i<games.getLength();i++)
                              {Node node=nList.item(i);System.out.println(node.getFirstChild().getNodeValue());}
     获取了元素后，可以查看所有属性，可以通过使用Node接口的getAttributes方法,如：
       NamedNodeMap attribute=node.getAttributes();
       For(int i=0;i<attribute.getLength();i++)
       {Node att=attribute.item(i); System.out.println(att.getNodeName()+"="+att.getNodeValue);}
   使用DOM创建XML文档:通过DOMImplementation接口的createDocument方法类实现，元素的创建是调用Document接口的createElement方法，还可以通过Element接口的setAttribute方法增加属性。
   SAX API应用
     SAX是解析XML文档的一个事件驱动的API，它以事件为基础，把元素、指令等都当成事件，常用事件：startDocument开始事件，endDocument结束事件等。
   使用XML可以使用户界面的创建和维护更方便。不用修改java源代码，只需修改XML文档。

命名服务和目录服务
命名服务(Naming Service):为某个对象取个名字。
解析(Resolve)：通过名字访问或得到一个对象。
上下文(Context)指一组绑定的集合，可以有SubContext,就像子目录。
命名系统(Naming System):指同类的Context集合，同类表示同样的命名规则。如文件系统
命名服务(Naming Service):命名系统提供的服务或功能。如文件系统通过文件名来查找、删除等
名字空间(Name Space):指命名系统中所有名字的集合
目录服务：是命名系统的扩展，不仅把名字和对象绑定在一起，对象还有属性，可通过属性来搜索对象。如电话簿。

java命名和目录服务
    软件：1、JDK/java名字和目录API：java中的提供名字和目录服务的类库（API）称为java命名和目录接口(The java Naming and Directory Interface,JNDI),JDK1.3以后的版本都包含了这些API。
          2、Sevice Provider Software(服务提供者软件)JNDI是"虚"的，名字和目录服务是"实"的，为了能使用某种服务，必须有个服务提供者软件，JDK1.4.1中已经包含了一些目录服务，其他的可从SUN公司的网站上下载相关的Service Provider;
          3、名字和命名服务：不同的服务器的安装、设置和使用方法都不相同。
    文件系统的服务器提供者和服务器，需要另外下载：fscontext.jar和providerutil.jar，复制到JDK下的JRE/LIB/EXT即可。
   JNDI体系结构：包含API（应用程序编程接口）和SPI（服务供应器接口），java应用程序首先通过Context和DirContext接口，使用JNDI API访问命名和目录服务。JNDI API 在javax.naming.directory包中定义。
   文件系统的命名服务
     引用上下文：文件系统的操作都要通过Context和与其相关的接口和类。
       JNDI用javax.naming.Context接口表示命名系统中的上下文。Context对象不像File对象，File对象可以告诉我们绝对和相对名字并返回父类的引用，而Context对象只知道他的绑定，而不能知道其绝对路径名。
       javax.naming.InitialContext类实现Context接口并充当命名系统的进入点，所以首先建立InitialContext对象，如：Hashtable env=new Hashtable();                      env.put(Context.INITIAL_CONTEXT_FACTORY,"com.sun.jndi.fscontext.RefFSContextFactory");--基本属性键java.naming.factory.initial对应常量Context.INITIAL_CONTEXT_FACTORY,该属性指定JNDI服务供应器中的厂类名。厂类的任务是建立一个与服务相应的InitialContext,并返回该对象。
env.put(Context.PROVIDER_URL,file:///); --指定厂类从java.naming.provider.url属性中获取协议、服务名和路径，就文件系统来说，可以蒋上述目录指定维名字空间范围，当确定这个目录后，命名服务只能在这个目录进行，目录外的不可访问。
Context ctx=new InitealContext(env);
得到Context对象后，可以通过lookup方法指定要查找的Context的孩子的名字。Lookup方法返回这个名字锁定的对象，类型为Object。如：Object obj=ctx.lookup("zyd");最后在结束前，用close方法关闭Context.
    文件名绑定的是文件地址，而目录绑定的是RefFSContext，是一种Context类型。
   文件系统的常用方法：
     list和listBindings显示Context中的内容
     createSubcontext和destroySubcontext建立和删除Context.
     rename更改文件名。
JNDI对象绑定：建立Initial对象后，程序即可查找现有的对象并向Context环境绑定新的对象。绑定对象是指向JNDI服务添加名字，并将这个名字和java对象关联。如：private final static String JNDI="java/book"
Context ctx=new InitialContext();
     ctx.bind(JNDI,"Java 2 Programing");
    被绑定的对象必须实现Serializable接口，可通过rebind重新绑定，如：ctx.rebind("java/book","This is rebind");也可通过Context.unbind()方法删除一个对象。因为程序关闭时绑定的名字不会被自动解开。

网络通信
   TCP和UDP是当前最常用的两个网络协议，网络通信是通过TCP协议和UDP协议完成两个计算机间点对点的数据交换。在java.net包中的Socket类和DatagramSocket类完全封装了协议通信的细节。
   TCP(Transmission Control Protocol)是传输控制协议。
   UDP(User Datagram Protocol)用户数据报协议是一种基于无连接的协议。采用一种称为“数据报”的短信息来传输。不管传输正确与否，也不保证正确次序。
   在TCP协议中，端口被规定为介于0～65535的整数，并且端口0～1023是系统为HTTP、FTP传输保留的端口。利用TCP通信时，两个程序只有地址和端口达成一致时，才建立连接。而UDP则不同，UDP是一种无连接的协议，所以可以随时进行收发数据报，速度较快，但不可靠，数据报的容量不能太大(不能超过64KB)。
   java中和网络通信有关的类都集中在java.net包中。
   URL(Uniform Resource Locator)是Internet中对网络资源进行统一的定位和管理。完整的URL包括以下内容：1、应用协议名称，如http/ftp等；2、资源位置，由.分割的网络路径，如www.sina.com。3、端口号4、文件路径。5、访问文件名6、文件中的编码位置。
   URL类是java.lang.Object类的直接子类。构造函数URL(String protocol,String host,int port,String file,URLStreamHandler handler)；URL(URL context,String spec):在提供上下文对象中匹配spec字符串来创建URL对象。如：URL aURL= new URL(www.sina.com);
   定义了MalformedURLException异常。
   InetAddress类用于网络地址的解析和编码。没有构造方法，即不能通过构造函数的方式创建InetAddress的实例。可以通过以下获取实例：1、InetAddress getLocalHost()获取本地主机的ip；2、InetAddress getByName()或InetAddress getAll-ByName()通过主机名获取IP地址。其成员方法还包括：Boolean equals(Object obj)判断IP是否相同，Byte[] getAddress()取得IP地址，String getHostName()取得IP地址的主机名。
   Socket(套接字)通信：是实现客户机和服务器进行通信的一种机制。他是两台计算机进行通信的端口。在java中，可以将Socket类和ServerSocket类分别用于客户机和服务器，分别创建Socket，然后连接通信。
   Socket编程的客户端用Socket类:构造方法：Socket(InetAddress address,int port,InetAddress localAddr,int localPort);Socket(String host,int port,InetAddress localAddr,boolean stream)等。其中:InetAddress为java中定义统一地址模型的类，参数address指定Socket通信指定的ip.port为端口，范围大于等于1024。host表示字符串形式的主机名称。布尔值stream为true则创建Socket流对象，否则创建数据报表Socket对象。如：Socket(166.111.102.101,1800,166.111.102.102,2000)表示从IP为102的计算机的2000端口向101的1800端口发出连接请求。
   服务端用ServerSocket类，构造方法：ServerSocket(int port,int backlog,InetAddress addr)其中：addr在创建套接字的同时指定主机的IP地址。如：ServerSocket aServerSocket=new ServerSocket(1800,0,166.111.102.101);
   利用Socket方式进行数据通信与传输，大致包括如下步骤：
      1、创建服务器ServerSocket，设置建立连接的端口号；
      2、创建客户机Socket,设置绑定的主机名称或IP地址，指定端口号
      3、客户机发起请求
      4、建立连接
      5、取得InputStream和OutputStream
      6、利用InputStream和OutputStream进行数据传输
      7、关闭Socket和ServerSocket
    传输时可设置传输属性：1、SO_RCVBUF接收缓冲区的大小2、SO_SNDBUF发送缓冲区的大小3、SO_LINGER闲置时间4、SO_TIMEOUT超出时间5、TCP_NODELAY非延迟时间。
    支持多客户连接的Socket通信方式，应用多线程。
    数据报通信DatagramSocket是面向无连接的通信方式。
    DatagramSocket和DatagramPacket类
      DatagramSocket的作用是在发送主机中建立数据报通信方式，提出发送请求。而DatagramPacket则用于表示要进行传输的数据报。
      DatagramSocket的构造方法：DatagramSocket(int port,InetAddress address)等。
      DatagramPacket的构造方法：DatagramPacket(byte[] buf,int offset,int length,InetAddress address int port)

------------------------------------------------------------
14 JAVA多线程处理
   线程是比进程更小的执行单位。
java线程类与Runnable接口
    实现多线程的方法：
      1、继承java.lang包中的Thread类，2、用户自己的类实现Runnable。
    Thread类
      优先级：static int MAX_PRIORITY 最大；MIN_PRIORITY 最小； NORM_PRIORITY 默认；
      构造方法：Thread([ThreadGroup group,Runnable targer,String name]);
    Runnable接口
      Runnable接口只有一个方法run(),用户定义的类必须实现这个方法。
线程管理
    线程的生命周期：1、初始状态；2、就绪状态；3、阻塞状态；4、运行状态；5、死亡状态。
    线程的调度：调度实际是分配处理器资源，java用调度程序。抢占式的调度，优先级高的先执行。如果相同，采用FIFO方法排队。
    守护(Daemon)线程：如果是守护线程，当线程运行结束后，只要有另一个用户线程在运行，该线程就可以继续运行。
线程同步
    同步关键字synchronized，通常将线程的执行方法设为同步。如果线程使用的同步方法需要其他线程修改后才行，则在同步方法中使用wait()方法，即本线程等待，并运行其他线程使用这个方法，当使用完这个同步方法后，用notifyAll()或notify()方法通知所有的等待线程，使其结束等待，再使用这个方法。若想同步某程序段，则可以使用synchronized(object){}方法。
线程中的sleep、yield和join方法区别
    sleep让线程睡眠，可使低优先级的线程执行
    yield让线程暂停，只能使同优先级的线程执行。
    join能使调用该方法的线程在此之前执行完成。
为避免死锁，java1.2后反对使用Thread的stop()、suspend()、resume()和destroy()等.
线程组ThreadGroup类：线程组中可以包含多个线程和其他线程组；ThreadGroup(ThreadGroup parent,String name);