JDK25 API文档

Chapter 07 面向对象编程(基础)

可变参数

  • 可变参数的使用:

    可变参数示例:

    1
    2
    3
    4
    5
    6
    /**
    * 实现多个参数求和
    */
    public int sum(int... nums){
    //方法体
    }

    代码解读:

    1.int… 表示接收的是可变参数,类型是int,可以接收多个int类型参数。

    2.使用可变参数时,可以当作数组来使用。

    3.遍历nums求和。

  • 注意事项和使用细节:

    1.可变参数的实参可以为数组。

    2.可变参数的本质就是数组。

    3.可变参数可以和普通类型的参数一起放在形参列表,但是需要保证可变参数在最后。

    1
    2
    3
    4
    5
    6
    /**
    * 示例
    */
    public void f(String str,double... nums){
    //方法体
    }

    4.一个形参列表中只能出现一个可变参数。

作用域

  • 作用域的基本使用:

    1.局部变量:一般指在成员方法中定义的变量,是除了属性之外的其他变量,作用域为定义它的代码块中。局部变量赋值后才可以使用,即无默认值。

    2.全局变量:即属性,作用域为整个类体。全局变量可以不赋值,直接使用(默认值)。

  • 注意事项和使用细节:

    1.属性和局部变量可以重名,访问时遵循就近原则。

    2.在同一个作用域中,两个局部变量不能重名。

    3.属性生命周期较长:伴随对象;局部变量生命周期较短:伴随代码块。

    4.属性不仅可以被本类使用,也可以被其他类使用(通过对象调用);局部变量只能在本类的对应方法中使用。

    5.属性可以加修饰符,局部变量不可以加修饰符。

构造方法/构造器

基本语法:

[修饰符] 方法名(形参列表){

​ 方法体;

}

说明:

1.构造器的修饰符可以默认。

2.构造器没有返回值。

3.方法名必须和类的名字一致。

4.参数列表的规则和成员方法相同。

5.构造器的调用由系统完成。

主要作用:完成对新对象的初始化。

  • 快速入门:

    示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    /**
    * 创建Person对象时,就直接指定这个对象的年龄和姓名
    */
    public class Example{
    public static void main(String[] args){
    //当我们创建一个对象时,直接通过构造器指定名字和年龄
    Person p1 = new Person("Smith",80);
    }
    }

    class Person{
    String name;
    int age;
    public Person(String pName,int pAge){
    name = pName;
    age = pAge;
    }
    }

    解读:

    1.构造器没有返回值**(也不能返回void类型)**

  • 注意事项和使用细节:

    1.一个类可以定义多个不同的构造器,即构造器的重载。

    2.构造器是完成对象的初始化的,不是创造对象。

    3.创建对象时,系统自动的调用该类的构造方法。

    4.如果程序员没有定义构造器,系统会自动给类生成一个默认无参构造器(也叫默认构造器)。

    5.一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非自己显式定义无参构造器。

    无参构造器语法:

    方法名(){

    }

对象创建的流程分析

案例:

1
2
3
4
5
6
7
8
9
class Person{
int age = 90;
String name;
Person(String n,int a){
name = n;
age = a;
}
}
Person p = new Person("小明",20);
  • 流程分析:

    1.加载Person类信息(Person.class),只会加载一次。

    2.在堆中分配空间(地址)。

    3.完成对象初始化:

    • 默认初始化。(age = 0,name = null)
    • 显式初始化。(age = 90,name = null)
    • 构造器的初始化。(age = 20,name = 小明)

    4.将对象在堆中的地址返回给p(p是对象名,也可以理解为对象的引用)。

this关键字

this代表当前对象。

  • 注意事项和使用细节:

    1.this关键字可以用来访问本类的属性、方法、构造器。

    2.this用于区分当前类的属性和局部变量。

    3.this关键字访问成员方法的语法:

    this.方法名(参数列表);

    4.this关键字访问构造器的语法:只能在构造器中访问另一个构造器,不可以在普通方法中使用。

    this(参数列表);

    该语句要使用,则必须放在构造器的第一句。

    5.this不能在类定义的外部使用,只能在类定义的方法中使用。

Chapter 08 面向对象编程(中级)

包

  • 作用:

    1.区分相同名字的类。

    2.当类很多时,可以很好的管理类。

    3.控制访问范围。

基本语法:

package 包名;

  • 本质:创建不同文件夹来保存类文件。

  • 包的命名:

    1.命名规则:只能包含数字、字母、下划线、小圆点,但不能用数字开头,不能是关键字或保留字。

    2.命名规范:一般是小写字母+小圆点

    com.公司名.项目名.业务模块名

  • 常用的包:

    1.java.lang.*:是基本包,默认引入。

    2.java.util.*:系统提供的工具包、工具类。

    3.java.net.*:网络包,网络开发。

    4.java.awt.*:做java的界面开发,GUI。

  • 如何引入包:

    语法:

    import 包;

    示例:

    import java.util.Scanner; 只是引入Scanner类。

    import java.util.*; 将java.util包的所有类都引入。

  • 注意事项和使用细节:

    1.package的作用是声明当前类所在的包,需要放在class的最上面,一个类中最多只有一句package。

    2.import指令放在package下面,在类定义前面,可以有多句且没有顺序要求。

访问修饰符

  • 基本介绍:用于控制方法和属性(成员变量)的访问权限(范围)。

    1.公开级别:用public修饰,对外公开。

    2.受保护级别:用protected修饰,对子类和同一个包中的类公开。

    3.默认级别:没有修饰符号,向同一个包的类公开。

    4.私有级别:用private修饰,只有类本身可以访问,不对外公开。

  • 4种访问修饰符的访问范围:

    访问级别 访问控制修饰符 同类 同包 子类 不同包
    公开 public √ √ √ √
    受保护 protected √ √ √ ×
    默认 没有修饰符 √ √ × ×
    私有 private √ × × ×
  • 使用的注意事项:

    1.修饰符可以用来修饰类中的属性、成员方法以及类。

    2.只有默认和public才能修饰类,并且遵守上述访问权限的特点。

    3.成员方法的访问规则和属性完全一样。

封装

  • 优点:

    1.隐藏实现细节。

    2.可以对数据进行验证,保证安全合理。

  • 封装实现的步骤:

    1.将属性进行私有化**(不能直接修改属性)**。

    2.提供一个公共的set方法,用于对属性判断并赋值。

    如果使用构造器且需要验证属性,则可以在构造器中使用set方法。

    public void setXxx(类型 参数名){ //Xxx表示某个属性

    ​ //加入数据验证的业务逻辑

    ​ 属性 = 参数名;

    }

    3.提供一个公共的get方法,用于获取属性的值。

    public XX getXxx{ //权限判断

    ​ return xx;

    }

继承

  • 基本介绍:

    继承可以解决代码复用。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类(基类)。在父类(基类)中定义这些相同的属性和方法,所有的子类(派生类)不需要重新定义这些属性和方法,只需要通过extends来声明继承父类(基类)即可。

  • 基本语法:

    class 子类 extends 父类{

    }

  • 注意事项和使用细节:

    1.子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访问(可以间接访问),要通过父类提供公共的方法(get方法)去访问。

    2.子类必须调用父类的构造器,完成父类的初始化。

    3.当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器。如果父类没有提供无参构造器,则必须在子类的构造器中用super(参数列表)去指定使用父类的哪个构造器完成对父类的初始化工作,否则编译不会通过。

    4.如果希望指定去调用父类的某个构造器,则显式调用super()。

    5.super在使用时,必须放在构造器第一行。(super只能在构造器中使用)

    6.super()和this()都只能放在构造器第一行,因此这两个方法不能共存在一个构造器中。

    7.Java所有类都是Object类的子类。

    8.父类构造器的调用不限于直接父类,将一直往上追溯直到Object类。

    9.子类最多只能直接继承一个父类,即Java中是单继承机制。

    10.不能滥用继承,子类和父类之间必须满足is-a的逻辑关系。

  • 本质分析:按照查找关系来返回信息

    1.首先看子类是否有该属性。

    2.如果子类有这个属性,并且可以访问,则返回信息;如果子类没有这个属性,则看父类有没有这个属性(如果父类有该属性,并且可以访问,则返回信息)。

    3.如果父类没有该属性,则按照2的规则,继续找上级父类,直到Object类。

    如果在查找过程中找到了该属性,但是无法访问,则直接报错。

super关键字

  • 基本介绍:

    super代表父类的引用,用于访问父类的属性、方法、构造器。

  • 基本语法:

    1.访问父类的属性,但不能访问父类的private属性。

    super.属性名;

    2.访问父类的方法,不能访问父类的private方法。

    super.方法名(参数列表);

    3.访问父类的构造器(只能放在构造器的第一句)。

    super(参数列表);

  • 注意事项和使用细节:

    1.当子类中有和父类中成员(属性和方法)重名时,为了访问父类的成员,必须通过super。如果没有重名,使用super(直接查找父类)、this(先查找本类)、直接访问是一样的。

    2.super的访问不限于直接父类,如果间接父类和本类中有同名的成员,也可以用super去访问间接父类的成员。如果多个基类中都有同名成员,使用super访问时,遵循就近原则。(也要遵守访问权限的相关规则)

super和this的比较

区别点 this super
访问属性 访问本类中的属性,如果本类没有此属性,则从父类中继续查找。 访问父类中的属性。
调用方法 访问本类中的方法,如果本类没有此方法,则从父类中继续查找。 直接访问父类中的方法。
调用构造器 调用本类构造器,必须放在构造器的首行。 调用父类构造器,必须放在子类构造器的首行。
特殊 表示当前对象。 子类中访问父类对象。

方法重写/覆盖

子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的那个方法。

  • 注意事项和使用细节:

    1.子类的方法的形参列表、方法名称要和父类方法的形参列表、方法名称完全一样。

    2.子类方法的返回类型和父类方法的返回类型一样,或者是父类返回类型的子类。

    3.子类方法不能缩小父类方法的访问权限(可以扩大)。

方法重写和重载的比较

名称 发生范围 方法名 形参列表 返回类型 修饰符
重载(overload) 本类 必须一样 类型、个数或者顺序,至少有一个不同 无要求 无要求
重写(override) 父、子类 必须一样 必须相同 子类重写的方法返回的类型和父类返回的类型一致,或者是其子类 子类方法不能缩小父类方法的访问范围

多态

  • 基本介绍:

    方法或对象具有多种形态,建立在封装和继承的基础之上。

  • 具体体现:

    1.方法的多态。(重写和重载均体现多态)

    2.对象的多态。

    • 一个对象的编译类型和运行类型可以不一致。
    • 编译类型在定义对象时就确定了,不能改变。
    • 运行类型是可以变化的。
    • 编译类型看定义时=的左边,运行类型看=的右边。
  • 多态的向上转型:

    1.本质:父类的引用指向了子类的对象。

    2.语法:

    父类类型 引用名 = new 子类类型();

    3.特点:

    • 编译类型看左边,运行类型看右边。

    • 可以调用父类中的所有成员(需遵循访问权限)。

    • 不能调用子类中的特有成员。

      在编译阶段,能调用哪些成员是由编译类型来决定的。

    • 最终运行效果看子类(运行类型)的具体实现,即调用方法时,按照从子类开始查找方法(根据运行类型),然后调用,规则与方法调用规则一致。

  • 多态的向下转型:

    1.语法:

    子类类型 引用名 = (子类类型) 父类引用;

    2.特点:

    • 只能强转父类的引用,不能强转父类的对象。
    • 要求父类的引用必须指向的是当前目标类型的对象。
    • 当向下转型后,可以调用子类类型中所有的成员。
  • 多态的注意事项和细节讨论:

    1.属性没有重写之说,属性的值看编译类型。

    2.instanceof比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型。

  • 动态绑定机制
    1.当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定。
    2.当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用。

多态的应用

多态数组

  • 数组的定义类型为父类类型,里面保存的实际元素类型为子类类型。
  • 使用向下转型。

多态参数

  • 方法定义的形参类型为父类,实参类型允许为子类。

Object类详解

equals方法

  • equals和==的对比
    1.==是比较运算符。既可以判断基本类型,又可以判断引用类型。如果判断基本类型,则判断的是值是否相等;如果判断引用类型,则判断的是地址是否相等(即判定是不是同一个对象)。
    2.equals是Object类中的方法,只能判断引用类型。默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等。

hashcode方法

  • 小结:
    1.提高具有哈希结构的容器的效率。
    2.两个引用,如果指向的是同一个对象,则哈希值一定相同;如果指向的是不同对象,则哈希值不相同。
    3.哈希值主要根据地址号来的,完全将哈希值等价于地址。

toString方法

  • 基本介绍:
    默认返回全类名(包名+类名) + @ + 哈希值的十六进制,子类往往重写toString方法,用于返回对象的属性信息。
  • 重写toString方法打印对象或拼接对象时,都会自动调用对象的toString形式。
  • 当直接输出一个对象时,toString方法会被默认地调用。

finalize方法

  • 当对象被回收时,系统自动调用该对象的finalize方法。子类可以重写该方法,做一些释放资源的操作。
  • 什么时候被回收:当某个对象没有任何引用时,则jvm就认为这个对象是一个垃圾对象,就会使用垃圾回收机制来销毁该对象。在销毁该对象前,会先调用finalize方法。
  • 垃圾回收机制的调用由系统来决定(即由自己的GC),也可以通过System.gc()主动触法垃圾回收机制。

断点调试debug

  • 在断点调试过程中,是运行状态,是以对象的运行类型来执行的。
  • 断点调试是指在程序的某一行设置一个断点,调试时,程序运行到这一行就会停住。然后可以一步一步往下调试,调试过程中可以看各个变量的当前值,出错的话,调试到出错的代码行即显示错误,停下。进行分析从而找到这个bug。

断点调试快捷键

按键 内容
F7 跳入方法内
F8 逐行执行代码
Shift+F8 跳出方法
F9 resume,执行到下一个断点
  • 将光标放在某个变量上,可以看到最新的数据。
  • 可以在debug过程中动态的下断点。

Chapter 10 面向对象编程(高级)

类变量/静态变量

类变量(静态变量/静态属性)是该类所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。

  • 类变量时对着类的加载而创建,所以即使没有创建对象实例也可以访问。
  • 类变量的生命周期是随类的加载开始,随着类消亡而销毁。

定义语法

(1)访问修饰符 static 数据类型 变量名; (推荐)
(2)static 访问修饰符 数据类型 变量名;

访问方法

(1)类名.类变量名 (推荐)
(2)对象名.类变量名

  • 类变量的访问必须遵循访问权限。

类方法/静态方法

定义语法

(1)访问修饰符 static 数据返回类型 方法名(){} (推荐)
(2)static 访问修饰符 数据返回类型 方法名(){}

调用

(1)类名.类方法名
(2)对象名.类方法名

使用场景

当方法中不涉及到任何和对象相关的成员,则可以将方法设计成静态方法,提高开发效率。

注意事项和细节讨论

  • 类方法和普通方法都是随着类的加载而加载,将结构信息储存在方法区。类方法中无this的参数,普通方法中隐含着this的参数。
  • 类方法可以通过类名调用,也可以通过对象名调用。
  • 普通方法和对象有关,需要通过对象名调用,不能通过类名调用。
  • 类方法中不允许使用和对象有关的关键字,比如this、super,普通方法(成员方法)可以。
  • 类方法中只能访问静态变量和静态方法。
  • 普通成员方法既可以访问非静态变量(/方法),也可以访问静态变量(/方法)。

理解main方法语法

  • main方法是由虚拟机调用。
  • Java虚拟机需要调用类的mian()方法,所以该方法的访问权限必须是public。
  • Java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static。
  • 该方法接收String类型的数组参数,该数组中保存执行Java命令时传递给所运行的类的参数。

特别提示

在main()方法中,我们可以直接调用main方法所在类的静态方法或静态属性。但是,不能直接访问该类中的非静态成员,必须创建该类的一个实例对象后,才能通过这个对象去访问类中的非静态成员。

代码块

基本介绍

代码化块又称为初始化块,属于类中的成员**(是类的一部分)。类似于方法,将逻辑语句封装在方法体中,通过{}包围起来。
但代码块
没有方法名,没有返回,没有参数,只有方法体**,而且不用通过对象或类显示调用,而是在加载类或创建对象时隐式调用。
代码块的调用优先于构造器。

基本语法

[修饰符]{
代码
};

注意:

  • “修饰符”可选,如果要写只能写static。
  • 代码块分为两类,使用static修饰的叫静态代码块,没有static修饰的叫普通代码块/非静态代码块。
  • 逻辑语句可以为任何逻辑语句。
  • ;可以写上,也可以省略。

好处

  • 相当于另一种形式的构造器(对构造器的补充机制),可以做初始化的操作。
  • 如果多个构造器中都有重复的语句,可以抽取到初始化块中,提高代码的重用性。

使用注意事项和细节讨论

  • static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行。并且只会执行一次。如果是普通代码块,每创建一个对象就执行。
  • 类什么时候被加载:
    • 创建对象实例时。
    • 创建子类对象实例,父类也会被加载。
    • 使用类的静态成员时(静态属性、静态方法)。
  • 普通的代码块在创建实例时,会被隐式的调用,被创建一次就被调用一次。如果只是使用类的静态成员时,普通代码块并不会执行。
  • 创建一个对象时,在一个类调用顺序是:
    1.调用静态代码块和静态属性初始化。(注意:静态代码块和静态属性初始化调用的优先级一样。如果有多个静态代码块和多个静态变量初始化,则按他们定义的顺序调用。)
    2.调用普通代码块和普通属性的初始化。(注意:普通代码块和普通属性初始化调用的优先级一样,如果有多个普通代码块和多个普通属性初始化,则按定义顺序调用。)
    3.调用构造方法。
  • 构造方法(构造器)的最前面其实隐含了super()和调用普通代码块。
  • 创建一个子类时(继承关系),他们的静态代码块、静待属性初始化、普通代码块、普通属性初始化、构造方法的调用顺序如下:
    1.父类的静态代码块和静态属性(优先级一样,按定义顺序执行)。
    2.子类的静态代码块和静态属性(优先级一样,按定义顺序执行)。
    3.父类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)。
    4.父类的构造方法。
    5.子类的普通代码块和普通属性初始化(优先级一样,按定义顺序执行)。
    6.子类的构造方法。
  • 静态代码块只能直接调用静态成员(静态属性和静态方法),普通代码块可以调用任意成员。

单例设计模式

理解

