杨校老师课堂之Java面向对象知识点整理集锦

ゝ一世哀愁。 2021-12-20 00:33 203阅读 0赞

**目录**

第一部分 Java面向对象

1.开发环境搭建及开发工具eclipse使用

2.类和对象

3. 成员变量和局部变量区别

4. 数据类型

5.构造函数

6.函数

7. 成员变量的初始化

8. this关键字

9. static关键字

9.1 静态成员变量、静态成员变量初始化

9.2 静态成员方法

10. JVM对象内存结构

11.   Java 继承

12. 继承中的构造方法

super和this的含义

13. InstanceOf关键字

14.动态Bingding

15.方法重写

16.Object类API

17. 访问控制（包、访问权限）

18. final关键字

19. 抽象类

20. 接口

21. 内部类

22.String和StringBuffer

23.正则表达式

24.System和Runtime类

25.Date和DateFormat类

26.Math等其它常用类介绍

--------------------

# **第一部分 Java面向对象** #

## **1.开发环境搭建及开发工具eclipse使用** ##

eclipse快捷键：

**Ctrl+1 快速修复**

**Ctrl+D:** **删除当前行**

**Ctrl+Alt+****↓****复制当前行到下一行****(****复制增加****)**

**Ctrl+Alt+****↑****复制当前行到上一行****(****复制增加****)**

