java从入门到精通

面向对象的程序设计语言

桌面应用开发系统

嵌入式开发系统

电子商务应用

企业级应用开发

交互式系统开发

多媒体系统开发

分布式系统开发

WEB应用开发

移动端应用开发

Javase和javaee

明确目标，基础学习，了解模式

1、打开编译器

2、编写代码

设置断点是程序调试中必不可少的手段，java调试器每次遇到程序断点时都会将单前线程挂起，即暂时当前程序的运行。

要在Eclipse中调试HelloJava程序，可以在“包资源管理器”视图中的Hellojava文件处右击，在弹出的快捷菜单中选择“调试方式”命令

程序执行到断点被暂停后，可以通过“调试”视图工具栏上的按钮执行相应的调试操作。

1、包声明：一个JAVA应用程序是由若干个类组成的.在例题3.1中就是一个类名为Frist的类，语句package Number为声明该类所在的包，package为包的关键字。

2、声明成员变量和局部变量：通常将类的属性称为类的全局变量（成员变量），将方法中的属性称为局部变量。全局变量声明在类体中，局部变量声明在方法体中。全局变量和局部变量都有各自的应用范围。在例题3.1中，s1是成员变量，s2是局部变量。

3、编写主方法：main（）方法是类体中的主方法。该方法从“{”开始，至“}”结束。public、static和void分别是main（）方法的权限修饰符、静态修饰符和返回值修饰符，Java程序中的main（）方法必须声明为public static void。String[]args是一个字符串类型的·数组，它是main（）方法的参数。main（）方法是程序开始执行的位置。

4、导入API类库：在java语言中可以通过import关键字导入相关的类。在·JDK的API中（应用程序接口）提供了130多个包，如java.awt、java.io等。可以通过JDK的API文档来查看这些包中的类，把握类的继承结构、类的应用、成员变量表。构造方法表等，并对每个变量的使用目的进行了解，API文档是程序开发人员不可或缺的工具。

代码中的所有标点符号都是英文字符。不要在中文输入法状态下输入标点符号，还要注意大小写。

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int、和long4种类型。它们具有不同的取值范围，如下图所示。

浮点类型简称浮点型，用来存储含有小数部分的数值。JAVA语言中浮点类型分为单精度浮点类型（float）和双精度浮点类型（double），它们具有不同的取值范围，如下图所示。

（1）char型：字符类型（char）用于存储单个字符，占用16（两个字节）的内存空间。在定义字符型变量时，要以单引号表示，如's'表示一个字符。但是“s”则表示一个字符串，虽然只有一个字符，但由于使用双引号，它仍然表示字符串，而不是字符。

（2）转义字符：转义字符是一种特殊的字行变量，它以反斜杠“\”开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”。例如，printf的数的格式串中用到的“\n”就是一个转义字符，意恩是“回车换行”。Java 中的转义字符如下表所示：

布尔类型又称逻辑类型，简称布尔型，通过关键字boolean来定义布尔类型变量。布尔类型只有true和false两个值，分别代表布尔逻辑中的“真”和“假”。布尔值不能与整数类型进行转换。布尔类型通常被用在流程控制中，作为判断条件。

1、标识符：标识符可以简单地理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。Java语言规定标识符由任意顺序的字母、下划线(___)、美元符号（$）和数字组成，并且第一个字符不能是数字。标识符不能是Java中的关键字（保留字）。

2、关键字：关键字又称保留字，是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

声明变量：变量的使用是程序设计中一个十分重要的环节。声明变量就是告诉编译器这个变量的数据类型，这样编译器才知道需要配置多少空间给它，以及它能存放什么样的数据。在程序运行过程中，空间内的值是变化的，这个内存空间就称为变量。为了便于操作，给这个空间取个名字，称为变量名。变量的命名必须是合法的标识符。内存空间内的值就是变量值。在声明变量时可以是没有赋值，也可以直接赋给初值。

对于变量的命名不是随意的，应遵循以下几条规则：1、变量名必须是一个有效的标识符。2、变量名不可以使用java中的关键字。 3、变量名不能重复。 4、应选择有意义的单词作为变量名。

在程序运行过程中一直不会改变的量称为常量（constant），通常也被称为“final变量”。常量在整个程序中只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。

由于变量被定义出来后只是暂存在内存中，等到程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。因此，变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译器会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数作处理），其功能是将右方操作所含的值赋给左方的操作数。（从右往左运行）

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余），它们都是二元运算符。

自增、自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整形或浮点型变量。自增、自减运算符的作用是使变量的值增1或减1。放在操作元前面的自增、自减运算符，会先将变量的值加1（减1），然后再使该变量参与表达式的运算。放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量加1（减1）。（符号在前先运算再使用，符号再后先试用再运算。）

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算结果为true，否则为false。所有比较运算符通常作为判断的依据用在条件语句。比较运算符共有6个，如下图所示。

返回类型为布尔型的表达式，如比较运算符，可以被组合在一起构成一个更复杂的表达式。这是通过逻辑运算符来实现的。逻辑运算符包括&（&&）（逻辑与）、||（逻辑或）、！（逻辑非）。逻辑运算符的操作元必须是boolean型数据。在逻辑运算符中，除了“！”是一元运算符，其他都是二元运算符。下表给出了逻辑运算符的用法和含义。

结果为boolean型的变量或表达式可以通过逻辑运算符组合为逻辑表达式。用逻辑运算符进行逻辑运算是如下图所示：

位运算符除“按位与”和“按位或”运算符外，其他只能用于处理整数的操作数，包括byte、short、char、int和long等数据类型。

三元运算符的使用格式为：条件式   ？   值1：值2   运算规则为：若条件式的值为true，则整个表达式取值1，否则取值2.   

通常，优先级由高到低的顺序依次是：增量和减量运算——>算术运算——>比较运算——>逻辑运算——>赋值运算

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高的顺序为byte<short<int<long<float<double。

当把高精度的变量的值赋给低精度的变量时，必须使用显式类型转换运算，语法为：（类型名）要转换的值      除boolean类型外，其他基本类型都能以显式类型转换的方法实现转换。

1、单倍注释：“//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均作为注释而被编译器忽略。语法为：//注释内容

2、多行注释：”/* */“为多行注释标记，符号”/*“与符号”*/"之间的所有内容均为注释内容。注释的内容可以换行。语法为：/* 注释内容     注释内容  …… */

3、文档注释：“/**  */“为文档注释标记。符号”/**“与”*/“之间的内容均为文档注释内容。

1.简单的if条件语句语法：if(布尔表达式){  语句序列  }    ·布尔表达式：必要参数，表示最后返回的结果必须是一个布尔值。它可以是一个单纯的布尔变量或常量，也可以是使用关系或布尔运算符的表达式。
语句序列：可选参数。可以是一条或多条语句，当表达式的值为true时执行这些语句。若语句序列中仅有一条语句，则可以省略条件语句中的“{}”。

2、if…else语句

3、if…else if多分支语句

4、switch多分支语句

while语句也称条件判断语句，它的循环方式为利用一个条件来控制是否要继续反复执行这个语句。语法如下：while（条件表达式）{
语句序列
}   当条件表达式的返回值为真时，则执行“{}”中的语句，当执行完“{}”中的语句后，重新判断条件表达式的返回值，直到表达式返回的结果为假时，退出循环。

do……while循环语句与while循环语句类似，它们之间的区别是while语句为先判断条件是否成立，再执行循环体，而do……while循环语句则先执行一次循环后，再判断条件成立。也就是说，do……while循环语句“{}”中的程序段至少要被执行一次。语法如下：do{
语句序列
}while（条件表达式）    do……while语句与while语句的一个明显的区别是，do……while语句在结尾处多了一个分号。