采取一定的方法保证在整个软件系统中对某个类只能存在一种对象实例,并且该类只提供一个取得其对象实例的方法。

方式

  • 饿汉式
  • 懒汉式

饿汉式(不使用也创建)单例模式的实现步骤

1.构造器私有化**(防止直接new)。
2.类的内部创建对象
(该对象是static)**。
3.向外暴露一个静态的公共方法。
4.代码实现。

饿汉式单例模式可能造成资源浪费。

懒汉式(不使用就不创建)单例模式的实现步骤

1.构造器私有化。
2.定义一个static静态属性对象。
3.提供一个public的static方法,可以返回对象。
4.代码实现。

饿汉式和懒汉式单例设计模式的区别

  • 两者最主要的区别在于创建对象的实际不同:饿汉式是在类加载就创建了对象实例,而懒汉式是在使用时才创建。
  • 饿汉式不存在线程安全问题,懒汉式存在线程安全问题。
  • 饿汉式存在资源浪费的可能。因为如果程序员一个对象实例都没有使用,那么饿汉式创建的对象就浪费了,懒汉式是使用时才创建的,就不存在这个问题。
  • 在JavaSE标准类中,java.lang.Runtime就是经典的单例模式。

final关键字

使用情景

修饰类、属性、方法和局部变量。
1.当不希望类被继承时,可以用final修饰。
2.当不希望父类的某个方法被子类覆盖/重写时,可以使用final关键字修饰。
3.当不希望类的某个属性的值被修改,可以用final修饰。
4.当不希望某个局部变量被修改,可以使用final关键字修饰。

使用注意事项和使用细节

  • final修饰的属性又叫常量,一般用XX_XX_XX来命名。

  • final修饰的属性在定义时,必须赋初值,并且以后不能再修改,赋值可以在如下位置之一:

    • 定义时。
    • 在构造器中。
    • 在代码块中。
  • 如果final修饰的属性时静态的,则初始化的位置只能是:

    • 定义时。
    • 在静态代码块,不能在构造器中赋值。
  • final类不能继承,但可以实例化对象。

  • 如果类不是final类,但是含有final方法,该方法虽然不能重写,但是可以被继承。

  • 一般来说,如果一个类已经是final类了,就没有必要再将方法修饰成final方法。

  • final不能修饰构造方法(即构造器)。

  • final和static往往搭配使用,效率更高,不会导致类加载。底层编译器做了优化处理。

  • 包装类(Integer,Double,Float,Boolean等都是final),String也是final类。

抽象类

当父类的某些方法需要声明,但是又不确定如何实现时,可以将其声明为抽象方法,那么这个类就是抽象类。当一个类中存在抽象方法时,需要将该类声明为abstract类。一般来说,抽象类会被继承,有其子类实现抽象方法。

介绍

1.用abstract关键字来修饰一个类,这个类就叫抽象类。

访问修饰符 abstract 类名{}

2.用abstract关键字来修饰一个方法时,这个方法就是抽象方法。

访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体

3.抽象类的价值更多作用是在于设计,是设计者设计好后,让子类继承并实现抽象类。
4.抽象类在框架和设计模式使用较多。

使用的注意事项和细节讨论

  • 抽象类不能被实例化。
  • 抽象类不一定包含abstract方法。
  • 一旦类包含了abstract方法,则这个类必须声明为abstract。
  • abstract只能修饰类和方法,不能修饰属性和其他的。
  • 抽象类可以有任意成员**(抽象类还是类)**,比如:非抽象方法、构造器、静态属性等等。
  • 抽象方法不能有主体,即不能实现。
  • 如果一个类继承了抽象类,则它必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类。
  • 抽象方法不能使用private、final和static来修饰,因为这些关键字都是和重写相违背的。

接口

基本介绍

接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,再根据具体情况把这些方法写出来。

  • 语法:

    interface 接口名{
    //属性
    //方法
    }

    class 类名 implements 接口{
    自己的属性/方法;
    必须实现的接口的抽象方法。
    }

小结:再Jdk7.0前,接口里的所有方法都没有方法体;Jdk8.0后,接口类可以有静态方法、默认方法(需要default关键词修饰)。
在接口中,抽象类可以省略abstract。

注意事项和使用细节

1.接口不能被实例化。
2.接口中所有的方法是public方法,接口中抽象方法可以不用abstract修饰。
3.一个普通类实现接口,就必须将该接口的所有方法都实现。(快捷键Alt+Enter)
4.使用抽象类实现接口,可以不用实现接口的方法。
5.一个类同时可以实现多个接口。
6.接口中的属性只能是final的,而且是pubic static final修饰符。
7.接口中的属性的访问形式:接口名.属性名。
8.一个接口不能继承其他的类,但是可以继承多个别的接口。
9.接口的修饰符只能是public和默认,这点和类的修饰符是一样的。

实现接口和继承类的比较

当子类继承了父类,就自动地拥有父类的功能;如果子类需要拓展功能,可以通过实现接口的方式来拓展。可以理解为实现接口是对Java单继承机制的一种补充。接口在一定程度上实现代码的解耦(降低不同模块之间的依赖,让它们可以独立变化和复用)。

接口的多态特性

1.多态参数。
2.多态数组。
3.接口存在多态传递现象。

内部类

基本介绍

一个类的内部又完整地嵌套了另一个类的结构。被嵌套的类称为内部类,嵌套其他类的类称为外部类。内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系。

基本语法

class Outer{ //外部类
class Inner{ //内部类
//代码块
}
}
class Other{ //外部其他类
//代码块
}

局部内部类

