个人整理java期末笔记（黑马程序员第一章到第八章）

JAVA笔记

JAVA笔记

第一章___面对对象程序设计

1.1面对对象

概念：面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物，这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物，使用对象的关系来描述事物之间的联系，这种思想就是面向对象。

面对过程	面对对象
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了，即以函数为中心。	面向对象则是把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题，即以对象为中心。

1.1.1面对对象的特点

封装

封装是面向对象的核心思想，它将对象的属性和行为封装(隐藏)起来，不让外界知道具体实现细节。
继承

继承主要描述类与类之间的关系，通过继承，可以实现代码重用，还能对原有类的功能进行扩展。
多态

多态指的是在一个类中定义的属性和功能被其他类继承后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法，会呈现出不同的行为。

1.1.2类与对象

1.类的定义格式

 [修饰符] class 类名 [extends 父类名] [implements 接口名]{
          // 类体，包括类的成员变量和成员方法
    }

2.定义成员变量

    [修饰符] 数据类型 变量名 [ = 值];

    private String name;        // 声明一个String类型的name;
    private int age = 20;        // 定义一个int类型的age，并赋值为20；

3.声明成员方法

    [修饰符] [返回值类型] 方法名([参数类型 参数名1,参数类型 参数名2,...]){ 
          //方法体
          ...
          return 返回值; //当方法的返回值类型为void时，return及其返回值可以省略
    }

注意

在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。如果在某一个方法中定义的局部变量与成员变量同名，这种情况是允许的，此时方法中通过变量名访问到的是局部变量，而并非成员变量。

    public class Person {
          int age = 10;        // 类中定义的变量被称作成员变量
          void speak() {  
	int age = 30;  // 方法内部定义的变量被称作局部变量
	System.out.println(“我今年” + age + “岁了!”); //局部优先
          }
    }

1.1.2.1对象创建与使用

1.1.2.1.1对象创建的语法格式

    类名 对象名称 = new 类名();  //对象名称也称为对象引用

1.1.2.1.2对象创建的内存分配

在创建对象时，程序会占用两块内存区域，分别是栈内存和堆内存。其中Person类型的变量p被存放在栈内存中，它是一个引用，会指向真正的对象；通过new Person()创建的对象则放在堆内存中，这才是真正的对象。

Java将内存分为两种，即栈内存和堆内存。其中栈内存用于存放基本类型的变量和对象的引用变量（如Person p），堆内存用于存放由new创建的对象和数组。

1.1.2.1.3对象成员的调用

通过对象的引用来访问对象所有的成员
```
    对象引用.对象成员
```

直接使用创建的对象本身来引用对象成员

    new 类名().对象成员

对比说明

对比说明：第2种方式，创建的对象没有引用（名称），在创建后只能访问其中某一个成员，在完成某一个对象成员的访问后，该对象就会变成垃圾对象。第1种方式可以访问对象的多个成员。因此，在实际开发中，创建对象时，多数会使用对象引用。

成员变量的默认初值

成员变量类型	默认初值
byte、short、int、long	0
float、double	0.0
char	一个空字符，即’\u0000’
boolean	false
引用数据类型	null，表示变量不引用任何对象

1.对象的引用超出作用域

    {
         Person p1 = new Person();
         ......
    }

2.对象的引用重新指向空地址（null）

    {
         Person p2 = new Person();
         ......
         p2 = null;
         ......
    }

1.2访问控制符

在Java中，针对类、成员方法和属性提供了四种访问级别，分别是private、default、protected和public。

private（当前类访问级别）：如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。类的良好封装就是通过private关键字来实现的。
default（包访问级别）：如果一个类或者类的成员不使用任何访问控制符修饰，则称它为默认访问控制级别，这个类或者类的成员可以被本包中的其他类访问。
protected（子类访问级别）：如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制符修饰，那么这个类或者类的成员能被所有的类访问。

访问范围	private	default	protected	public
同一类中	🌙	🌙	🌙	🌙
同一包中		🌙	🌙	🌙
子类中			🌙	🌙
全局范围				🌙

1.3类的封装

定义：类的封装，是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问，而要通过该类所提供的方法间接访问。

class Person{
	String name;
	int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

1.3.1方法的重载

class Person{
    String name;
	int age;
	public void show()
    {
        System.out.println("show");
    }
    public void show(String name,int age)
    {
        System.out.println("show");
    }
}

1.3.2构造方法

1.3.2.1构造方法的定义

定义：构造方法（也被称为构造器）是类的一个特殊成员，它会在类实例化对象时被自动调用。

    [修饰符] 方法名 ([参数列表]){
           // 方法体
    }

构造方法的特殊性：

方法名与类名相同。
在方法名的前面没有返回值类型的声明。
在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

1.3.2.2构造方法的重载

定义：与普通方法一样，构造方法也可以重载：在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同即可。提倡重载构造方法。

说明：在创建对象时，可以通过调用不同的构造方法来为不同的属性进行赋值。

注意

在Java中的每个类都至少有一个构造方法。如果在一个类中没有显示地定义构造方法，系统会自动为这个类创建一个默认的无参构造方法。
构造方法被定义为private后，无法在类的外部被调用，也就无法通过该私有构造方法来创建对象。因此，构造方法通常会使用public来修饰。

1.4this关键字

1.4.1为什么要使用this关键字

加强程序的可读性，不会导致属性和局部变量的名称冲突，无法修改属性

1.4.2this关键字的三种常用方法

通过this调用成员变量

class Person{
    int age;
    public Person(int age)
    {
        this.age = age;
	}
}

this关键字调用成员方法

class Person{
    public void openMouth()
    {
        ;
	}
    public void speak()
    {
        this.openMouth();
	}
}

通过this调用构造方法

class Person{
    public Person(int age)
    {
       System.out.println("无参的构造方法被调用。。。");
	}
    public Person(int age)
    {
        this();
        System.out.println("有参的构造方法被调用。。。");
    }
}
public class Example11{
    public static void main(String[] args)
    {
        Person p = new Person(18);
    }
}

1.4.3使用this所需要注意的是

只能在构造方法中使用this调用其他的构造方法，不能在成员方法中使用。
在构造方法中，使用this调用构造方法的语句必须是该方法的第一条执行语句，且只能出现一次。
不能在一个类的两个构造方法中使用this互相调用。

1.5static关键字

为什么要使用static关键字

Java中的static关键字，用于修饰类的成员，如成员变量、成员方法以及代码块等，被static修饰的成员具备一些特殊性。比如被static关键字修饰的成员变量、方法可以被类直接访问，而不需要预先构造类的实例对象。

静态属性

在一个Java类中，可以使用static关键字来修饰属性，该属性被称作静态属性。
静态属性只有1份，被所有对象共享。非静态属性每个对象1份。
除了通过“引用.属性”的方式来访问外，可以使用“类名.属性”的形式来访问。
static关键字只能用于修饰成员变量，不能用于修饰局部变量，否则编译会报错。

静态方法

被static关键字修饰的方法称为静态方法。
同静态属性一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。
静态方法中只能访问用static修饰的成员，原因是静态方法没有this引用，非静态的成员隐式都是通过this在访问。

静态代码块

在Java中，使用一对大括号包围起来的若干行代码被称为一个代码块。
使用static关键字修饰的代码块称为静态代码块。
随着类被加载，静态代码块会执行，并且只会执行一次。
在程序中，经常使用静态代码块来对类的成员变量进行初始化。

1.6类的继承

定义：在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类或派生类，现有类被称作父类或基类，子类会自动拥有父类所有可继承的属性和方法。