for循环是Java程序设计中最有用的循环语句之一。一个for循环可以用来重复执行某条语句，直到某个条件得到满足。for循环有两种语句，一种是传统的for语句，一种是foreach语句

使用 break语句可以跳出Switch结构。在循环结构中，同样也可以 break语句跳出当前语句结束循环体。从而中断当前循环。循环嵌套情况下，break语句将只会使程序流程跳出包含它的最内层的循环结构，即只跳出一层循环。
如果想让break跳出外层循环，Java提供了“标签”的功能，语法如下：标签名：循环体{
    break标签名；
}                                                                                                                                                                                                                                                              标签名：任意表示符

循环体：任意循环语句

break标签名：break跳出指定的循环体，此循环体的标签名必须与break的标签名一致。带有标签的break可以指定跳出的循环，这个循环可以是内层循环，也可以是外层循环。

continue语句是针对break语句的补充。 continue不是立即跳出循环体，而是跳过本次循环，回到循环的条件测试部分，重新开始执行循环。在for循环语句中遇到 continue后，首先执行循环的增量部分，然后进行条件测试。与break语句一样，continue也支持标签功能，语法如下：                                                                                  标签名：循环体{
continue标签名
}                                                                                                                                                                                                                                                             标签名：任意标识符
循环体：任意循环语句
continue标签名：continue跳出指定的循环体，此循环体的标签名必须与continue的标签名一致。                                                                                   

5.2.1 创建一维数组

5.2.2 初始化一维数组

5.2.3 使用一维数组

5.3.1 创建二维数组

5.3.2 初始化二维数组

5.3.3 使用二维数组

遍历数组就是获取数组中的每一个元素。通常遍历数组都是使用for循环来实现。遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

在遍历数组时，使用foreach语句可能会更简单。

数组中的元素定义完成后，可通过Arrays类的静态方法fill()来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。

通过Arrays类的静态方法sort()可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：
Arrays,sort(object)

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象，该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重裁形式，用于满足各种类型数组的查找需要。

冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是将较小的数往前放、较大的数往后放，类似水中气泡往上升的动作，所以称为冒泡排序。

直接选择排序属于的基本思想是将排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。

反转排序的基本思想比较简单，也很好理解，其实现思路就是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换。

6.1.1 对象

6.1.2 类

6.1.3 封装

6.1.4 继承

6.1.5多态

在Java中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围。

在Java语言中，使用成员方法对应于类对象的行为。一个·成员方法可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回任何值的选择，如果方法需要返回值，可以在方法体中使用return关键字，使用这个关键字后，方法的执行将被终止。

局部变量是在方法被执行是创建，在方法执行结束时销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译器错误。

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

语法：public void setName(String name){  //定义一个setName()方法                    this.name = name;  // 将参数值赋予类中的成员变量

package b;
 
public class s {
    public static void main(String [] args) {//主方法
        for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
            System.out.println(args[i]);//打印结果
        }
    }
}                                                                                                    在代码运行前要先设置参数，右击界面    

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间

真正的操作标识符实质上是一个引用，引用的语法      类名 对象的引用变量
b d1 =new b();

b是类名，d1是引用名，new b对象的实体

为什么要销毁对象
每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收
垃圾回收器
在其他语言中，需要用户手动回收废弃的对象，JAVA拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源
怎么判断对象会被JAVA虚拟机视为垃圾？主要包括两种情况：1、对象引用超过其作用范围，这个对象将被视为垃圾。2、将对象赋值为null

getClass()方法

toString（）方法

equals()方法

向上转型可以被理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象之间赋值给父类类型的对象，进而实现按照父类描述子类的效果。

向下转型可以被理解为将父类类型的对象转换为子类类型的对象。但是，运用向下转型，如果把一个较抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误。

final关键字可用于变量声明，一旦该变量被设定，就不可以再改变该变量的值。通常，由final定义的变量为常量。final关键字定义的变量必须声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量还可以修饰对象的引用，也可以用来修饰数组。一旦一个对象引用被修饰为final后，它就只能恒定指向一个对象，无法将其改变以指向另一个对象。

将方法定义为final类型，可以防止子类修改父类的定义与实现方式，同时定义为final的方法的执行效率要高于非final方法。如果一个父类的某个方法被设置为private，子类将无法访问该方法，自然无法覆盖该方法。

定义为final的类不能被继承。如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为final类。语法如下：
final 类名{}

如果将某个类设置为final类，则该类中的所有方法都被隐式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式。
版权协议，转载请附上原文出处链接及本声明。

class Shape1{};                                    //图形类
class Square1 extends Shape1{};                    //正方形类继承图形类
class Circular1 extends Shape1{};                //图形类继承图形类
 
public class Demo6 {
    public static void draw(Shape1 s) {            //绘制方法
        if(s instanceof Square1) {                //如果是正方形
            System.out.println("绘制正方形");
        }else if(s instanceof Circular1) {        //如果是圆形
            System.out.println("绘制圆形");
        }else {                                    //如果是其他类型
            System.out.println("绘制父类图形");
        }
    }
    public static void main(String[]args) {
        draw(new Shape1());
        draw(new Square1());
        draw(new Circular1());
    }
}

抽象方法：修饰符 abstract 返回参数 方法名（传入参数）;                                                                                                                                   使用abstract关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，没有意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承没有任何意义。语法如下：                                                                           public abstract class Parent{    //修饰类 abstract class  类名
    abstract void testAbstract();    //定义抽象方法                                                                                                                                           如果声明一个抽象方法，就必须将承载这个抽象方法的类定义为抽象类，不能在非抽象中获取抽象方法。只要类中有一个抽象方法，此类就被标记为抽象类。抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称、参数列表和返回值类型创建出非抽象方法，当然也可以是抽象方法。

接口是抽象类的延伸，可以将它看作纯粹的抽象类，所有的方法都是抽象方法，接口中的所有方法都设有方法体。Java语言每个语言每个类可以实现多个接口。接口使用interface关键字进行定义，语法如下：                                                                                                                              public interface Paintable{    
    void draw();        //定义接口方法可省略public abstract关键字
}                                                                                                                                                                                                                         public：修饰符。
interface：定义接口关键字
Paintable：接口名称

Java中每个接口或类都来自不同的类包，无论是Java API中的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。如果没有包存在，管理程序中的类名称将是一件麻烦的事情。为了避免类名重叠的问题，则需创建新的类。

一个完整的类名需要包名和类名的组合，每个类都隶属一个类包，只要保证同一类包的类不同名，就可以有效避免同名类冲突的情况。

（1）在项目的src节点上右击，选择“新建”/“包”命令（英文为New/Package)。
（2）弹出“新建Java包”（New java Package）对话框，在“名称”（Name）文本框中输入新建的包名，然后单击“完成”（Finish）按钮。
（3）在Eclipse中创建类时，可以在新建立的包上右击，选择“新建”（New）命令，这样新建的类会默认保存在该包中。另外也可以在New Java Class对话框中指定新建类的所在包。
 在Java中包含设计应与文件系统结构相对应。没有定义包的类会被归纳在默认包（defaul package）中。在类中定义包名的语法为：**package 包名**

1.使用import关键字导入包语法如下：
**import com.mr.*;  // 导入com.mr包中的所有类。**   **import com.mr/Math //导入com.mr包中的Math类**
2.使用import导入静态成员语法：import static  静态成员

1.成员内部类简介

2、使用this关键字获取内部类与外部类的引用

3、匿名内部类

使用匿名类时应该遵循以下原则：
1、匿名类不能写构造方法。
2、匿名类不能定义静态的成员。
3、如果匿名类创建的对象没有赋值给任何应用变量，会导致该对象用完一次就会被Java虚拟机销毁。