说明:局部内部类是定义在外部类的局部位置,比如方法中,并且有类名。
1.可以直接访问外部类的所有成员,包含私有成员。
2.不能添加当问修饰符。因为它的地位就是一个局部变量,局部变量不能使用修饰符,但可以用final修饰,因为局部变量也可以用fianl。
3.作用域:仅在定义它的方法或代码中。
4.局部内部类访问外部类成员:直接访问。
5.外部类访问局部内部类的成员:先创建对象再访问。(注意:必须在作用域内)
6.外部其他类不能访问局部内部类。(因为局部内部类的地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时,默认遵循就近原则。如果想访问外部类的成员,则可以使用外部类名.this.成员去访问。

匿名内部类

匿名内部类的使用

1.本质是类。
2.是内部类。
3.该类没有名字。(实则名字由系统分配,无法直接看见。对象名.getClass()获得对象的运行类型。)
4.是一个对象。
5.匿名内部类使用一次就不能再使用了。
6.可以使用匿名内部类来简化开发。

基本语法

new 类/接口(参数列表){
//类体
}

注意事项和细节

1.因为匿名内部类既是一个类的定义,也是一个对象,因此从语法上看,它既有定义类的特征,也有创建对象的特征。因此可以调用匿名内部类方法。
2.可以直接访问外部类的所有成员,包括私有的。
3.不能添加访问修饰符,因为它的地位就是一个局部变量。
4.作用域:仅在定义它的方法或代码块中。
5.匿名内部类访问外部类成员:直接访问。
6.外部其他类不能访问匿名内部类,因为匿名内部类的地位是一个局部变量。
7.如果外部类和匿名内部类的成员重名时,匿名内部类访问的话默认遵循就近原则;如果想访问外部类的成员,则可以使用外部类名.this.成员去访问。

匿名内部类的实践

当作实参直接传递,简洁高效。

成员内部类的使用

说明:成员内部类是定义在外部类的成员位置,并且没有static修饰。
1.可以直接访问外部类的所有成员,包含私有的。
2.可以添加任意访问修饰符,因为它的地位就是一个成员。
3.作用域和外部类的其他成员一样,为整个类体。
4.成员内部类访问外部类:直接访问。
5.外部类访问成员内部类:先创建对象,再访问。
6.外部其他类访问成员内部类:

  • 方式1

    1
    2
    Outer outer = new Outer();
    Inner Inner = outer.new Inner();
  • 方式2:使用一个方法来获取,更加简洁

    1
    2
    3
    4
    5
    6
    7
    Outer outer = new Outer();
    Outer.Inner innerInstance = Outer.getInnerInstance();

    //在外部类中编写一个方法:
    public Inner getInnerInstance(){
    return new Inner();
    }

7.如果外部类和成员内部类的成员重名时,成员内部类访问的话,默认遵循就近原则;如果想访问外部类的成员,则可以使用外部类名.this.成员去访问。

静态内部类的使用

说明:静态内部类是定义在外部类的成员位置,**并且有static修饰。
1.可以直接访问外部类的所有静态成员,包括私有的。但不能直接访问非静态成员。
2.可以添加任意访问修饰符,因为它的地位就是一个成员。
3.作用域:同其他的成员,为整个类体。
4.静态内部类访问外部类:直接访问所有静态类。
5.外部类访问静态内部类:先创建对象,再访问。
6.外部其他类访问静态内部类:

  • 方式1:

    1
    Outer.Inner inner = new Outer.Inner();

    注意:前提是要满足访问权限。

  • 方式2:编写一个方法,可以返回静态内部类的实例。

    1
    2
    3
    4
    5
    6
    Outer outer = new Outer();
    Outer.Inner inner = outer.getInner();

    //在外部类中编写一个方法:
    public Inner getInner(){
    return new Inner();
  • 方法3:使用静态方法。

    1
    2
    3
    4
    5
    Outer.Inner inner = Outer.getInner();

    //在外部类中编写一个方法:
    public static Inner getInner(){
    return new Inner();

7.如果外部类和静态内部类的成员重名,静态内部类访问时,默认遵循就近原则;如果想访问外部类成员,则可以使用外部类名.成员去访问。

Chapter 11 枚举和注解

枚举的实现方式

自定义类实现枚举

1.不需要提供setXxx方法,因为枚举对象值通常为只读。
2.对枚举对象/属性使用final + static共同修饰,实现底层优化。
3.枚举对象名通常使用全部大写,满足常量的命名规范。
4.枚举对象根据需要,也可以有多个属性。

演示自定义类枚举实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
pubilc class Enumeration{
public static void main(String[] args){
System.out.println(Season.AUTUMN);
}
}
class Season{
private String name;
private String desc;

//定义了四个对象(固定)
public final static Season SPRING = new Season("春天","温暖");
public final static Season SUMMER = new Season("夏天","炎热");
public final static Season AUTUMN = new Season("秋天","凉爽");
public final static Season WINTER = new Season("冬天","寒冷");

//1.将构造器私有化,目的:防止直接new。
//2.去掉set相关的方法,目的:防止属性被修改。
//3.在Season类内部,直接创建固定的对象。
private Season(String name,String desc){
this.name = name;
this.desc = desc;
}

public String getName(){
return name;
}

public String getDesc(){
return desc;
}

@Override
public String toString(){
return "Season{" +
"name='" + name + '\'' +
",desc='" + desc + '\'' +
'}';
}
}

特点:
1.构造器私有化。
2.本类内部创建一组对象。
3.对外暴露对象(通过为对象添加public final static修饰符)。
4.可以提供get方法,但是不要提供set方法。

使用enum关键字实现枚举

演示使用enum关键字来实现枚举:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
pubilc class Enumeration{
public static void main(String[] args){
System.out.println(Season.AUTUMN);
}
}
enum Season{
//如果使用了enum来实现枚举类
//1.使用关键字enum替代class。
//2.public final static Season SPRING = new Season("春天","温暖");直接使用SPRING("春天","温暖");替代。
// 解读:常量名(实参列表)
//3.如果有多个常量(对象),使用“,”间隔即可。
//4.如果使用enum来实现枚举,要求将定义的常量对象写在最前面。
SPRING("春天","温暖"),SUMMER("夏天","炎热"),AUTUMN("秋天","凉爽"),WINTER("冬天","寒冷");
private String name;
private String desc;

private Season(String name,String desc){
this.name = name;
this.desc = desc;
}

public String getName(){
return name;
}

public String getDesc(){
return desc;
}

@Override
public String toString(){
return "Season{" +
"name='" + name + '\'' +
",desc='" + desc + '\'' +
'}';
}
}

注意事项

1.当我们使用enum关键字开发一个枚举类时,默认会继承Enum类,而且是一个final类。
2.如果使用无参构造器创建枚举对象,则实参列表和小括号都可以省略。
3.当有多个枚举对象时,使用,间隔,最后有一个;结尾。
4.枚举对象必须放在枚举类的行首。

常用方法说明

使用关键字enum时,会隐式继承Enum类,这样我们就可以使用Enum类相关的方法。
1.toString:Enum类已经重写过了,返回的是当前对象名,子类可以重写该方法,用于返回对象的属性信息。
2.name:返回当前对象名(常量名),子类中不能重写。
3.ordinal:返回当前对象的位置号,默认从0开始。
4.values:返回当前枚举类中所有的常量。
5.valueOf:将字符串转换成枚举对象,要求字符串必须为已有的常量名,否则报异常。
执行流程:

  • 根据输入的字符串到枚举对象中去查找。
  • 如果找到了就返回;如果没有找到就报错。

6.compareTo:比较两个枚举常量,比较的就是位置号。如果位置号不相同,则返回前者的位置号-后者位置号的值。

总结

1.使用enum关键字后,就不能再继承其他类了,因为enum会隐式继承Enum,而Java是单继承机制。
2.枚举类和普通类一样,可以实现接口:

enum 类名 implements 接口1,接口2{}

注解

理解

1.注解也被称为元数据,用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。
2.和注释一样,注解不影响程序逻辑,但注解可以被编译或运行,相当于嵌入在代码中的补充信息。
3.再JavaSE中,注解的使用目的比较简单,例如标记过时的功能,忽略警告等。在JavaEE中,注解占据了更重要的角色,例如用来配置应用程序的任何切面,代替JavaEE旧版中所遗留的繁冗代码和XML配置等。

基本介绍

使用注解时要在其前面增加@符号,并把该注解当成一个修饰符使用,用于修饰它支持的程序元素。

@Override

限定某个方法,是重写父类方法,该注释只能用于方法。
如果写了@Override注解,编译器就会去检查该方法是否真的重写了父类的方法。如果的确重写了,则编译通过;如果没有构成重写,则编译错误。(语法校验)

补充:@interface表示一个注解类。

使用说明

1.@Override表示指定重写父类的方法(从编译层面验证),如果父类没有被重写的方法,则会报错。
2.如果不写@Override注解,而父类仍有被重写的方法,仍然构成重写。
3.@Override只能修饰方法,不能修饰其他类、包、属性等等。
4.查看@Override注解源码如下,说明只能修饰方法。

@Target(ElementType.METHOD)

5.@Target是修饰注解的注解,称为元注解。

@Deprecated

说明

1.用于表示某个程序元素(类、方法等)已过时。即不再推荐使用,但是仍然可以使用。
2.可以修饰方法、类、字段、包、参数等等。
3.@Target(value={CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE}) 4.@Deprecated`的作用可以做到新旧版本的兼容和过度。

@SuppressWarnings

当不希望看见警告时,可以使用@SuppressWarnings抑制编译器警告信息。在{""}中,可以写入希望抑制(不显示)的警告信息。@SuppressWarnings作用范围与放置的位置相关。

@Target({TYPE,FIELD,METHOD,PARAMATER,CONSTRUCTOR,LOCAL_VARIABLE})

该注解类有数组String[] values()设置一个数组。
生成@SuppressWarnings时,直接点击左侧的黄色提示就可以选择抑制警告的类型。(注意可以指定生成的位置)

可以抑制的警告类型有:

all 抑制所有警告
boxing 抑制与封装/拆装作业相关的警告
cast 抑制与强制转型作业相关的警告
dep-ann 抑制与淘汰注释相关的警告
deprecation 抑制与淘汰相关的警告
fallthrough 抑制与switch陈述式中遗漏break相关的警告
finally 抑制与未传回finnlly区块相关的警告
hiding 抑制与隐藏变数的区域变数相关的警告
incomplete-switch 抑制与switch陈述式enum case中遗漏项目相关的警告
javadoc 抑制与javadoc相关的警告
nls 抑制与非nls字串文字相关的警告
null 抑制与空值分析相关的警告
rawtypes 抑制与使用raw类型相关的警告
resource 抑制与使用Closeable类型的资源相关的警告
restriction 抑制与使用不建议或者禁止参照相关的警告
serial 抑制与可序列化的类别遗漏serialVersionUID栏位相关的警告
static-access 抑制与静态存取不正确相关的警告
static-method 抑制与可能宣告位static的方法相关的警告
super 抑制与置换方法相关但不含super呼叫的警告
synthetic-access 抑制与内部类别的存取未最佳化相关的警告
sync-override 抑制因为置换同步方法而遗漏同步化的警告
unchecked 抑制与未检查的作业相关的警告
unqualified-field-access 抑制与栏位存取不合格相关的警告
unused 抑制与未用的程式码及停用的程式码相关的警告

JDK的元注解

JDK的元注解用于修饰其他注解。

@Retention

说明

只能用于修饰一个注释定义,用于指定该注释可以保留多长时间。@Rentention包含一个RetentionPolicy类型的成员变量,使用@Rentention时,必须为该value成员变量指定值。

@Rentention的三种值

1.RetentionPolicy.SOURCE:编译器使用后,直接丢弃这种策略的注解。
2.RetentionPolicy.CLASS:编译器将把注解记录在class文件中,当运行Java程序时,JVM不会保留注解。这是默认值。
3.RetentionPolicy.RUNTIME:编译器将把注解记录在class文件中,当运行Java程序时,JVM会保留注释,程序可以通过反射获取该注解。

@Target

用于修饰注解定义,用于指定被修饰的注解能用于修饰哪些程序元素。@Target也包含一个名为value的成员变量。

@Documented

用于指定被该元注解修饰的注解类将被javadoc工具提取成文档,即在生成文档时,可以看到该注解。
说明:定义为Documented的注解必须设置Retention值为RUNTIME。

@Inherited

被它修饰的注解将具有继承性。如果某个类使用了被@Inherited修饰的注解,则其子类将自动具有该注解。

Chapter 12 异常

将代码块选中,使用快捷键Ctrl+Alt+T,选中try-catch。

基本概念

异常:程序执行中发生的不正常行为。(开发过程中的语法错误和逻辑错误不是异常)

分类

1.Error(错误):Java虚拟机无法解决的严重问题,如:JVM系统内部错误、资源耗尽等严重情况。Error是严重错误,程序会崩溃。
2.Exception:其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理,如:空指针访问、试图读取不存在的文件、网络连接中断等。
Exception分为两大类:

  • 运行时异常。
  • 编译时异常。

异常体系图

异常体系图

1.异常分为两大类:运行时异常、编译时异常。
2.“运行时异常”:编译器检查不出来的异常,一般是指编程时的逻辑错误,是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常。
3.对于“运行时异常”可以不做处理,因为这类异常很普遍,若全处理可能会对程序的可读性和运行效率产生影响。
4.“编译时异常”:是编译器要求必须处置的异常。

常见运行时异常

1.NullPointerException空指针异常:当应用程序试图在需要对象的地方使用null时,抛出该异常。
2.ArithmeticException数学运算异常:当出现异常的运算条件,抛出此异常。
3.ArrayIndexOutOfBoundsException数组下标越界异常:用非法索引访问数组时抛出的异常,如果索引为负或大于等于数组大小,则该索引为非法索引。
4.ClassCastException类型转换异常:当试图将一个对象强制转换为不是实例的子类时,抛出该异常。
5.NumberFormatException数字格式不正确异常:当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为当前格式时,抛出该异常。(使用异常我们可以确保输入是满足条件的数字)

常见的编译异常

1.SQLException:操作数据库时,查询表可能发生异常。
2.IOException:操作文件时,发生的异常。
3.FileNotFoundException:当操作一个不存在的文件时,发生异常。
4.ClassNotFoundException:加载类,而该类不存在时,异常。
5.EOFException:操作文件,到文件末尾,发生异常。
6.IIlegalArguementException:参数异常。

异常处理

基本介绍

异常处理就是当异常发生时,对异常处理的方式。

异常处理的方式

1.try-catch-finally:程序员在代码中捕获发生的异常,自行处理。
2.throws:将发生的异常抛出,交给调用者(方法)来处理,最顶级的处理者就是JVM。

两种异常处理方式二选一。如果程序员没有显式处理异常,默认采用throws。

try-catch异常处理

Java提供try和catch块来处理异常,try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个数量的try...catch块。

基本语法

try{
//可疑代码
//将异常生成对应的异常对象,传递给catch块
}catch(异常){
//对异常的处理
}
//如果没有finally,语法是可以通过的。

注意事项

1.如果异常发生了,则异常发生后面的代码不会执行,直接进入到catch块。
2.如果异常没有发生,则顺序执行try的代码块,不会进入到catch。
3.如果希望不管是否发生异常,都执行某段代码(比如:关闭连接、释放资源等),则使用finally。
4.可以有多个catch语句,捕获不同的异常(进行不同的业务处理),要求父类异常在后、子类异常在前(比如:Exception在后,NullPointException在前),如果发生异常,只会匹配一个catch。
5.可以进行try-finally配合使用,这种用法相当于没有捕获异常,因此程序会直接崩溃。(应用场景:执行一段代码,不管是否发生异常,都必须执行某个业务逻辑)

throws异常处理

基本介绍

1.如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显式地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法的调用者(方法)负责处理。
2.在方法声明中用throws语句可以声明抛出异常的列表,throws后面的异常类型可以是方法中产生的异常类型,也可以是它的父类。
3.throws关键字后面也可以是异常列表,即可以抛出多个异常。

注意事项和使用细节

1.对于编译异常,程序中必须处理,比如:try-catch或throws。
2.对于运行时异常,程序中如果没有处理,默认就是throws的方式处理。
3.子类重写父类的方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致,要么为父类抛出的异常的类型的子类型。
4.在throws过程中,如果有方法try-catch,就相当于处理异常,就可以不必throws。

throw和throws的区别
意义 位置 后面跟的东西
throws 异常处理的一种方式 方法声明处 异常类型
throw 手动生成异常对象的关键字 方法体中 异常对象

自定义异常

基本概念

当程序中出现了某些“错误”,但该错误信息并没有在Throwable子类中描述处理,这个时候可以自己设计异常类,用于描述该错误信息。

自定义异常的步骤

1.定义类:自定义异常类名(程序员自己写)继承Exception或RuntimeException。
2.如果继承Exception,属于编译异常。
3.如果继承RuntimeException,属于运行异常。

Chapter 13 常用类

包装类

分类

1.针对八种基本数据类型相应的引用类型——包装类。
2.有了类的特点,就可以调用类中的方法。

基本数据类型 包装类
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
包装类继承关系图1 包装类继承关系图2 包装类继承关系图3

包装类和基本数据的转换

1.jdk5前的手动装箱和拆箱方式:

  • 装箱:基本类型→包装类型
    示例:

    1
    2
    3
    int n1 = 100;
    Integer integer = new Integer(n1); //方法1
    Integer integer = Integer.valueOf(n1); //方法2
  • 拆箱:包装类型→基本类型
    示例:

    1
    int i = integer.intValue();

2.jdk5以后(含jdk5)的自动装箱和拆箱方式。

1
2
3
4
5
//自动装箱
int n2 = 200;
Integer integer2 = n2; //底层使用的是Integer.valueOf(n2)
//自动拆箱
int n3 = integer2; //底层使用的是intValue()方法

包装类型和String类型的相互转换

以Integer和String转换为例,其他类似:

1
2
3
4
5
6
7
8
9
10
11
12
13
//包装类型→String类型
Integer i = 10;
//方式1
String s1 = i.toString();
//方式2
String s2 = String.valueOf(i);
//方式3
String s3 = i + "";
//String→包装类型
//方式1
Integer j1 = new Integer(s1);
//方式2
Integer j2 = Integer.valueOf(s2);

Integer类和Character类的常用方法

1
2
3
4
5
6
7
8
9
10
11
System.out.println(integer.MIN_VALUE);			 //返回最小值
System.out.println(integer.MAX_VALUE); //返回最大值

System.out.println(Character.isDigit('a')); //判断是不是数字
System.out.println(Character.isLetter('a')); //判断是不是字母
System.out.println(Character.isUpperCase('a')); //判断是不是大写
System.out.println(Character.isLowerCase('a')); //判断是不是小写

System.out.println(Character.isWhitespace('a')); //判断是不是空格
System.out.println(Character.toUpperCase('a')); //转换成大写
System.out.println(Character.toLowerCase('a')); //传换成小写

Integer创建机制

看看下面代码,输出什么结果?为什么?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public void method1(){
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j); //False

//主要看范围-128~127,就是直接返回;否则就new Integer(xx);
Integer m = 1; //底层:Integer.valueOf(1);
Integer n = 1; //底层:Integer.valueOf(1);
System.out.println(m == n); //True

Integer x = 128;
Integer y = 128;
System.out.println(x == y); //False

//只要有基本数据类型,判断的就是值是否相同
Integer a = 127;
int b = 127;
System.out.println(a == b); //True
}

String类

理解

1.String对象用于保存字符串,也就是一组字符序列。
2.字符串常量对象是用双引号括起的字符序列,如:”你好”、”12.97”等。
3.字符串的字符使用Unicode字符编码,一个字符(不区分字母还是汉字),占两个字节。
4.String类较常用的构造器:

方法一:String s1 = new String();
方法二:String s2 = new String(String original);
方法三:String s3 = new String(char[] a);
方法四:String s4 = new String(char[] a,int startIndex,int count);
方法五:String s5 = new String(byte[] b);

5.String类是final类,不能被其他的类继承。
6.String有属性private final char value[]用于存放字符串内容。字符串是不可变的,一个字符串对象一旦被分配,其内容是不可变的。

注意:value是一个final类型,地址不可修改(不可让其指向另一个对象),但是单个字符内容是可以变化的。

String类继承关系

1.String实现了Serializable接口,说明String可以串行化,可以在网络上传输。
2.String实现了Comparable接口,说明String对象可以比较。

创建String对象的两种方式

1.直接赋值。String s = "xxx";

先从常量池查看是否有”xxx”数据空间,如果有,直接指向;如果没有则重新创建,然后指向。s最终指向的是常量池的空间地址。

2.调用构造器。String s = new String("xxx");

先在堆中创建空间,里面维护了value属性,指向常量池的xxx空间。如果常量池中没有”xxx”,则重新创建;如果有,直接通过value指向。最终指向的是堆中的空间地址。

String c = "a" + "b";常量相加,看的是池;String c = a + b;变量相加,看的是堆。

常见方法

说明:String类是保存字符串常量的。每次更新都需要重新开辟空间,效率极低。

方法名 作用
equals 区分大小写地判断内容是否相等
equalsIgnoreCase 忽略大小写地判断内容是否相等
length 获取字符的个数,字符串的长度
indexOf 获取字符在字符串中第1次出现的索引,索引从0开始,如果找不到则返回-1
lastIndexOf 获取字符在字符串中最后1次出现的索引,索引从0开始,如果找不到则返回-1
substring 截取指定范围的子串
trim 去前后空格
charAt 获取某索引处的字符,注意不能使用Str[index]这种方式
compareTo 比较两个字符串的的大小(如果前者大,则返回正数;如果后者大,则返回负数;如果相等,则返回0)
toCharArray 转换成字符数组
format 格式字符串,%s字符串,%c字符,%d整型,%.2f浮点型
replace 替换字符串中的字符
split 分隔字符串,对于某些分割字符,我们需要转义,比如`
toUpperCase 转换成大写
toLowerCase 转换成小写

StringBuffer类

基本介绍

1.java.lang.StringBuffer代表可变的字符序列,可以对字符串内容进行增删。
2.很多方法与String相同,但StringBuffer是可变长度的。
3.StringBuffer是一个容器。
4.StringBuffer的直接父类是AbstractStringBuilder。StringBuffer实现了Serializable,即StringBuffer的对象可以串行化。在父类AbstractStringBuilder中有属性char[] value,不是final。该value数组存放字符串内容,因此存放在堆中。
5.StringBuffer是final类,不能被继承。

String和StringBuffer的对比

1.String保存的是字符串常量,里面的值不能更改,每次String类的更新实际上就是更改地址,效率极低。
2.StringBuffer保存的是字符串变量,里面的值可以更改,每次StringBuffer的更新实际上可以更新内容,不用更新地址,效率较高。

StringBuffer的构造器

1.StringBuffer:构造一个其中不带字符的字符串缓冲区,其初始容量为16个字符。
2.StringBuffer(CharSequence seq):构造一个字符串缓冲区,它包含与指定的CharSequence相同的字符串。
3.StringBuffer(int capacity):构造一个不带字符,但具有指定初始容量的字符串缓冲区。即对char[]大小进行指定。
4.StringBuffer(String str):构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容,容量为创建字符串大小+16。

String和StringBuffer相互转换

String→StringBuffer

1
2
3
4
5
//方式1:使用构造器,返回的是StringBuffer对象,对s本身没有影响
StringBuffer b1 = new StringBuffer(s);
//方式2:使用append方法
StringBuffer b2 = new StringBuffer();
b2.append(s);

StringBuffer→String

1
2
3
4
//方式1:使用StringBuffer提供的toString方法
String s2 = b1.toString(); //b1 [StringBuffer]
//方式2:使用构造器
String s3 = new String(b1);

StringBuffer类的常见方法

1.增append。
2.删delete(start,end)(区间前闭后开)。
3.改replace(start,end,string)(将start-end间的内容替换掉,不含end)。
4.查indexOf(查找子串在字符串第1次出现的索引,如果找不到,返回-1)。
5.插insert。
6.获取长度length。

StringBuilder类

基本介绍

1.一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步**(StringBuilder不是线程安全)。该类被设计用作StringBuffer的一个简易替换,用在字符串缓冲区被单个线程使用的时候,如果可能,建议优先采用该类。因为在大多数实现中,它比StringBuffer要快。
2.在StringBuilder上的主要操作是append和insert方法,可重载这些方法,以接收任意类型的数据。
3.StringBuilder是final
(不能被继承),继承了AbstractStringBuilder,属性char[] value,内容存到value(因此字符序列在堆中)**。
4.实现了Serializable接口,串行化(即对象可以网络传输,可以保存到文件)。

StringBuilder常用方法

StringBuilder和StringBuffer均代表可变的字符序列,方法是一样的。所以,使用和StringBuffer一样。
StringBuilder的方法没有做互斥的处理(即没有synchronized关键字),因此在单线程的情况下使用StringBuilder。

String、StringBuffer和StringBuilder的比较

1.StringBuilder和StringBuffer非常类似,均代表可变的字符序列,而且方法也一样。
2.String:不可变字符序列,效率低,但是复用率高。
3.StringBuffer:可变字符序列,效率较高(增删)、线程安全。
4.StringBuilder:可变字符序列,效率最高、线程不安全。
5.String使用注意说明:

1
2
3
4
5
6
String s = "a";	//创建了一个字符串
s += "b";
/*
实际上原来的“a”字符串对象已经丢弃了,现在又产生了一个字符串s+"b"(也就是“ab”)。如果多次执行这些改变串内容的操作,会导致大量副本字符串对象存留在内存中,降低效率。如果这样的操作放到循环中,会极大影响程序的性能。
结论:如果需要对String做大量修改,不要使用String。
*/

String、StringBuffer和StringBuilder的选择

1.如果字符串存在大量的修改操作,一般使用StringBuffer或StringBuilder。
2.如果字符串存在大量的修改操作,并在单线程的情况,使用StringBuilder。
3.如果字符串存在大量的修改操作,并在多线程的情况,使用StringBuffer。
4.如果字符串很少修改,被多个对象引用,使用String,比如配置信息等。

Math类

基本介绍

Math类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。

常用方法

1.abs:绝对值。
2.pow:求幂。
3.ceil:向上取整。
4.floor:向下取整。
5.round:四舍五入。
6.sqrt:求开方。
7.random:求随机数。

获取一个a-b之间的一个随机整数
int num = (int)(Math.random()*(b - a + 1) + a);

8.max:求两个数的最大值。
9.min:求两个数的最小值。

Arrays类

常见方法

1.toString:返回数组的字符串形式。

Arrays.toString(arr);

2.sort:排序(自然排序和定制排序)

因为数组是引用类型,所以通过sort排序后,会直接影响到实参。
sort重载,可以通过传入一个接口Comparator实现定制排序。调用定制排序时,传入两个参数(排序的数组、实现了Comparator接口的匿名内部类),要求实现compare方法。

3.binarySearch:通过二分搜索法进行查找,要求必须排好序,如果该数组是无序的,则不能使用。(如果数组中不存在该元素,则返回-(low + 1)。low:这个元素应该存在的位置)
4.copyOf:数组元素的复制。如果拷贝的长度大于被拷贝数组的长度,就在新数组后面加null;如果拷贝长度小于0,就抛出异常NegativeArraySizeException。
5.fill:数组元素的填充(替换原来的所有元素)。
6.equals:比较两个数组元素的内容是否完全一致。
7.asList:将一组值转换成list集合。

System类

常见方法

1.exit:退出当前程序。
2.arraycopy:复制数组元素,比较适合底层调用。一般使用Arrays.copy()完成复制数组。
3.currentTimeMillens:返回当前时间距离1970-01-01的毫秒数。
4.gc:运行垃圾回收机制。(System.gc())

BigInteger和BigDecimal类

应用场景

1.BigInteger适合保存比较大的整型。
2.BigDecimal适合保存精度更高的浮点型。

常见方法

1.add:加。
2.subtract:减。
3.multiply:乘。
4.divide:除。可能抛出异常ArithmeticException。在调用divide方法时,指定精度即可。(BigDecimal.ROUND_CEILING:如果有无限循环小数,就会保留分子的精度)

日期类

第一代日期类

1.Date:精确到毫秒,代表特定的日期。(此处的Date在java.util包下)默认输出的日期格式时国外的格式,所以通常需要对格式进行转换。
2.SimpleDateFormat:格式化和解析日期的具体类。它允许进行格式化(日期 →文本)、解析(文本→日期)和规范化。创建SimpleDateFormat对象,可以指定相应的格式。(format:将日期转换成指定格式的字符串;parse:将文本转换为日期的方法)

SimpleDateFormat字母格式

第二代日期类

Calendar:Calendar类是一个抽象类,构造器为private,可以通过getInstance()来获取实例,它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法。
Calendar没有专门的格式化方法,所以需要自己组合输出。
默认小时按照12小时进制获取时间,如果需要按照24小时进制获取时间,则将Calendar.HOUR改成Calendar.HOUR_OF_DAY。

第三代日期类常见方法

1.LocalDate:只包含日期,可以获取日期字段。
2.LocalTime:只包含时间,可以获取时间字段。
3.LocalDateTime:包含日期和时间,可以获取日期和时间字段。
4.DateTimeFormatter格式日期类:类似于SimpleDateFormat。
5.Instant时间戳:类似于Date,提供了一系列和Date类转换的方式。

1
2
3
4
//Instant→Date
Date date = Date.from(instant);
//Date→Instant
Instant instant = date.toInstant();

提供的plus和minus方法可以对当前时间进行加或减。

Chapter 14 集合

集合的框架体系图

  • 单列集合

    单列集合
  • 双列集合

    双列集合

Collection接口和常用方法

Collection接口实现类的特点

1.Collection实现子类可以存放多个元素,每个元素可以是Object。
2.有些Collection的实现类,可以存放重复的元素,有些不可以。
3.有些Collection的实现类,有些是有序的(List),有些不是有序的(Set)。(有序指存放顺序和取出顺序保持一致)
4.Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的。

Collection接口的常用方法

1.add:添加单个元素。
2.remove:删除指定元素。
3.contains查找元素是否存在。
4.size:获取元素个数。
5.isEmpty:判断是否为空。
6.clear:清空。
7.addAll:添加多个元素。
8.containsAll:查找多个元素是否都存在。
9.removeAll:删除多个元素。

Collection接口遍历元素的方式

使用Iterator(迭代器)

1.Iterator对象成为迭代器,主要用于遍历Collection集合中的元素。
2.所有实现了Collection接口的集合类都有一个Iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器。
3.Iterator仅用于遍历集合,Iterator本身并不存放对象。

在调用iterator.next()方法之前必须要调用iterator.hasNext()进行检测。若不调用,且下一条记录无效,直接调用iterator.next()会抛出NoSuchElementException异常。
当退出while循环后,这时Iterator迭代器指向最后的元素。如果希望再次遍历,需要重置迭代器。

  • 基本语法

    while (iterator.hasNext()) {
    …
    }

使用for循环增强

增强for循环,可以替代iterator迭代器**(但底层仍然是迭代器)**,特点:增强for就是简化版的iterator,本质一样。只能用于遍历集合或数组。

  • 基本语法

    for(元素类型 元素名 : 集合名或数组名){
    访问元素
    }

List接口和常用方法

List接口基本介绍

List接口是Collection接口的子接口。
1.List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复。
2.List集合中的每个元素都有其对应的顺序索引,即支持索引。
3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素。
4.常用的List接口的实现类有:ArrayList、LinkedList、Vector。

List接口的常用方法

1.void add(int index,Object ele):在index位置插入ele元素。(前面没有带索引,则默认插入到最后)
2.boolean addAll(int index,Colletcion eles):从index位置开始将eles中的所有元素添加进来。
3.Object get(int index):获取指定index位置的元素。
4.int indexOf(Object obj):返回obj在集合中首次出现的位置。
5.Object remove(int index):移除指定index位置的元素,并返回此元素。
6.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。
7.Object set(int index,Object ele):设置指定index位置的元素为ele,相当于是替换。
8.List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合。(集合前闭后开)

List的三种遍历方式

使用iterator

1
2
3
4
Iterator iter = col.iterator();
while(iter.hasNext()){
Object o = iter.next();
}

使用增强for

1
2
3
for(Object o : col){
System.out.println("o=" + o);
}

使用普通for

1
2
3
4
for(int i = 0;i < list.size;i++){
Object object = list.get(i);
System.out.println(object);
}

说明:使用LinkedList完成使用方式和ArrayList一样。

ArrayList的注意事项

1.ArrayList可以加入null,并且可以放入多个空值。
2.ArrayList是由数组来实现数据存储的。
3.ArrayList基本等同于Vector,除了ArrayList是线程不安全(执行效率高),在多线程情况下,不建议使用ArrayList。

ArrayList的底层操作机制源码分析

1.ArrayList中维护了一个Object类型的数组elementData。
2.当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0。第1次添加,则扩容elementData为10,如果需要再次扩容,则扩容elementData为1.5倍。
3.如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍。

Vector底层结构与源码剖析

Vector的基本介绍

1.Vector类的定义说明:

1
2
3
public class Vector<E>
extends AbstractList<E>
inplements List<E>,RandomAccess,Cloneable,Serializable

2.Vector底层也是一个对象数组,protected Object[] elementData;。
3.Vector是线程同步的,即线程安全。Vector类的操作方法带有synchronized。在开发中,需要线程同步安全时,考虑使用Vector。

Vector和ArrayList的比较

底层结构 版本 线程安全(同步)效率 扩容倍数
ArrayList 可变数组 jdk1.2 不安全,效率高 如果有参构造:1.5倍;如果无参构造:第一次10,从第二次开始按1.5倍
Vector 可变数组 jdk1.0 安全,效率不高 如果无参构造:默认10,满后按2倍扩容;如果指定大小:每次直接按2倍扩容

LinkedList底层结构

说明

1.LinkedList底层实现了双向链表和双向队列特点。
2.可以添加任意元素**(元素可以重复),包括null。**
3.线程不安全,没有实现同步。

ArrayList和LinkedList的比较

底层结构 增删的效率 改查的效率
ArrayList 可变数组 较低,数组扩容 较高
LinkedList 双向链表 较高,通过链表追加 较低

Set接口和常用方法

Set接口基本介绍

1.无序**(添加和取出的顺序不一致,但是取出的顺序固定),没有索引**。
2.不允许重复元素,所以最多包含一个null。

Set接口的常用方法

和List接口一样,Set接口也是Collection的子接口,因此常用方法和Collection接口一样。

Set接口的遍历方式

同Collection的遍历方式一样,因为Set接口是Collection接口的子接口。
1.可以使用迭代器。
2.增强for。
3.不能使用索引的方式来获取(即不能用普通for循环)。

HashSet

HashSet的全面说明

1.HashSet实现了Set接口。
2.HashSet实际上是HashMap。
3.可以存放null值,但只能有一个null。
4.HashSet不保证元素是有序的,取决于hash后,再确定索引的结果(即不保证存入顺粗和取出顺序一致)。
5.不能有重复元素/对象。
6.在执行add方法后,会返回一个boolean值。

HashSet底层机制说明(分析HashSet的添加元素底层的实现方法)

1.HashSet底层是HashMap。
2.添加一个元素时,先得到hash值会转成索引值。
3.找到存储数据表table,看这个索引位置是否已经存放有元素。如果没有,直接加入;如果有,调用equals比较,如果相同,就放弃添加,如果不同,则添加到最后。
4.HashSet底层是HashMap,第一次添加时,table数组扩容到16,临界值threshold是16加载因子loadFactor0.75=12。
5.如果table数组使用到了临界值12,就会扩容到16
2=32,新的临界值就是32*0.75=24,以此类推。
6.在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8),并且table的大小大于等于MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),否则仍然采用数组扩容机制。

LinkedHashSet

LinkedHashSet的全面说明

1.LinkedHashSet是HashSet的子类。
2.LinkedHashSet底层是一个LinkedHashMap,底层维护了一个数组+双向链表。
3.LinkedHashSet根据元素的HashCode值来决定元素的存储位置,同时使用链表维护元素的次序,这使得元素看起来是以插入的顺序保存的。
4.LinkedHashSet不允许添加重复元素。

Map接口和常用方法

Map接口实现类的特点

注意:以下为JDK8的Map接口特点。
1.Map和Collection并列存在。用于保存具有映射关系的数据:key-value。
2.Map中的key和value可以是任何引用类型的数据,会封装到HashMap$Node对象中。
3.Map中的key不允许重复,原因和HashSet一样。
4.Map中的value可以重复。
5.Map的key可以为null,value可以为null。**注意:key为null只能有一个,value为null可以多个。
6.**常用String类作为Map的key。
7.key和value之间存在单向一对一关系,即通过指定的key总能找到对应的value。
8.Map存放数据的key-value:一对k-v是放在一个HashMap$Node中的,又因为Node实现了Entry接口,有些书上也说“一对k-v就是一个Entry”。

Map接口的常用方法

1.put:添加。
2.remove:根据键,删除映射关系。
3.get:根据键,获取值。
4.size:获取元素个数。
5.isEmpty:判断个数是否为0。
6.clear:清除。
7.containsKey:查找键是否存在。

Map接口遍历方法

1.containsKey:查找键是否存在。
2.keySet:获取所有的键。(增强for)
3.entrySet:获取所有关系(k-v)。(迭代器)
4.values:获取所有的值。

小结

1.Map接口的常用实现类:HashMap、HashTable、Properties。
2.HashMap是Map接口使用频率最高的实现类。
3.HashMap是以key-val对的方式来存储数据(HashMap$Node类型)。
4.key不能重复,但是祉可以重复。允许使用null键和null值。
5.如果添加相同的key,则会覆盖原来的key-val,等同于修改**(key不会替换,val会替换)。
6.与HashSet一样,不保证映射的顺序,因为底层是以hash表的方式来存储的(JDK8的HashMap底层:数组+链表+红黑树)。
7.HashMap没有实现同步,因此是
线程不安全**的,方法没有做同步互斥的操作,没有synchronized。

HashMap底层机制

扩容机制

和HashSet相同。
1.HashMap底层维护了Node类型的数组table,默认为null。
2.当创建对象时,将加载因子loadfactor初始化为0.75。
3.当添加key-val时,通过key的哈希值得到在table的索引。然后判断该索引位置是否已经存放有元素。如果没有,直接加入;如果有,继续判断该元素的key和准备加入的key是否相等,如果相等则直接替换val,如果不相等需要判断是树结构还是链表结构,做出相应处理。如果添加时发现容量不够,则需要扩容。
4.第1次添加,则需要扩容table容量为16,临界值threshold为12(16*0.75)。
5.以后再次扩容,则需要扩容table容量为原来的2倍,临界值为原来的2倍,以此类推。
6.在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8),并且table的大小大于等于MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树)。