    [修饰符] class 子类名 extends 父类名 {          //子类新增的属性、方法    }

注意

在Java中，只支持单重继承，不允许多重继承，也就是说一个类只能有一个直接父类。
```
    class A{}     class B{}    class C extends A,B{}  // C类不可以同时继承A类和B类
```

在Java中，多个类可以继承同一个父类。

    class A{}    class B extends A{}    class C extends A{}   // 类B和类C都可以继承类A

在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类。

    class A{}    class B extends A{}   // 类B继承类A，类B是类A的子类    class C extends B{}   // 类C继承类B，类C是类B的子类，同时也是类A的子类

在Java中，子类和父类是一种相对概念，也就是说，一个类是某个类的父类的同时，也可以是另一个类的子类。

继承中方法的重写

定义：在继承关系中，子类会自动继承父类中公共的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。

注意：

子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
子类重写父类方法时，方法的访问权限不能被削弱。

初始化顺序

父类和子类都可以有静态代码块、普通代码块、静态属性、普通属性和构造器，这些初始化是有顺序关系的。

初始化原则：

父类优先于子类、静态优先于非静态、属性优先于块。

1.6.1super关键字

问题：在继承关系中，当子类重写父类的方法后，子类对象将无法直接访问父类被重写的方法。

解决方法：在Java中专门提供了一个super关键字来访问父类的成员，例如访问父类的成员变量、成员方法和构造方法。

1.6.1.1super关键字——具体使用

使用super关键字调用父类的成员变量和成员方法。

    super.成员变量    super.成员方法([参数1,参数2...])

使用super关键字调用父类的构造方法。

    super([参数1,参数2...])

1.6.2Object类

在Java中提供了一个Object类，它是所有类的父类，即每个类都直接或间接继承自该类。

Object类通常被称之为超类、基类或根类。

当定义一个类时，如果没有使用extends关键字为这个类显示地指定父类，那么该类会默认继承Object类。

1.6.2.1Object类——常用方法

方法声明	功能描述
boolean equals(Object obj)	判断某个对象与此对象是否相等
final Class<?> getClass()	返回此Object的运行时类
int hashCode()	返回该对象的哈希码值
String toString()	返回该对象的字符串表示
void finalize()	垃圾回收器调用此方法来清理没有被任何引用变量所引用对象的资源

1.7final关键字

final关键字可用于修饰类、变量和方法，它有“不可更改”或者“最终”的含义。因此被final修饰的类、变量和方法将具有以下特性。

final修饰的类不能被继承
final修饰的方法不能被子类重写
final修饰的变量（成员变量和局部变量）是常量，只能赋值一次

1.8抽象类

1.8.1抽象类及抽象方法定义的语法格式：

    // 定义抽象类    [修饰符] abstract class 类名 {          // 定义抽象方法          [修饰符] abstract 方法返回值类型 方法名([参数列表]);          // 其他方法或属性 }

注意：包含抽象方法的类必须定义为抽象类，但抽象类中可以不包含任何抽象方法。另外，抽象类是不可以被实例化的，如果想调用抽象类中定义的抽象方法，需要创建一个子类，在子类中实现抽象类中的抽象方法。

1.9接口

定义：接口中除了抽象方法外，还可以有默认方法和静态方法（也叫类方法），默认方法使用default修饰，静态方法使用static修改，并且这两种方法都允许有方法体。

    [修饰符] interface 接口名 [extends 父接口1,父接口2,...] {          [public] [static] [final] 常量类型 常量名 = 常量值;          [public] [abstract] 方法返回值类型 方法名([参数列表]);          [public] default 方法返回值类型 方法名([参数列表]){	// 默认方法的方法体          }          [public] static 方法返回值类型 方法名([参数列表]){	// 类方法的方法体          }    }

1.9.1接口——语法定义说明

接口中可以包含三类方法，抽象方法、默认方法、静态方法。
静态方法可以通过“接口名.方法名”的形式来调用。
抽象方法和默认方法只能通过接口实现类的实例对象来调用。

接口的实现类，必须实现接口中的所有抽象方法。

    [修饰符] class 类名 [extends 父类名] [implements 接口1,接口2,...] {          ...    }

1.10多态

定义：在Java中，多态是指不同类的对象在调用同一个方法时所呈现出的多种不同行为。如，“彩色打印机”和“黑白打印机”的“打印”功能略有不同。

说明：通常来说，在一个类中定义的属性和方法被其他类继承或重写后，当把子类对象直接赋值给父类引用变量时，相同引用类型的变量调用同一个方法所呈现出的多种不同形态。
作用：通过多态，消除了类之间的耦合关系，大大提高了程序的可扩展性和可维护性

1.10.1多态概述

注意：Java的多态性是由类的继承、方法重写以及父类引用指向子类对象体现的。由于一个父类可以有多个子类，多个子类都可以重写父类方法，并且多个不同的子类对象也可以指向同一个父类。这样，程序只有在运行时程序才能知道具体代表的是哪个子类对象，这就体现了多态性（动态绑定）。

1.10.2对象的类型转换

向上转型：在多态的学习中，涉及到将子类对象当做父类类型使用的情况，此种情况在Java的中称为“向上转型”。

    Animal an1 = new Cat();     // 将Cat类对象当做Animal类型来使用    Animal an2 = new Dog();    // 将Dog类对象当做Animal类型来使用

注意：将子类对象当做父类使用时不需要任何显式的强制类型转换。还需要注意的是，此时不能通过父类变量去调用子类特有的方法。

类型判断：Java提供了一个关键字instanceof，它可以判断一个对象是否为某个类（或接口）的实例或者子类实例。

    对象（或者对象引用） instanceof 类（或接口）

向下转型：如果一个父类类型的对象引用实际引用的子类对象，则可以进行向下转型。

1.11内部类

在Java中，允许在一个类的内部定义类，这样的类称作内部类，这个内部类所在的类称作外部类。

内部类分类：成员内部类、局部内部类、静态内部类、匿名内部类

1.11.1局部内部类

定义：也叫做方法内部类，就是定义在某个局部范围中的类，它和局部变量一样，都是在方法中定义的，其有效范围只限于方法内部。

说明：在局部内部类中，局部内部类可以访问外部类的所有成员变量和方法，而局部内部类中的变量和方法却只能在创建该局部内部类的方法中进行访问。

1.11.2静态内部类

定义：所谓静态内部类，就是使用static关键字修饰的成员内部类。
说明：静态内部类在成员内部类前增加了static关键字，在功能上，静态内部类中只能访问外部类的静态成员，同时通过外部类访问静态内部类成员时，可以跳过外部类从而直接通过内部类访问静态内部类成员。

    外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名();

1.11.3匿名内部类

定义：匿名内部类其实就是没有名称的内部类，特别适合于创建那种只需要使用一次的类。
说明：在调用包含有接口类型参数的方法时，通常为了简化代码，可以直接通过匿名内部类的形式传入一个接口类型参数，在匿名内部类中直接完成方法的实现。

注意：从JDK 8开始，允许在局部内部类、匿名内部类中访问非final修饰的局部变量，而在JDK 8之前，局部变量前必须加final修饰符，否则程序编译报错。

    new 父接口(){        // 匿名内部类实现部分    }

1.12Lambda表达式

Lambda表达式是JDK 8中一个重要的新特性，它使用一个清晰简洁的表达式来表达一个接口，同时Lambda表达式也简化了对集合以及数组数据的遍历、过滤和提取等操作。

Lambda表达式主要用于只有一个抽象方法的接口（又称为函数式接口）实现，它把函数式接口作为一个方法的参数。

Lambda表达式基本语法格式：

    ([数据类型 参数名,数据类型 参数名,...]) -> {表达式主体}

1.13异常

Exception：称为异常类，它表示程序本身可以处理的错误。在Java程序开发中进行的异常处理，都是针对Exception类及其子类的。

Error：称为错误，表示Java运行时产生的系统内部错误或资源耗尽的错误，是比较严重的，仅靠修改程序本身是不能恢复执行的，例如系统崩溃，虚拟机错误等。

方法声明	功能描述
String getMessage()	返回此throwable的详细消息字符串
void printStackTrace()	将此throwable及其追踪输出至标准错误流
void printStackTrace(PrintStream s)	将此throwable及其追踪输出到指定的输出流

异常类型

编译时异常：在程序编译时期产生的异常，而这些异常必须要进行处理，也称为checked异常。

特点：编译时异常的特点是在程序编写过程中，Java编译器就会对编写的代码进行检查，如果出现比较明显的异常就必须对异常进行处理，否则程序无法通过编译。
运行时异常：这种异常即使不编写异常处理代码，依然可以通过编译，也称为unchecked异常。

特点：运行时异常是在程序运行时由Java虚拟机自动进行捕获处理的，即使没有使用try..catch语句捕获或使用throws关键字声明抛出，程序也能编译通过，只是在运行过程中可能报错。

Java中常见的运行时异常如下：

异常类名称	异常类说明
ArithmeticException,	算术异常
IndexOutOfBoundsException	角标越界异常
ClassCastException	类型转换异常
NullPointerException	空指针异常
NumberFormatException	数字格式化异常

1.13.1try...catch和finally

当程序发生异常时，会立即终止，无法继续向下执行。为了保证程序能够有效的执行，Java中提供了一种对异常进行处理的方式——异常捕获。

异常捕获try…catch语句的基本语法格式：

    try {         // 可能发生异常的语句    } catch(Exception类或其子类 e){         // 对捕获的异常进行相应处理    }

注意：在try{}代码块中，发生异常语句后面的代码是不会被执行的。

异常捕获try…catch...finally语句的基本语法格式：

    try {         // 可能发生异常的语句    } catch(Exception类或其子类 e){         // 对捕获的异常进行相应处理    } finally {         // 无论是否发生异常，此代码块代码总会执行}

1.13.2throws关键字

一般在程序开发中，开发者通常会意识到程序可能出现的问题，可以直接通过try...catch对异常进行捕获处理。但有些时候，方法中代码是否会出现异常，开发者并不明确或者并不急于处理，为此，Java允许将这种异常从当前方法中抛出，然后让后续的调用者在使用时再进行异常处理。

throws关键字抛出异常的基本语法格式：

    [修饰符] 返回值类型 方法名([参数类型 参数名1...]) throws 异常类1,异常类2,... {	// 方法体...    }

注意：当调用者在调用有抛出异常的方法时，除了可以在调用程序中直接进行try…catch异常处理外，也可以根据提示使用throws关键字继续将异常抛出，这样程序也能编译通过。但是，程序发生了异常，终究是需要进行处理的，如果没有被处理，程序就会非正常终止。

程序开发中，除了可以通过throws关键字抛出异常外，还可以使用throw关键字抛出异常。

throw关键字：throw关键字用于方法体内，并且抛出的是一个异常类对象。

throws关键字：throws关键字用在方法声明中，用来指明方法可能抛出的多种异常。

throw关键字

说明：通过throw关键字抛出异常后，还需要使用throws关键字或try…catch对异常进行处理。
注意：如果throw抛出的是Error、RuntimeException或它们的子类异常对象，则无需使用throws关键字或try…catch对异常进行处理。

throw关键字抛出异常的基本语法格式：

    [修饰符] 返回值类型 方法名([参数类型 参数名,...]) throws 抛出的异常类 {            // 方法体...            throw new Exception类或其子类构造方法;}

1.13.3自定义异常

Java中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况，例如在设计divide()方法时不允许被除数为负数

解决方法：Java允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。

第二章___Java常用类

2.1字符串类

字符串是指一连串的字符，这些字符必须包含在一对英文双引号(“”)中。
Java提供了String、StringBuilder和StringBuffer三个类来封装字符串，并提供了一系列操作字符串的方法。这三个类都位于java.lang包中，因此不需要导包就可以直接使用。

2.1.1 String类

2.1.1.1 String类的初始化——初始化方式

使用字符串常量直接初始化

    String 引用名= 字符串;    String str1 = null;    // 初始化为空    String str2 = "";      // 初始化为空字符串    String str3 = "abc";  // 初始化为abc,其中abc为字符串常量

使用String的构造方法初始化

    String 引用名 = new String(实参列表);

String类中常用的构造方法：

方法声明	功能描述
String()	创建一个内容为空的字符串
String(String value)	根据指定的字符串内容创建对象
String(char[] value)	根据指定的字符数组创建对象

String类的常用操作

方法声明	功能描述
int indexOf(int ch)	返回指定字符在此字符串中第一次出现处的索引
int lastIndexOf(int ch)	返回指定字符在此字符串中最后一次出现处的索引
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现处的索引
int lastIndexOf(String str)	返回指定子字符串在此字符串中最后一次出现处的索引
char charAt(int index)	返回字符串中index位置上的字符，其中index的取值范围是：0~（字符串长度-1）
boolean endsWith(String suffix)	判断此字符串是否以指定的字符串结尾
int length()	返回此字符串的长度
boolean equals(Object anObject)	将此字符串与指定的字符串比较
boolean isEmpty()	当且仅当字符串长度为0时返回true
boolean startsWith(String prefix)	判断此字符串是否以指定的字符串开始
boolean contains(CharSequence cs)	判断此字符串中是否包含指定的字符序列

方法声明	功能描述
String toLowerCase()	使用默认语言环境的规则将String中的所有字符都转换为小写
String toUpperCase()	使用默认语言环境的规则将String中的所有字符都转换为大写
static String valueOf(int i)	返回 int 参数的字符串表示形式
char[] toCharArray()	将此字符串转换为一个字符数组
String replace(CharSequence oldstr, CharSequence newstr)	返回一个新的字符串，它是通过用newstr替换此字符串中出现的所有oldstr得到的
String[] split(String regex)	根据参数regex（regex是一个正则表达式，用来限定分隔规则）将字符串分割为若干个子字符串
String substring(int beginIndex)	返回一个新字符串，它包含从指定的beginIndex起始角标处开始，直到此字符串末尾的所有字符
String substring(int beginIndex, int endIndex)	返回一个新字符串，它包含从指定的beginIndex起始角标处开始，直到索引endIndex-1角标处的所有字符
String trim()	返回一个新字符串，它去除了原字符串首尾的空格

注意

字符串中的字符有索引，字符的索引也是从0开始的且小于字符串长度。如果字符的索引不合法，则会发生StringIndexOutOfBoundsException（字符串角标越界异常）。

    String s = "abcde";     System.out.println(s.charAt(10)); /*访问字符串中的字符时，不能超出字符的索引范围，否则会出现异常，这与数组中的角标越界异常相似。*/

2.1.2StringBuffer

在Java中，由于String类是final类型的，所以使用String定义的字符串是一个常量，因此它一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串。String类的操作中，所有改变了字符串内容的操作(所有返回类型是String的方法)，都是生成了新的字符串。
解决方法：可以使用StringBuffer类（也称字符串缓冲区）来操作字符串。
说明：StringBuffer类和String类最大的区别在于它的内容和长度都是可以改变的。StringBuffer类似一个字符容器，当在其中添加或删除字符时，所操作的都是这个字符容器，因此并不会产生新的StringBuffer对象。

方法声明	功能描述
StringBuffer append(char c)	添加字符到StringBuffer对象中末尾
StringBuffer insert(int offset,String str)	在StringBuffer对象中的offset位置插入字符串str
StringBuffer deleteCharAt(int index)	移除StringBuffer对象中指定位置的字符
StringBuffer delete(int start,int end)	删除StringBuffer对象中指定范围的字符或字符串
StringBuffer replace(int start,int end,String s)	将StringBuffer对象中指定范围的字符或字符串用新的字符串s进行替换
void setCharAt(int index, char ch)	修改指定位置index处的字符
String toString()	返回StringBuffer缓冲区中的字符串对象
StringBuffer reverse()	将此StringBuffer对象用其反转形式取代

StringBuffer类和String类的对比分析如下：

String类定义的字符串是常量，一旦创建后，内容和长度都是无法改变的。StringBuffer表示字符容器，其内容和长度可以随时修改。
String类重写了Object类的equals()方法，而StringBuffer类没有重写Object类的equals()方法。

2.1.3StringBuilder

除了使用StringBuffer外，JDK 1.5之后提供了一个StringBuilder类。
主要区别：二者所不同的是StringBuffer是线程安全的，而StringBuilder没有实现线程安全功能，所以性能略高。通常情况下，如果创建一个内容可变的字符串对象，应该优先考虑StringBuilder类。

2.2System类与Runtime类

2.2.1System类

常用方法介绍

getProperties()

该方法用于获取当前系统的全部属性该方法会返一个Properties对象，其中封装了系统的所有属性，这些属性是以键值对形式存在的。

currentTimeMillis()

该方法返回一个long类型的值，该值表示当前时间与1970年1月1日0点0分0秒之间的时间差，单位是毫秒，通常也将该值称作时间戳。

arraycopy()

该方法用于将一个数组中的元素快速拷贝到另一个数组。
src：表示源数组；

dest：表示目标数组；

srcPos：表示源数组中拷贝元素的起始位置；

destPos：表示拷贝到目标数组的起始位置；

length：表示拷贝元素的个数。

2.2.2Runtime类

定义：Runtime类用于表示Java虚拟机运行时的状态，它用于封装Java虚拟机进程。Runtime类采用单例模式设计
说明：每次使用“java”命令启动Java虚拟机时都会对应一个Runtime实例，并且只有一个实例，应用程序会通过该实例与其运行时的环境相连。

    Runtime run = Runtime.getRuntime();

注意：Runtime类中提供了一个exec()方法，该方法用于执行一个DOS命令，从而实现和在命令行窗口中输入DOS命令同样的效果。

2.3Math类与Ramdom类

2.3.1Math类

Math类是一个工具类，主要用于完成复杂的数学运算，如求绝对值、三角函数、指数运算等。
由于Math类的构造方法被定义成private，因此无法创建Math类的对象。
Math类中的所有方法都是静态方法，可以直接通过类名来调用它们。
除静态方法外，Math类中还有两个静态常量PI和E，分别代表数学中的π和e。

2.3.2Ramdom类

在JDK的java.util包中，有一个Random类，它可以在指定的取值范围内随机产生数字。

Random类的两个构造方法：

方法声明	功能描述
Random()	构造方法，用于创建一个随机数生成器，每次实例化Random对象会生成不同的随机数
Random(long seed)	构造方法，使用一个long型的seed（种子）创建伪随机数生成器，当seed相同时，每次实例化Random对象会生成相同的随机数

4.3.2 Random类——常用方法

方法声明	功能描述
boolean nextBoolean()	随机生成boolean类型的随机数
double nextDouble()	随机生成double类型的随机数
float nextFloat()	随机生成float类型的随机数
int nextInt()	随机生成int类型的随机数
int nextInt(int n)	随机生成[0,n)之间int类型的随机数
long nextLong()	随机生成long类型的随机数

2.4包装类

基本类型——包装类对照表：

基本数据类型	对应的包装类
byte	Byte
char	Character
int	Integer
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

自动装箱（Autoboxing）：是指将基本数据类型的变量赋给对应的包装类变量；
自动拆箱（AutoUnboxing）：是指将包装类对象类型直接赋给一个对应的基本数据类型变量。

基本数据类型、基本数据包装类以及字符串之间的相互转换：

通过引String类的valueOf()方法可以将8种基本数据类型转换为对应的字符串，或者用字符串连接操作；
通过8种包装类的静态方法valueOf()既可以将对应的基本数据类型转换为包装类，也可以将与变量内容匹配的字符串转换为对应的包装类（Character包装类除外）；
通过8种包装类的有参构造方法同样既可以将对应的基本数据类型转换为包装类，也可以将与变量内容匹配的字符串转换为对应的包装类（Character包装类除外）；
通过8种包装类的静态方法parseXxx()可以将与变量内容匹配的字符串转换为对应的基本数据类型；
包装类都重写了Object类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。

注意使用valueOf(String s)和parseXxx(String s)方法注意事项：

valueOf(String s)方法，可以根据String类型的参数创建包装类对象，但参数字符串s不能为null，而且字符串的内容必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会有异常。
```
    Integer i = Integer.valueOf("123");       // 合法    Integer i = Integer.valueOf("12a");      // 不合法
```
parseXxx(String s) 方法，可以将字符串转换为对应的基本类型的数据。但参数s不能为null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时会有异常。

    int i = Integer.parseInt("123");             // 合法        Integer in = Integer.parseInt("itcast");  // 不合法

2.5日期与时间类

2.5.1Date类

在JDK的java.util包中，提供了一个Date类用于表示日期和时间。
随着JDK版本的不断升级和发展，Date类中大部分的构造方法和普通方法都已经过时了。
目前JDK 8中，Date类只有两个构造方法是可以使用的。
Date()：用来创建当前日期时间的Date对象。
Date(long date)：用于创建指定时间的Date对象，其中date参数表示1970年1月1日0时0分0（称为历元）以来的毫秒数，即时间戳。

2.5.2 Calendar类

Calendar类用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分和秒等。

Calendar类是一个抽象类，不可以被实例化。

在程序中需要调用其静态方法getInstance()来得到一个Calendar对象，然后才能调用其相应的方法。

    Calendar calendar = Calendar.getInstance();

Calendar类——常用方法

方法声明	功能描述
int get(int field)	返回指定日历字段的值
void add(int field,int amount)	根据日历规则，为指定的日历字段增加或减去指定的时间量
void set(int field,int value)	为指定日历字段设置指定值
void set(int year,int month,int date)	设置Calendar对象的年、月、日三个字段的值
void set(int year.int month,int date,int hourOfDay,int minute,int second)	设置Calendar对象的年、月、日、时、分、秒六个字段的值

Calendar日历宽松模式与非宽松模式

Calendar有两种解释日历字段的模式——lenient模式（宽松模式）和non-lenient模式（非宽松模式）。当Calendar处于lenient模式时，它的字段可以接收超过允许范围的值，当调用get(int field)方法获取某个字段值时，Calendar会重新计算所有字段的值，将字段的值标准化。

2.6格式化类

2.6.1 格式化类——DateFormat类

作用：DateFormat类专门用于将日期格式化为字符串或者将用特定格式显示的日期字符串转换成一个Date对象。
说明：DateFormat是一个抽象类，不能被直接实例化，但它提供了一系列的静态方法来获取DateFormat类的实例对象，并能调用其他相应的方法进行操作。

方法声明	功能描述
static DateFormat getDateInstance()	用于创建默认语言环境和格式化风格的日期格式器
static DateFormat getDateInstance(int style)	用于创建默认语言环境和指定格式化风格的日期格式器
static DateFormat getDateTimeInstance()	用于创建默认语言环境和格式化风格的日期/时间格式器
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	用于创建默认语言环境和指定格式化风格的日期/时间格式器
String format(Date date)	将一个 Date 格式化为日期/时间字符串。
Date parse(String source)	将给定字符串解析成一个日期

2.6.2 格式化类—— SimpleDateFormat类

在使用DateFormat对象的parse()方法将字符串解析为日期时，需要输入固定格式的字符串，这显然不够灵活。为了能够更好地格式化日期、解析字符串，Java中提供了一个SimpleDateFormat类。
说明：SimpleDateFormat类是DateFormat类的子类，它可以使用new关键字创建实例对象。在创建实例对象时，它的构造方法需要接收一个表示日期格式模板的字符串参数。

使用SimpleDateFormat类将日期对象以特定的格式转为字符串形式：

    SimpleDateFormat sdf = new SimpleDateFormat(  		                   "Gyyyy年MM月dd日：今天是yyyy年的第D天，E");     System.out.println(sdf.format(new Date()));

使用SimpleDateFormat类将一个指定日期格式的字符串解析为Date对象：

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");    String str = "2018/01/27";    System.out.println(sdf.parse(str));

第三章___集合

3.1集合概述

定义：Java中的集合就像一个容器，专门用来存储Java对象。
说明：集合对象可以是任意的数据类型，并且长度可变。
注意：这些集合类都位于java.util包中，在使用时一定要注意导包的问题。

3.2____Collection

Collection接口——主要方法

方法声明	功能描述
boolean add(Object o)	向集合中添加一个元素
boolean addAll(Collection c)	将指定集合c中的所有元素添加到该集合中
void clear()	删除该集合中的所有元素
boolean remove(Object o)	删除该集合中指定的元素
boolean removeAll(Collection c)	删除该集合中包含指定集合c中的所有元素
boolean isEmpty()	判断该集合是否为空
boolean contains(Object o)	判断该集合中是否包含某个元素
boolean containsAll(Collection c)	判断该集合中是否包含指定集合c中的所有元素
Iterator iterator()	返回在该集合的元素上进行迭代的迭代器（Iterator），用于遍历该集合所有元素
int size()	获取该集合元素个数
Stream stream()	将集合源转换为有序元素的流对象（JDK 8新方法）

3.2.1____List

定义：List接口继承自Collection接口，是单列集合的一个重要分支，习惯性的会将实现了List接口的对象称为List集合。

特点：
List集合中允许出现重复元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引（类似于数组中的元素角标）来访问集合中的元素。
List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致。

方法声明	功能描述
void add(int index,Object element)	将元素element插入在List集合的指定索引位置
boolean addAll(int index,Collection c)	将集合c包含的所有元素插入到List集合的指定索引位置
Object get(int index)	返回集合索引index处的元素
Object remove(int index)	删除index索引处的元素
Object set(int index, Object element)	将索引index处元素替换成element元素，并将替换后的元素返回
int indexOf(Object o)	返回对象o在List集合中首次出现的位置索引
int lastIndexOf(Object o)	返回对象o在List集合中最后一次出现的位置索引
List subList(int fromIndex, int toIndex)	返回从索引fromIndex（包括）到 toIndex（不包括）处所有元素集合组成的子集合
Object[] toArray()	将集合元素转换为数组
default void sort(Comparator<? super E> c)	根据指定的比较器规则对集合元素排序（JDK 8新方法）

3.2.2____ ArrayList集合

说明：

ArrayList是List接口的一个实现类，它是程序中最常见的一种集合。

ArrayList内部的数据存储结构是数组形式。

特点：
由于ArrayList的存储结构，在增加或删除指定位置的元素时，会创建新的数组，效率比较低，因此不适合做大量的增删操作。
这种数组结构允许程序通过索引的方式来访问元素，使用ArrayList集合在遍历和查找元素时显得非常高效。

ArrayList创建

ArrayList list = new ArrayList();list.add("stu1");                    list.add("stu2");System.out.println("集合的长度：" + list.size()); System.out.println("第2个元素是：" + list.get(1));

3.2.3____ LinkedList集合

说明：

LinkedList是List接口的另一个实现类。
LinkedList内部包含有两个Node类型的first和last属性的双向循环链表结构。

特点：

由于LinkedList的存储结构， LinkedList集合对于元素的遍历和查找效率较低。

LinkedList集合对于元素的增删操作表现出很高的效率。

3.2.3.2____LinkedList集合——双向循环链表结构

方法声明	功能描述
void add(int index, E element)	在此列表中指定的位置插入指定的元素。
void addFirst(Object o)	将指定元素插入集合的开头
void addLast(Object o)	将指定元素添加到集合的结尾
Object getFirst()	返回集合的第一个元素
Object getLast()	返回集合的最后一个元素
Object removeFirst()	移除并返回集合的第一个元素
Object removeLast()	移除并返回集合的最后一个元素
boolean offer(Object o)	将指定元素添加到集合的结尾
boolean offerFirst(Object o)	将指定元素添加到集合的开头
boolean offerLast(Object o)	将指定元素添加到集合的结尾

3.2.3.3____LinkedList集合——特有方法

方法声明	功能描述
void add(int index, E element)	在此列表中指定的位置插入指定的元素。
void addFirst(Object o)	将指定元素插入集合的开头
void addLast(Object o)	将指定元素添加到集合的结尾
Object getFirst()	返回集合的第一个元素
Object getLast()	返回集合的最后一个元素
Object removeFirst()	移除并返回集合的第一个元素
Object removeLast()	移除并返回集合的最后一个元素
boolean offer(Object o)	将指定元素添加到集合的结尾
boolean offerFirst(Object o)	将指定元素添加到集合的开头
boolean offerLast(Object o)	将指定元素添加到集合的结尾

方法声明	功能描述
Object peek()	获取集合的第一个元素
Object peekFirst()	获取集合的第一个元素
Object peekLast()	获取集合的最后一个元素
Object poll()	移除并返回集合的第一个元素
Object pollFirst()	移除并返回集合的第一个元素
Object pollLast()	移除并返回集合的最后一个元素
void push(Object o)	将指定元素添加到集合的开头
Object pop()	移除并返回集合的第一个元素

LinkedList创建

LinkedList link = new LinkedList();  link.add("stu1");link.add("stu2");link.offer("offer");                    // 向集合尾部追加元素link.push("push");                  // 向集合头部添加元素Object object = link.peek();   //获取集合第一个元素link.removeFirst();                 // 删除集合第一个元素link.pollLast();                        // 删除集合最后一个元素

3.3____Set接口

3.3.1____Set接口简介

3.3.2____HashSet接口

说明：HashSet是Set接口的一个实现类，它所存储的元素不可重复，并且无序。
特点：当向HashSet集合中添加一个元素时，首先会调用该元素的hashCode()方法来确定元素的存储位置，然后再调用元素对象的equals()方法来确保该位置没有重复元素。

    HashSet set = new HashSet();      set.add("Jack");                     set.add("Eve");    ...    set.forEach(o -> System.out.println(o));

当向集合中存入元素时，为了保证HasheSet正常工作，要求在存入对象时，需要重写Object类中的hashCode()和equals()方法。

3.3.3____TreeSet集合

说明： TreeSet是Set接口的另一个实现类，它内部采用平衡二叉树来存储元素，来保证TreeSet集合中没有重复的元素，并且可以对元素进行排序。
定义：二叉树就是每个节点最多有两个子节点的有序树，每个节点及其子节点组成的树称为子树，左侧的节点称为“左子树”，右侧的节点称为“右子树”，其中左子树上的元素小于它的根结点，而右子树上的元素大于它的根结点。

添加元素：向TreeSet中依次添加13、8、17、17、1、11、15、25元素

结构说明:同一层的元素可分为1个根节点元素和2个子节点元素，左边的元素总是小于右边的元素。

【存储原理】

TreeSet集合没有元素时，新增的第1个元素会在二叉树最顶层；
接着新增元素时，首先会与根节点元素比较；
如果小于根节点元素就与左边的分支比较；
如果大于根节点元素就与右边的分支比较；
以此类推。

【存储过程】

将元素13个放在二叉树的最顶端；

之后存入的元素与13比较，如果小于13就将该元素放左子树上，如果大于13，就将该元素放在右子树上；

当二叉树中已经存入一个17的元素时，再向集合中存入一个为17的元素时，TreeSet会将重复的元素去掉。
以此类推。

3.3.3.1____特有方法

方法声明	功能描述
Object first()	返回TreeSet集合的首个元素
Object last()	返回TreeSet集合的最后一个元素
Object lower(Object o)	返回TreeSet集合中小于给定元素的最大元素，如果没有返回null
Object floor(Object o)	返回TreeSet集合中小于或等于给定元素的最大元素，如果没有返回null
Object higher(Object o)	返回TreeSet集合中大于给定元素的最小元素，如果没有返回null
Object ceiling(Object o)	返回TreeSet集合中大于或等于给定元素的最小元素，如果没有返回null
Object pollFirst()	移除并返回集合的第一个元素
Object pollLast()	移除并返回集合的最后一个元素

3.4____Map接口

3.4.1____简介

方法声明	功能描述
void put(Object key, Object value)	向Map集合中添加指定键值映射的元素
int size()	返回Map集合键值对映射的个数
Object get(Object key)	返回指定键所映射的值，如果此映射不包含该键的映射关系，则返回null
boolean containsKey(Object key)	查看Map集合中是否存在指定的键对象key
boolean containsValue(Object value)	查看Map集合中是否存在指定的值对象value
Object remove(Object key)	删除并返回Map集合中指定键对象Key的键值映射元素
void clear()	清空整个Map集合中的键值映射元素
Set keySet()	以Set集合的形式返回Map集合中所有的键对象Key

方法声明	功能描述
Collection values()	以Collection集合的形式返回Map集合中所有的值对象Value
Set<Map.Entry<Key,Value>> entrySet()	将Map集合转换为存储元素类型为Map的Set集合
Object getOrDefault(Object key, Object defaultValue)	返回Map集合指定键所映射的值，如果不存在则返回默认值defaultValue（JDK 8新方法）
void forEach(BiConsumer action)	通过传入一个函数式接口对Map集合元素进行遍历（JDK 8新方法）
Object putIfAbsent(Object key, Object value)	向Map集合中添加指定键值映射的元素，如果集合中已存在该键值映射元素，则不再添加而是返回已存在的值对象Value（JDK 8新方法）
boolean remove(Object key, Object value)	删除Map集合中键值映射同时匹配的元素（JDK 8新方法）
boolean replace(Object key, Object value)	将Map集合中指定键对象Key所映射的值修改为value（JDK 8新方法）

3.4.2____HashMap集合

说明：HashMap集合是Map接口的一个实现类，它用于存储键值映射关系，该集合的键和值允许为空，但键不能重复，且集合中的元素是无序的。
特点：HashMap底层是由哈希表结构组成的，其实就是“数组+链表”的组合体，数组是HashMap的主体结构，链表则主要是为了解决哈希值冲突而存在的分支结构。正因为这样特殊的存储结构，HashMap集合对于元素的增、删、改、查操作表现出的效率都比较高。

在哈希表结构中，主体结构为图中水平方向的数组结构，其长度称为HashMap集合的容量（capacity）；
数组结构垂直对应的是链表结构，链表结构称为一个桶（bucket），每个桶的位置在集合中都有对应的桶值，用于快速定位集合元素添加、查找时的位置。

3.4.3____TreeMap集合

介绍： TreeMap集合是Map接口的另一个实现类，在TreeMap内部是通过二叉树的原理来保证键的唯一性，这与TreeSet集合存储的原理一样，因此TreeMap中所有的键是按照某种顺序排列的。
说明：为了实现TreeMap元素排序，可以参考TreeSet 集合排序方式，使用自然排序和定制排序。

3.5____ Iterator遍历集合

定义：Iterator接口是Java集合框架中的一员，主要用于迭代访问（即遍历）Collection中的元素，因此Iterator对象也被称为迭代器。

    Iterator iterator = list.iterator();     while (iterator.hasNext()) {                   Object obj = iterator.next();   // 取出ArrayList集合中的元素          System.out.println(obj);    }

3.5.1____Map集合遍历

3.5.1.1____keySet()方法

遍历思路：先将Map集合中所有键对象转换为Set单列集合，接着将包含键对象的Set集合转换为Iterator接口对象，然后遍历Map集合中所有的键，再根据键获取相应的值。

    Set keySet = map.keySet();           // 获取键的集合    Iterator it = keySet.iterator();          // 迭代键的集合    while (it.hasNext()) {          Object key = it.next();          Object value = map.get(key);  // 获取每个键所对应的值          System.out.println(key + ":" + value);    }

3.5.1.2____entrySet()方法

遍历思路：将原有Map集合中的键值对作为一个整体返回为Set集合，接着将包含键值对对象的Set集合转换为Iterator接口对象，然后获取集合中的所有的键值对映射关系，再从映射关系中取出键和值。

    Set entrySet = map.entrySet();    Iterator it = entrySet.iterator();                 // 获取Iterator对象    while (it.hasNext()) {          Map.Entry entry = (Map.Entry) (it.next());          Object key = entry.getKey();              // 获取Entry中的键          Object value = entry.getValue();        // 获取Entry中的值          System.out.println(key + ":" + value);    }

3.6____ foreach遍历集合

定义：foreach循环是一种更加简洁的for循环，也称增强for循环，用于遍历数组或集合中的元素。

    for(容器中元素类型 临时变量 ：容器变量) {            // 执行语句    }////////////////举例/////////////////    for (Object obj : list) {	           System.out.println(obj);    } 	    }

注意：

foreach循环遍历集合和数组时，只能访问集合中的元素，不能对其中的元素进行修改。
Iterator迭代器对集合中的元素进行迭代时，如果调用了集合对象的remove()方法删除元素，会出现ConcurrentModificationException异常。

3.4.2____forEach遍历集合
```
    Iterator it = list.iterator();    it.forEachRemaining(obj -> System.out.println("迭代集合元素："+obj));
```

3.7____泛型

定义：泛型可以限定操作的数据类型，在定义集合类时，可以使用“<参数化类型>”的方式指定该集合中存储的数据类型。

语法：以ArrayList集合为例

    ArrayList<参数化类型> list = new ArrayList<参数化类型>();    ArrayList<参数化类型> list = new ArrayList<参数化类型>();

3.8____ 常用工具类

说明：Java提供了一个工具类专门用来操作集合，这个类就是Collections，它位于java.util包中。
Collections类中提供了大量的静态方法用于对集合中元素进行排序、查找和修改等操作。

方法声明	功能描述
static boolean addAll(Collection<? super T> c, T... elements)	将所有指定元素添加到指定集合c中
static void reverse(List list)	反转指定List集合中元素的顺序
static void shuffle(List list)	对List集合中的元素进行随机排序
static void sort(List list)	根据元素的自然顺序对List集合中的元素进行排序
static void swap(List list,int i,int j)	将指定List集合中角标i处元素和j处元素进行交换

3.8.2____查找、替换操作——常用方法

方法声明	功能描述
static int binarySearch(List list,Object key)	使用二分法搜索指定对象在List集合中的索引，查找的List集合中的元素必须是有序的
static Object max(Collection col)	根据元素的自然顺序，返回给定集合中最大的元素
static Object min(Collection col)	根据元素的自然顺序，返回给定集合中最小的元素
static boolean replaceAll(List list,Object oldVal,Object newVal)	用一个新值newVal替换List集合中所有的旧值oldVal

3.8.3____Arrays工具类

第四章I/O流

4.1____I/O流概述

定义：I/O（Input/Output）流，即输入/输出流，是Java中实现输入/输出的基础，它可以方便地实现数据的输入/输出操作。

说明：
InputStream和OutPutStream是字节流，而Reader和Writer是字符流；
InputStream和Reader是输入流，而OutPutStream和Writer是输出流；
图中的4个顶级类都是抽象类，并且是所有流类型的父类。

4.2____字节流

4.2.1____字节流概述

定义：在计算机中，无论是文本、图片、音频还是视频，所有文件都是以二进制（字节）形式存在的，I/O流中针对字节的输入/输出提供了一系列的流，统称为字节流。

说明：
字节流是程序中最常用的流。
在JDK中，所有的字节输入流都继承自InputStream，所有的字节输出流都继承自OutputStream。

说明： InputStream被看成一个输入管道，OutputStream被看成一个输出管道，数据通过InputStream从源设备输入到程序，通过OutputStream从程序输出到目标设备，从而实现数据的传输。

4.2.1.1____ InputStream的常用方法

方法声明	功能描述
int read()	从输入流读取一个8位的字节，把它转换为0~255之间的整数，并返回这一整数。当没有可用字节时，将返回-1
int read(byte[] b)	从输入流读取若干字节，把它们保存到参数b指定的字节数组中，返回的整数表示读取字节的数目
int read(byte[] b,int off，int len)	从输入流读取若干字节，把它们保存到参数b指定的字节数组中，off指定字节数组开始保存数据的起始下标，len表示读取的字节数目
void close()	关闭此输入流并释放与该流关联的所有系统资源

说明：
前三个read()方法都是用来读数据的，分按字节读取和按字节数组读取。
进行I/O流操作时，应该调用close()方法关闭流，从而释放当前I/O流所占的系统资源。

4.2.1.2____ OutputStream的常用方法

方法声明	功能描述
void write(int b)	向输出流写入一个字节
void write(byte[] b)	把参数b指定的字节数组的所有字节写到输出流
void write(byte[] b,int off,int len)	将指定byte数组中从偏移量off开始的len个字节写入输出流
void flush()	刷新此输出流并强制写出所有缓冲的输出字节
void close()	关闭此输出流并释放与此流相关的所有系统资源

说明：

前三个write()方法都是用来写数据的，分按字节读取和按字节数组写入。
flush()方法用来将当前输出流缓冲区（通常是字节数组）中的数据强制写入目标设备，此过程称为刷新。
close()方法是用来关闭流并释放与当前IO流相关的系统资源。

4.2.1.3____InputStream与OutputStream的继承体系

4.2.2____字节流读写文件

说明：
针对文件的读写操作，JDK专门提供了两个类，分别是FileInputStream和FileOutputStream。
FileInputStream是InputStream的子类，它是操作文件的字节输入流，专门用于读取文件中的数据。
从文件读取数据是重复的操作，因此需要通过循环语句来实现数据的持续读取

    FileInputStream in = new FileInputStream("test.txt");    int b = 0;    while((b=in.read()) != -1){          System.out.println(b);     }    in.close();

注意:

在读取文件数据时，必须保证文件在相应目录存在并且是可读的，否则会抛出FileNotFoundException。

示例

    FileOutputStream out = new FileOutputStream("out.txt");    String str = "hello";    out.write(str.getBytes());    out.close();///////////////////////////////////////    finally{          try{                if(in!=null)       in.close();          }catch(Exception e){	e.printStackTrace();          }          try{	if(out!=null)     out.close();          }catch(Exception e){	e.printStackTrace();          }    }

4.2.3____文件的拷贝

说明：I/O流通常都是成对出现的，即输入流和输出流一起使用。例如文件的拷贝就需要通过输入流来读取源文件中的数据，并通过输出流将数据写入新文件。

示例

    FileInputStream in = new FileInputStream("source/src.jpg");    FileOutputStream out = new FileOutputStream("target/dest.jpg");    int len = 0;    long beginTime = System.currentTimeMillis();    while ((len = in.read()) != -1) {			            out.write(len);    }    long endTime = System.currentTimeMillis();    System.out.println("花费时间为："+(endTime-beginTime) +"毫秒");    in.close();    out.close();

4.2.4____字节流的缓冲区

假设从北京运送快递到上海，如果有一万件
快递，一件一件的运送就必须运输一万次，这样
的效率显然非常低。为了减少运输次数，可以先
把一批快递装在一个车厢中，这样就可以成批的运送快递，这时的车厢就相当于一个临时缓冲区。
同理：在文件拷贝过程中，通过以字节形式逐个拷贝，效率也非常低。为此，可以定义一个字节数组缓冲区，在拷贝文件时，就可以一次性读取多个字节的数据。

示例（使用字节流缓冲区拷贝文件）：

    FileInputStream in = new FileInputStream("source/src.jpg");    FileOutputStream out = new FileOutputStream("target/dest.jpg");    int len = 0;    byte[] buff = new byte[1024];    long beginTime = System.currentTimeMillis();    while ((len = in.read(buff)) != -1) {          out.write(buff,0,len);    }    long endTime = System.currentTimeMillis();    System.out.println("花费时间为："+(endTime-beginTime) +"毫秒");    in.close();    out.close();

4.2.5____字节缓冲流

说明：除了定义字节缓冲区来提高文件拷贝效率外，IO中还提供了两个字节缓冲流来提高文件拷贝效率：BufferedInputStream和BufferedOutputStream。它们的构造方法中分别接收InputStream和OutputStream类型的参数作为对象，在读写数据时提供缓冲功能。

示例（使用字节缓冲流拷贝文件）：

    BufferedInputStream bis = new BufferedInputStream(				new FileInputStream("source/src.jpg"));    BufferedOutputStream bos = new BufferedOutputStream(			                new FileOutputStream("target/dest.jpg"));    int len = 0;    long beginTime = System.currentTimeMillis();    while ((bis.read()) != -1) {            bos.write(len);    }    long endTime = System.currentTimeMillis();    System.out.println("花费时间为："+(endTime-beginTime) +"毫秒");    bis.close();    bos.close();

4.3____字符流

4.3.1____字符流概述

说明：除了字节流，JDK还提供了用于实现字符操作的字符流，同字节流一样，字符流也有两个抽象的顶级父类，分别是Reader和Writer。

4.3.2____字符流操作文件

说明：想从文件中直接读取字符便可以使用字符输入流FileReader，通过此流可以从文件中读取一个或一组字符。

示例（逐个字符读取文件）：

    FileReader fileReader = new FileReader("reader.txt");    int len = 0;    while ((len = fileReader.read()) != -1) {          System.out.print((char)len);    }    fileReader.close();

4.3.3____转换流

说明：在JDK中，提供了两个类用于实现将字节流转换为字符流，它们分别是InputStreamReader和OutputStreamWriter。
InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符。
OutputStreamWriter是Writer的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符。
转换流操作文件示意图：

示例:使用转换流拷贝文件

    FileInputStream in = new FileInputStream("reader.txt");    InputStreamReader isr = new InputStreamReader(in);    BufferedReader br = new BufferedReader(isr);     FileOutputStream out = new FileOutputStream("writer.txt");    OutputStreamWriter osw = new OutputStreamWriter(out);    BufferedWriter bw = new BufferedWriter(osw);     String line = null;    while ((line = br.readLine()) != null) {          bw.write(line);           bw.newLine();    }    br.close();    bw.close();

4.4____File类

说明：File类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径，也可以是相对于当前目录而言的相对路径。封装的路径可以指向一个文件，也可以指向一个目录，在File类中提供了针对这些文件或目录的一些常规操作。

File类常用构造方法：

方法声明	功能描述
File(String pathname)	通过指定的一个字符串类型的文件路径来创建一个新的File对象
File(String parent,String child)	根据指定的一个字符串类型的父路径和一个字符串类型的子路径（包括文件名称）创建一个File对象
File(File parent,String child)	根据指定的File类的父路径和字符串类型的子路径（包括文件名称）创建一个File对象

4.4.1____File类的常用方法

方法声明	功能描述
boolean exists()	判断File对象对应的文件或目录是否存在，若存在则返回ture，否则返回false
boolean delete()	删除File对象对应的文件或目录，若成功删除则返回true，否则返回false
boolean createNewFile()	当File对象对应的文件不存在时，该方法将新建一个此File对象所指定的新文件，若创建成功则返回true，否则返回false
String getName()	返回File对象表示的文件或文件夹的名称
String getPath()	返回File对象对应的路径
String getAbsolutePath()	返回File对象对应的绝对路径（在Unix/Linux等系统上，如果路径是以正斜线/开始，则这个路径是绝对路径；在Windows等系统上，如果路径是从盘符开始，则这个路径是绝对路径）
String getParent()	返回File对象对应目录的父目录（即返回的目录不包含最后一级子目录）
boolean canRead()	判断File对象对应的文件或目录是否可读，若可读则返回true，反之返回false
boolean canWrite()	判断File对象对应的文件或目录是否可写，若可写则返回true，反之返回false
boolean isFile()	判断File对象对应的是否是文件（不是目录），若是文件则返回true，反之返回false

方法声明	功能描述
boolean isFile()	判断File对象对应的是否是文件（不是目录），若是文件则返回true，反之返回false
boolean isDirectory()	判断File对象对应的是否是目录（不是文件），若是目录则返回true，反之返回false
boolean isAbsolute()	判断File对象对应的文件或目录是否是绝对路径
long lastModified()	返回1960年1月1日0时0分0秒到文件最后修改时间的毫秒值
long length()	返回文件内容的长度
String[] list()	列出指定目录的全部内容，只是列出名称
String[] list(FilenameFilter filter)	接收一个FilenameFilter参数，通过该参数可以只列出符合条件的文件
File[] listFiles()	返回一个包含了File对象所有子文件和子目录的File数组

示例（对当前目录下的txt文件进行操作）：

    File file = new File("example.txt");       System.out.println("文件名称:" + file.getName());    System.out.println("文件的相对路径:" + file.getPath());    System.out.println("文件的绝对路径:" + file.getAbsolutePath());    System.out.println("文件的父路径:" + file.getParent());    System.out.println(file.canRead() ? "文件可读" : "文件不可读");    System.out.println(file.canWrite() ? "文件可写": "文件不可写");    System.out.println(file.isFile() ?  "是一个文件" :"不是一个文件");    System.out.println(file.isDirectory()? "是一个目录":"不是一个目录");    System.out.println(file.isAbsolute() ? "是绝对路径": "不是绝对路径");    System.out.println("最后修改时间为:" + file.lastModified());    System.out.println("文件大小为:" + file.length() + " bytes");    System.out.println("是否成功删除文件"+file.delete());

4.4.2____遍历目录下的文件

说明：File类中提供了一个重载的list(FilenameFilter filter)方法，该方法接收一个FilenameFilter接口类型的参数，其中定义了一个抽象方法accept(File dir,String name)用于依次对指定File的所有子目录或文件进行迭代。

示例：

    File file = new File("F:\\Java基础入门\\workspace\\chapter06");    if (file.isDirectory()) {          String[] fileNames = file.list((dir,name) -> name.endsWith(".txt"));          Arrays.stream(fileNames)                    .forEach(f -> System.out.println(f));    }

4.4.3____删除文件及目录

【注意】：Java中删除目录的操作是通过Java虚拟机直接删除而不走回收站的，文件一旦删除就无法恢复。

    public static void main(String[] args){          File files = new File("D:\\test\\新建文件夹");          deleteDir(files);    }    public static void deleteDir(File files) {          File[] listFiles = files.listFiles();          for (File file : listFiles) {              if(file.isDirectory()){                    deleteDir(file);              }               file.delete();          }          files.delete();}

4.5____RandomAccesseFile

说明：在IO包中，提供了一个RandomAccesseFile类，它不属于流类，但具有读写文件数据的功能，可以随机从文件的任何位置开始并以指定的操作权限（如只读、可读写等）执行读写数据的操作。

RandomAccesseFile类构造方法：

方法声明	功能描述
RandomAccessFile(File file,String mode)	使用参数file指定被访问的文件，并使用mode来指定访问模式
RandomAccessFile(String name,String mode)	使用参数name指定被访问文件的路径，并使用mode来指定访问模式

4.6____对象序列化

程序在运行过程中，可能需要将一些数据永久的保存到磁盘上，而数据在Java中都是保存在对象当中的。那么我们要怎样将对象中的数据保存到磁盘上呢？这时就需要使用Java中的对象序列化。

定义：对象的序列化（Serializable）是指将一个Java对象转换成一个I/O流中字节序列的过程。

目的：为了将对象保存到磁盘中，或允许在网络中直接传输对象。
说明：
对象序列化可以使内存中的Java对象转换成与平台无关的二进制流；
既可以将这种二进制流持久地保存在磁盘上，又可以通过网络将这种二进制流传输到另一个网络节点；
其他程序在获得了这种二进制流后，还可以将它恢复成原来的Java对象；
这种将I/O流中的字节序列恢复为Java对象的过程被称之为反序列化（Deserialize）。

说明：想让某个对象支持序列化，那么这个对象所在的类必须是可序列化的。在Java中，可序列化的类必须实现Serializable或Externalizable两个接口之一。

示例（通过Serializable接口实现对象序列化）：

    public class Person implements Serializable {          // 为该类指定一个serialVersionUID变量值          private static final long serialVersionUID = 1L;          //声明变量          private int id;          private String name;          private int age;          // 此处省略各属性的getter和setter方法          ...    }

第五章___GUI

5.1____Swing概述

什么是AWT？

定义：在早期JDK1.0发布时，Sun公司就为GUI开发提供了一套基础类库，这套类库被称为AWT（Abstract Window Toolkit），即抽象窗口工具包。

目的：AWT的起初设想就是为了统一实现不同操作系统的图像界面。
缺陷：
不同操作系统图形库的功能可能不一样，在一个平台上存在的功能在另外一个平台上则可能不存在，为此AWT不得不通过牺牲功能来实现平台无关性。
AWT是一个重量级组件，使用麻烦，设计出的图形界面不够美观且功能有限。

什么是Swing？

定义：Swing是在原有的AWT的基础上进行了补充和改进，提供了更加丰富的组件和功能，来满足GUI设计的一切需求。

说明：
Swing是一种轻量级组件，它由Java语言开发，同时底层以AWT为基础。
同AWT相比，在实际开发中，更多的是使用Swing进行图形用户界面开发。
Swing组件为实现图形用户界面提供了很多基础类库，多数位于java.awt、javax.swing包及其子包下。

Swing组件继承关系：

说明：
Swing组件的所有类都继承自Container类，然后根据GUI开发的功能扩展了2个主要分支：容器分支（包括Window窗口和Panel面板）和组件分支。
容器分支就是为了实现图形用户界面窗口容器而设计的。
组件分支则是为了实现向容器中填充数据、元素以及人机交互组件等功能。
Swing组件类中，常用的顶级容器类包括有JApplet、JFrame和JDialog。
常用组件AbstractButton类及其子类是用来定义按钮常见行为的工具类。
JTextComponent类及其子类就是用来定义文本内容编辑区域的工具类。

5.2____Swing顶级容器

5.2.1____JFrame

说明：

在Swing组件中，最常见的一个容器就是JFrame。
JFrame是一个独立存在的顶级容器（也叫窗口），不能放置在其他容器之中。
JFrame支持通用窗口所有的基本功能，例如窗口最小化、设定窗口大小等。\

示例

    private static void createAndShowGUI() {          // 创建并设置JFrame容器窗口          JFrame frame = new JFrame("JFrameTest");          // 设置关闭窗口时的默认操作          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);            frame.setSize(250, 150);     // 设置窗口尺寸          frame.setVisible(true);         // 展示JFrame容器窗口    }    public static void main(String[] args) {          //使用SwingUtilities工具类调用createAndShowGUI()方法显示GUI程序          SwingUtilities.invokeLater(Example01::createAndShowGUI);    }

5.2.2____JDialog

说明：

JDialog是Swing的另外一个顶级容器，通常用来表示对话框窗口。
JDialog对话框可分为两种：模态对话框和非模态对话框。

常用构造方法：

方法声明	功能描述
JDialog(Frame owner)	构造方法，用来创建一个非模态的对话框，owner为对话框所有者（顶级窗口JFrame）
JDialog(Frame owner，String title)	构造方法，创建一个具有指定标题的非模态对话框
JDialog(Frame owner，boolean modal)	创建一个有指定模式的无标题对话框，默认值false（即非模态对话框）

示例:

    private static void createAndShowGUI() {              JFrame frame = new JFrame("JFrameTest");          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);          frame.setSize(350, 150);          frame.setVisible(true);          JDialog dialog = new JDialog(frame, "JDialog对话框",true);          dialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);          dialog.setSize(200, 100);          dialog.setVisible(true);    }    public static void main(String[] args) {          SwingUtilities.invokeLater(Example02::createAndShowGUI);    }

5.3____布局管理器

说明：Swing组件不能单独存在，必须放置于容器当中，而组件在容器中的位置和尺寸是由布局管理器来决定的。

分类：

5.3.1____BorderLayout

说明：
BorderLayout（边界布局管理器）是一种较为复杂的布局方式，它将容器划分为五个区域，分别是页头（PAGE_START）、页尾（PAGE_END）、行首（LINE_START）、行尾（LINE_END）、中部（CENTER）。
组件可以被放置在这五个区域中的任意一个位置。
官方布局效果图：

5.3.2____FlowLayout

说明：
FlowLayout（流式布局管理器）是最简单的布局管理器。
在这种布局下，容器会将组件按照添加顺序从左向右放置，当到达容器的边界时，会自动将组件放到下一行的开始位置。
这些组件可以按左对齐、居中对齐（默认方式）或右对齐的方式排列。

构造方法：

方法声明	功能描述
FlowLayout()	组件默认居中对齐，水平、垂直间距默认为5个单位
FlowLayout(int align)	指定组件相对于容器的对齐方式，水平、垂直间距默认为5个单位
FlowLayout(int align,int hgap,int vgap)	指定组件的对齐方式和水平、垂直间距

说明：
参数align决定组件在每行中相对于容器边界的对齐方式，分别为左对齐、右对齐、居中对齐。
对齐方式可以使用该类中提供的常量FlowLayout.LEFT、FlowLayout.RIGHT、FlowLayout.CENTER表示。
参数hgap和参数vgap分别设定组件之间的水平和垂直间距，可以填入一个任意数值。

5.3.3____GridLayout

GridLayout（网格布局管理器）使用纵横线将容器分成n行m列大小相等的网格，每个网格中可以添加一个组件。
添加到容器中的组件会从左向右、从上向下依次填充到网格中。
与FlowLayout不同的是，放置在GridLayout布局管理器中的组件将自动占据网格的整个区域

构造方法：

方法声明	功能描述
GridLayout()	默认只有一行，每个组件占一列
GridLayout(int rows,int cols)	指定容器的行数和列数
GridLayout(int rows,int cols,int hgap,int vgap)	指定容器的行数和列数以及组件之间的水平、垂直间距

说明：参数rows代表行数，cols代表列数，hgap和vgap规定窗格之间水平和垂直方向的间距。

5.4____事件处理

5.4.1____事件处理机制

定义：Swing组件中的事件处理专门用于响应用户的操作，例如，响应用户的单击鼠标、按下键盘等操作。
Swing事件处理涉及的三类对象：

5.4.1.1____主要步骤

1、创建事件源

2、自定义事件监听器

3、为事件源注册监听器

5.4.2____Swing常用事件处理

窗体事件（WindowEvent）
鼠标事件（MouseEvent）
键盘事件（KeyEvent）
动作事件（ActionEvent）

5.5____Swing常用组件

5.5.1____面板组件

说明：Swing组件中供了一些面板组件（中间容器），这些面板组件不能单独存在，只能放置在顶级窗口容器中。
常见组件：

5.5.1.1____JScrollPane常用构造方法

方法声明	功能描述
JScrollPane()	创建一个空的JScrollPane面板
JScrollPane(Component view)	创建一个显示指定组件的JScrollPane面板，只要组件的内容超过视图大小就会显示水平和垂直滚动条
JScrollPane(Component view,int vsbPolicy,int hsbPolicy)	创建一个显示指定容器、并具有指定滚动条策略的JScrollPane。参数vsbPolicy和hsbPolicy分别表示垂直滚动条策略和水平滚动条策略

说明：第三个构造方法，是在第二个构造方法的基础上指定滚动条策略。如果在构造方法中没用指定显示组件和滚动条策略，也可以使用JScrollPane提供的方法进行设置。

5.5.1.2____JScrollPane设置面板滚动策略的方法

方法声明	功能描述
void setHorizontalBarPolicy(int policy)	指定水平滚动条策略，即水平滚动条何时显示在滚动面板上
void setVerticalBarPolicy(int policy)	指定垂直滚动条策略，即垂直滚动条何时显示在滚动面板上
void setViewportView(Component view)	设置在滚动面板显示的组件

说明：
上述表格方法是JScrollPane滚动面板组件对象提供的设置滚动策略的方法。

滚动策略方法取值可以使用ScrollPaneConstants接口中声明了多个常量属性来进行设置。

5.5.2____文本组件

定义：文本组件用于接收用户输入的信息，包括文本框（JTextField）、文本域（JTextArea）等。
说明：它们都有一个共同父类JTextComponent，JTextComponent是一个抽象类。

常用方法：

方法声明	功能描述
String String getText()	返回文本组件中所有的文本内容
String getSelectedText()	返回文本组件中选定的文本内容
void selectAll()	在文本组件中选中所有内容
void setEditable()	设置文本组件为可编辑或者不可编辑状态
void setText(String text)	设置文本组件的内容
void replaceSelection(String content)	用给定的内容替换当前选定的内容

5.5.2.1____ JTextField

定义：JTextField称为文本框，它只能接收单行文本的输入。
常用构造方法：

方法声明	功能描述
JTextField()	创建一个空的文本框，初始字符串为null
JTextFiled(int columns)	创建一个具有指定列数的文本框，初始字符串为null
JTextField(String text)	创建一个显示指定初始字符串的文本框
JTextField(String text,int column)	创建一个具有指定列数、并显示指定初始字符串的文本框

说明：
JTextField有一个子类JPasswordField，表示一个单行输入密码框。

在此框中是通过显示指定的回显字符作为占位符。

新创建的密码框默认的回显字符为“*”。

5.5.2 .2____JTextArea

定义：JTextArea称为文本域，它能接收多行文本的输入，使用JTextArea构造方法创建对象时可以设定区域的行数、列数。

常用构造方法：

方法声明	功能描述
JTextArea()	构造方法，创建一个空的文本域
JTextArea(String text)	构造方法，创建显示指定初始字符串的文本域
JTextArea(int rows,int columns)	构造方法，创建具有指定行和列的空的文本域
JTextArea(String text,int rows,int columns)	构造方法，创建显示指定初始文本并指定了行列的文本域

5.5.3____标签组件

定义：Swing中提供了用于仅供展示的标签组件。
说明：标签组件主要用到的是JLabel，JLabel组件可以显示文本、图像，还可以设置标签内容的垂直和水平对齐方式。
构造方法：

方法声明	功能描述
JLabel()	创建无图像并且其标题为空字符串的JLabel
JLabel(Icon image)	创建具有指定图像的JLabel实例
JLabel(Icon image, int horizontalAlignment)	创建具有指定图像和水平对齐方式的JLabel实例
JLabel(String text)	创建具有指定文本的JLabel实例
JLabel(String text, Icon icon, int horizontalAlignment)	创建具有指定文本、图像和水平对齐方式的 JLabel 实例
JLabel(String text, int horizontalAlignment)	创建具有指定文本和水平对齐方式的 JLabel 实例

5.5.4____按钮组件

说明：在Swing中常见的按钮组件有JButton、JCheckBox、JRadioButton等，它们都是抽象类AbstractButton类的直接或间接子类。

AbstractButton常用方法：

方法声明	功能描述
Icon getIcon()	获取按钮的图标
void setIcon(Icon icon)	设置按钮的图标
String getText()	获取按钮的文本
void setText(String text)	设置按钮的文本
void setEnable(boolean b)	设置按钮是否可用
boolean setSelected(boolean b)	设置按钮是否为选中状态
boolean isSelected()	返回按钮的状态（true为选中，反之为未选中）

5.5.4.1____JCheckBox

说明：JCheckBox组件被称为复选框组件，它有选中和未选中两种状态，通常复选框会有多个，用户可以选中其中一个或者多个。
常用构造方法：

方法声明	功能描述
JCheckBox()	创建一个没有文本信息，初始状态未被选中的复选框
JCheckBox(String text)	创建一个带有文本信息，初始状态未被选定的复选框
JCheckBox(String text,boolean selected)	创建一个带有文本信息，并指定初始状态（选中/未选中）的复选框

说明：除了上述构造方法，还可以调用从父类继承的setText(String text)来设置复选框文本信息，调用setSelected(boolean b)方法来设置复选框状态（是否被选中），也可以调用isSelected()方法来判断复选框是否被选中。。

5.5.4.1____JRadioButton

说明：JRadioButton组件被称为单选按钮组件，单选按钮只能选中一个。
使用：
要JRadioButton按钮之间的互斥，需要使用ButtonGroup类。
ButtonGroup是一个不可见的单选按钮组。将多个JRadioButton按钮添加到同一个单选按钮组中就能实现JRadioButton按钮的单选功能。
常用构造方法：

方法声明	功能描述
JRadioButton ()	创建一个没有文本信息、初始状态未被选中的单选框
JRadioButton (String text)	创建一个带有文本信息、初始状态未被选定的单选框
JRadioButton (String text,boolean selected)	创建一个具有文本信息，并指定初始状态（选中/未选中）的单选框。

5.5.5____下拉框组件

定义：
JComboBox组件被称为下拉框或者组合框，它将所有选项折叠在一起，默认显示的是第一个添加的选项。
当用户单击下拉框时，会出现下拉式的选择列表，用户可以从中选择其中一项并显示。

说明：
JComboBox下拉框组件分为可编辑和不可编辑两种形式。

对于不可编辑的下拉框，用户只能选择现有的选项列表。

对于可编辑的下拉框，用户既可以选择现有的选项列表，也可以自己输入新的内容。

注意：自己输入的内容只能作为当前项显示，并不会添加到下拉框的选项列表中。

JComboBox常用构造方法：

方法声明	功能描述
JComboBox()	创建一个没有可选项的下拉框
JComboBox(Object[] items)	创建一个下拉框，将Object数组中的元素作为下拉框的下拉列表选项
JComboBox(Vector items)	创建一个下拉框，将Vector集合中的元素作为下拉框的下拉列表选项

JComboBox常用方法：

方法声明	功能描述
void addItem(Object anObject)	为下拉框添加选项
void insertItemAt(Object anObject,int index)	在指定的索引处插入选项
Objct getItemAt(int index)	返回指定索引处选项，第一个选项的索引为0
int getItemCount()	返回下拉框中选项的数目
Object getSelectedItem()	返回当前所选项
void removeAllItems()	删除下拉框中所有的选项
void removeItem(Object object)	从下拉框中删除指定选项
void removeItemAt(int index)	移除指定索引处的选项
void setEditable(boolean aFlag)	设置下拉框的选项是否可编辑，aFlag为true则可编辑，反之则不可编辑

5.5.6____菜单组件

说明：
计算机中很多文件的菜单都是下拉式的，如记事本的菜单。
在Swing中，创建下拉式菜单需要使用三个组件：JMenuBar（菜单栏）、JMenu（菜单）和JMenuItem（菜单项）。
图示（以记事本为例）：

5.5.6.1____JMenuBar（菜单栏）

JMenuBar表示一个水平的菜单栏，它用来管理一组菜单，不参与同用户的交互式操作。
菜单栏可以放在容器的任何位置，但通常情况下会使用顶级容器（如JFrame、Jdialog）的setJMenuBar()方法将它放置在顶级容器的顶部。
创建菜单栏时，只需要使用new关键字创建JMenubar对象即可。
创建完菜单栏对象后，可以调用它的add(JMenu c)方法为其添加JMenu菜单。

5.5.6.2____JMenu（菜单）

JMenu表示一个菜单，它用来整合管理菜单项。
菜单可以是单一层次的结构，也可以是多层次的结构。
大多情况下，会使用JMenu(String text)构造函数创建JMenu菜单，参数text表示菜单上的文本内容。

方法声明	功能描述
JMenuItem add(JMenuItem menuItem)	将菜单项添加到菜单末尾，返回此菜单项
void addSeparator()	将分隔符添加到菜单的末尾
JMenuItem getItem(int pos)	返回指定索引处的菜单项，第一个菜单项的索引为0
int getItemCount()	返回菜单上的项数，菜单项和分隔符都计算在内
JMenuItem insert(JmenuItem menuItem,int pos)	在指定索引处插入菜单项
void insertSeparator(int pos)	在指定索引处插入分隔符
void remove(int pos)	从菜单中移除指定索引处的菜单项
void remove(JMenuItem menuItem)	从菜单中移除指定的菜单项
void removeAll()	从菜单中移除所有的菜单项

5.5.6.3____JMenuItem（菜单项）

JMenuItem表示一个菜单项，它是菜单系统中最基本的组件。
通常会使用JMenumItem(String text)这个构造方法为菜单项指定文本内容。
JMenuItem继承自AbstractButton类，因此可以把它看成是一个按钮。
如果使用无参的构造方法创建了一个菜单项，则可以调用从AbstractButton类中继承的setText(String text)方法和setIcon()方法为其设置文本和图标。

203101405026_吴晓丽

posted @ 2022-01-11 21:04 YRJQD 阅读(83) 评论(0) 收藏举报

刷新页面返回顶部