例 9.1 0可以作为除数吗？                                                                  public class Baulk {       //创建类Baulk
 public static void main(String[] args) { //主方法
  int result = 3/0;      //定义int型变量并赋值
  System.out.println(result);    //将变量输出
 }
}

9.2.1 抛出异常

9.2.2 捕捉异常

例9.4 如何创建自定义异常                                                   public class MyException extends Exception{ //创建自定义异常，继承Exception类
 public MyException(String ErrorMessage) {//构造方法
  super(ErrorMessage);//父类构造方法
 }
}

例9.5 自定义异常的抛出与捕捉                                                       public class Tran {            //创建类
 static int avg(int number1,int number2)throws MyException{ //定义方法，抛出异常
  if(number1 < 0||number2<0) {       //判断方法中参数是否满足指定条件
   throw new MyException("不可以使用负数");    //错误信息
  }
  if(number1>100||number2>100) {       //判断方法中参数是否满足指定条件
   throw new MyException("数值太大了");     //错误信息
  }
  return (number1 + number2)/2;       //将参数的平均值返回
 }
 public static void main(String[] args) {     //主方法
  try {             //try语句块处理可能出现异常的代码
   int result = avg(102,150);       //调用avg（）方法
   System.out.println(result);       //将avg（）方法返回值输出
  }catch(MyException e) {
   System.out.println(e);        //输出异常信息
  }
 }

throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。

throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常；如果要捕捉throw抛出的异常，则必须使用try-catch语句块。

在java语言中，字符串必须包含在一对双引号("  ")之内。
在Java中由双引号(" ")包围的都是字符串，不能作为其他数据类型来使用。
可以通过String str;语句来声明字符串变量。String：指定该变量为字符串类型。str：任意有效的标识符，表示字符串变量的名称。
声明的字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”。

在Java语言中，将字符串作为对象来处理，因此可以像创建其他类对象一样来创建字符串对象。创建对象要使用类的构造方法。

使用“+”运算符可实现连接多个字符串的功能。“+”运算符可以连接多个String对象并产生一个新的String对象。

字符串也可同其他基本数据类型进行连接。如果将字符串同其他数据类型数据进行连接，会将其他数据类型的数据直接转换成字符串。

使用Sring类型的length()方法可获取声明的字符串对象的长度。语法：str.length();
其中，str为字符串对象

1、indexOf(String s)

2、lastlndexOf(String str)

例3：用两种方式判断字符串的长度                                                       public class Text {            //创造类
 public static void main(String[] args) {     //主方法
  String str = "We are students";       //定义字符串str
  int size = str.lastIndexOf("");       //将空字符串在str中的索引位置赋值给变量size
  System.out.println("空字符串在字符串str中的索引位置是："+size); //将变量size输出
  System.out.println("字符串str的长度是："+str.length());  //将字符串str的长度输出
 }

}

10.3.3 获取指定索引位置的字符

通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。

trim()方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：
str.trim
其中，str为任何字符串对象。

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。
语法：str.replace(CharSequence target,CharSequence replacement)
1.targt: 要替换的字符或字符串。
2.replacement：用于替换原来字符串的内容。
replace()方法返回的结果是一个新的字符串。如果字符或字符串 oldChar 没有出现在该对象表达式中的字符串序列中，则将原字符串返回。

startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。

对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。
此时，布尔型变量b的值为false，因为字符串是对象，tom、jerry是引用。
因此，要比较两个字符串内容是否相等，应使用equals()方法和equalsIgnoreCase()方法。
A版权协议，转载请附上原文出处链接及本声明。

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。语法如下：
str.compareTo(String otherstr)
其中，str、otherstr是要比较的两个字符串对象。

String类的toLowerCase()方法可将字符串中的所有大小字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改写为大写字母

使用split()方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串分割形式

1…format(String format,Object…args)

2.format(Local l,String format,Object…args)

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要编写大量的代码、经过各种算法才能实现。formatI()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

常规类型格式化可应用于任何参数类型，可通过表中的转换符来实现。

例18:效率比拼                                                                                      public class Jerque {
 
 public static void main(String[] args) {
  String  str="";//创建空字符串
  long StarTime=System.currentTimeMillis();//获取字符串执行前的时间
  for(int i=0;i<10000;i++) {//循环追加字符串
   str=str+i;
   
  }
  long endTime=System.currentTimeMillis();//获取字符串执行后的时间
  long time=endTime-StarTime;//计算时间差
  System.out.println("string消耗的时间："+time);//输出
  StringBuilder builder=new StringBuilder("");//创建字符串生成器
   StarTime=System.currentTimeMillis();//获取字符串执行前的时间
   for(int j=0;j<10000;j++) {//循环追加字符串
    builder.append(j);
    
   }
   endTime=System.currentTimeMillis();//获取字符串执行后的时间
   time=endTime-StarTime;//计算时间差
   System.out.println("stringBuilder消耗的时间："+time);//输出
 }
}

该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。语法如下:
append(comtemt)
其中，content表示要追加到字符串生成器中的内容，可以是任何类型的数据或者其他对象。

该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。语法如下:
insert(int offset, arg)
ofset:字符串生成器的位置。该参数必须大于等于0，且小于等于此序列的长度。

arg:将插入至字符串生成器的位置。该参数可以是任何数据类型的数据或其他对象。
协议，转载请附上原文出处链接及本声明。

ava.lang 包中的 Integer 类、Byte 类、Short 类和 Long 类，分别将基本数据类型 int、byte、short和 long 封装成一个类，由于这些类都是 Number 类的子类，区别就是封装不同的数据类型，其包含方法基本相同，所以本节以Integer 类为例讲解整数包装类。
nteger 类在对象中包装了一个基本数据类型 int 的值，该类的对象包含一个 int 类型的字段。此外该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了其他一些处理 int 类时非常有用的常量和方法。Integer 类的常用方法如表：

Double类和 Float类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于 Float 类，可以参考 Double类的相关内容。
Double类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个double类的字段。此外，该类还提供多个方法，可以将 double类型转换为 String类型，将 String类型转换为 doubl类型，也提供了其他一些处理 double 类型时有用的常量和方法。Double类的常用方法如表：

Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为boolean 的字段。此外，此类还为 boolean 类型和 String 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean类的常用方法如表：

Character 类在对象中包装一个基本类型为 char 的值,该类提供了多种方法,以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作，常用的方法如表：

前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类-Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byteint、short、long、float 和 double 的方法。例如，doubleValue()方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如表：

数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 foat 型数据。在 Java 中使用 java.textDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。
在Java 中，没有格式化的数据遵循以下原则:

1、如果数据绝对值大于0.001 并且小于10000000，使以常规小数形式表示
2、如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。在 Java中，可以使用DecimalFormat类进行格式化操作
DecimalForat类是NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一般情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中的applyPatten0方法来实现数字格式化。
当格式化数字时，可在 DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照-定的特殊字符规则进行匹配。表中列举了格式化模板中的特殊字符及其所代表的含义。

Math 类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值、最小值，以及平均值函数方法。这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用：
Math.数学方法

在Math 类中，除函数方法外还存在一些常用数学常量，如 PI、E等。这些数学常量作为Math类的成员变量出现，调用起来也很简单。可以使用如下形式调用：
Math.PI
Math.E
Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数函数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。

Random 类是JDK 中的随机数生成器类，可以通过实例化一个 Radom 对象创建一个随机数生器，语法如下：
Random r = new Random();

以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为每时刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结果相同的随机数。

用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。语法如下：
Random r = new Random(seedValue);

r: Random类对象。

seedValue:随机数生成器的种子。

Biginteger 类的数字范围较 Integer 类的数字范围要大得多。前文介绍过 Integer 类是 int 的包装类int 的最大值为 23-1，如果要计算更大的数字，使用 nteer 类就无法实现了，所以 Java 中提供]BigInteger 类来处理更大的数字。Biginteger 类支持任意精度的整数，也就是说，在运算中 BigIntege类可以准确地表示任何大小的整数值而不会丢失信息。