Hashtable

基本介绍

1.存放的元素是键值对:K-V。
2.Hashtable的键和值都不能为null。
3.Hashtable使用方法基本上和HashMap一样。
4.Hashtable是
线程安全的,HashMap是线程不安全**的。

底层

1.底层有数组Hashtable$Entry[]初始化大小为11。
2.初始临界值threshold为8(11*0.75)。
3.扩容:按照自己的扩容机制来进行即可。
4.执行方法addEntry(hash,key,value,index);添加K-V,封装到Entry。
5.当if(count => threshold)满足时,就进行扩容。
6.按照int newCapacity = (oldCapacity << 1) + 1;的大小进行扩容。

Hashtable和HashMap对比

版本 线程安全(同步) 效率 允许null键、null值
HashMap 1.2 不安全 高 可以
Hashtable 1.0 安全 较低 不可以

Properties

基本介绍

1.Properties类继承自Hashtable类并且实现了Map接口,也是使用一种键值对的形式来保存数据。
2.使用特点和Hashtable类似。
3.Properties还可以用于从xxx.properties文件中,加载数据到Properties类对象,并进行读取和修改。

开发中如何选择集合实现类

在开发中选择什么集合实现类,主要取决于业务操作特点,然后根据集合实现类特性进行选择,分析如下:
1.先判断存储的类型(一组对象[单列]或一组键值对[双列])
2.一组对象[单列]:Collection接口

  • 允许重复:List

    • 增删多:LinkedList(底层维护了一个双向链表)
    • 改查多:ArrayList(底层维护Object类型的可变数组)
  • 不允许重复:Set

    • 无序:HashSet(底层是HashMap,维护了一个哈希表,即数组+链表+红黑树)
    • 排序:TreeSet
    • 插入和取出顺序一致:LinkedHashSet(维护数组+双向链表)

3.一组键值对[双列]:Map

  • 键无序:HashMap(底层是哈希表)
  • 键排序:TreeMap
  • 键插入和取出顺序一致:LinkedHashMap
  • 读取文件:Properties

TreeSet

1.当我们使用无参构造器创建TreeSet时,仍然是无序的。
2.使用TreeSet提供的一个构造器,可以传入一个比较器(匿名内部类)并指定排序规则。
3.构造器把传入的比较器对象赋给了TreeSet底层的TreeMap的属性this.comparator。

TreeMap

1.使用默认的构造器创建TreeMap,是无序的。
2.构造器把传入的实现了Comparator接口的匿名内部类(对象),传给了TreeMap的this.comparator。

Collections工具类

Collections工具类介绍

1.Collections是一个操作Set、List、Map等集合的工具类。
2.Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作。

排序方法(均为static方法)

1.reverse(List):反转List中元素的顺序。
2.shuffle(List):对List集合元素进行随机排序。
3.sort(List):根据元素的自然顺序对指定List集合元素按升序排序。
4.sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序。
5.swap(List,int,int):将指定List集合中的i处元素和j处元素进行交换。

查找、替换

1.Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素。
2.Object max(Collection,Comparator):根据Comparator指定的顺序,返回给定集合中的最大元素。
3.Object min(Collection):根据元素的自然顺序,返回给定集合中的最小元素
4.Object min(Collection,Comparator):根据Comparator指定的顺序,返回给定集合中的最小元素。
5.int frequency(Collection,Object):返回指定集合中指定元素的出现次数。 6.void copy(List dest,List src):将src中的内容复制到dest中。
7.boolean replaceAll(List list,Object oldval,Object newVal):使用新值替换List对象的所有旧值。

HashSet和TreeSet分别如何实现去重的

1.HashSet去重机制:hashCode()+equals()。底层先通过存入对象,进行运算得到一个hash值,通过hash值得到对应的索引。如果发现table索引所在的位置没有数据,就直接存放;如果有数据,就进行equals比较**(遍历比较)**。如果比较后不相同,就加入;否则就不加入。
2.TreeSet去重机制:如果传入了一个Comparator匿名对象,就使用实现的compare去重。如果方法返回0,就认为是相同的元素,就不添加。如果没有传入一个Comparator匿名对象,则以添加的对象实现的Compareable接口的compareTo去重。

Chapter 15 泛型

泛型的好处

1.编译时检查添加元素的类型,提高了安全性。
2.减少了类型转换次数,提高效率。
3.不再提示编译警告。

泛型介绍

1.泛型又称参数化类型,是JDK5.0出现的新特性,解决数据类型的安全问题。
2.在类声明或实例化时只要指定好需要的具体的类型即可。
3.Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException(类型转换)异常。同时,代码更加简洁、健壮。
4.泛型的作用是:可以在类声明时通过一个标识表示类中某个属性的类型,或者某个方法的返回值的类型,或者是参数类型。

泛型的语法

  • 泛型的声明

    interface 接口{}
    class 类<K,V>{}

    说明:
    1.其中,T,K,V不代表值,而是表示类型。
    2.任何字母都可以,常用T表示,是Type的缩写。

  • 泛型的实例化
    要在类名后面指定类型参数的值(类型)。

泛型的语法和使用

泛型使用的注意事项和细节

1.interface List<T>{},public class HashSet<E>{},…
说明:T,E只能是引用类型。
2.在指定泛型具体类型后,可以传入该类型或者其子类类型。
3.泛型使用形式:

1
2
List<Integer> list1 = new ArrayList<Integer>();
List<Integer> list2 = new ArraryList<>();

4.如果写作List list3 = new ArrayList();,默认给它的泛型是<E>就是Objcet。

自定义泛型

自定义泛型类

基本语法

class 类名<T,R,…>{ //…表示可以有多个泛型
成员
}

注意细节

1.普通成员可以使用泛型(属性、方法)。
2.使用泛型的数组,不能初始化。因为数组在创建时不能确定泛型数组的类型,就无法在内存开空间。
3.**静态方法中不能使用类的泛型。**因为静态是和类相关的,在类加载时,对象还没有创建。所以,如果静态方法和静态属性使用了泛型,JVM就无法完成初始化。
4.泛型类的类型是在创建对象时确定的。因为创建对象时,需要指定确定的类型。
5.如果在创建对象时,没有指定类型,默认为Object。

自定义泛型接口

基本语法

interface 接口名<T,R,…>{

}

注意细节

1.接口中,静态成员也不能使用泛型。
2.泛型接口的类型,在继承接口或实现接口时确定。
3.没有指定类型,默认为Object。

自定义泛型方法

基本语法

修饰符 <T,R,…> 返回类型 方法名(参数列表){

}

注意细节

1.泛型方法,可以定义在普通类中,也可以定义在泛型类中。
2.当泛型方法被调用时,传入参数,编译器就会确定类型。
3.修饰符后没有<T,R,...>的方法不是泛型方法,而是使用了泛型。
4.泛型方法可以使用类声明的泛型,也可以使用自己声明的泛型。

泛型的继承和通配符说明

1.泛型不具备继承性.
2.<?>:支持任意泛型类型。
3.<? extends A>:支持A类以及A类的子类,规定了泛型的上限。
4.<? super A>:支持A类以及A类的父类,不限于直接父类,规定了泛型的下限。

JUnit

在需要单独测试的方法前面写入@Test,使用快捷键Alt+Enter。

Chapter 16 坦克大战1.0

Java绘图坐标体系

像素(密度单位)

Java绘图技术

绘图原理

= Component类提供了两个和绘图相关最重要的方法:
1.paint(Graphics g):绘制组件的外观。
2.repaint():刷新组件的外观。

  • 当组件第一次在屏幕显示的时候,程序会自动的调用paint()方法来绘制组件。
  • 在以下情况paint()将会被调用:
    1.窗口最小化,再最大化。
    2.窗口的大小发生变化。
    3.repaint方法被调用。

Graphics类

1.画直线:drawLine(int x1,int y1,int x2,int y2)
2.画形边框:drawRect(int x, int y, int width, int height)
3.画圆边框:drawOval(int x, int y, int width, int height)
4.填充矩形:fillRect(int x, int y, int width, int height)
5.填圆:fillOval(int x, int y, int width, int height)
6.画图片:drawlmage(lmage img, int x, int y,..)

获取图片资源:
Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/..."));
注:需要把图片放在根目录指定位置。

7.画字符串:drawString(String str, int x, int y)

x,y的坐标位置是文字的左下角。

8.设置画笔的字体:setFont(Font font)
9.设置画笔的颜色:setColor(Color c)

Java事件处理机制

基本说明

Java事件处理是采取“委派事件模型”。当事件发生时,产生事件的对象,会把此“信息”传递给“事件监听者”处理。这里所说的信息实际上就是java.awt.event事件类库里某个类所创建的对象,把它称为“事件的对象”。(事件发生的地方和处理的地方不同)

事件处理机制深入理解

1.事件源:事件源是一个产生事件的对象,比如按钮、窗口等。
2.事件:事件就是承载事件源状态改变时的对象,比如当键盘事件、鼠标事件、窗口事件等等,会产生一个事件对象。该对象保存着当前事件很多信息,比如KeyEvent对象有含义被按下键的Code值。java.awt.event包和javax.swing.event包中定义了各种事件类型。
3.事件类型:查阅JDK文档。
4.事件监听接口:

  • 当事件源产生一个事件,可以传递给事件监听者处理。
  • 事件监听者实际上就是一个类,该类实现了某个事件监听器接口。
  • 事件监听器接口有多种,不同的事件监听器接口可以监听不同的事件,一个类可以实现多个监听接口。
  • 这些接口在java.awt.event包和javax.swing.event包中定义。

Chapter 17 多线程基础

线程相关概念

  • 程序:是为了完成特定任务,用某种语言编写的一组指令的集合。

  • 进程:
    1.进程是指运行中的程序。
    2.进程是程序的一次执行过程,或者是正在运行的一个程序,是动态过程,有它自身的产生、存在和消亡的过程。

  • 线程:
    1.线程由进程创建的,是进程的一个实体。
    2.一个进程可以拥有多个线程。

  • 其他相关概念:
    1.单线程:同一个时刻,只允许执行一个线程。
    2.多线程:同一个时刻,可以执行多个线程。
    3.并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉。简单地说,单核CPU实现的多任务就是并发。
    4.并行:同一个时刻,多个任务同时执行。多核CPU可以实现并行。

线程基本使用

创建线程的两种方式

在Java中,线程来使用有两种方法。
1.继承Thread类,重写run方法。
2.实现Runnable接口,重写run方法。

继承Thread类

当一个类继承了Thread类,该类就可以当作线程使用。我们会重写run方法,写上自己的业务代码。Thread类实现了Runnable接口的run方法。所有线程全都结束之后,进程才会结束。

继承Thread类
**真正实现多线程效果的是`start0()`而不是`run()`。**

实现Runnable接口

继承Thread和实现Runnable的区别

1.从Java的设计来看,通过继承Thread或者实现Runnable接口来创建线程本质上没有区别。从JDK帮助文档可以发现,Thread类本身就实现了Runnable接口start()->start0()。
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制。建议使用Runnable。