**Alt+↓ 当前行和下面一行交互位置(特别实用,可以省去先剪切,再粘贴**

**Alt+****↑****当前行和上面一行交互位置****(****同上****)**

**Alt+****←****前一个编辑的页面**

**Alt+****→****下一个编辑的页面****(****当然是针对上面那条来说了****)**

**Alt+Enter** **显示当前选择资源****(****工程****,or** **文件** **or****文件****)****的属性**

**Ctrl+L** **定位在某行** **(****对于程序超过****100****的人就有福音了****)**

**Ctrl+M** **最大化当前的****Edit****或****View (****再按则反之****)**

**Ctrl+/** **注释当前行****,****再按则取消注释**

**Ctrl+O** **快速显示** **OutLine**

**Ctrl+T** **快速显示当前类的继承结构**

**Ctrl+W** **关闭当前****Editer**

## **2.类和对象** ##

什么是类

**类**：是一组相关**属性**和**行为**的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

类与对象的关系：

对象是**具体**的，真是存在的物种。

类是对象的**抽象**出来的，理论上的概念物种

>     类：
>         我说现在已经开始公布HUAWEI手机  P50的概念机，那就是说这款手机还没有实体机存在，只是官方还在设计这个手机。
>     
>     　　　　　　  其中包含：颜色、尺寸、分辨率等。以上说的是这款概念机中的属性、
>     
>      　　　　 　　另还包含：上网、打电话、发短信、拍照、看电视等。这是在说的是这款概念机所具有的功能，也就是行为！
> 
> 对象： 
> 
>     我说现在已经开始公布HUAWEI手机  P30的实体机，那就是说这款手机已经存在实体机。
>     
>      但是有这款手机之前，也一定会先有该机的设计图或是概念机。

## 3. 成员变量和局部变量区别 ##

*  **定义类**：就是定义类的成员，包括**成员变量**和**成员方法**。
 *  **成员变量**：和以前定义变量几乎是一样的。只不过位置发生了改变。**在类中，方法外**。
 *  **成员方法：**和以前定义方法几乎是一样的。只不过把**static去掉**，static的作用在面向对象后面中再详细 讲解。

接下来通过一幅图来认识一下成员和局部

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

*  在类中的位置不同  【`重点`】
    
     *  成员变量：类中，方法外
     *  局部变量：方法中或者方法声明上(形式参数)
 *  作用范围不一样  【`重点`】
    
     *  成员变量：类中
     *  局部变量：方法中
 *  初始化值的不同  【`重点`】
    
     *  成员变量：有默认值
     *  局部变量：没有默认值。必须先定义，赋值，最后使用
 *  在内存中的位置不同  【`重点`】
    
     *  成员变量：堆内存
     *  局部变量：栈内存
 *  生命周期不同  【`重点`】
    
     *  成员变量：随着对象的创建而存在，随着对象的消失而消失
     *  局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

## 4. 数据类型 ##

Java的数据类型划分为两大类：基础数据类型和引用数据类型

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

## 5.**构造函数** ##

定义格式：

权限修饰符 构造方法名(参数列表){
    
        // 方法体 
    
    }

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。

1.  如果你不提供构造方法，系统会给出无参数构造方法。
2.  如果你提供了构造方法，系统将不再提供无参数构造方法。
3.  构造方法是可以重载的，既可以定义参数，也可以不定义参数

## 6.**函数** ##

**函数定义格式：**

权限修饰符 [修饰符] 返回值类型 方法名(参数列表){
        //代码省略...
        return 结果;
    }
    
    // 上方用方括号包括的修饰符可以有、也可以没有。
    // 修饰符有抽象修饰符abstract、有静态修饰符static、也有线程同步锁方法 synchronized 等。

*  修饰符： public static 固定写法
 *  返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
 *  参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
 *  return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
    
     *  注意:  不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。
     *  注意:  返回值类型，必须要和 return 语句返回的类型相同，否则编译失败

**如何定义方法**

首先要确定**返回值类型**和**参数列表**

**调用方法的流程图解**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2][]

**函数重载**

*  方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返 回值类型无关。
 *  参数列表：个数不同，数据类型不同，顺序不同。
 *  重载方法调用：JVM通过方法的参数列表，调用不同的方法。

## **7. 成员变量的初始化** ##

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>数据类型</td> 
 <td>默认值</td> 
 </tr> 
 <tr> 
 <td colspan="1">基础数据类型</td> 
 <td> 整型【byte,short,int,long】 </td> 
 <td>0</td> 
 </tr> 
 <tr> 
 <td>浮点型【float,double】</td> 
 <td>0.0</td> 
 </tr> 
 <tr> 
 <td>字符【char】</td> 
 <td>'\u0000'</td> 
 </tr> 
 <tr> 
 <td>布尔【boolean】</td> 
 <td>false</td> 
 </tr> 
 <tr> 
 <td>引用数据类型</td> 
 <td>数组、类、接口</td> 
 <td>null</td> 
 </tr> 
 </tbody> 
</table>

## 8. this关键字 ##

我们发现 `setXxx` 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意 了呢？代码如下：

public class Student {
        private String name;
        private int age;
        
        public void setName(String name) {
        	name = name;
        }
        public void setAge(int age) {
        	age = age;
        }
    }

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 `setXxx()` 的形参变量名后，方 法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无 法访问到成员变量，从而赋值失败。所以，我们只能使用`this`关键字，来解决这个重名问题。

this代表的是当前类对象。

## 9. static关键字 ##

**概述**

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。

也就是说，既然属于类，就可以不靠创建对象来调用了。

### **9.1 静态成员变量、静态成员变量初始化** ###

**静态成员变量：**

当 static 修饰成员变量时，该变量称为类变量。

该类的每个对象都共享同一个类变量的值。

任何对象都可以更改 该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

**静态成员变量初始化**

静态成员只会在每个类中初始化一次 【静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次】

> 【Java笔试题】：构造方法、成员变量初始化以及静态成员变量初始化三者的先后顺序是什么样的？

答：**先后顺序是**：静态成员变量、成员变量、构造方法。

原因：

a. 当类第一次被加载的时候,静态变量会首先初始化,接着编译器会把实例变量初始化为默认值,然后执行构造方法。

b. Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减):

① 静态对象(变量)优先于非静态对象(变量)初始化,其中,静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次；

② 父类优先于子类进行初始化；

③ 按照成员变量定义顺序进行初始化,即使变量定义散布于方法定义中,它们依然在任何方法(包括构造方法)被调用之前先初始化。

### 9.2 **静态成员方法** ###

*  当 static 修饰成员方法时，该方法称为类方法 。
 *  静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。
 *  调用方式非常简单。

## **10. JVM对象内存结构** ##

Java中的内存分配：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对数据进行了不同空间的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

具体划分为如下5个内存空间：

*  栈：存放局部变量
 *  堆：存放所有new出来的东西
 *  方法区：被虚拟机加载的类信息、常量、静态常量等。
 *  寄存器(和系统CPU相关)
 *  本地方法区

## 11.**   Java** **继承** ##

**概述：**

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要 继承那一个类即可。

如图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3][]

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。 继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动 物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

**定义： **

继承：就是子类继承父类的**属性**和**行为**，使得子类对象具有与父类相同的属性、相同的行为。

子类可以直接 访问父类中的**非私有**的属性和行为。

**好处:**

1. 提高**代码的复用性**。

2. 类与类之间产生了关系，继承**是多态的前提**。

**继承的格式:**

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
    ...
    }
    class 子类 extends 父类 {
    ...
    }

继承演示，代码如下：

/*
     * 定义员工类Employee，做为父类
     */
    class Employee {
        String name; // 定义name属性
        // 定义员工的工作方法
        public void work() {
            System.out.println("尽心尽力地工作");
        }
    }
    
    /*
     * 定义讲师类Teacher 继承 员工类Employee
     */
    class Teacher extends Employee {
        // 定义一个打印name的方法
        public void printName() {
        System.out.println("name=" + name);
        }
    }
    
    /*
     * 定义测试类
     */
    public class ExtendDemo01 {
        public static void main(String[] args) {
            // 创建一个讲师类对象
            Teacher t = new Teacher();
            // 为该员工类的name属性进行赋值
            t.name = "小明";
            // 调用该员工的printName()方法
            t.printName(); // name = 小明
            // 调用Teacher类继承来的work()方法
            t.work(); // 尽心尽力地工作
        }
    }

## 12.** 继承中的构造方法** ##

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

1. 构造方法的名字是与类名一致的。所以**子类是无法继承父类构造方法**的。

2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。

**子类的构造方法中默认有一个 super()** ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

代码如下

class Aminal {
    
        private int age;
    
        Aminal() {
            System.out.println(age);
        }
    }
    
    class Dog extends Aminal {
        // 不写 super(); Jvm 也会调用执行super();
    
        Dog() {
            System.out.println("wangcai");
        }
    }
    
    public class TestExtendsDemo {
    
        public static void main(String[] args) {
            Dog dog = new Dog();
        }
    }
    
    // 打印出结果是：0        wangcai

### super和this的含义 ###

super ：代表父类的存储空间标识(可以理解为父亲的引用)。

this ：    代表当前对象的引用(谁调用就代表谁)。

1.  子类的每个构造方法中均有默认的super()，调用父类的空参构造。
2.  手动调用父类构造会覆盖默认的super()。
3.  super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现

## **13. InstanceOf关键字** ##

instanceof关键字  
        1:用于判断某个对象是否是某种类型。  
        2:格式  
            对象名 instanceof 子类(实现)名

## 14.动态Bingding ##

动态绑定（后期绑定）是指：在程序运行过程中，根据具体的实例对象才能具体确定是哪个方法。

## 15.方法重写 ##

## 16.**Object类API** ##

`java.lang.Object`类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候，最终找的父类就是Object。

如果一个类没有特别指定父类， 那么默认则继承自Object类

根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。今天我们主要学习其中的2个：

*  `public String toString()`：返回该对象的字符串表示。
 *  `public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。

**toString方法**

`public String toString()`：返回该对象的字符串表示。

toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

**equals方法**

`public boolean equals(Object obj)`：指示其他某个对象是否与此对象“相等”。

调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否是相同的。

这里的“相同”有默认和自定义两种方式。

## **17. 访问控制（包、访问权限）** ##

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

*  public：公共的。
 *  protected：受保护的
 *  default：默认的
 *  private：私有的

**不同权限的访问范畴：**

<table> 
 <tbody> 
 <tr> 
 <td>&nbsp;</td> 
 <td>public</td> 
 <td>protected</td> 
 <td>default</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>同一类中</td> 
 <td>√</td> 
 <td>√</td> 
 <td>√</td> 
 <td>√</td> 
 </tr> 
 <tr> 
 <td>同一包中(子类与无关类)</td> 
 <td>√</td> 
 <td>√</td> 
 <td>√</td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td>不同包的子类</td> 
 <td>√</td> 
 <td>√</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 </tr> 
 <tr> 
 <td>不同包中的无关类</td> 
 <td>√</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

根据上表可知，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，**建议**这样使用权限：

1.  成员变量使用 private ，隐藏细节。
2.  构造方法使用 public ，方便创建对象。
3.  成员方法使用 public ，方便调用方法。 
4.  不加权限修饰符，其访问能力与default修饰符相同。

## **18. final****关键字** ##

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承 API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字， 用于修饰不可改变内容。

*  **final：** 不可改变。可以用于修饰类、方法和变量
    
     *  类：被修饰的类，不能被继承。
     *  方法：被修饰的方法，不能被重写。
     *  变量：被修饰的变量，不能被重新赋值。

**使用方式：**

*  **修饰类 **
    
     *  **格式如下**

final class 类名 {
    }

通过查询API回发现像 public final class String 、 public final class Math 、 public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容

*  **修饰方法**
    
     *  **格式如下**

修饰符 final 返回值类型 方法名(参数列表){
    //方法体
    }

*  **修饰变量** 
    
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下 
    
     
    
     *  **局部变量——基本类型**
     *  **局部变量——引用类型**

## **19.** **抽象类** ##

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为**抽象方法**。Java语法规定，包含抽象方法 的类就是**抽象类**。

*  定义抽象方法 ：
    
     *  没有方法体的方法。
 *  定义抽象类：
    
     *  包含抽象方法的类。

**abstract使用格式：**

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

*  定义格式

权限修饰符 abstract 返回值类型 方法名 (参数列表);

public abstract void playBall()；

**抽象类: **如果一个类包含抽象方法，那么该类必须是抽象类。

public abstract class Animal {
        public abstract void run()；
    }

**abstract注意：**

*   抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    
     *  理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。  
 *  抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    
     *  理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
 *  抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    
     *  理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。
 *  抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象 类。
    
     *  理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有 意义。

## **20.** **接口** ##

*  接口，是Java语言中一种**引用类型**，是抽象方法的集合，
 *  如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。
 *  接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型
 *  接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象 类。

public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
    }

抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。

public interface UserService {
        public abstract void userLogin();
    }

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

public interface UserService {
        public default void set() {
            // 方法内容
        }
    }

静态方法：使用 static 修饰，供接口直接调用。

public interface UserService {
        public static void get() {
            // 方法内容
        }
    }

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

public interface UserService {
        public static void getById(Integer id) {
            // 方法内容
        }
    }

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。

*  实现的动作类 似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。
 *  非抽象子类实现接口：
    
     *  必须重写接口中所有抽象方法。
     *  继承了接口的默认方法，即可以直接调用，也可以重写。

实现格式：

public class 类名 implements 接口名 {
        // 重写接口中抽象方法【必须】
        // 重写接口中默认方法【可选】
    }

**接口特点：**

*   接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
 *  接口中，没有构造方法，不能创建对象。
 *  接口中，没有静态代码块。

## **21.** **内部类** ##

**什么是内部类**

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

**成员内部类：**

定义在类中方法外的类

定义格式：

class 外部类 {
        class 内部类{
        }
    }

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，笔记本电脑类 Laptop 中包含主板 类 Mainboard，如此， MainBoard 就可以采用内部类形式来描述，定义在成员位置。

public class Laptop {
        class MainBoard{
    
        }
    }

**访问特点：**

*  内部类可以直接访问外部类的成员，包括私有成员。
 *  外部类要访问内部类的成员，必须要建立内部类的对象。

**实例化内部类格式：**

/*
        实例化格式：
        外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
     */
    public class Laptop {
        class MainBoard{
    
        }
    }
    class Demo{
        Laptop.MainBoard  lm = new Laptop().new MainBoard();
    }

## **22.String和StringBuffer** ##

**String类:**

*  查看类
    
     *  java.lang.String ：此类不需要导入。
 *  查看构造方法
    
     *  public String() ：初始化新创建的 String对象，以使其表示空字符序列。
     *  public String(char\[\] value) ：通过当前参数中的字符数组来构造新的String。
     *  public String(byte\[\] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。
 *  构造举例，代码如下：

// 无参构造
    String str = new String();
    // 通过字符数组构造
    char chars[] = {'H', 'e', 'l', 'l', 'o'};
    String str2 = new String(chars);
    // 通过字节数组构造
    byte bytes[] = { 66, 88, 108 };// 注意： 这里数字范围是 { -128 ~ 127，包括0}
    String str3 = new String(bytes);

**常用方法:**

*  判断功能的方法
    
     *  public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
     *  public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小 写。
     *  public boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。

public class Demo {
        public static void main(String[] args) {
            // 创建字符串对象
            String s1 = "hello";
            String s2 = "hello";
            String s3 = "HELLO";
            // boolean equals(Object obj):比较字符串的内容是否相同
            System.out.println(s1.equals(s2)); // true
            System.out.println(s1.equals(s3)); // false
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
            //boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
            System.out.println(s1.equalsIgnoreCase(s2)); // true
            System.out.println(s1.equalsIgnoreCase(s3)); // true
            System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
            //boolean contains(CharSequence s):该方法是判断字符串中是否有子字符串。如果有则返回true，如果没有则返回false。
            System.out.println(s1.contains("-"));   // false
            System.out.println(s2.contains("l"));  // true
            System.out.println(s2.contains("he")) ;// true
            System.out.println(s2.contains("hl")); // false
            System.out.println(s3.contains("."));  // false
        }
    }

*   获取功能的方法
    
     *  public int length () ：返回此字符串的长度。
     *  public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
     *  public char charAt (int index) ：返回指定索引处的 char值。
     *  public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
     *  public int lastIndexOf (String str) ：返回指定子字符串最后一次出现在该字符串内的索引。
     *  public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符 串结尾。
     *  public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。\[包头不包尾\]

public class Demo {
        public static void main(String[] args) {
    
    //创建字符串对象
                String s = "helloworld";
    // int length():获取字符串的长度，其实也就是字符个数
                System.out.println("字符串s的长度是：" + s.length());// 10
                System.out.println("‐‐‐‐‐‐‐‐");
    // String concat (String str):将将指定的字符串连接到该字符串的末尾.
                String s1 = "helloworld";
                String s2 = s1.concat("**Cheer HuaWei");
                System.out.println(s2);// helloworld**Cheer HuaWei
    // char charAt(int index):获取指定索引处的字符
                System.out.println(s.charAt(0));
                System.out.println(s.charAt(1));
                System.out.println("‐‐‐‐‐‐‐‐");
    // int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1
                System.out.println(s1.indexOf("l"));
                System.out.println(s1.indexOf("owo"));
                System.out.println(s1.indexOf("ak"));
                System.out.println("‐‐‐‐‐‐‐‐");
    // int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索引,没有返回‐1
                System.out.println(s1.indexOf("l"));
                System.out.println(s1.indexOf("owo"));
                System.out.println(s1.indexOf("ak"));
                System.out.println("‐‐‐‐‐‐‐‐");
    // String substring(int start):从start开始截取字符串到字符串结尾
                System.out.println(s.substring(0));
                System.out.println(s.substring(5));
                System.out.println("‐‐‐‐‐‐‐‐");
    // String substring(int start,int end):从start到end截取字符串。含start，不含end。
                System.out.println(s.substring(0, s.length()));
                System.out.println(s.substring(3,8));
            }
    
            }
    }

*   转换功能的方法
    
     *  public char\[\] toCharArray () ：将此字符串转换为新的字符数组。
     *  public byte\[\] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
     *  public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

public class Demo {
 
 public static void main(String[] args) {
 //创建字符串对象
 String s = "abcde";
 // char[] toCharArray():把字符串转换为字符数组
 char[] chs = s.toCharArray();
 for (int x = 0; x < chs.length; x++) {
 System.out.println(chs[x]);
 }
 System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
 // byte[] getBytes ():把字符串转换为字节数组
 byte[] bytes = s.getBytes();
 for (int x = 0; x < bytes.length; x++) {
 System.out.println(bytes[x]);
 }
 System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
 // 替换字母huawei为大写HuaWei
 String str = "Cheer huawei";
 String replace = str.replace("huawei", "HuaWei");
 System.out.println(replace); // Cheer HuaWei
 System.out.println("‐‐‐‐‐‐‐‐‐‐‐");
 }
 
 }

*  分割功能的方法
    
     *  public String\[\] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。

public class Demo {
 
 public static void main(String[] args) {
 //创建字符串对象
 String s = "forward:index";
 String[] strArray = s.split(":"); // ["forward","index"]
 System.out.println(strArray.length);// 2
 for(int x = 0; x < strArray.length; x++) {
 System.out.print(strArray[x] + " "); // forward index 
 }
 }
 }

**StringBuilder类**

*  查阅`java.lang.StringBuilder`的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
 *  原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
 *  它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
 *  StringBuilder已经覆盖重写了Object当中的toString方法。

**构造方法：**

*  `public StringBuilder()`：构造一个空的StringBuilder容器。
 *  `public StringBuilder(String str)`：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
        public static void main(String[] args) {
            StringBuilder sb1 = new StringBuilder();
            System.out.println(sb1); // (空白)
            // 使用带参构造
            StringBuilder sb2 = new StringBuilder("you");
            System.out.println(sb2); // you
        }
    }

**常用方法：**

*  `public StringBuilder append(...)`：添加任意类型数据的字符串形式，并返回当前对象自身。
 *  `public String toString()`：将当前StringBuilder对象转换为String对象

分别介绍两个方法：

*  append方法
    
     *   append方法具有多种重载形式，可以接收任意类型的参数。
     *  任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。

public class StringBuilderDemo {
    	public static void main(String[] args) {
    		//创建对象
    		StringBuilder builder = new StringBuilder();
    		//public StringBuilder append(任意类型)
    		StringBuilder builder2 = builder.append("hello");
    		//对比一下
    		System.out.println("builder:"+builder);
    		System.out.println("builder2:"+builder2);
    		System.out.println(builder == builder2); //true
    	    // 可以添加 任何类型
    		builder.append("hello");
    		builder.append("world");
    		builder.append(true);
    		builder.append(100);
    		// 在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
            // 这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
    		//链式编程
    		builder.append("hello").append("world").append(true).append(100);
    		System.out.println("builder:"+builder);
    	}
    }

*  toString方法
    
     *  通过toString方法，StringBuilder对象将会转换为不可变的String对象

public class StringBuilderDemo {
        public static void main(String[] args) {
            // 链式创建
            StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
            // 调用方法
            String str = sb.toString();
            System.out.println(str); // HelloWorldJava
        }
    }

## 23.**正则表达式** ##

<table> 
 <tbody> 
 <tr> 
 <td>字符</td> 
 <td>描述</td> 
 </tr> 
 <tr> 
 <td>\</td> 
 <td>将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，"n"匹配字符"n"。"\n"匹配换行符。序列"\\\\"匹配"\\"，"\\("匹配"("。</td> 
 </tr> 
 <tr> 
 <td>^</td> 
 <td>匹配输入字符串开始的位置。如果设置了&nbsp;RegExp&nbsp;对象的&nbsp;Multiline&nbsp;属性，^ 还会与"\n"或"\r"之后的位置匹配</td> 
 </tr> 
 <tr> 
 <td>$</td> 
 <td>匹配输入字符串结尾的位置。如果设置了&nbsp;RegExp&nbsp;对象的&nbsp;Multiline&nbsp;属性，$ 还会与"\n"或"\r"之前的位置匹配</td> 
 </tr> 
 <tr> 
 <td>*</td> 
 <td>零次或多次匹配前面的字符或子表达式。例如，zo* 匹配"z"和"zoo"。* 等效于 {0,}</td> 
 </tr> 
 <tr> 
 <td>+</td> 
 <td>一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+ 等效于 {1,}</td> 
 </tr> 
 <tr> 
 <td>?</td> 
 <td>零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。? 等效于 {0,1}</td> 
 </tr> 
 <tr> 
 <td>{n}</td> 
 <td>n&nbsp;是非负整数。正好匹配&nbsp;n&nbsp;次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配</td> 
 </tr> 
 <tr> 
 <td>{n,}</td> 
 <td>n是非负整数。至少匹配&nbsp;n&nbsp;次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有 o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*</td> 
 </tr> 
 <tr> 
 <td>{n,m}</td> 
 <td>m&nbsp;和&nbsp;n&nbsp;是非负整数，其中&nbsp;n&nbsp;&lt;=&nbsp;m。匹配至少&nbsp;n&nbsp;次，至多&nbsp;m&nbsp;次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间</td> 
 </tr> 
 <tr> 
 <td>?</td> 
 <td>当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"</td> 
 </tr> 
 <tr> 
 <td>.</td> 
 <td>匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式</td> 
 </tr> 
 <tr> 
 <td>x|y</td> 
 <td>匹配&nbsp;x&nbsp;或&nbsp;y。例如，'z|food' 匹配"z"或"food"。'(z|f)ood' 匹配"zood"或"food"</td> 
 </tr> 
 <tr> 
 <td>[xyz]</td> 
 <td>字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"</td> 
 </tr> 
 <tr> 
 <td>[^xyz]</td> 
 <td>反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"</td> 
 </tr> 
 <tr> 
 <td>[a-z]</td> 
 <td>字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母</td> 
 </tr> 
 <tr> 
 <td>[^a-z]</td> 
 <td>反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符</td> 
 </tr> 
 <tr> 
 <td>\b</td> 
 <td>匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"</td> 
 </tr> 
 <tr> 
 <td>\B</td> 
 <td>非字边界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"</td> 
 </tr> 
 <tr> 
 <td>\cx</td> 
 <td>匹配&nbsp;x&nbsp;指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x&nbsp;的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身</td> 
 </tr> 
 <tr> 
 <td>\d</td> 
 <td>数字字符匹配。等效于 [0-9]</td> 
 </tr> 
 <tr> 
 <td>\D</td> 
 <td>非数字字符匹配。等效于&nbsp;[^0-9]</td> 
 </tr> 
 <tr> 
 <td> \f </td> 
 <td> 换页符匹配。等效于 \x0c 和 \cL </td> 
 </tr> 
 <tr> 
 <td> \n </td> 
 <td> 换行符匹配。等效于 \x0a 和 \cJ </td> 
 </tr> 
 <tr> 
 <td> \r </td> 
 <td> 匹配一个回车符。等效于 \x0d 和 \cM </td> 
 </tr> 
 <tr> 
 <td> \s </td> 
 <td> 匹配任何空白字符，包括空格、制表符、换页符等。与 [&nbsp;\f\n\r\t\v] 等效 </td> 
 </tr> 
 <tr> 
 <td> \S </td> 
 <td> 匹配任何非空白字符。与 [^&nbsp;\f\n\r\t\v] 等效 </td> 
 </tr> 
 <tr> 
 <td> \t </td> 
 <td> 制表符匹配。与 \x09 和 \cI 等效 </td> 
 </tr> 
 <tr> 
 <td> \v </td> 
 <td> 垂直制表符匹配。与 \x0b 和 \cK 等效 </td> 
 </tr> 
 <tr> 
 <td> \w </td> 
 <td> 匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效 </td> 
 </tr> 
 <tr> 
 <td> \W </td> 
 <td> 与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效 </td> 
 </tr> 
 <tr> 
 <td> \xn </td> 
 <td> 匹配&nbsp;n，此处的&nbsp;n&nbsp;是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&amp;"1"等效。允许在正则表达式中使用 ASCII 代码 </td> 
 </tr> 
 <tr> 
 <td> \num </td> 
 <td> 匹配&nbsp;num，此处的&nbsp;num&nbsp;是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符 </td> 
 </tr> 
 <tr> 
 <td> \n </td> 
 <td> 标识一个八进制转义码或反向引用。如果 \n&nbsp;前面至少有&nbsp;n&nbsp;个捕获子表达式，那么&nbsp;n&nbsp;是反向引用。否则，如果&nbsp;n&nbsp;是八进制数 (0-7)，那么&nbsp;n是八进制转义码 </td> 
 </tr> 
 </tbody> 
</table>

## 24.**System和Runtime类** ##

**System类**

`java.lang.System`类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

*  `public static long currentTimeMillis()`：返回以毫秒为单位的当前时间。
 *  `public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)`：将数组中指定的数据拷贝到另一个数组中。

**currentTimeMillis方法**

实际上，currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

public class Demo {
    
        public static void main(String[] args) throws ParseException {
            //获取当前时间毫秒值
            System.out.println(System.currentTimeMillis()); // 1562038452052
        }
    }

public class Demo {
 
 /*
 需求： 验证for循环打印数字1-9999所需要使用的时间（毫秒）
 */
 public static void main(String[] args) throws ParseException {
 long start = System.currentTimeMillis();
 for (int i = 0; i < 10000; i++) {
 System.out.println(i);
 }
 long end = System.currentTimeMillis();
 System.out.println("共耗时毫秒：" + (end - start));
 }
 }

**Runtime类**

## 25**.Date****和DateFormat类** ##

**Date类**

`java.util.Date`类 表示特定的瞬间，精确到毫秒

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。

*  `public Date()`：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
 *  `public Date(long date)`：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

提醒：我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。

通俗来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

例如

import java.util.Date;
    
    /*
     * 注意：
     *  在使用println方法时，会自动调用Date类中的toString方法。
     *  Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串
     */
    public class Demo {
    
        public static void main(String[] args) {
            // 创建日期对象，把当前的时间
            System.out.println(new Date()); // Tue Jul 02 11:22:10 CST 2019
            // 创建日期对象，把当前的毫秒值转成日期对象
            System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
        }
    }

**DateFormat类**

`java.text.DateFormat` 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

*  **格式化**：按照指定的格式，从Date对象转换为String对象。
 *  **解析**：按照指定的格式，从String对象转换为Date对象。

**构造方法：**

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类`java.text.SimpleDateFormat`。

这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

*  `public SimpleDateFormat(String pattern)`：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
    
     *  参数pattern是一个字符串，代表日期时间的自定义格式。

**格式规则：**

常用的格式规则为：

<table style="width:500px;"> 
 <tbody> 
 <tr> 
 <td>标识字母（区分大小写 ）</td> 
 <td>文字描述含义</td> 
 </tr> 
 <tr> 
 <td>y</td> 
 <td>年</td> 
 </tr> 
 <tr> 
 <td>M</td> 
 <td>月</td> 
 </tr> 
 <tr> 
 <td>d</td> 
 <td>日</td> 
 </tr> 
 <tr> 
 <td>H</td> 
 <td>时</td> 
 </tr> 
 <tr> 
 <td>m</td> 
 <td>分</td> 
 </tr> 
 <tr> 
 <td>s</td> 
 <td>秒</td> 
 </tr> 
 </tbody> 
</table>

# #

示例代码：

public class Demo {
    
        public static void main(String[] args) {
            // 对应的日期格式如：2019-07-02 11:28:29
            DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(format.format(new Date()));// 输出结果：2019-07-02 11:28:29
        }
    }

常用方法:

DateFormat类的常用方法有：

*  `public String format(Date date)`：将Date对象格式化为字符串。
 *  `public Date parse(String source)`：将字符串解析为Date对象。

## **26.Math和Random** ##

**Math类**

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

**基本运算的方法：**

*  public static double abs(double a) ：返回 double 值的绝对值

double d1 = Math.abs(‐2); //d1的值为2
    double d2 = Math.abs(2); //d2的值为2

*  public static double ceil(double a) ：返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0
    double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0
    double d3 = Math.ceil(5.1); //d3的值为 6.0

*  public static double floor(double a) ：返回小于等于参数最大的整数

double d1 = Math.floor(3.3); //d1的值为3.0
    double d2 = Math.floor(‐3.3); //d2的值为‐4.0
    double d3 = Math.floor(5.1); //d3的值为 5.0

*  public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0
    long d2 = Math.round(5.4); //d2的值为5.0

**Random类**

此类的实例用于生成伪随机数。

Random r = new Random();
    int randomNumber = r.nextInt();

*  查看类 java.util.Random ：
    
     *  该类需要 import导入使后使用。
 *  查看构造方法 public Random() ：
    
     *  创建一个新的随机数生成器。
 *  查看成员方法
    
     *  public int nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n （不包括）之间的 int 值。

使用Random类，完成生成5个20以内的随机整数的操作，代码如下：

//1. 导包
 import java.util.Random;
 
 public class RandomDemo {
 public static void main(String[] args) {
 
 //2. 创建键盘录入数据的对象
 Random random = new Random();
 for (int i = 0; i < 5; i++) {
 //3. 随机生成一个数据
 int randomNumber = random.nextInt(20);
 //4. 输出数据
 System.out.println("randomNumber:" + randomNumber);
 }
 }
 }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20211219/1a9bc1a97bff46078db2e64b4a0c5d4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20211219/9ca87f0cada0455383e7b41ec239f161.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: /images/20211219/8926fb385e924796bd0f808bb096b760.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9tcnlhbmcuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: /images/20211219/bd0d5147677d4d18ae461874129930cc.png