在 BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数最大公约数以及判断是否为质数等操作。

使用 BigInteger类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。

例如，将2转换为 BigInteger 类型，可以使用以下语句进行初始化操作:
BigIntege twoInstance = new BigIntege(“2”);

BigDecimal类和BigInteger类都能实现大数字的运算，不同的是 BigDecimal类加入了小数的概念般的foat 型和 double 型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。在BigDecimal类中，常用的两个构造方法如表:

BigDecimal类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal类实现的加、减、乘、除的方法 下表：

在上述方法中，BigDecimal类中divide()方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义下表

例13：使用BigDecimal类进行数学运算                                                                                  import java.math.BigDecimal;
import java.math.RoundingMode;
public class BigDecimalDemo {
 public static void main(String[] args) {
  BigDecimal b1 = new BigDecimal("0.00987654321987654321");//第1个大小数
  BigDecimal b2 = new BigDecimal("0.00123456789123456789");//第2个大小数
  System.out.println("两个数字相加结果："+b1.add(b2));//加法运算
  System.out.println("两个数字相减结果："+b1.subtract(b2));//减法运算
  System.out.println("两个数字相乘结果："+b1.multiply(b2));//乘法运算
  //除法运算，商小数点后保留9位，并将结果进行四舍五入操作
  System.out.println("两个数字相除,保留小数点后9位："+b1.divide(b2,9,RoundingMode.HALF_UP));//
 }

}

使用Scanner类扫描控制台的代码如下：
Scanner sc = new Scanner(System.in);

Date类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如下图：

使用Date类的第2种构造方法创建一个Date类的对象，代码如下：
long timeMillis = System.currentTimeMillis();
Date date = new Date(TimeMillis);
上述代码中的System类的currentTimeMillis()方法主要用于获取当前系统时间距标准时间的毫秒数。另外，这里需要注意的是，创建Date类对象时使用的是long型整数，而不是double型，这主要是因为double类型可能会损失精度。Date类的常用方法及其说明，图如下：

例16：获取当前的日期和时间                                                                                  import java.util.Date;
public class DateDemo {

 public static void main(String[] args) {
  Date date = new Date();     //创建现在的日期
  long value = date.getTime(); //获取毫秒数
  System.out.println("日期："+date);//输出
  System.out.println("到现在所经历的毫秒数为："+value);

 }

}

DateFormat类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化，DateFormat类提供了很多类方法，以获得基于默认或给定语环境和多种格式化风格的默认日期时间formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
1.SHORT: 完全为数字，如11.13.42或3:30pm。

2.MEDIUM: 较长，如Jan 12,1343。

3.LONG: 更长，如January 12,1343或3:30:32pm。

4.FULL: 完全指定，如Tuesday、April 12、1952AD或3:30:42pm PST。

另外，使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此使用其静态方法getDateInstance()进行创建，语法如下：
DateFormat of = DateFormat.getDateInstanse();

使用getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimelnstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明下表：

由于DateFormat类是一个抽象类，不能用new 创建实例对象。因此，除了使用getXXXInstance()方法创建其对象，还可以使用其子类，如 SimpleDateFormat 类，该类是一个以与语言环境相关的方式来格式化和分析日期的具体类，它允许进行格式化(日期一文本)、分析(文本一日期)和规范化。

SimpleDateFormat类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符下表：

通常表中的字符出现的数量会影响数字的格式。例如，yyyy 表示4 位年份，这样输入会显示202l:yy 表示两位，这样输入就会显示为 21; 只有一个y的话，会按照 yyyy 显示:如果超过4个一些常用的日期时间格式如表中所示。y，如yyyyyy，会在4位年份左侧补0，结果为02021。一些常用的日期时间格式下表：

例17：以中文形式打印当前的日期和时间                                                                            import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateFormatDemo {

 public static void main(String[] args) {
  DateFormat df = new SimpleDateFormat("yyy年MM月dd日EEEEE HH时mm分ss秒");
  System.out.print("各位观众大家好，现在是");
  System.out.print(df.format(new Date()));
  System.out.println(", 欢迎收看新闻。");

 }

}

从表中可以看到，add()方法和 roll()方法都用来为给定的日历字段添加或减去指定的时间量,它们的主要区别在于:使用 add()方法时会影响大的字段，像数学里加法的进位或错位，而使用 roll()方法设置的日期字段只是进行增加或减少，不会改变更大的字段。

例18：具体离中华人民共和国成立100周年差多少天                                                                                                                   import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class CountDown {

 public static void main(String[] args) {
  System.out.println("——————————————中华人民共和国成立100周年倒计时——————————————");
  Date date = new Date();//当前时间
  //创建SimpleDateFormat对象，指定目标格式
  SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy年MM月dd日");
  //创建format方法，格式化时间，转换为指定格式
  String today = simpleDateFormat.format(date);
  System.out.println("今天是"+today);//输出当前日期
  //获取自1970年1月1日至当前时间所经过的毫秒数
  long time1 = date.getTime();
  //使用默认时区和语言环境得一个日历calendar
  Calendar calendar = Calendar.getInstance();
  //设置日历calendar中的年、月和日的值。因为月份是从0开始计算的，所以这里要减一
  calendar.set(2049,10-1,1);
  //计算自1970年1月1日至2049年10月1日所经过的毫秒数
  long time2 = calendar.getTimeInMillis();
  //计算2049年10月1日距离当前时间的天数
  long day = (time2 - time1)/(1000*60*60*24);
  System.out.println("距离2049年10月1日还有"+day+"天！");

 }

}

最后对 Calendar 类的使用做出几点总结:

c.set(Calendar.DAY OF_MONTHO)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。

Calenda.rMONTH 的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。

Calendar.DAY_OF_WEEK 的第一天是周日，周一是第二天，周六是最后一天。

通常遍历集合，都是迭代器来实现。Collection接口中的Iterator()方法可返回在此Collection进行迭代的迭代器。右边实例是遍历集合的例题

12.3.1  List接口

12.3.2  List接口的实现类

Map接口提供了将key映射到值的对象。一个映射不能包含重复的key，每一个key最多只能映射到一个值。除集合的常用的方法外，其他特殊方法如右图

HashMap类是基于哈希表的Map接口的实现，此实现提供所有可选的映射操作，并允许使用null值和null值，但必须保证键的唯一性。HashMap类通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
TreeMap类不仅实现了Map接口，还实现了java.utli.SortedMap接口，因此集合中的映射关系具有一定的顺序。但在添加、删除和定位映射关系，TreeMap类比HashMap类性能稍差。由于TreeMap类实现的Map集合中的映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是null。

设置常量时，通常将常量放置在接口中，这样在程序中直接使用。该常量不能被修改，因为在接口定义常量时，该常量的修饰符为final与static。常规定义常量的代码：                                                                                                                                                                                                                           public interface Constants{
    public static final int Constants_A=1;
    public static final int Constants_B=12;
}                                                                                                                                                                                                                                         枚举类型出现后，逐渐取代了上述常量定义方式。使用枚举类型定义常量的语法如下：                                                                                                                 public enum Constants{                                                                                                                                                                                                      Constants_A,
    Constants_B,
}                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  其中，enum是定义枚举类型的关键字。当需要在程序中使用该常量时，可以是使用Constants.Constants_A来表示

例题.分别创建四季接口常量和枚举

枚举类型较传统定义常量的方式，除具有参数类型检测的优势外，还具有其他方面的优势。用户可以将一个枚举类型看作是一个类，它继承于java.lang.Enum类，当定义一个枚举类型时，每个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员都默认被 final、public、static修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。
由于枚举类型对象继承于javalang.Enum类,所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。