线程终止

基本说明

1.当线程完成任务后,会自动退出。
2.还可以通过使用变量来控制run()方法退出的方式停止线程,即通知方式。

线程常用方法

常用方法

1.setName:设置线程名称,使之与参数name相同。
2.getName:返回该线程的名称。
3.start:使该线程开始执行;JVM底层调用该线程的start0()方法。
4.run:调用线程对象run()方法。
5.setPriority:更改线程的优先级。
6.getPriority:获取线程的优先级。
7.sleep:在指定的毫秒数内让当前正在执行的线程休眠。
8.interrupt:中断线程。
9.yield:线程的礼让。让出CPU,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功。
10.join:线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程的所有任务。

注意事项和细节:
1.start底层会创建新的线程,调用run,run就是一个简单的方法调用,不会启动线程。
2.线程优先级的范围:MIN_PRIORITY、NORM_PRIORITY、MAX_PRIOPRITY。
3.interrupt中断线程,但并没有真正的结束线程,所以一般用于中断正在休眠的线程,
4.sleep:线程的静态方法,使当前线程休眠。

用户线程和守护线程

1.用户线程:也叫工作线程。当线程的任务执行完成或通知的方式结束。
2.守护线程:一般是为工作线程服务的。当所有的用户线程结束,守护线程自动结束。
3.常见的守护线程:垃圾回收机制。

线程的生命周期

线程生命周期

线程的同步

线程同步机制

1.在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完成性。
2.线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对话该内存地址进行操作。

同步具体方法-Synchronized

1.同步代码块:

synchronized (对象){ //得到对象的锁,才能操作同步代码
//需要被同步的代码
}

2.synchronized还可以放在方法声明中,表示整个方法为同步方法。

public synchronized void m(String name){
//需要被同步的代码
}

互斥锁

基本介绍

1.Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性。
2.每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象。
3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。
4.同步的局限性:导致程序的执行效率降低。
5.同步方法(非静态)的锁可以是this,也可以是其他对象**(要求是同一个对象)**。
6.同步方法(静态)的锁为当前类本身(类名.class)。

注意事项和细节

1.同步方法如果没有使用static修饰:默认锁对象为this。
2.如果方法使用static修饰,默认锁对象:当前类.class。
3.实现的落地步骤:

  • 需要先分析上锁的代码。
  • 选择同步代码块或同步方法。
  • 要求多个线程的锁对象为同一个即可(保证上锁的对象是共同的对象)。

线程的死锁

基本介绍

多个线程都占用了对方的锁资源,但不肯相让,导致了死锁。在编程时,一定要避免死锁的发生。

释放锁

会释放锁的操作

1.当前线程的同步方法、同步代码块执行结束。
2.当前线程在同步代码块、同步方法中,遇到break、return。
3.当前线程在同步代码块、同步方法中,出现了未处理的Error或Exception,导致异常结束。
4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。

不会释放锁的操作

1.线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁。
2.线程执行同步代码块时,其他线程调用了该线程的suspend()(挂起)方法将该线程挂起,该线程不会释放锁。
应尽量避免使用suspend()和resume()来控制线程,方法不再推荐使用。

Chapter 19 I/O流

文件

文件是保存数据的地方。

文件流

文件在程序中是以流的形式来操作的。
流:数据在数据源(文件)和程序(内存)之间经历的路径。
输入流:数据从数据源(文件)到程序(内存)的路径。
输出流:数据从程序(内存)到数据源(文件)的路径。

常用的文件操作

创建文件对象相关构造器和方法

1
2
3
4
5
6
7
8
9
//根据路径构建一个File对象
new File(String pathname);
//根据父目录文件+子路径构建
new File(File parent,String child);
//根据父目录+子路径构建
new File(String parent,String child);

//在磁盘创建文件
file.creatNewFile();

获取文件的相关信息

1.getName:获取文件名。
2.getAbsolutePath:获取文件绝对路径。
3.getParent:获取文件父目录。
4.length:获取文件大小。
5.exists:判断文件是否存在。
6.isFile:判断其是不是一个文件。
7.isDirectory:判断其是不是一个目录。

目录的操作和文件删除

1.mkdir:创建一级目录。
2.mkdirs:创建多级目录。
3.delete:删除空目录或文件。

在Java编程中,目录也当作文件。

I/O流原理及流的分类

Java I/O流原理

1.I/O是Input/Output的缩写,I/O技术是非常实用的技术,用于处理数据传输。
2.Java程序中,对于数据的输入/输出操作以“流”的方式进行。
3.java.io包下提供了各种“流”类和接口,用以获取不同种类的数据,并通过方法输入或输出数据。
4.输入Input:读取外部数据(磁盘、光盘等存储设备的数据)到程序(内存)中。
5.输出Output:将程序(内存)数据输出到磁盘、光盘等存储设备中。

流的分类

  • 按操作数据单位不同分为:字节流(8 bit)、字符流(按字符)。
  • 按数据流的流向不同分为:输入流、输出流。
  • 按流的角色的不同分为:节点流、处理流/包装流。
抽象基类 字节流 字符流
输入流 InputStream Reader
输出流 OutputStream Writer

1.Java的I/O流共涉及40多个类,实际上非常规则,都是从如上4个抽象基类派生的。
2.由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

I/O流体系图-常用的类

InputStream:字节输入流

  • InputStream抽象类是所有类字节输入流的超类。
  • InputStream常用的子类:
    1.FileInputStream:文件输入流。
    2.BufferedInputStream:缓冲字节输入流。
    3.ObjectInputStream:对象字节输入流。

OutputStream:字节输出流

1.new FileOutputStream(filePath):创建方式,当写入内容时,会覆盖原本的内容。
2.new FileOutputStream(filePath,true):创建方式,当写入内容时,是追加到文件后面。

FileReader和FileWriter介绍

FileReader和FileWriter是字符流,即按照字符来操作I/O。

FileReader相关方法

1.new FileReader(File/String)
2.read:每次读取单个字符,返回该字符,如果到文件末尾返回-1。
3.read(char[]):批量读取多个字符到数组,返回读取到的字符数,如果到文件末尾返回-1。

相关API:
1.new String(char[]):将char[]转换成String。
2.new String(char[],off len):将char[]的指定部分转换成String`。

FileWriter相关方法

1.new FileWriter(File/String):覆盖模式,相当于流的指针在首端。
2.new FileWriter(File/String,true):追加模式,相当于流的指针在尾端。
3.writer(int):写入单个字符。
4.writer(char[]):写入指定数组。
5.writer(char[],off,len):写入指定数组的指定部分。
6.writer(String):写入整个字符串。
7.writer(String,off,len):写入字符串的指定部分。

相关API:
String类:toCharArray,将String转换成char[]。

注意:
FileWriter使用后,必须要关闭close或刷新flush,否则写入不到指定的文件!

节点流和处理流

基本介绍

1.节点流可以从一个特定的数据源读写数据。
2.处理流(也叫包装流),是“连接”在已存在的流(节点流或处理流)之上,为程序提供更为强大的读写功能,也更加灵活。

节点流和处理流的区别和联系

1.节点流是底层流/低级流,直接跟数据源相接。
2.处理流包装节点流,既可以消除不同节点流的实现差异,也可以提供更方便的方法来完成输入输出。
3.处理楼(也叫包装流)对节点进行包装,使用了修饰器设计模式,不会直接与数据源相连。

处理流功能的主要体现

1.性能的提高:主要以增加缓冲的方式来提高输入输出效率。
2.操作的便捷:处理流可能提供了一系列便捷的方法来一次输入输出大批量的数据,使用更加灵活方便。

处理流:BufferedReader和BufferedWriter

BufferedReader和BufferedWriter属于字符流,是按照字符来读取数据的。
关闭处理流时,只需要关闭外层流即可。

处理流:BufferedInputStream和BufferedOutputStream

BufferedInputStream和BufferedOutputStream是字节流。在创建时,会创建一个内部缓冲区数组。

对象流:ObjectInputStream和ObjcetOutputStream

序列化和反序列化:
1.序列化就是在保存数据时,保存数据的值和数据类型。
2.反序列化就是在回复数据时,恢复数据的值和数据类型。
3.需要让某个对象支持序列化机制,则必须让其类是可序列化的,为了让某个类是可序列化的,该类必须实现如下两个接口之一:
``Serializable(这里一个标记接口,里面**没有方法**)、Externalizable`。

基本介绍

1.功能:提供了对基本类型或对象类型的序列化和反序列化的方法。
2.ObjectInputStream:提供序列化功能。
3.ObjcetOutputStream:提供反序列化功能。

注意事项和细节说明

1.读写顺序要一致。
2.要求实现序列化或反序列化对象,**需要实现Serializable。
3.序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性。
4.序列化对象时,默认将里面所有的属性都进行序列化,但除了static或transient修饰的成员。
5.序列化对象时,要求里面属性的类型也需要实现序列化接口。
6.序列化具备可继承行,也就是如果某类已经实现了序列化,则它的所有子类也已经默认实现了序列化。

标准输入输出流

类型 默认设备
System.in 标准输入 InputStream 键盘
System.out 标准输出 PrintStream 显示器

转换流:InputStreamReader和OutputStreamWriter

1.InputStreamReader:Reader的子类,可以将InputStream(字节流)包装成Reader(字符流)。
2.OutputStreamWriter:Writer的子类,实现将OutputStream(字节流)包装成Writer(字符流)。
3.当处理纯文本数据时,如果使用字符流效率更高,并且可以有效解决中文问题,所以建议将字节流传换成字符流。
4.可以在使用时指定编码格式。

打印流:PrintStream和PrintWriter

打印流只有输出流,没有输入流。

Properties类

基本介绍

1.专门用于读写配置文件的集合类。

配置文件格式:
键=值

2.注意:键值对不需要有空格,值不需要用引号引起来,默认类型是String。
3.Properties的常见方法:

  • load:加载配置文件的键值对到Properties对象。
  • list:将数据显示到指定设备。
  • getProperty(key):根据键,获取值。
  • setProperty(key,value):设置键值对到Properties对象。
  • store:将Properties中的键值对存储到配置文件中。在IDEA中,保存信息到配置文件,如果含有中文,会存储为unicode码。

Chapter 21 网络编程

网络的相关概念

网络通信

1.概念:两台设备之间通过网络实现的数据传输。
2.网络通信:将数据通过网络从一台设备传输到另一台设备。
3.java.net包下提供了一系列的类或接口,供程序员使用,完成网络通信。

网络

1.概念:两台或多台设备通过一定物理设备连接起来构成了网络。
2.根据网络的覆盖范围不同,对网络进行分类:

  • 局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房。
  • 城域网:覆盖范围较大,可以覆盖一个城市。
  • 广域网:覆盖范围最大,可以覆盖全国、甚至全球,万维网是广域网的代表。

ip地址

1.概念:用于唯一标识网络中的每台计算机。
2.查看ip地址:ipconfig
3.ip地址的表示形式:电分十进制xx.xx.xx.xx
4.每一个十进制数的范围:0~255
5.ip地址的组成:网络地址+主机地址。
6.IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议,其地址数量号称可以为全世界的每一粒沙子编上一个地址。
7.由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了多种接入设备连入互联网的障碍。

域名

1.好处:为了方便记忆,解决记ip的困难。
2.概念:将ip地址映射成域名。

端口号

1.概念:用于标识计算机上某个特定的网络程序。
2.表示形式:以整数形式,范围065535。
3.0
1024已经被占用。
4.常见的网络程序端口号:

  • tomcat:8000
  • mysql:3306
  • oracle:1521
  • sqlserver:1433

网络通信协议

协议(tcp/ip)

TCP/IP中文译名为传输控制协议/因特网互联协议,又叫网络通讯协议。这个协议是Internet最基本的协议,Internet国际互联网络的基础。简单地说,就是由网络层的IP协议和传输层的TCP协议组成的。

网络通信协议

OSI模型 TCP/IP模型 TCP/IP模型各层对应协议
应用层 应用层 HTTP、ftp、
telnet、DNS....
表示层
会话层
传输层 传输层 TCP、UDP....
网络层 网络层 IP、ICMP、ARP....
数据链路层 物理+数据链路层 Link
物理层

TCP协议:传输控制协议

1.使用TCP协议前,须先建立TCP连接,形成传输数据通道。
2.传输前,采用“三次握手”方式,是可靠的。
3.TCP协议进行通信的两个应用进程:客户端、服务端。
4.在连接中可进行大数据的传输。
5.传输完毕,需释放已建立的连接,效率低。

UDP协议:用户数据协议

1.将数据、源、目的封装成数据包,不需要建立连接。
2.每个数据包的大小限制在64KB内,不适合传输大量数据。
3.因无需链接,故是不可靠的。
4.发送数据结束时,无需释放资源(因为不是面向连接的),速度快。

InetAdress类

相关方法

1.获取本机InetAdress对象:getLocalHost
2.根据指定主机名/域名获取ip地址对象:getByName
3.获取InetAdress对象的主机名:getHostName
4.获取InetAdress对象的地址:getHostAdress

Socket

基本介绍

1.套接字(Socket)开发网络应用程序被广泛采用,以至于称为事实上的标准。
2.通信的两端都要有Socket,是两台机器间通信的端点。
3.网络通信其实就是Socket间的通信。
4.Socket允许程序吧网络连接当成一个流,数据在两个Socket间通过IO传输。
5.一般主动发起通信的应用程序输入客户端,等待通信请求的为服务端。

TCP网络通信编程

基本介绍

1.基于客户端—服务端的网络通信。
2.底层使用的是TCP/IP协议。
3.基于Socket的TCP编程。

netstat指令

1.netstat -an:可以查看当前主机网络情况,包括端口监听情况和网络链接情况。
2.netstat -an|more:可以分页显示。
3.要求在dos控制台下执行。

说明:
1.LISTENING表示某个端口在监听。
2.如果有一个外部程序(客户端)连接到该端口,就会显示一条连接信息。
3.可以输入Ctrl+c退出指令。

其他

当客户端连接到服务器后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的,是随机的。

UDP网络通信编程

基本介绍

1.类DatagramSocket和DatagramPacket实现了基于UDP协议网络程序。
2.UPD数据报通过数据报套接字DatagramSocket发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
3.DatagramPacket对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
4.UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接。

说明:
1.没有明确的服务端和客户端,演变成数据的发送端和接收端。
接收数据和发送数据是通过DatagramSocket对象完成的。
将数据封装到DatagramPacket对象/装包。
当接收到DatagramPacket对象,需要进行拆包,取出数据。
DatagramSocket可以指定在哪个端口接收数据。

基本流程

1.核心的两个类/对象:DatagramSocket和DatagramPacket
2.建立发送端、接收端(没有服务端和客户端概念)
3.发送数据前,建立数据包。
4.调用DatagramSocket的发送、接受方法。
5.关闭DatagramSocket。

Chapter 23 反射

反射机制

1.反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量、构造器、成员方法等等),并能操作对象的属性及方法。反射在设计模式和底层框架都会用到。
2.、加载完类之后,在堆中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象包含了类的完整结构信息。通过这个对象得到类的结构。

  • 反射机制原理示意图:

    反射原理图

反射机制的作用

1.在运行时,判断任意一个对象所属的类。
2.在运行时,构造任意一个类的对象。
3.在运行时,得到任意一个类所具有的成员变量和方法。
4.在运行时,调用任意一个对象的成员变量和方法。
5.生成动态代理。

反射相关的主要类

1.java.lang.Class:代表一个类,Class对象表示某个类加载后在堆中的对象。
2.java.lang.reflect.Method:代表类的方法,Method对象表示某个类的方法。
3.java.lang.reflect.Field:代表类的成员变量,Field对象标识某个类的成员变量。
4.java.lang.reflect.Constructor:代表类的构造方法。Constructor对象表示构造器。

反射优点和缺点

1.优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
2.缺点:使用反射基本是解释执行,对执行速度有影响。

反射调用优化 - 关闭访问检查

1.Method和Field、Constructor对象都有setAccessible()方法。
2.setAccessible()作用是启动和禁用访问安全检查的开关。
3.参数值为true表示:反射的对象在使用时取消访问检查,提高反射的效率。
参数值为false则表示反射的对象执行访问检查。

Class类

基本介绍

1.Class也是类,因此也继承Object类。
2.Class类对象不是new出来的,而是系统创建的。
3.对于某个类的Class类对象,在内存中只有一份,因为类只加载一次。
4.通过Class对象的一系列API,可以完整地得到一个类的完整结构。
5.Class对象是存放在堆的。
6.类的字节码二进制数据是放在方法区的,有的地方称为类的元数据(包括方法代码、变量名、方法名、访问权限等等)。

Class类的常用方法

方法名 功能说明
static Class forName(String name) 返回指定类名name的Class对象
Object newInstance() 调用缺省构造函数,返回该Class对象的一个实例
getName() 返回此Class对象所表示的实体(类、接口、数组类、基本类型等)名称
Class getSuperClass() 返回当前Class对象的父类Class对象
Class[] getInterfaces() 获取当前Class对象的接口
ClassLoader getClassLoader() 返回该类的类加载器
Class getSuperclass() 返回表示此Class所表示的实体的超类Class
Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields() 返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes) 返回一个Method对象,此对象的形参类型为paramType

获取Class类对象

1.代码阶段/编译阶段:已知一个类的全类名,且该类在类路径下,可以通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException。
应用场景:多用于配置文件,读取类全路径,加载类。
2.Class类阶段(加载阶段):若已知具体的类,通过类的class获取,该方式最为安全可靠,程序性能最高。
应用场景:多用于参数传递。
3.Runtime运行阶段:已知某个类的实例,调用该实例的getClass()方法获取Class对象。
应用场景:通过创建好的对象,获取Class对象。
4.其他方式(类加载器):
(1)先得到类加载器:ClassLoader cl = 对象.getClass().getClassLoader();
(2)通过类加载器得到Class对象:Class clazz = cl.loadClass("类的全类名");
5.基本数据(int、char、boolean、float、double、byte、long、short)按照如下方式得到Class类对象:Class cls = 基本数据类型.class。
6.基本数据类型对应的包装类,可以通过.TYPE得到Class类对象:Class cls = 包装类.TYPE。

有Class对象的类型

  • 外部类、成员内部类、静态内部类、局部内部类、匿名内部类。
  • 接口(interface)。
  • 数组。
  • 枚举(enum)。
  • 注解(annotation)。
  • 基本数据类型。
  • void。