1.values()方法
枚举类型实例包含一个values()方法，该方法可以将枚举类型成员以数组的形式返回

2. valueOf()方法与compareTo()方法
枚举类型中静态方法valueOf()方法可以将普通字符串转换为枚举类型，而compareTo()方法用于比较两个枚举类型对象定义时的顺序。

3.ordinal()方法
枚举类型中的ordinal()方法用于获取某个枚举对象的位置索引值

4.枚举类型中的构造方法
枚举类型定义的构造方法语法如右所示

类型安全。
紧凑有效的数据定义。
可以和程序其他部分完美交互。
运行效率高。

13.2.1  回顾向上转型与向下转型

13.2.2  定义泛型类

13.2.3  泛型的常规用法

13.2.4  泛型的高级用法

13.2.5  泛型总结

1.lambda表达式可以用非常少的代码实现抽象方法。
2.lambda表达式不能独立执行，因此必须实现函数式接口，并且会返回一个函数式接口的对象。
3.lambdab表达式的语法非常特殊

语法格式：
（）-> 结果表达式 
参数-> 结果表达式
（参数1，参数2...，参数n）-> 结果表达式

第1行实现无参方法，单独写一对圆括号表示方法无参数，操作符右侧的结果表达式表示方法的返回值。
第2行实现只有一个参数的方法，参数可以写在圆括号里，或者不写圆括号。
第3行实现多参数的方法，所有参数按顺序写在圆括号里，且圆括号不可以省略。