类加载

基本说明

反射机制是Java实现动态语言的关键,也就是通过反射实现类动态加载。
1.静态加载:编译时加载相关的类,如果没有则报错,依赖性太强。
2.动态加载:运行时加载需要的类,如果运行时不用该类,即使该类不存在,也不报错,降低了依赖性。

类加载时机

静态加载:
1.当创建对象时(new)。
2.当子类被加载时。
3.调用类中的静态成员时。

动态加载:通过反射。

类加载过程图

类加载流程图

类加载各阶段完成的任务

1.加载:将类的class文件读入内存,并为之创建一个java.lang.Class对象。此过程由类加载器完成。
2.连接:将类的二进制数据合并到JRE中。

  • 验证:目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。内容包括文件格式验证(是否以魔数oxcafebabe开头)、元数据验证、字节码验证和符号引用验证。可以考虑使用-Xverify:none参数来关闭大部分的类验证措施,缩短虚拟机类加载的时间。
  • 准备:JVM会在该阶段对静态变量分配内存并默认初始化(对应数据类型的默认初始值,如0、0L、null等)。这些变量所使用的内存都将在方法区中进行分配。实例对象在准备阶段不会分配内存,常量一旦分配值就不会发生更改。
  • 解析:虚拟机将常量池内的符号引用替换为直接引用的过程。
    3.初始化:JVM负责对类进行初始化,这里主要是指静态成员。

通过反射获取类的结构信息

java.lang.Class类

1.getName:获取全类名。
2.getSimpleName:获取简单类名。
3.getFields:获取所有public修饰的属性,包含本类以及父类的。
4.getDeclaredFields:获取本类中所有属性。
5.getMethods:获取所有public修饰的方法,包含本类以及父类的。
6.getDeclaredMethods:获取本类中所有方法。
7.getConstructors:获取所有public修饰的构造器,包含本类以及父类的。
8.getDeclaredConstructors:获取本类中所有构造器。
9.getPackage:以Package形式返回包信息。 10.getSuperClass:以Class形式返回父类信息。 11.getlnterfaces:以Class[]形式返回接口信息。 12.getAnnotations:以Annotation[]`形式返回注解信息。

java.lang.reflect.Field类

1.getModifiers:以int形式返回修饰符。(默认修饰符是0,public是1,private是2,protected是4,static是8,final是16。)
2.getType:以Class形式返回类型。
3.getName:返回属性名。

java.lang.reflect.Method类

1.getModifiers:以int形式返回修饰符。(默认修饰符是0,public是1,private是2,protected是4,static是8,final是16。)
2.getReturnType:以Class形式获取返回类型。
3.getName:返回方法名。
4.getParameterTypes:以Class[]返回参数类型数组。

java.lang.reflect.Constructor类

1.getModifiers:以int形式返回修饰符。(默认修饰符是0,public是1。)
2.getName:返回构造器名(全类名)。
3.getParameterTypes:以Class[]返回参数类型数组。

通过反射创建对象

1.方式一:调用类中的public修饰的无参构造器。
2.方式二:调用类中的指定构造器。
3.Class类相关方法:

  • newInstance:调用类中的无参构造器,获取对应类的对象。
  • getConstructor(Class...clazz):根据参数列表,获取对应的公有构造器对象。
  • getDecalaredConstructor(Class...clazz):根据参数列表,获取对应的所有构造器对象。

4.Constructor类相关方法:

  • setAccessible:暴力破解。
  • newInstance(Object...obj):调用构造器。

通过反射访问类中的成员

1.根据属性名获取Field对象。

Field f = clazz.对象.getDeclaredField(属性名);

2.暴力破解:f.setAccessible(true);
3.访问:

f.set(o,值);
syso(f.get(o));

4.注意:如果是静态属性,则set和get中的参数o,可以写成null。

通过反射访问类中的成员

1.根据方法名和参数列表获取Method方法对象:

Method m = clazz.getDeclaredMethod(方法名,XX.class);

2.获取对象:

Object o = clazz.newInstance();

3.暴力破解:

m.setAccessible(true);

4.访问:

Object returnValue = m.invoke(o,实参列表);

5.注意:如果是静态方法,则invoke的参数o,可以写成null。

Chapter 24 MySQL

连接到MySQL的指令

mysql -h 主机IP -P 端口 -u 用户名 -p密码

1.-p密码不要有空格。
2.-p后面没有写密码,回车会要求输入密码。
3.如果没有写-h 主机,默认就是本机。
4.如果没有写-P 端口,默认就是3306。

SQL语句分类

  • DDL:数据定义语句(creat)。
  • DML:数据操作语句(增加insert/修改update/删除delete)。
  • DQL:数据查询语句(select)。
  • DCL:数据控制语句(管理数据库:比如用户权限)。

创建数据库

1
2
3
4
5
6
7
CREATE DATABASE [IF NOT EXISTS] db_name
[create_specification[,create_specification]...]

create_specification:

[DEFAULT] CHARACTER SET charset_name
[DEFAULT] COLLATE collation_name

1.CHARACTER SET:指定数据库采用的字符集,如果不指定字符集,默认utf8。
2.COLLATE:指定数据库字符集的校对规则(常用的utf8_bin区分大小写、utf8_general_ci不区分大小写。注意:默认是utf8_general_ci)。

查看/删除数据库

1
2
3
4
5
6
7
8
#查看当前数据库服务器中的所有数据库:
SHOW DATABASES

#显示数据库创建语句:
SHOW CREATE DATABASE db_name

#数据库删除语句:
DROP DATABASE [IF EXISTS] db_name

在创建数据库/表时,为了规避关键字,可以使用反引号``解决。

备份恢复数据库

  • 备份数据库(注意:在DOS执行)

    mysqldump -u 用户名 -p -B 数据库1 数据库2 数据库n > 文件名.sql

  • 恢复数据库(注意:进入MySQL命令行再执行)

    Source 文件名.sql
    或者直接将文件名.sql的内容放到SQLyog的查询编辑器中执行。

备份恢复数据库的表

  • 备份库的表

    mysqldump -u 用户名 -p密码 数据库 表1 表2 表n > 文件名.sql

创建表

1
2
3
4
5
6
CREATE TABLE table_name
(
field1 datatype,
field2 datatype,
field3 datatype
)CHARACTER SET charset_name COLLATE collation_name ENGINE engine_name;

field:指定列名。
datatype:指定列类型(字段类型)。
CHARACTER SET:如不指定,则为所在数据库字符集。
COLLATE:如不指定,则为所在数据库校对规则。
ENGINE:存储引擎。

MySQL常用数据类型

整型

类型 字节 最小值 最大值
TINYINT 1 -128 127
TINYINT UNSIGNED 1 0 255
SMALLINT 2 -32768 32767
SMALLINT UNSIGNED 2 0 65535
MEDIUMINT 3 -8388608 8388607
MEDIUMINT UNSIGNED 3 0 16777215
INT 4 -2147483648 2147483647
INT UNSIGNED 4 0 4294967295
BIGINT 8 -9223372036854775808 9223372036854775807
BIGINT UNSIGNED 8 0 18446744073709551615

使用规范:在能够满足需求的情况下,尽量选择占用空间小的类型。

bit

基本使用

1
2
3
mysql> create table t02(num bit(8));
mysql> insert into t02(1,3);
mysql> insert into t02 values(2,65);

细节说明

1.bit字段显示时,按照位的方式显示。
2.查询的时候仍然可以使用添加的数值来查询。
3.如果一个值只有0/1,可以考虑使用bit(1),可以节约空间。
4.位类型,bit(M)中,M指定位数,默认值为1,范围为1-64。
5.使用不多。
6.添加数据的范围按照设定的位数来确定。

小数类型

1
FLOAT/DOUBLE [UNSIGNED]

FLOAT:单精度小数。
DOUBLE:双精度小数。

1
DECIMAL[M,D] [UNSIGNED]

1.可以支持更加精确的小数位。M是小数位数(精度)的总数,D是小数点(标度)后面的位数。
2.如果D是0,则值没有小数点或分数部分。M最大为65,D最大为30。如果D被省略,默认是0;如果M被省略,默认是10。
建议:如果希望小数的精度高,推荐使用DECIMAL。

字符串类型

字符串的基本使用

1
2
3
4
5
CHAR(size)
# 固定长度字符串,最大255字符

VARCHAR(size)
# 可变长度字符串,最大65532字节(utf8编码最大21844字符,其中1-3个字节用于记录大小。不同编码可以存放的最大字符数不同)

字符串使用细节

1.char(4):这个4表示字符数(最大为255),不是字节数。不管是中文还是字母都是放四个,按照字符计算。
varchar(4):这个4表示字符数,不管是字母还是中文都以定义好的表的编码来存放数据,是按照字符来存放的。
2.char(4)是定长,即即使插入的内容长度不足4个字符,也会占用分配的4个字符空间。
varchar(4)是变长,即插入的内容长度不足4个字符,则按照实际占用空间来分配**(VARCHAR本身还需要占用1-3个字节来记录存放内容的长度)。
3.如果数据是定长,推荐使用char;如果一个字段的长度是不确定的,则使用varchar。
4.查询速度:CHAR > VARCHAR。
5.在存放文本时,也可以使用Text数据类型。可以将TEXT列视为VARCHAR列。
(注意:Text不能有默认值,大小为0-2^16字节。如果希望存放更多字符,可以选择MEDIUMTEXT或者LONGTEXT。)

日期类型的基本使用

代码示例:

1
2
3
4
5
6
7
8
9
CREATE TABLE birthday
( t1 DATE,t2 DATETIME,
t3 TIMESTAMP NOT NULL DEFAULT
CURRENT_TIMESTAMP ON UPDATE
CURRENT_TIMESTAMP);
# TIMESTAMP:时间戳

mysql>INSERT INTO birthday(t1,t2)
VALUES('2026-07-22','2026-07-22 16:53:24');

细节说明:
时间戳在INSERT和UPDATE时,自动更新。

修改表

基本介绍

使用ALTER TABLE语句追加、修改或删除列的语法。

  • 添加列:

    1
    2
    3
    ALTER TABLE tablename
    ADD (column datatype[DEFAULT expr]
    [,column datatype]...);
  • 修改列:

    1
    2
    3
    ALTER TABLE tablename
    MODIFY (column datatype [DEFAULT expr]
    [,column datatype]...);
  • 删除列:

    1
    2
    ALTER TABLE tablename
    DROP (column);
  • 查看表的结构(查看表的列):DESC 表名。

  • 修改表名:RENAME TABLE 表名 TO 新表名。

  • 修改表字符集:ALTER TABLE 表名 CHARACTER SET 字符集。

数据库CRUD语句

INSERT语句:添加数据

1
2
INSERT INTO table_name[(column[,column...])]
VALUES (value[,value...]);

细节说明:
1.插入的数据应与字段的数据类型相同。
2.数据的长度应在列的规定范围内。
3.在VALUES中列出的数据位置必须与被加入的列的排列位置相对应。
4.字符和日期型数据应包含在单引号中。
5.列可以插入控制**(前提是该字段允许为空)**。
6.使用INSERT INTO table_name(列名...) VALUES(),(),()的形式添加多条记录。
7.如果是给表中的所有字段添加数据,可以不写前面的字段名称。
8.默认值的使用:当不给某个字段值时,如果有默认值就会添加,否则报错。

UPDATE语句:更新数据

1
2
3
UPDATE table_name
SET col_name1=expr1[,col_name2=expr2...]
[WHERE where_defintion]

使用细节:
1.UPDATE语法可以用新值更新原有表行中的各列。
2.SET子句指示要修改哪些列和要给予哪些值。
3.WHERE子句指定应更新哪些行。如果没有WHERE语句,则更新所有的行(记录)。
4.如果需要修改多个字段,可以通过SET 字段1=值1,字段2=值2...。

DELETE语句:删除语句

1
2
DELETE FROM table_name
[WHERE where_defintion]

使用细节:
1.如果不适用WHERE子句,将删除表中所有数据。
2.DELETE语句不能删除某一列的值(可以使用UPDATE设为NULL或者'')。
3.使用DELETE语句仅删除记录,不删除表本身。如要删除表,使用DROP TABLE 表名语句。

SELECT语句:查找语句

1
2
SELECT [DISTINCT] *|{column1,column2,column3...}
FROM table_name;

注意事项:
1.SELECT指定查询哪些列的数据。
2.column指定列名。
3.*代表查询所有列。
4.FROM指定查询哪张表。
5.DISTINCT可选,指显示结果时,是否去掉重复数据。

使用表达式,对查询的列进行运算

1
2
SELECT *|{column1|expression,column2|expression,...}
FROM table_name;

AS语句

1
SELECT column_name AS 别名 FROM 表名;

在WHERE子句中经常使用的运算符

分类 运算符 说明
比较运算符 > 大于
< 小于
<= 小于等于
>= 大于等于
= 等于
<>、!= 不等于
BETWEEN ... AND ... 显示在某一区间的值
IN (set) 显示在集合中的值,例如:IN (100, 200)
LIKE 'pattern' 模糊查询
NOT LIKE 'pattern' 模糊查询(取反)
IS NULL 判断是否为空
逻辑运算符 AND 多个条件同时成立
OR 多个条件任一成立
NOT 条件不成立,例如:WHERE NOT (salary > 100)

使用ORDER BY子句排序查询结果

1
2
3
SELECT column1,column2,column3...
FROM table;
ORDER BY column ASC|DESC,...

1.ORDER BY指定排序的列,排序的列既可以是表中的列名,也可以是SELECT语句后指定的列名。
2.ASC为升序(默认),DESC为降序。
3.ORDER BY子句应位于SELECT语句的结尾。

查询加强

  • 使用WHERE子句。

  • 使用LIKE操作符模糊查询:

    • %:表示0到多个任意字符。
    • _:表示单个任意字符。
  • 使用ORDER BY子句。

  • 分页查询:

    1
    SELECT ... LIMIT start,rows

    表示从start+1行开始取,取出rows行,start从0开始计算。

  • 使用分组函数和分组子句GROUP BY。

  • 总结:如果SELECT语句同时包含有GROUP BY、HAVING、LIMIT、ORDER BY,那么它们的顺序是:GROUP BY→HAVING→ORDER BY→LIMIT。

多表查询

笛卡尔集

在默认情况下,当两张表查询时,会从第一张表中取出一行与第二张表的每一行进行组合,返回结果(含有两张表的所有列)。一共返回的记录数为第一张表的行数*第一张表的行数。
解决办法:**写出正确的过滤条件。**多表查询的条件不能少于表的个数-1,否则会出现笛卡尔集。

自连接

自连接是指在同一张表的连接查询(将同一张表看做两张表)。
特点:
1.把同一张表当作两张表使用。
2.需要给表取别名。
3.列名不明确,可以指定列的别名。

外连接
  • 左外连接:左侧的表完全显示。

    1
    SELECT ... FROM table_left LEFT JOIN table_right ON ...
  • 右外连接:右侧的表完全显示。

    1
    SELECT ... FROM table_left RIGHT JOIN table_right ON ...

子查询

子查询是指嵌入在其他SQL语句中的SELECT语句,也叫嵌套查询。

  • 单行子查询:只返回一行数据的子查询语句。
  • 多行子查询:返回多行数据的子查询,使用关键字IN。
  • 子查询当作临时表使用,在FROM子句中使用子查询。
  • 在多行子查询中使用ALL、ANY操作符。
  • 多列子查询:查询返回多个列数据的子查询语句。

    (字段1,字段2…) = (SELECT 字段1,字段2 FROM …)

合并查询

为了合并多个SELECT语句的结果,可以使用集合操作符号UNION、UNION ALL。

  • UNION ALL:该操作符用于取得两个结果集的并集。当使用该操作符时,不会取消重复行。
  • UNION:该操作符与UNION ALL相似,但是会自动去掉结果集中的重复行。

函数

统计函数

COUNT

COUNT返回行的总数:

1
2
SELECT COUNT (*)|COUNT(列名) FROM table_name
[WHERE where_defintion]

COUNT (*)不排除为NULL的内容,COUNT(列名)会排除为NULL的内容。

SUM

SUM函数返回满足WHERE条件的行的和:

1
2
SELECT  SUM(列名) {,SUM(列名)} FROM table_name
[WHERE where_defintion]

1.SUM仅对数值起作用,否则会报错。
2.对多列求和,,不能少。

AVG

AVG函数返回满足WHERE条件的一列的平均值:

1
2
SELECT AVG(列名) {,AVG(列名)...} FROM table_name
[WHERE where_defintion]

MAX/MIN

MAN/MIN函数返回满足WHERE条件的一列的最大/小值:

1
2
SELECT MAX(列名) FROM table_name
[WHERE where_defintion]

分组统计

  • 使用GROUP BY子句对列进行分组:

    1
    2
    SELECT column1,column2,column3... FROM table
    GROUP BY column
  • 使用HAVING子句对分组后的结果进行过滤

    1
    2
    3
    SELECT column1,column2,column3...
    FROM table
    GROUP BY column HAVING ...

字符串函数

字符串函数 说明
CHARSET(str) 返回字符串字符集
CONCAT(string2 [, ... ]) 连接字符串
INSTR(string, substring) 返回 substring 在 string 中出现的位置,没有返回 0(如果没有设定好的表,可以使用DUAL亚元表作为测试表)
UCASE(string2) 转换成大写
LCASE(string2) 转换成小写
LEFT(string2, length) 从 string2 的左边起取 length 个字符
RIGHT(string2, length) 从 string2 的右边起取 length 个字符
LENGTH(string) string 长度(按照字节)
REPLACE(str, search_str, replace_str) 在 str 中用 replace_str 替换 search_str
STRCMP(string1, string2) 逐字符比较两字符串大小
SUBSTRING(str, position [, length]) 从 str 的 position 开始(从1开始计算),取 length 个字符
LTRIM(string2) / RTRIM(string2) 去除前端空格或后端空格
TRIM(string) 去除前后两端的空格

数学函数

数学函数 说明
ABS(num) 绝对值
BIN(decimal_number) 十进制转二进制
CEILING(number2) 向上取整,得到比 number2 大的最小整数
CONV(number2, from_base, to_base) 进制转换
FLOOR(number2) 向下取整,得到比 number2 小的最大整数
FORMAT(number, decimal_places) 保留小数位数(四舍五入)
HEX(decimalNumber) 转换为十六进制
LEAST(number, number2 [, ...]) 求最小值
MOD(numerator, denominator) 求余(取模)
RAND([seed]) RAND([seed]):返回一个随机数,其范围为 0 ≤ v ≤ 1.0

日期函数

日期和时间函数 说明
CURRENT_DATE() 当前日期
CURRENT_TIME() 当前时间
CURRENT_TIMESTAMP() 当前时间戳
DATE(datetime) 返回 datetime 的日期部分
DATE_ADD(date2, INTERVAL d_value d_type) 在 date2 中加上日期或时间
DATE_SUB(date2, INTERVAL d_value d_type) 在 date2 上减去一个时间
DATEDIFF(date1, date2) 两个日期之差(结果是天数)
TIMEDIFF(date1, date2) 两个时间之差(多少小时、多少分钟、多少秒)
NOW() 当前时间
YEAR(datetime)
MONTH(datetime)
DATE(datetime)
获取年月日
UNIX_TIMESTAMP() 返回1970-1-1到现在的秒数
FROM_UNIXTIME() 把一个UNIX_TIMESTAMP秒数转成指定格式的日期

1.DATE_ADD()中的INTERVAL后面可以是YEAR、HOUR、MINUTE、SECOND、DAY等。
2.DATE_SUB()中的INTERVAL后面可以是YEAR、HOUR、MINUTE、SECOND、DAY等。
3.DATEDIFF(date1,date2)得到的是天数,而且是date1-date2的天数,因此可以取复数。
4.DATE()、DATE_ADD()、DATE_SUB()、DATEDIFF()这四个函数的日期类型可以是date、datetime或者timestamp。
5.在实际开发中,经常使用int来保存一个unix时间戳,然后使用FROM_UNIXTIME进行转换。

加密和系统函数

系统信息与加密函数 说明
USER() 查询当前用户,返回格式:用户@IP地址
DATABASE() 返回当前数据库名称
MD5(str) 为字符串 str 计算一个 32 位 MD5 字符串,常用于用户密码加密
PASSWORD(str)
SELECT * FROM mysql.user \G
从原文密码 str 计算并返回密码字符串,通常用于对 MySQL 数据库用户密码进行加密

流程控制函数

条件判断函数 说明
IF(expr1, expr2, expr3) 如果 expr1 为 True,则返回 expr2,否则返回 expr3
IFNULL(expr1, expr2) 如果 expr1 不为空 NULL,则返回 expr1,否则返回 expr2
SELECT CASE
WHEN expr1 THEN expr2
WHEN expr3 THEN expr4
ELSE expr5 END
(类似多重分支)
如果 expr1 为 TRUE,则返回 expr2;
如果 expr3 为 TRUE,则返回 expr4;
否则返回 expr5

表复制

自我复制数据(蠕虫复制):
为了对某个SQL语句进行效率测试,需要海量数据时,可以使用此法为表创建海量数据。

  • 表去重思路:
    1.先创建一张临时表,该表的结构和原表一样。
    2.把临时表的记录通过DISTINCT关键字处理后把记录复制到临时表。
    3.清除掉原表记录。
    4.把临时表的记录复制到原表。
    5.DROP掉临时表。

约束

基本介绍

约束用于确保数据库的数据满足特定的商业规则。在MySQL中,约束包括:NOT NU LL、UNIQUE、PRIMARY KEY、FOREIGN KEY和CHECK五种。

PRIMARY KEY 主键

基本使用

字段名 字段类型 PRIMARY KEY

用于唯一的标示表行的数据。当定义主键约束后,该列不能重复。

细节说明

1.PRIMARY KEY不能重复而且不能为NULL。
2.一张表最多只能有一个主键,但可以是复合主键。
3.主键的指定方式有2中:

  • 直接在字段名后面指定:

    字段 PRIMARY KEY

  • 在表定义最后写:

    PRIMARY KEY(列名);

4.使用DESC 表名,可以看到PRIMARY KEY的情况。

NOT NULL 非空

如果在列上定义了NOT NULL,那么当插入数据时,必须为列提供数据。

字段名 字段类型 NOT NULL

UNIQUE 唯一

当定义了唯一约束后,该列值是不能重复的。

字段名 字段类型 UNIQUE

细节说明:
1.如果没有指定NOT NULL,则UNIQUE字段可以有多个NULL。
2.如果一个列(字段)是UNIQUE NOT NULL,则使用效果类似PRIMARY KEY。
3.一张表可以有多个UNIQUE字段。

FOREIGN KEY 外键

用于定义主表和从表之间的关系:外键约束要定义在从表上,主表则必须具有主键约束或是UNIQUE约束。当定义外键约束后,要求外键列数据必须在主表的主键列存在或是为NULL。

FOREIGN KEY (本表字段名) REFERENCES 主表名(主键名或UNIQUE字段名)

细节说明:
1.外键指向的表的字段,要求是PRIMARY KEY或者是UNIQUE。
2.表的类型是InnoDB,这样的表才支持外键。
3.外键字段的类型要和主键字段的类型一致(长度可以不同)。
4.外键字段的值,必须在主键字段中出现过,或者为NULL(前提是外键字段允许为NULL)
5.一旦建立主外键的关系,数据就不能随意删除了。

CHECK

用于强制行数据必须满足的条件。

列名 类型 CHECK(CHECK条件)

自增长

基本介绍

字段名 整型 PRIMARY KEY AUTO_INCREMENT

添加自增长的字段方式

  • INSERT INTO xxx (字段1,字段2...) VALUES(NULL,'值'...);
  • INSERT INTO xxx (字段2...) VALUES('值1','值2'...);
  • INSERT INTO xxx VALUES(NULL,'值1'...);

使用细节

1.一般来说,自增长是和PRIMARY KEY配合使用的。
2.自增长也可以单独使用,但是需要配合一个UNIQUE。
3.自增长修饰的字段一般为整数型的。虽然小数也可以,但是使用情况极少。
4.自增长默认从1开始,也可以通过如下命令修改:

ALTER TABLE 表名 AUTO_INCREMENT = xxx;

5.如果添加数据时,给自增长字段(列)指定的值,则以指定的值为准。由于自增长会遵循目前字段中的最大值进行,所以一般来说,如果指定了自增长,就按照自增长的规则来添加数据。

索引

索引的类型

1.主键索引:主键自动的为主索引(类型:PRIMARY KEY)。
2.唯一索引:UNIQUE。
3.普通索引:INDEX。
4.全文索引:FULLTEXT。一般不适用MySQL自带的全文索引,而是使用全文搜索Solr和ElasticSearch。

索引的使用

1.创建索引:

1
CREATE [UNIQUE] INDEX index_name ON table_name(column_name[(length) ASC|DESC],...);

另一个添加普通索引的办法:

1
ALTER TABLE table_name ADD INDEX [index_name] (index_column_name,..)

添加主键索引:

1
ALTER TABLE table_name ADD PRIMARY KEY [index_name] (index_column_name)

2.删除索引:

1
DROP INDEX index_name ON table_name

删除主键索引:

1
ALTER TABLE table_name DROP PRIMARY KEY

3.查询索引:

1
2
3
SHOW INDEX[/INDEXES/KEYS] FROM table_name

DESC table_name

4.修改索引:先删除,再添加新的索引。

创建索引的规则

1.较频繁的作为查询条件字段应该创建索引。
2.唯一性太差的字段不适合单独创建索引,即使频繁作为查询条件。
3.更新非常频繁的字段不适合创建索引。
4.不会出现在WHERE子句中的字段不该创建索引。

事务

概念

事务用于保证数据的一致性,它由一组相关的dml语句组成。该组的dml语句要么全部成功,要么全部失败。

事务和锁

当执行事务操作时,MySQL会在表上加锁,防止其他用户改表的数据。

基本操作

1.START TRANSACTION/SET autocommit = off:开始一个事务。
2.SAVEPOINT 保存点名:设置保存点。
3.ROLLBACK TO 保存点名:回退事务。
4.ROLLBACK:回退全部事务。
5.COMMIT:提交事务,所有操作生效,不能回退。

细节说明

1.如果不开始事务,在默认情况下,dml操作是自动提交的,不能回滚。
2.如果开始一个事务,在没有创建保存点时执行ROLLBACK默认回滚到事务开始的状态。
3.可以在事务还没有提交时,创建多个保存点。
4.可以在事务没有提交前,选择回退到哪个保存点。
5.MySQL的事务机制需要InnoDB的存储引擎才可以使用。

事务隔离级别

介绍

多个连接开启各自事务,操作数据库中数据时,数据库系统要负责隔离操作,以保证各个连接在获取数据时的准确性。
如果不考虑隔离性,则可能会引发脏读、不可重复读、幻读的问题。

  • 脏读:当一个事务读取另一个事务尚未提交的修改时,产生脏读。
  • 不可重复读:同一查询在同一事务中多次进行,由于其他提交事务所做的修改或删除,每次返回不同的结果集,此时发生不可重复读。
  • 幻读:同一查询在同一事务中多次进行,由于其他提交事务所做的插入操作,每次返回不同的结果集,此时发生幻读。

概念:MySQL隔离级别定义了事务与事务之间的隔离程度。

事务隔离级别

MySQL隔离级别 脏读 不可重复读 幻读 加锁读
读未提交(Read uncommitted) √ √ √ 不加锁
读已提交(Read committed) × √ √ 不加锁
可重复读(Repeatable read) × × × 不加锁
可串行化(Serializable) × × × 加锁

1.查看当前会话的隔离级别:SELECT @@tx_isolation
2.查看系统当前的隔离级别:SELECT @@global.tx_isolation
3.设置当前会话隔离级别:SET SESSION TRANSACTION ISOLATION LEVEL …
4.设置系统当前隔离级别:SET GLOBAL TRANSACTION ISOLATION LEVEL …
5.MySQL默认的事务隔级别是REPEATABLE READ。一般情况下,该级别可以满足绝大部分项目需求,没有特殊要求,没有必要修改。
6.全局修改:修改my.ini配置文件,在最后加上
#可选参数有:READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE.
[mysqld]
transaction-isolation = REPEATABLE-READ

ACID特性

1.原子性:事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。
2.一致性:事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
3.隔离性:多个用户并发访问数据库时,数据库为每一个用户开启的事务,不能被其他事务的操作数据所干扰,多个并发事务之间要相互隔离。
4.持久性:一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障,也不应该对其有任何影响。

表类型和存储引擎

基本介绍

1.MySQL的表类型由存储引擎决定,主要包括MyISAM、InnoDB、MEMORY等。
2.MySQL数据表主要支持六种类型,分别是:CSV、Memory、ARCHIVE、MRG_MYISAM、MyISAM、InnoDB。这六种类型又可以分为两类,一类是事务安全型,如InnoDB,其余都属于第二类,成为非事务安全型。

主要的存储引擎/表类型特点

特点 MyISAM InnoDB MEMORY Archive
批量插入的速度 高 低 高 非常高
事务安全 支持
全文索引 支持
锁机制 表锁 行锁 表锁 行锁
存储限制 没有 64TB 有 没有
B树索引 支持 支持 支持
哈希索引 支持 支持
集群索引 支持
数据缓存 支持 支持
索引缓存 支持 支持 支持
数据可压缩 支持 支持
空间使用 低 高 N/A 非常低
内存使用 低 高 中等 低
支持外键 支持

细节说明

1.MyISAM不支持事务,也不支持外键,但其访问速度快,对事务完整性没有要求。
2.InnoDB存储引擎提供了具有提交、回滚和崩溃回复能力的事务安全,但是比起MyISAM存储引擎,InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引。
3.MEMORY存储引擎使用存在内存中的内容来创建表。每个MEMORY表只实际对应一个磁盘文件。MEMORY类型的表访问非常得快,因为它的数据是存放在内存中的,并且默认使用HASH索引。但是一旦服务关闭,表中的数据就会丢失掉,表的结构还在。

如何选择表的存储引擎

1.如果不需要事务,处理的只是基本的CRUD操作,那么MyISAM是不二选择,速度快。
2.如果需要支持事务,选择InnoDB。
3.MEMORY存储引擎就是将数据存储在内存中,由于没有磁盘I/O的等待,速度极快。但由于是内存存储引擎,所做的任何修改在服务器重启后都将消失。

通过指令修改存储引擎

1
ALTER TABLE table_name ENGINE = 存储引擎;

视图

基本概念

视图是一个虚拟表,其内容由查询定义。同真实的表一样,视图包含列,其数据来自对应的真实表(基表)。

基本使用

1.CREATE VIEW view_name AS SELECT ...:创建视图。
2.ALTER VIEW view_name AS SELECT ...:更新成新的视图。
3.SHOW CREATE VIEW view_name:查看创建视图的指令。
4.DROP VIEW view_name1...:删除视图。

细节讨论

1.创建视图后,到数据库去看,对应视图只有一个视图结构文件(形式:视图名.frm)。
2.视图的数据变化会影响到基表,基表的数据变化也会影响到视图。
3.视图中可以再使用视图,数据仍然来自基表。

视图最佳实践

1.安全。
2.性能。
3.灵活。

MySQL管理

MySQL用户管理

MySQL中的用户都存储在系统数据库mysql中的user表中。
其中user表的重要字段说明:
1.host:允许登录的位置。localhost表示该用户只允许本机登录,也可以指定IP。
2.user:用户名。
3.authentication string:密码。通过MySQL的password()函数加密之后的密码。

创建用户

1
CREATE USER '用户名'@'允许登录的位置' IDENTIFIED BY '密码'

创建用户,同时指定密码。

删除用户

1
DROP USER '用户名'@'允许登录的位置'

用户修改密码

  • 修改自己的密码:

    1
    SET PASSWORD = PASSWORD('密码');
  • 修改他人密码(需要有修改用户密码的权限):

    1
    SET PASSWORD FOR '用户名'@'登陆位置' = PASSWORD('密码');

MySQL权限管理

权限 意义
ALL [PRIVILEGES] 设置除GRANT OPTION之外的所有简单权限
ALTER 允许使用ALTER TABLE
ALTER ROUTINE 更改或取消已存储的子程序
CREATE 允许使用CREATE TABLE
CREATE ROUTINE 创建已存储的子程序
CREATE TEMPORARY TABLES 允许使用CREATE TEMPORARY TABLE
CREATE USER 允许使用CREATE USER、DROP USER、RENAME USER和REVOKE ALL PRIVILEGES。
CREATE VIEW 允许使用CREATE VIEW
DELETE 允许使用DELETE
DROP 允许使用DROP TABLE
EXECUTE 允许用户运行已存储的子程序
FILE 允许使用SELECT…INTO OUTFILE和LOAD DATA INFILE
INDEX 允许使用CREATE INDEX和DROP INDEX
INSERT 允许使用INSERT
LOCK TABLES 允许对您拥有SELECT权限的表使用LOCK TABLES
PROCESS 允许使用SHOW FULL PROCESSLIST
REFERENCES 未被实施
RELOAD 允许使用FLUSH
REPLICATION CLIENT 允许用户询问从属服务器或主服务器的地址
REPLICATION SLAVE 用于复制型从属服务器(从主服务器中读取二进制日志事件)
SELECT 允许使用SELECT
SHOW DATABASES SHOW DATABASES显示所有数据库
SHOW VIEW 允许使用SHOW CREATE VIEW
SHUTDOWN 允许使用mysqladmin shutdown
SUPER 允许使用CHANGE MASTER、KILL、PURGE MASTER LOGS和SET GLOBAL语句,mysqladmin debug命令;允许您连接(一次),即使已达到max_connections。
UPDATE 允许使用UPDATE
USAGE “无权限”的同义词
GRANT OPTION 允许授予权限

给用户授权

  • 基本语法:

    1
    GRANT 权限列表 ON 库.对象名 TO '用户名'@'登陆位置' [IDENTIFIED BY '密码']
  • 说明:
    1.权限列表,多个权限用逗号分开。

    1
    2
    3
    GRANT SELECT ON...
    GRANT SELECT,DELETE,CREATE ON ...
    GRANT ALL [PRIVILEGES] ON ... #表示赋予该用户在该对象上的所有权限

    2.特别说明:
    *.*:代表本系统中的所有数据库的所有对象(表、视图、存储过程)。
    库.*:表示某个数据库中的所有数据对象(表、视图、存储过程等)。
    3.IDENTIFIED BY可以省略,也可以写出。如果用户存在,就是修改该用户的密码;如果该用户不存在,就是创建该用户。

回收用户授权

1
REVOKE 权限列表 ON 库.对象名 FROM '用户名'@'登陆位置'

权限生效指令

如果权限没有生效,可以执行下面命令:

1
FLUSH PRIVILEGES;

细节说明

1.在创建用户的时候,如果不指定host,则为%。%表示所有的IP都有连接权限。
2.如果指定CREATE USER 'xxx'@'192.168.1.%'则表示xxx用户在192.168.1.*的IP可以登录MySQL。
3.在删除用户时,如果host不是%,则需要明确指定'用户'@'host值'。

Chapter 25 JDBC和数据库连接池

基本介绍

1.JDBC为访问不同的数据库提供了统一的接口,为使用者屏蔽了细节问题。
2.使用JDBC,可以连接任何提供JDBC驱动程序的数据库系统,从而完成对数据库的各种操作。
3.JDBC是Java提供一套用于数据库操作的接口API。**Java程序员只需要面向这套接口编程即可。**不同的数据库厂商,需要针对这套接口提供不同实现。
4.JDBC API是一系列的接口,它统一和规范了应用程序与数据库的连接,执行SQL语句,并得到返回结果等各类操作,相关类和接口在java.sql和javax.sql包中。

JDBC程序编写步骤

1.注册驱动:加载Driver类。
2.获取连接:得到Connection。
3.执行增删改查:发送相关的SQL指令给MySQL执行。
4.释放资源:关闭相关连接。

获取数据库连接的5种方式

  • 方式1:获取Driver实现类对象

    1
    2
    3
    4
    5
    6
    7
    Driver driver = new com.mysql.jdbc.Driver()_;
    String url = "jdbc:mysql://localhost:3306/jdbc_db";
    Properties info = new Properties();
    info.setProperty("user","root");
    info.setProperty("password", "XXX");
    Connection conn = driver.connect(url, info);
    System.out.println(conn);

    方式1会直接使用com.mysql.jdbc.Driver(),属于静态加载,灵活性差,依赖强。

  • 方式2:反射机制

    1
    2
    3
    4
    5
    6
    7
    8
    Class clazz = Class.forName("com.mysql.jdbc.Driver")
    Driver driver = (Driver) clazz.newInstance();
    String url = "jdbc:mysql://localhost:3306/jdbc_db";
    Properties info = new Properties();
    info.setProperty("user","root");
    info.setProperty("password", "XXX");
    System.out.println(conn);
    Connection conn = driver.connect(url, info);

    使用反射加载Driver类,动态加载,更加灵活,减少依赖性。

  • 方式3:使用DriverManager替换Driver

    1
    2
    3
    4
    5
    6
    7
    8
    9
    Class clazz = Class.forName("com.mysql.jdbc.Driver");
    Driver driver = (Driver) clazz.newInstance();
    String user = "root";
    String password = "XXX";
    String url = "jdbc:mysql://localhost:3306/jdbc_db";
    DriverManager.registerDriver(driver);
    System.out.println(conn);
    Connection conn = DriverManager.getConnection(url, user, password);
    System.out.println(conn);
  • 方式4:使用Class.forName自动完成注册驱动,简化代码

    1
    2
    3
    4
    5
    6
    7
    Class.forName("com.mysql.jdbc.Driver");
    String url = "jdbc:mysql://localhost:3306/jdbc_db";
    String user = "root";
    String password = "xxx";
    System.out.println(conn);
    Connection conn = DriverManager.getConnection(url, user, password);
    System.out.println(conn);

    1.MySQL驱动5.1.6可以无需Class.forName("com.mysql.jdbc.Driver");。
    2.从JDK1.5以后使用了JDBC4,不再需要显示调用Class.forName();注册驱动,而是自动调用驱动jar包下META-INF\service\java.sql.Driver文本中的类名称去注册。
    3.建议还是写上Class.forName("com.mysql.jdbc.Driver");,更加明确。

  • 方式5:使用配置文件,连接数据库更灵活
    1.Connection conn = DriverManager.getConnection(jdbc:mysql://localhost:3306/jdbc_db, "root", "xxx");中的字符串各个值(比如端口、数据库、用户名、密码)为了方便,可以将信息写入到.properties文件中,方便操作。
    2.jdbc.properties

    1
    2
    3
    4
    user=root
    password=xxx
    url=jdbc:mysql://localhost:3306/jdbc_db
    driver=com.mysql.jdbc.Driver

    3.通过Properties对象,获取配置文件的信息。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //通过Properties对象获取配置文件的信息
    Properties properties = new Properties();
    properties.load(new FileInputStream("src\\mysql.properties"));
    //获取相关的值
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    String driver = properties.getProperty("driver");
    String url = properties.getProperty("url");
    Class.forName(driver);
    Connection conn = DriverManager.getConnection(url, user, password);
    System.out.println(conn);

ResultSet 结果集

基本介绍

1.表示数据库结果集的数据表,通常通过执行查询数据库的语句生成。
2.ResultSet对象保持一个光标指向其当前的数据行。最初,光标位于第一行之前。
3.next方法将光标移动到下一行,并且由于在ResultSet对象中没有更多行时返回false,因此可以在while循环中,使用循环来遍历结果集。

Statement

基本介绍

1.Statement对象,用于执行静态SQL语句,并返回其生成的结果的对象。
2.在连接建立后,需要对数据库进行访问,执行命名或是SQL语句,可以通过

  • Statement(存在SQL注入)
  • PreparedStatement(预处理)
  • CallableStatement(存储过程)

3.Statement对象执行SQL语句,存在SQL注入风险。
4.SQL注入是利用某些系统没有对用户输入的数据进行充分的检查,而在用户输入数据中注入非法的SQL语句段或是命令。恶意攻击数据库。
5.要防范SQL注入,只要用PreparedStatement(从Statement扩展而来)取代Statement就可以了。

PreparedStatement

基本介绍

1.PreparedStatement执行的SQL语句中的参数用问号来表示,调用PreparedStatement对象的setXxx()方法来设置这些参数setXxx()方法有两个参数,第一个参数是要设置的SQL语句中的参数的索引(从1开始),第二个参数是设置的SQL语句中的参数的值。
2.调用executeQuery(),返回ResultSet对象。
3.调用executeUpdate(),执行更新,包括增、删、修改。

预处理的好处

1.不用再使用+拼接SQL语句,减少语法错误。
2.有效的解决了SQL注入问题。
3.大大减少了编译次数,效率极高。

封装JDBCUtils

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class JDBCUtils{
//定义相关的属性,因为只需要一份,所以使用static
private static String user; //用户名
private static String password; //密码
private static String url; //URL
private static String driver; //驱动名

//在static代码块去初始化
static{
try{
Properties properties = new Properties();
properties.load(new FileInputStream("src\\mysql.properties"));
//读取相关的属性值
user = properties.getProperty("user");
password = properties.getProperty("password");
url = properties.getProperty("url");
driver = properties.getProperty("driver");
}
catch(IOException e){
//在实际开发中,我们可以这么处理:
//1.将编译异常转成运行异常。
//2.这是调用者,可以选择捕获该异常,也可以选择默认处理该异常,比较方便。
throw new RuntimeException(e);
}
}

//连接数据库,返回Connection
public static Connection getConnection(){
try{
return DriverManager.getConnection(url,user,password);
}catch(SQLException e){
//1.将编译异常转成运行异常。
//2.这是调用者,可以选择捕获该异常,也可以选择默认处理该异常,比较方便。
throw new RuntimeException(e);
}
}

//关闭相关资源
/*
1.ResultSet 结果集
2.Statement 或者 PreparedStatement
3.Connection
4.如果需要关闭资源,就传入对象,否则传入null
*/
public static void close(ResultSet set,Statement statement,Connection connection){
try{
//判断是否为null
if(set != null){
set.close();
}
if(statement != null){
statement.close();
}
if(connection != null){
connection.close();
}
}catch(SQLException e){
//将编译异常转成运行异常抛出
throw new RuntimeException(e);
}
}
}

事务

基本介绍

1.JDBC程序中,当一个Connection对象创建时,默认情况下是自动提交事务:每次执行一个SQL语句时,如果执行成功,就会向数据库自动提交,而不能回滚。
2.JDBC程序中,为了让多个SQL语句作为一个整体执行,需要使用事务。
3.调用Connection的setAutoCommit(false)可以取消自动提交事务。
4.在所有的SQL语句都成功执行后,调用Connection对象的commit()方法提交事务。
5.在其中某个操作失败或出现异常时,调用Connection对象的rollback()方法回滚事务。

批处理

基本介绍

1.当需要成批插入或者更新记录时,可以采用Java的批量更新机制,这一机制允许多条语句一次性提交给数据库批量处理。通常情况下,比单独提交处理更有效率。
2.JDBC的批量处理语句包括下面方法:

  • addBatch():添加需要批量处理的SQL语句或参数。
  • executeBatch():执行批量处理语句。
  • clearBatch():清空批处理包的语句。

3.JDBC连接MySQL时,如果要使用批处理功能,请在URL中加参数?ewriteBatchedStatements = true。
4.批处理往往和PreparedStatement一起搭配使用,可以即减少编译次数,又减少运行次数,效率大大提高。

数据库连接池

基本介绍

1.预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从缓冲池中取出一个,使用完毕之后再放回去。
2.数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。
3.当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中。

数据库连接池的种类

1.JDBC的数据库连接池使用javax.sql.DataSource来表示,DataSouce只是一个接口,该接口通常由第三方提供实现(jar包)。
2.C3P0数据库连接池,速度相对较慢,稳定性不错。
3.DBCP数据库连接池,速度相对C3P0较快,但不稳定。
4.Proxool数据库连接池,有监控连接池状态的功能,稳定性较C3P0差一点。
5.BoneCP数据库连接池,速度快。
6.Druid(德鲁伊)是阿里提供的数据库连接池,集DBCP、C3P0、Proxool优点于一身的数据库连接池。

C3P0

  • 示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    public class C3P0_{
    //方式1:相关参数,在程序中指定user、url、password等
    public void testC3P0_01() throws Exception{
    //1.创建一个数据源对象
    ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
    //2.通过配置文件mysql.properties获取相关连接的信息
    Properties properties = new Properties();
    properties.load(new FileInputStream("src\\mysql.properties"));
    //读取相关的属性值
    String user = properties.getProperty("user");
    String password = properties.getProperty("password");
    String url = properties.getProperty("url");
    String driver = properties.getProperty("driver");

    //给数据源 comboPooledDataSource 设置相关的参数
    //注意:连接管理是由 comboPooledDataSource 来管理
    comboPooledDataSource.setDriverClass(driver);
    comboPooledDataSource.setJdbcUrl(url);
    comboPooledDataSource.setUser(user);
    comboPooledDataSource.setPassword(password);

    //设置初始化连接数
    comboPooledDataSource.setInitialPoolSize(10);
    //最大连接数
    comboPooledDataSource.setMaxPoolSize(50);
    Connection connection = comboPooledDataSource.getConnection(); //这个方法就是从 DataSource 接口实现
    //stem.out.println("连接OK");
    connection.close();
    }

    //方式2:使用配置文件模板来完成
    //1. 将c3p0 提供的 c3p0.config.xml 拷贝到 src目录下
    //2. 该文件指定了连接数据库和连接池的相关参数
    public void testC3P0_02() throws SQLException {
    ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource("xxx"); //xxx写入配置文件中数据源名称
    Connection connection = comboPooledDataSource.getConnection();
    System.out.println("连接OK");
    connection.close();
    }
    }
  • c3p0-config.xml

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    <c3p0-config>
    <!-- 数据源名称代表连接池 -->
    <named-config name="xxx">

    <!-- 驱动类 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>

    <!-- url-->
    <property name="jdbcUrl">jdbc:mysql://127.0.0.1:3306/hsp_db02</property>

    <!-- 用户名 -->
    <property name="user">root</property>

    <!-- 密码 -->
    <property name="password">hsp</property>

    <!-- 每次增长的连接数-->
    <property name="acquireIncrement">5</property>

    <!-- 初始的连接数 -->
    <property name="initialPoolSize">10</property>

    <!-- 最小连接数 -->
    <property name="minPoolSize">5</property>

    <!-- 最大连接数 -->
    <property name="maxPoolSize">50</property>

Druid(德鲁伊)连接池

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Druid_ {
public void testDruid() throws Exception {
//1. 加入 Druid的jar包
//2. 加入配置文件druid.properties,将该文件拷贝项目的src目录
//3. 创建Properties对象,读取配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\druid.properties"));
//4. 创建一个指定参数的数据库连接池
DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
Connection connection = dataSource.getConnection();
System.out.println("连接成功!");
connection.close();
}
}
基于Druid数据库连接池的工具类JDBCUtils

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class JDBCUtilsByDruid {
private static DataSource ds;
//在静态代码块完成DataSource初始化
static {
Properties properties = new Properties();
try {
properties.load(new FileInputStream("src\\druid.properties"));
ds = DruidDataSourceFactory.createDataSource(properties);
} catch (Exception e) {
e.printStackTrace();
}
}

//编写getConnection方法
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}

//关闭连接, 在数据库连接池技术中, close不是真的断掉连接,而是把使用的Connection对象放回连接池
public static void close(ResultSet resultSet, Statement statement, Connection connection) {
try{
if(resultSet != null) {
resultSet.close();
}
if(statement != null) {
statement.close();
}
if(connection != null) {
connection.close();
}
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}

Apache-DBUtils

  • 对JDBC封装,简化JDBC编码的工作量。

1.QueryRunner类: 该类封装了SQL的执行,是线程安全的。可以实现增、删、改、查、批处理
2.使用QueryRunner类实现查询。
3.ResultSetHandler接口: 该接口用于处理java.sql.ResultSet,将数据按要求转换为另一种形式。

  • ArrayHandler:把结果集中的第一行数据转成对象数组。
  • ArrayListHandler:把结果集中的每一行数据都转成一个数组,再存放到List中。
  • BeanHandler:将结果集中的第一行数据封装到一个对应的JavaBean实例中。
  • BeanListHandler:将结果集中的每一行数据都封装到一个对应的JavaBean实例中,存放到List里。
  • ColumnListHandler:将结果集中某一列的数据存放到List中。
  • KeyedHandler(name):将结果集中的每行数据都封装到Map里,再把这些map再存到一个map里,其key为指定的key。
  • MapHandler:将结果集中的第一行数据封装到一个Map里,key是列名,value就是对应的值。
  • MapListHandler:将结果集中的每一行数据都封装到一个Map里,然后再存放到List。

DAO和增删改查通用方法-BasicDao

Chapter 27 正则表达式

基本介绍

一个正则表达式,就是用某种模式去匹配字符串的一个公式。

语法

基本介绍

按照功能分类,元字符可以分为:

  • 限定符
  • 选择匹配符
  • 分组组合和反向引用符
  • 特殊字符
  • 字符匹配符
  • 定位符

元字符-转义号

\\符号:
在我们使用正则表达式去检索某些特殊字符的时候,需要用到转义符号,否则检索不到结果,甚至会报错。
需要用到转义符号的字符有:.、*、+、(、)、$、/、\、?、[、]、^、{、}。

在Java的正则表达式中,\\代表其他语言中的\。

元字符-字符匹配符

字符匹配
符号 含义 说明
[ ] 可接收的字符列表 e、f、g、h中的任意1个字符
[^] 不接收的字符列表 除a、b、c之外的任意1个字符,包括数字和特殊符号
- 连字符 表示字符范围
. 匹配除\n以外的任何字符 以a开头、b结尾,中间包括2个任意字符的长度为4的字符串
\d 匹配单个数字字符,相当于[0-9] 包含3个或4个数字的字符串
\D 匹配单个非数字字符,相当于[^0-9] 以单个非数字字符开头,后接任意个数字字符串
\w 匹配单个数字、大小写字母字符,相当于[0-9a-zA-Z] 以3个数字字符开头的长度为7的数字字母字符串
\W 匹配单个非数字、大小写字母字符,相当于[^0-9a-zA-Z] 以至少1个非数字字母字符开头,2个数字字符结尾的字符串
大小写匹配

Java 正则表达式默认区分字母大小写。如果需要忽略大小写,可以使用 (?i)。

写法 含义
(?i)abc abc整体不区分大小写
a(?i)bc 只有bc不区分大小写
a((?i)b)c 只有b不区分大小写
Pattern pat = Pattern.compile(regEx, Pattern.CASE_INSENSITIVE); 在编译正则表达式时指定忽略大小写

元字符-选择匹配符

在匹配某个字符串的时候是选择性的,即:既可以匹配这个,又可以匹配那个,这时需要用到选择匹配符。

符号 含义 示例 解释
` ` 匹配` `之前或之后的表达式

元字符-限定符

用于指定其前面的字符和组合项连续出现多少次。

符号 含义 示例 说明
* 指定字符重复0次或n次(不要求) (abc)* 匹配任意个abc,包括 0 次
+ 指定字符重复1次或n次(至少一次) m+(abc)* m至少出现1次,后面可接任意个 abc
? 指定字符重复0次或1次(最多一次) m+abc? m至少出现1次,后面接ab或abc
{n} 指定字符重复n次 [abcd]{3} 只能匹配恰好3个字符
{n,} 指定至少n个匹配 [abcd]{3,} 由abcd中字符组成的任意长度不小于3的字符串
{n,m} 指定至少n个但不多于m个匹配 [abcd]{3,5} 由abcd中字符组成的长度不小于3、不大于5的字符串

元字符-定位符

定位符,规定要匹配的字符串出现的位置,比如在字符串的开始还是在结束的位置。

符号 含义 示例 说明
^ 指定起始字符 ^[0-9]+[a-z]* 以至少1个数字开头,后接任意个小写字母的字符串
$ 指定结束字符 ^[0-9]\\-[a-z]+$ 以1个数字开头,后接字符-,并以至少1个小写字母结尾的字符串
\b 匹配目标字符串的边界 han\b 字符串边界指子串间有空格,或者目标字符串位于字符串的结束位置
\B 匹配目标字符串的非边界 han\B 与\b的含义相反

分组

分组构造形式 说明
(pattern) 非命名捕获。捕获匹配的子字符串。编号为零的第一个捕获是由整个正则表达式模式匹配的文本,其它捕获结果则根据左括号的顺序从1开始自动编号。
(?<name>pattern) 命名捕获。将匹配的子字符串捕获到一个组名或编号名称中name的字符串不能包含任何标点符号,并且不能以数字开头。可以使用单引号替代尖括号,例如(?‘name’)。
(?:pattern) 匹配pattern,但不捕获该匹配的子表达式,即它是一个非捕获匹配,不存储供以后使用的匹配。对于用or字符(`
(?=pattern) 非捕获匹配。匹配pattern前面的字符串,但不消耗pattern。例如Windows (?=95|98|NT|2000)可以匹配Windows 2000中的Windows,但不能匹配Windows 3.1中的Windows。
(?!pattern) 非捕获匹配。匹配不处于pattern前面的字符串。例如,Windows (?!95|98|NT|2000)可以匹配Windows 3.1中的Windows,但不能匹配Windows 2000中的Windows。