lambda表达式也可以实现复杂方法，将操作符右侧的结果表达式换成代码块即可
语法格式如下：
（）->{代码块）
参数->（代码块}
（参数1，参数2，..参数n)->{代码块）
第1行实现无参方法，方法体是操作符右侧代码块。
第2行实现只有一个参数的方法，方法体是操作符右侧代码块。
第3行实现多参数的方法，方法体是操作符右侧代码块。

lambda表达式的功能归纳总结，语法理解为：
（）                       ->               {代码块}
这个方法            按照              这样的代码来实现

简单总结：操作符左侧的方法参数，操作符右侧是方法体

1. 函数式接口

2.Iambda表达式实现无参数抽象方法

3.lambda表达式实现有参抽象方法

4.lambda表达式使用代码块

这些外部的变量有些可以被更改，有些则不能。例如，lambda表达式无法更改局部变量的值，但是却可以更改外部类的成员变量（也可以叫做类属性）的值他。

lambda 表达式中并有抛出异常的语法，这是因为lambda表达式会默认抛出抽象方法原有的异常，当此方法被调用时则要进行异常处理。

例题  防沉迷接口

语法：
类名::静态方法名 
新的操作符“::”，中间无空格，左边表示方法所属的类名，右边是方法名，语法中方法名是没有括号的。

例题.  使用lambda表达式引用静态方法

从代码结果可以看出，接口的方法得出的结果正是按照add()方法中的逻辑计算出来的

引用成员方法的语法：
对象名::成员方法名
操作符左侧必须是一个对象名，而不是类名。

例题.  使用lambda表达式引用成员方法

结果可以看出，抽象方法的结果是按照类成员方法的逻辑计算出来的

Iambda表达式有3种引用构造方法的语法，分别是引用无参数构造方法、引用有参构造方法和引用数构造方法

这个接口有以下两个泛型：
T：被操作的类型，可以理解为方法参数类型。
R：操作结果类型，可以理解为方法的返回类型。
Function 接口是函数式接口，所以只有一个抽象方法，但是Function 接口还提供方法以方便开发者对函数逻辑进行更深层的处理。

14.3.1 Stream接口简介

14.3.2 Optional类

14.3.3 Collectors类

14.3.4 数据过滤

14.3.5数据映射

14.3.6 数据查找

14.3.7 数据收集

流是一组有序的数据序列，可分为输入流和输出流两种。

程序从指向源的输入流中读取源中数据，源可以是文件、网络、压缩包或者其他数据源。

输出流的指向是数据要到达的目的地，输出流的目标可以是文件、网络、压缩包、控制台和其他数据输出目标。

15.1.1 输入流 

15.1.2 输出流

File 类是 java.io包中唯一代表磁盘文件本身的类。File类定义了一些与平台无关的方法来操作文件，可以通过调用 File类中的方法，实现创建、删除、重命名文件等操作。File类的对象主要用来获取文件本身的一些信息，如文件所在的目录、文件的长度、文件读写权限等。数据流可以将数据写入文件中，文件也是数据流最常用的数据媒体

程序运行期间，大部分数据都在内存中进行操作，当程序结束或关闭时，这些数据将消失。如果需要将数据永久保存，可使用文件输入/输出流与指定的文件建立连接，将需要的数据永久保存到文件中。本节将讲解文件输入/输出流。

缓存是I/O的一种性能优化。缓存流为I/O流增加了内存缓存区，使得在流上执行skip()、mar()和reset()方法都成为可能

数据输入/输出流（DataInputStream 类与DataOutputStream类）允许应用程序以与机器无关的方式从底层输入流中读取基不）ava数据类型。也就是说，当读取一不数据时，不必再关心这个数值应当是哪种字节。DatalnputStream 类与DataOutputStream类的构造方法如下。

1. DatalnputStream(InputStream in)：使用指定的基础 InputStream 对象创建一个DataInputStream对象。

2. DataOutputStream(OutputStream out)：创建一个新的数据输出流，将数据写入指定基础输出流。

DataOutputStream 类提供了将字符串、double 数据、int 数据、boolean数据写入文件的方法。其中，将字符串写入文件的方法有 3种，分别是writeBytes(String s)、writeChars(String s)、writeUTF(String s)。由于Java 中的字符是Unicode 编码，是双字节的，writeBytes( )方法只是将字符串中的每一个字符的低字节内容写入目标设备中；而writeChars( )方法将字符串中的每一个字符的两个字节的内容都写到目标设备中；writeUTF( )方法将字符串按照UTF 编码后的字节长度写入目标设备，然后才是每一个字节的UTF 编码。

DatalnputStream 类只提供了一个readUTF( )方法返回字符串。这是因为要在一个连续的字节流读取一个字符串，如果没有特殊的标记作为一个字符串的结尾，并且不知道这个字符串的长度，就无法知道读取到什么位置才是这个字符串的结束。DataOutputStream 类中只有writeUTF( )方法向目标设备中写入字符串的长度，所以也能准确地读回写入字符串。

16.1.1 访问构造方法

16.1.2  访问成员变量

16.1.3  访问成员方法

16.2.1  定义Annotation类型

16.2.2 访问Annotation 信息

//注册驱动 获取链接
 public void getConnection() throws SQLException{
  //第一步:注册驱动
  DriverManager.registerDriver(new Driver());

coonection = DriverManager.getConnection("jdbc:mysql://localhost:3306/school_java","root","1234");

PreparedStatement prepareStatedment = coonection.prepareStatement("insert into course values (?,?)");

ResultSet resultSet=prepareStatedment.executeQuery();

while(resultSet.next()) {
   System.out.print(resultSet.getInt("id"));
   System.out.println(resultSet.getString("name"));
  }

```java
resultSet.close();
      prepareStatedment.close();
  
```//关闭连接
private void close() throws SQLException{
  coonection.close();
 }

JFrame 类的常用构造方法包括以下两种形式：
public JFrame（）：创建一个初始不可见、没有标题的窗体。
public JFrame(String title)：创建一个不可见、具有标题的窗体。

例如，创建一个不可见、具有标题的窗体，关键代码如下：
JFrame jf = new JFrame(“登录系统”)；
Container container = jf.getContentPane();

在创建窗体后，先调用getContentPaneO方法将窗体转换为容器，再调用addO方法或者removeO方法向容器中添加组件或者删除容器中的组件。向容器中添加按钮，关键代码如下：
JButton okBtn= new JButton(“确定“)
container.add(okBtn);

删除容器中的按钮，关键代码如下:
container.remove(okBtn);

创建窗体后，要对窗体进行设置，如设置窗体的位置、大小、是否可见等。JFrame 类提供的相应方法可实现上述设置操作，具体如下：

setBounds(int x, int y, int width, int leight)：设置窗体左上角在屏幕中的坐标为(x，y），窗体的宽度为width，窗体的高度为height。
setLocation(int x,int y)：设置窗体左上角在屏幕中的坐标为(x，y）。
setSize(int width, int height)：设置窗体的宽度为width，高度为height。
setVisibale(boolean b)：设置窗体是否可见。b为true时，表示可见；b为false时，表示不可见。setDefaultCloseOperation(int operation)：设置窗体的关闭方式，默认值为DISPOSE_ON_CLOSE 

Java 语言提供了多种窗体的关闭方式，常用的有4种，如表所示。

例题..  第一个窗体程序

JDialog 类常用的构造方法如下：

public JDialogO：创建一个没有标题和父窗体的对话框。
public JDialog(Frame f)：创建一个没有标题，但指定父窗体的对话框。
public JDialog(Frame f, boolean model)：创建一个没有标题，但指定父窗体和模式的对话框。如果model为true，那么弹出对话框后，用户无法操作父窗体。
public JDialog(Frame f, String title)：创建一个指定标题和父窗体的对话框.。
public JDialog(Frame f， String title, boolean model)：创建一个指定标题、父窗体和模式的对话框。

例题..  在窗体中弹出对话框

JOptionPane提供了4种创建对话框的方法

特点：硬性指定组件在容器中的位置和大小，组件的位置通过绝对坐标的方式来指定。

例题..使用绝对布局定位按钮的大小和位置

FlowLayout类具有以下常用的构造方法：

public FlowLayout()。
public FlowLayout(int alignment)。
public FlowLayout(int alignment,int horizGap,int vertGap)。

例题.. 使用流布局排序按钮

addo方法被用于实现向容器中添加组件的功能，它可以设置组件的摆放位置。addO方法常用的语
法格式如下：

public void add(Component comp, Object constraints)

comp：被添加的组件。
constraints：被添加组件的布局约束对象。

例题.. 使用边界布局排列按钮

网格布局管理器主要有以下两个常用的构造方法：

public GridLayout(int rows, int columns)。
public GridLayout(int rows, int columns, int horizGap, int vertGap)。

其中，参数rows 和columns分别代表网格的行数和列数，这两个参数只允许有一个参数可以为0，被用于表示一行或一列可以排列任意多个组件；参数horizGap和vertGap分别代表网格之间的水平间距和垂直间距。

例题.  使用网格布局排列按钮

JScrollPane 滚动面板 不能使用布局管理器，且只能容纳一个组件

例题..  为窗体添加上下滚动条

JLabel类常用的构造方法如下：

public JLabel0：创建一个不带图标或文本的标签。
public JLabel(Icon icon)：创建一个带图标的标签。
public JLabel(Icon icon, int aligment)：创建一个带图标的标签，并设置图标的水平对齐方式。
public JLabel(String text, int aligment)：创建一个带文本的标签，并设置文本的水平对齐方式。
public JLabel(String text, Icon icon, int aligment)：创建一个带文本和图标的JLabel对象，并设置文本和图标的水平对齐方式。

在Swing 程序设计中，图标经常被添加到标签、按钮等组件，使用javax.swing.Imagelcon类可以依据现有的图片创建图标。ImageIcon类实现了Icon接口，它有多个构造方法，常用的如下：

public ImagelconO：创建一个 Imagelcon 对象，创建 ImageIcon对象后，使用其调用 setImage(Image image）方法设置图片。
public Imagelcon(Image image)：依据现有的图片创建图标。
public ImageIcon(URL url)：依据现有图片的路径创建图标。

Swing 按钮由JButton对象表示，JButton常用的构造方法如下：

public JButtonO：创建一个不带文本或图标的按钮。
public JButton(String text)：创建一个带文本的按钮。
public JButton(Icon icon)：创建一个带图标的按钮。
public JButton(String text, Icon icon)：创建一个带文本和图标的按钮。
创建JButon 对象后，如果要对JButton 对象进行设置，那么可以使用JButton类提供的方法。

Button 类的常用方法及其说明

1.单选按钮
创建JRadioButton 对象需要使用JRadioButton 类的构造方法。JRadioButton类常用的构造方法如下：

public JRadioButton()：创建一个未被选中、文本未被设定的单选按钮。
public JRadioButton(Icon icon）：创建一个未被选中、文本未被设定，但具有指定图标的单选按钮。
public JRadioButton(Icon icon, boolean selected)：创建一个具有指定图标、选择状态，但文本区未被设定的单选按钮。
public JRadioButton(String text)：创建一个具有指定文本，但未被选中的单选按钮。
public JRadioButton(String text， Icon icon)：创建一个具有指定文本、指定图标，但未被选中的
单选按钮。
public JRadioButton(String text, Icon icon, boolean selected)：创建一个具有指定的文本、指定图标和选择状态的单选按钮。
根据上述构造方法的相关介绍，不难发现，单选按钮的图标、文本和选择状态等属性能够被同时设定。例如，使用JRadioButton 类的构造方法创建一个文本为“选项 A”的单选按钮，关键代码如下：

JRadioButton rbtn = new JRadioButton("选项 A");

2.按钮组
Swing 按钮组由 ButtonGroup对象表示，多个单选按钮被添加到按钮组后，能够实现“选项有多个,
但只能选中一个”的效果。ButtonGroup 对象被创建后，可以使用add()方法把多个单选按钮添加到
ButtonGroup对象中。

JCheckBox的常用构造方法如下:

public JCheckBox()：创建一个文本、图标未被设定且默认未被选中的复选框。
public JCheckBox(Icon icon, Boolean checked)：创建一个具有指定图标、指定初始时是否被选中，但文本未被设定的复选框。
public JCheckBox(String text, Boolean checked)：创建一个具有指定文本、指定初始时是否被选中，但图标未被设定的复选框。

JComboBox 类的常用构造方法如下：

public JComboBox(ComboBoxModeldataModel)：创建一个 JComboBox对象，下拉列表中的列表项使用ComboBoxModel中的列表项，ComboBoxModel 是一个用于组合框的数据模型。
public JComboBox(Object[]arrayData)：创建一个包含指定数组中的元素的JComboBox对象。
public JComboBox(Vector vector):创建一个包含指定 Vector 对象中的元素的JComboBox 对象.Voetor对象中的元素可以通过整数索引进行访问，而且 Vector 对象中的元素可以根据需求被添加或者移除。

JComboBox类的常用方法及其说明

JList类的常用构造方法如下：

public void JList()：创建一个空的JList对象。
public void JList(Object[] listData)：创建一个显示指定数组中的元素的JList对象。
public void JList(Vector listData)：创建一个显示指定 Vector 中的元素的JList对象。
public void JList(ListModel dataModel)：创建一个显示指定的非 null模型的元素的JList对象。

文本框组件由JTextField对象表示。JTextField类的常用构造方法如下：

public JTextFieldO：创建一个文本未被指定的文本框。
public JTextField(String text)：创建一个指定文本的文本框。
public JTextField(int fieldwidth)：创建一个指定列宽的文本框。
public JTextField(String text, int fieldwidth)：创建一个指定文本和列宽的文本框。
public JTextField(Document docModel, String text, int fieldWidth)：创建一个指定文本模型、本内容和列宽的文本框。
如果要为一个文本未被指定的文本框设置文本内容，那么需要使用 setTextO方法。setText0方法的语法如下：

public void setText(String t)

其中，t表示文本框要显示的文本内容。

密码框组件由JPasswordField对象表示，其作用是把用户输入的字符串以某种符号进行加密。JPasswordField类的常用构造方法如下：

public JPasswordFieldO：创建一个文本未被指定的密码框。
public JPasswordFiled(String text)：创建一个指定文本的密码框。
public JPasswordField(int fieldwidth)：创建一个指定列宽的密码框。
public JPasswordField(String text, int fieldwidth)：创建一个指定文本和列宽的密码框。
public JPasswordField(Document docModel, String text, int fieldWidth)：创建一个指定文本模型和列宽的密码框。
JPasswordField 类提供了setEchoCharO方法，这个方法被用于改变密码框的回显字符。setEchoCharO方法的语法如下：

public void setEchoChar(char c)

其中，c表示密码框要显示的回显字符

文本城组件曲 JTextArea 对象表示，其作用是接受用户的多行文本输入。JTextArea类的常用构造方法如下：

 patie TextArea0：创建一个文本未被指定的文本域。
publie NTtextArea(String text)：创建一个指定文本的文本域。
pabic leatAesfint rows,int columns)：创建一个指定行高和列宽，但文本未被指定的文本域。
public JTextArea(Document doc)： 创建一个指定文档模型的文本域。
public JTextArea(Document doc,String Text,int rows,int columns)：创建内容以及行高和列宽的文本域

JTable 类除提供了默认的构造方法外，还提供了被用于显示二维数组中的元素的构造方法，这个

构造方法的语法如下：

JTable(Object[][] rowData, Objectl columnNames)

rowData：存储表格数据的二维数组。
columnNames：存储表格列名的一维数组。

Swing 使用 TableModel 接口定义了一个表格模型，AbstractTableModel 抽象类实现了 TableModel接口的大部分方法，只有以下3个抽象方法没有实现：

public int getRowCountO);
public int getColumnCountO);
public Object getValueAt(int rowIndex, int columnIndex);
为了实现使用表格模型创建表格的功能，Swing 提供了表格模型类，即DefaultTableModel类。DefaultTableModel 类继承了 AbstractTableModel 抽象类且实现了上述3个抽象方法。

DefaultTableModel类提供的常用构造方法

动作事件（ ActionEvent）监听器是Swing中比较常用的事件监听器，很多组件的动作都会使用它监听，如按钮被单击等。下表描述了动作事件监听器的接口与事件源等。

当向文本框中输入内容时，将发生键盘事件。KeyEvent类负责捕获键盘事件，可以通过为组件添加实现了KeyListener接口的监听器类来处理相应的键盘事件。
KeyListener接口共有三个抽象方法，分别在发生击键事件（按下并释放键）、按键被按下（手指按下键但不松开）和按键被释放（手指从按下的键松开）时被触发，具体如下：
 

public interface KeyListener extends EventListener {

        public void keyTyped(KeyEvent e);                //发生击键事件时被触发

        public void keyPressed(KeyEvent e);              //按键被按下时被触发

        public void keyReleased(KeyEvent e);                //按键被释放时被触发
}

MouseEvent鼠标事件
所有组件都能发生鼠标事件，MouseEvent类负责捕获鼠标事件，可以通过为组件添加实现MouseListener接口的监听器来处理相应的鼠标事件。
MouseListener接口共有5个抽象方法，分别在光标移入或者移出组件、鼠标按键被按下或释放和发生单击事件时被触发。所谓单击事件，就是按键被按下并释放。需要注意的是，如果按键是在移出组件之后才被释放，则不会触发单击事件。MouseListener接口的具体定义如下：
 

public interface MouseListener extends EventListener {

        public void mouseEntered(MouseEvent e);        //光标移入组件时被触发

        public void mousePressed(MouseEvent e);        //鼠标按键被按下时被触发

        public void mouseReleased(MouseEvent e);      //鼠标按键被释放时被触发

        public void mouseClicked(MouseEvent e);        //发生单击事件时被触发

        public void mouseExited(MouseEvent e);        //光标移出组件时被触发
}

在上述每个抽象方法中，均传入了MouseEvent类的对象。MouseEvent类中比较常用的方法

当 需要判断触发此次事件的按键时，可以通过表18.12中的静态常量判断由getButton（）方法返回的int型值代表的键。

Grapics 类是所有图形上下文的抽象基类，它允许应用程序在组件以及闭屏图像上进行绘制。Graphics 类封装了Java 支持的基本绘图操作所需的状态信息，主要包括颜色、字体、画笔、文本、图像等。

       Graphics 类提供了绘图常用的方法，利用这些方法可以实现直线、钜形、多边形、椭面、圆弧等形状和文本、图片的绘制操作。另外，在执行这些操作之前，还可以使用相应的方法设置给图的颜色和字体等状态属性。

使用Graphics 类可以完成简单的图形绘制任务，但是它所实现的功能非常有限，如无法改变线条的粗细、不能对图片使用旋转和模糊等过滤效果。

        Graphics2D 类继承Graphics 类，实现了功能更加强大的绘图操作的集合。由子Graphies2D类是Graphics 类的扩展，也是推荐使用的Java 绘图类。

使用Color 类可以创建任意颜色的对象，不用担心平台是否支持该颜色，因为Java以跨平台和与硬件无关的方式支持颜色管理。创建Color 对象的构造方法有如下两种：

Color col = new Color(int r, int g, int b)

Color col = new Color(int rgb

rgb：颜色值，该值是红、绿、蓝三原色的总和。
r：该参数是三原色中红色的取值。
g：该参数是三原色中绿色的取值。
b：该参数是三原色中蓝色的取值。

绘图类可以使用setColor()方法设置当前颜色。语法如下：

setColor(Color color)

其中，参数color是Color对象，代表一个颜色值，如红色、黄色或默认的黑色

默认情况下，Graphics 类使用的画笔属性是粗细为1个像素的正方形，而Graphics2D类可以调用setStrokeO方法设置画笔的属性，如改变线条的粗细、虚实，定义线段端点的形状、风格等。语法格式如下：

setStroke(Stroke stroke)

其中，参数stroke是Stroke 接口的实现类对象。

      setStroke0方法必须接受一个 Stroke 接口的实现类对象作参数，java.awrt包中提供了BasisSrke类它实现了Stroke接口，并且通过不同的构造方法创建画笔属性不同的对象。这些构造方法如下：

• BasicStroke（）
• BasicStroke(float width)
• BasicStroke(float width, int cap, int join)
• BasicStroke(float width, int cap, int join, float miterlimit)
• BasicStroke(float width, int cap, int join, float miterlimit, float[] dash, float dash_phase)

Java 使用Font 类封装了字体的大小、样式等属性，该类在java.awt包中定义，其构造方法可以指定字体的名称、大小和样式3个属性。语法如下:

Font(String name, int style, int size)

name：字体的名称
style：字体的样式
size：字体的大小
设置绘图类的字体可以使用绘图类的setFontO方法。设置字体以后在图形上下文中绘制的所有文字都使用该字体，除非再次设置其他字体。语法如下：

setFont(Font font)

其中，参数font 是Font 类的字体对象。

Graphics2D类提供了drawString0方法，使用该方法可以实现图形上下文的文本绘制，从而实现在图片上显示文字的功能。语法格式有如下两种：

drawString(String str, int x, int y)
drawString(String str, float x, float y)
str：要绘制的文本字符串。
x：绘制字符串的水平起始位置。
y：绘制字符串的垂直起始位置。
这两个方法唯一不同的就是x和y的参数类型不同。

在显示图片时，使用了drawImageO方法将图片以原始大小显示在窗体中，要想实现图片的放大与缩小，则需要使用它的重载方法。语法如下：

drawlmage(lmage img, int x, int y, int width, int height, ImageObserver observer)

图像的翻转需要使用drawImage()方法的另一个重载方法。语法如下:

drawimage(lmage img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)

此方法总是用非缩放的图像来呈现缩放的矩形，并动态地执行所需的缩放。此操作不使用缓存的缩放图像。执行图像从源到目标的缩放，要将源矩形的第一个坐标映射到目标矩形的第一个坐标，源矩形的第二个坐标映射到目标矩形的第二个坐标，按需要缩放和翻转子图像，以保持这些映射关系。

子主题

图像旋转需要调用Graphics2D类的rotateO方法，该方法将根据指定的弧度旋转图像。语法如下：

rotate(double theta)

其中，theta 是指旋转的弧度

可以使用Graphics2D类提供的shearO方法设置绘图的倾斜方向，从而使图像实现倾斜的效果。语法如下:

shear(double shx, double shy)

shx：水平方向的倾斜量
shy : 垂直方向的倾斜量

Thread 类时 java.lang 包中的一个类，从类中实例化的对象代表线程，程序员启动一个新线程需要建立 Thread 实例。

Thread类中常用的两个构造方法如下：

public Thread()：创建一个新的线程对象。
public Thread(String threadName)：创建一个名称为threadName的线程对象。
继承Thread类创建一个新的线程的语法如下：

public class ThreadTest extends Threadf {
}

完成线程真正功能的代码放在类的run0方法中，当一个类继承Thread类后，就可以在该类中覆盖run0方法，将实现该线程功能的代码写入runO方法中，然后调用 Thread类中的start0方法执行线程也就是调用run0方法。

Thread 对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run0方法中。run0方法必须使用以下语法格式：

public void run() {
}

当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不再启动其他线程时，该程序就为单线程程序，如本章以前的程序都是单线程程序。主方法线程启动由Java 虚拟机负责，程序员负责启动自己的线程。代码如下:

public static void main(String[] args){
        new ThreadTest().start();

}

实现Runnable接口的语法如下：

public class Thread extends Object implements Runnable

实现Runnable 接口的程序会创建一个Thread对象，并将 Runnable 对象与Thread对象相关联。Thread类中有以下两个构造方法：

public Thread(Runnable target)
public Thread(Runnable target,String name)
这两个构造方法的参数中都存在Runnable 实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。

使用Runnable 接口启动新的线程的步骤如下：

建立Runnable对象
使用参数为Runnable对象的构造方法创建Thread实例
调用startO方法启动线程
通过Runnable 接口创建线程时，程序员首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象；接下来使用相应的构造方法创建Thread 实例；最后使用该实例调用Thread类中的startO方法启动线程。

子主题

一种能控制线程行为的方法是调用sleep()方法，sleep()方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。sleep()方法语法如下

try{
        Thread.sleep(2000);

}catch(InterruptedException e){
        e.printStackTrace(();

}

当某一个线程使用join()方法加入另外一个线程时，另一个线程会等待该线程执行完毕后再继续执行

以往有的时候会使用stop()方法停止线程，但当前版本的JDK早己废除了stop()方法，不建议使用stop()方法来停止一个线程的运行。现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

        如果线程是因为使用了slcep()或wait()方法进入了就绪状态，可以使用Thread 类中 interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。

        下面的实例演示了某个线程使用interrupted()方法，同时程序抛出了InterruptedException异常，在异常处理时结束了while 循环。在项目中，经常在这里执行关闭数据库连接和关闭Socket连接等操作。

Thread 类中提供了一种礼让方法，使用yield()方法表示，它只是给当前正处于运行状态的线程个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。

yield()方法使具有同样优先级的线程有进入可执行状态的机会，在当前线程放弃执行权时会再度回到就绪状体。对于支持多任务的操作系统来说，不需要调用yield()方法，因为操作系统会为线程自动分配CPU时间片来执行。

20.6.1  线程安全

20.6.2 线程同步机制

为了实现两台计算机的通信，必须用一个网络线路连接两台计算机。如下图所示

1.IP协议
IP是Internet Protocol的简称，是一种网络协议。Internet 网络采用的协议是TCP/IP协议，其全称是Transmission Control Protocol/Internet Protocol。Internet 依靠TCP/IP协议，在全球范围内实现了不同硬件结构、不同操作系统、不同网络系统间的互联。在Internet 网络上存在着数以亿计的主机，每台主机都用网络为其分配的 Internet 地址代表自己，这个地址就是I地址。到目前为止，I地址用4个字节，也就是32位的二进制数来表示，称为IPv4。为了便于使用，通常取用每个字节的十进制数，并且每个字节之间用圆点隔开来表示I地址，如192.168.1.1。现在人们正在试验使用16个字节来表示I地址，这就是IPv6，但IPv6还没有投入使用。

TCP/IP 模式是一种层次结构，共分为4层，分别为应用层、传输层、互联网层和网络层。各层实现特定的功能，提供特定的服务和访问接口，并具有相对的独立性，

2. TCP与UDP协议
在TCPAIP 协议栈中，有两个高级协议是网络应用程序编写者应该了解的，即传输控制协议(Transmission Control Protocol，TCP)与用户数据报协议（User Datagram Protocol， UDP）。

TCP 协议是一种以固接连线为基础的协议，它提供两台计算机间可靠的数据传送。TCP可以保证数据从一端送至连接的另一端时，能够确实送达，而且抵达的数据的排列顺序和送出时的顺序相同。因此，TCP协议适合可靠性要求比较高的场合。就像拨打电话，必须先拨号给对方，等两端确定连接后，相互才能听到对方说话，也知道对方回应的是什么。

HTTP、FTP 和Telnet 等都需要使用可靠的通信频道。例如，HTTP从某个URL读取数据时，如果收到的数据顺序与发送时不相同，可能就会出现一个混乱的HTML文件或是一些无效的信息。

UDP是无连接通信协议，不保证数据的可靠传输，但能够向若干个目标发送数据，或接收来自若干个源的数据。UDP以独立发送数据包的方式进行。这种方式就像邮递员送信给收信人，可以寄出很多信给同一个人，且每一封信都是相对独立的，各封信送达的顺序并不重要，收信人接收信件的顺序也不能保证与寄出信件的顺序相同。

UDP 协议适合于一些对数据准确性要求不高，但对传输速度和时效性要求非常高的网站，如网络聊天室、在线影片等。这是由于TCP协议在认证上存在额外耗费，可能使传输速度减慢，而UDP协议即使有一小部分数据包遗失或传送顺序有所不同，也不会严重危害该项通信。

一般而言，一台计算机只有单一的连到网络的物理连接（Physical Connection），所有的数据都通过此连接对内、对外送达特定的计算机，这就是端口。网络程序设计中的端口（port）并非真实的物理存在，而是一个假想的连接装置。端口被规定为一个在0~65535的整数。HTTP服务一般使用80端口,FTP 服务使用21端口。假如一台计算机提供了HTTP、FTP等多种服务，那么客户机会通过不同的端口来确定连接到服务器的哪项服务上

通常，0~1023的端口数用于一些知名的网络服务和应用，用户的普通网络应用程序应该使用1024以上的端口数，以避免端口号与另一个应用或系统服务所用端口冲突。

网络程序中的套接字（Socket）用于将应用程序与端口连接起来。套接字是一个假想的连接装置，就像插座一样可连接电器与电线，

21.2.1 InetAddress 类

21.2.2  ServerSocket 类

21.2.3  TCP网络程序设计

21.3.1DatagramPacket类

21.3.2 DatagramSocker 类

21.3.3 UDP网络程序设计