正则表达式的三个常用类

java.util.regex包主要包括以下三个类:

  • Pattern类
  • Matcher类
  • PatternSyntaxException类

Pattern类

Pattern对象是一个正则表达式对象。

  • Pattern类没有公共构造方法。
  • 要创建Pattern对象,需要调用其公共静态方法compile()。
  • compile()方法接收一个正则表达式作为参数,并返回一个Pattern对象。

Matcher类

Matcher对象是对输入字符串进行解释和匹配的引擎。

  • Matcher类没有公共构造方法。
  • 需要调用Pattern对象的matcher()方法来获得一个Matcher对象。

PatternSyntaxException

PatternSyntaxException是一个非强制异常类,用于表示正则表达式模式中的语法错误。

分组、捕获、反向引用

分组

可以用圆括号()组成一个比较复杂的匹配模式。圆括号中的部分可以看作一个子表达式 / 分组。

捕获

将正则表达式中子表达式/分组匹配的内容保存到内存中,以数字编号或显式命名的组里,方便后续引用。

  • 分组按照左括号出现的顺序从左向右编号。
  • 第一个出现的分组编号为1,第二个为2,以此类推。
  • 0代表整个正则表达式匹配的内容。

反向引用

圆括号中的内容被捕获后,可以在这个括号后被再次使用,从而写出比较实用的匹配模式。这种引用称为反向引用。反向引用可以出现在正则表达式内部,也可以出现在正则表达式外部:

  • 内部反向引用:使用\\分组号
  • 外部反向引用:使用$分组号

String类中使用正则表达式