JavaSE学习

数组

数组的初始化

int[] ids = new int[]{1,2,3};    //1. 数组静态初始化   数组的初始化和数组元素的赋值操作同时进行
String[] names = new String[3];  //2. 动态初始化        数组的初始化和数组元素的赋值操作分开进行

属性

属性和局部变量

相同点：

定义的格式数据类型变量名 = 变量值
先声明，后使用
变量都有其对应的作用域

不同点：

在类中声明的位置不同

属性：直接定义在类中的{}内

局部变量：声明在方法内、方法形参、代码块、构造器形参、构造器内部的变量
关于权限修饰符的不同

属性：可以在声明属性是，指明其权限、使用权限修饰符

局部变量：不可以使用权限修饰符
默认初始化值

属性：有默认初始化值

局部变量：没有默认初始化值
位置

属性：存放在堆空间中

局部变量：存放在栈空间中

方法

描述类应该具有的功能

方法的声明：权限修饰符返回值类型方法名（形参列表）{

? 方法体
说明
- 关于权限修饰符：关于JAVA规定的4种权限修饰符：private、public、缺省、protected
- 返回值类型：
  - 有返回值：必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量
  - 无返回值：方法声明时，使用void来表示，如要使用，只能“return；”结束方法
- 方法名：属于标识符，遵循标识符规则和规范，”见名知意“
- 形参列表：方法可以声明0个，1个，或多个形参。格式：数据类型1 形参1，数据类型2 形参2，...

重载和重写

重载

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
"两个一不同"：同一个类、相同的方法名

? 参数列表不同，参数个数不同，参数类型不同
判断是否是重载：

? 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
在通过对象调用方法时，如果确定某一个指定的方法：

? 方法名 ---> 参数列表

重写

什么是重写？

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

重写的规则

方法的声明：权限修饰符返回值类型方法名（形参列表） throws异常的类型{

? //方法体

约定俗称：子类中的叫重写的方法，父类中的叫被重写方法

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

特殊情况：子类不能重写父类中声明为private权限的方法
返回值类型：
- 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型（比如：double），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须是double）
子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写，要么都声明为static的（不是重写））

重载和重写的区别

概念的不同
重写和重载的具体规则不同
- 重载发生在本类，重写发生在父类与子类之间
- 重载的方法名必须相同，重写的方法名相同且返回值类型必须相同
- 重载的参数列表不同，重写的参数列表必须相同
重载：不表现为多态性

重写：表现为多态性。

this和super

this关键字的使用

this可以用来修饰：属性、方法、构造器
this修饰属性和方法：
- this理解为：当前对象或当前正在创建的对象
- 在类的方法中，我们可以使用“this.属性”或"this.方法",调用当前对象属性或方法，但是通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名是，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
- 在类的构造器中，我们可以使用“this.属性”或"this.方法",调用当前正在创建的对象属性或方法，但是通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名是，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

super关键字的使用

super关键字可以理解为：父类的
可以用来调用的结构：属性、方法、构造器
super调用属性、方法：
- 我们可以在子类的方法或构造器中，通过使用"super.属性"或者"spuer.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
- 特殊情况，当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
- 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
super调用构造器
- 我们可以在子类的构造器中显式的使用"super（形参列表）"的方式。调用父类中声明的指定的构造器
- "super（形参列表）"的使用，必须声明在子类构造器的首行！
- 我们在类中的构造器中，针对于"this（形参列表）"或"super（形参列表）"只能选择一个使用，不能同时出现
- 在构造器的首行，没显式的声明"this（形参列表）"或"super（形参列表）"，则默认调用的是父类中空参的构造器：super（）
- 在类的多个构造器中，至少一个类的构造器使用了"super（形参列表）"，调用父类中的构造器

封装性

封装就是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体。

追求"高内聚，低耦合"

高内聚：类的内部数据操作细节自己掌握，不允许外部干涉
低耦合：仅对外暴露少部分的方法便于使用

隐藏对象内部的复杂性，只对外公开简单的接口，便于外界使用，从而提高系统的可扩展性、可维护性。通俗的说，把改隐藏的隐藏起来，该暴露的暴露出来，这就是封装性的设计思想，

封装性的体现

将类的属性xxx私有化（private），同时，提供公共的（public）方法来获取（getXxx）和设置（setXxx）此属性的值。
不对外暴露私有的方法
单例模式（将构造器私有化）
如果不希望类在包外被调用，可以将设置为缺省的。

继承性

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

继承性的好处

减少了代码的冗余性，提高了代码的复用性
便于功能的扩展
为之后多态性的使用，提供了前提

继承性的格式

class A extends B{

? A：子类、派生类、subclass

? B：父类、超类、基类、superclass

子类继承父类的不同之处

体现：一旦子类A继承父类B之后，子类A就获取了父类B中的声明的所有属性和方法。特别的，父类中声明为private的属性和方法，子类继承父类之后，仍然认为获取了父类中私有的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
子类继承父类以后，还可以声明自己特有的属性和方法。类实现功能的扩展。

Java继承性的说明

一个类可以被多个子类继承
Java中类的单继承性，一个类只能继承一个父类
子父类是相对的概念
子类直接继承的父类，称之为直接父类，间接继承的父类成为：间接父类
子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

多态性

多态是指一个类实例（对象）的相同方法在不同情形有不同表现形式

理解多态性

一个事物的多种形态

何为多态性

对象的多态性：父类的引用指向子类的对象（或者子类的对象赋给父类的引用）

举例：

Person p = new Man();

Objoct obj = new Date();

多态的使用，虚拟方法的调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法，总结：编译，看左边；运行，看右边。

多态性的使用前提

类的继承关系
方法的重写

多态性使用的注意点

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

"=="和equals()的区别

==

可以使用在基本数据类型变量和引用数据类型变量中
如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（类型不一定相同）

如果比较的是引用数据类型变量：比较两个变量保存的数据是否相同。-

equals()

是一个方法，而非运算符
只能适用于引用数据类型
Object类中equals()的i当以：

publi boolean equals(Object obj){

? return (this == obj);

说明：Object类中定义的equals()和==的作用是相同的。
像String、Date、File，包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
通常情况下，我们自定义的类如果使用equals()的话，他通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。

重写的原则：比较两个对象的实体内容是否相同

因为在Object类中，equals()方法它之间的比较是用"=="来比较的，所以要重写equals()来比较两个对象的"实体内容"是否相同。

toString

1. toString的说明

当我们输出一个对象的引用时，实际上就是调用对象的toString()
Object类中toString的定义：

public String toString(){

? return getClass().getName() + "@" + Interger.toHexString(hashCode());
像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体信息"
自定义类也可以重写toStrng()方法，当调用此方法时，返回对象的“实体内容”。

包装类

基本数据类型具有类的特征

包装类的使用

java提供了8中基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征

Byte,Short,Integer,Long,Float,Double,Boolean,Character 前六个的父类时Number
掌握的：基本数据类型、包装类、String三者之间的相互转换

基本数据类型<--->包装类：自动装箱和自动拆箱

基本数据类型、包装类---->String：调用String重载的valueOf（Xxx xxx）

String--->基本数据类型、包装类:调用包装类的parseXxx(String s)

转换时，可能会包NumberFormatException

static

1. 可以用来修饰的结构：

主要用来修饰类的内部结构

属性、方法、代码块、内部类

static修饰属性：静态变量（或类变量）
- 属性，是否使用static修饰，又分为：静态属性 vs 非静态属性（实际变量）
  
  实际变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性，当修改其中以恶对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
  
  静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静变量时，会导致其他对象调用此静态变量时，是修改过了的。
- static修饰属性的其他说明：
  1. 静态变量随着类的加载而加载。可以通过”类.静态变量“的方式进行调用
  2. 静态变量的加载要早于对象的创建
  3. 由于类只会加载一次，则静态变量再内存中也只会存在一份：存在方法区的静态域中。
  4. ? 类变量实例变量
    
    类 yes no
    
    对象 yes yes
- 静态属性距离：System.out，Math.PI;

2. static的内存解析

3. static修饰方法：

静态方法、类方法

随着类的加载而加载，可以通过”类.静态方法“的方式进行调用
? 静态方法非静态方法

? 类 yes no

? 对象 yes yes
静态方法中，只能调用静态的方法或属性

非静态发放中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

4. static的注意点：

在静态的方法内，不饿能使用this关键字、super关键字
关于静态属性和静态方法的使用，要从生民周期的角度去理解。

5. 如果判断属性和方法应该使用static关键字：

关于属性
- 属性是可以被多个对象所共享的，不会随着对象的不同而不同
- 类中的常量也常常声明为static
关于方法
- 操作静态属性的方法，通常设置为static的
- 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

6. 使用举例：

举例一：Math、Arrays、Collections等工具类

举例二：单例模式

举例三：

设计模式

1. 设计模式的说明

理解

设计模式是在大量的实践中总结和理论化之后优的代码结构、编程风格、以及解决问题的思考方法。
常用的设计模式 ---23中经典的设计模式

创建型模式：共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构性模式：共7种：设配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

2. 单例模式

2.1 要解决的问题：

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统种，对某个类只能存在一个对象实例。

2.2 具体代码的实现：

饿汉式1：

class Bank{
    //1. 私化的构造器
    private Bank(){
        
    }
    //2. 内部创建类的对象
    //4. 要求此对象也必须声明为静态的 
    private static Bank instance = new Bnak();
    
    //3. 提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

饿汉式2：

class Bank{
    //1. 私化的构造器
    private Bank(){
        
    }
    //2. 内部创建类的对象
    //4. 要求此对象也必须声明为静态的 
    private static Bank instance = null;
    
    static{
        instance = new Bnak();
    }
    
    //3. 提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

懒汉式（目前线程不安全，要用到锁来让线程变得安全）：

class Bank{
    //1. 私化的构造器
    private Bank(){
        
    }
    //2. 内部创建类的对象
    //4. 要求此对象也必须声明为静态的 
    private static Bank instance = null;
    
    //3. 提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        if(instance == null){
            instance = new Bank();
        }
         return instance;
    }
}

懒汉式（线程安全的）：

class Bank{
    //1. 私化的构造器
    private Bank(){
        
    }
    //2. 内部创建类的对象
    //4. 要求此对象也必须声明为静态的 
    private static Bank instance = null;
    
    //3. 提供公共的静态的方法，返回类的对象
    public synchronized static Bank getInstance(){
        if(instance == null){
            instance = new Bank();
        }
         return instance;
    }
}

2..3 两种方式的对比：

饿汉式：

? 坏处：对象加载时间过长

? 好处：饿汉式是线程安全的

懒汉式：

? 好处：延迟对象的创建

3 模板方法设计模式

3.1 要解决的问题

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的暴露出去，让子类实现。
换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了，但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

4 代理模式（Proxy）

4.1 概述

代理模式是Java开发使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

4.2 应用场景

安全代理：屏蔽对真实角色的直接访问。
远程代理：通过代理类处理远程方法调用（RMI）。
延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

4.3 分类

静态代理（静态定义代理类）
动态代理（动态生成代理类）
- JDK自带的动态代理，需要反射等知识

5 工厂模式

5.1 概念

工厂模式：实现了创建者和调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

其实设计模式和面向对象设计原则都是为了使得开发项目更加容易扩展和维护，解决方式就是要给”分工“。

核心本质：

实例化对象，用工厂方法代替new操作。将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

5.2 举例

无工厂模式

interface Car{
    void run();
}
class Audi implenments Car{
    public void run(){
        System.out.println("奥迪在跑");
    }
}
class BYD implenments Car{
    public void run(){
        System.out.println("比亚迪在跑");
    }
}

public class Client01{
    public static void main(String[] arg){
        Car a = new Audi();
        Car b = new BYD();
        a.run();
        b.run();
    }
}

简单工厂模式

简单工厂模式，从命名上就可以看出这个模式一定很简单，他存在的目的很简单，定义一个用于创建对象的工具类。

interface Car{
    void run();
}
class Audi implenments Car{
    public void run(){
        System.out.println("奥迪在跑");
    }
}
class BYD implenments Car{
    public void run(){
        System.out.println("比亚迪在跑");
    }
}

class CarFactory{
    //方式一
    public static Car getCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type){
            return new BYD();
        }else{
            return null;
        }
    }
    //方式二
   // public static CargetAudi(){
   //     return new Audi();
   // }
   // public static CargetBYD(){
   //     return new BYD();
   // }        
}
    
public class Client02{
    public static void main(String[] arg){
        Car a = CarFactory.getCar("奥迪");
        a.run();
        Car b = CarFactory.getCar("比亚迪");
        b.run();
    }
}

把调用者和创建者分离，简单共产也叫静态工厂模式，就是共产类一般是使用静态方法，通过接受的参数不同来返回不同的实例对象。

缺点：对于增加新产品，不修改代码的话，是无法扩展的。违反了开闭原则(对扩展开放，对修改封闭)。

工厂方法模式

为了避免简单工厂模式的缺点，不完全满足OCP(对扩展开放，对修改关闭)。工厂方法模式和简单工厂模式最大的不同在于，简单工厂只有一个(对于一个项目或者一个独立的模块而)共产类，而工厂方法模块有一组实现了相同接口的工厂类。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

interface Car{
    void run();
}
class Audi implenments Car{
    public void run(){
        System.out.println("奥迪在跑");
    }
}
class BYD implenments Car{
    public void run(){
        System.out.println("比亚迪在跑");
    }
}
//工厂接口
interface Factory{
    Car getCar();
}
//两个工厂类
class AudiFactory implements Factory{
    public Audi getCar(){
        return new Audi();
    }
}
class BYDFactory implements Factory{
    public BYD getCar(){
        return new BYD();
    }
}

public class Client{
    public static void main(String[] arg){
        Car a = AudiFactory.getCar();
        a.run();
        Car b = BYDFactory.getCar();
        b.run();
    }
}

抽象工厂模式

抽象工厂模式和工厂方法模式的区别在于需要创建对象的复杂程度上，而且抽象工厂模式是三个里面最为抽象的、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。而且使用抽象工厂模式还要满足以下条件：
1. 系统中由多个产品族，而系统一次只可能消费其中一族产品。
2. 同属于用一个产品族的产品以其使用。

代码块

1. 代码块的作用：

用来初始化类、对象的信息

2.分类：

代码块要是使用修饰符，只能使用static

分类：静态代码块 vs 非静态代码块

3. 静态代码块和非静态代码块

静态代码块：

内部可以输出语句
随着类的加而执行，而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态的代码块，则按照声明分先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：

内部可以输出语句
随着类的加而执行，而且只执行一次
作用：可以在创建对象时，对对象的属性进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或用非静态的属性、非静态的方法

4. 加载顺序

实例化子类对象时，涉及到父类、子类中静态代码块、非静态代码库奥、构造器的加载的加载顺序：

由父及子，静态先行。

默认初始化
显式初始化
构造器中初始化
有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值
在代码块中赋值

执行的先后顺序：1 - 2 / 5 - 3 - 4

final

最终的

1. 可以用来修饰：

类、方法、变量

2. 具体的：

final用来修饰一个类：此类不能被其他类所继承。

比如：String类、System类、StringBuffer类
final用来修饰方法：表明此方法不可以被重写

比如：Object类中getClass();
final用来修饰变量：此时的”变量“就称为是一个常量
- final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
- final修饰局部变量：尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局变量

abstruct

abstra：抽象的
abstract可以用来修饰的结构：类、方法

1. 具体的

abstract修饰类：抽象类
- 此类不能实例化
- 抽象类中一定有构造器，便于类实例化时调用（涉及：子类对象实例化的全过程）
- 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作。--->抽象的前提：继承性
abstract修饰方法：抽象方法
- 抽象方法只有方法的声明，没有方法体
- 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
- 若子类重写了父类中的所有的抽象方法后，此子类可实例化
  
  若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

2. 注意点

abstract不能用来修饰：属性、构造器等结构
abstract不能用来修饰私有方法、静态方法、final的方法、final的类

3. 应用举例

举例一：

public abstract class Vehicle{
    public abstract double calcFuelEfficiency(); //计算燃料效率的抽象方法
    public abstract double calcTripDistance();  //计算行驶距离的抽象方法
   
}
public class Truck extends Vehicle{
    public abstract double calcFuelEfficiency(); //写出计算卡车的燃料效率的具体方法
    public abstract double calcTripDistance();  //写出计算卡车行驶举例的具体方法
}

public class RiverBarge extends Vehicle{
    public abstract double calcFuelEfficiency(); //写出计算驳船的燃料效率的具体方法
    public abstract double calcTripDistance();  //写出计算驳船行驶举例的具体方法
}

举例二：

abstract class GemetricObject{
    public abstract double findArea();
}
class Circle extends  GemetricObject{
    private double radius;
    public double findArea(){
        return 3.14 * radius * radius;
    }
}

举例三：IO流中涉及到的抽象类：InputStream / OutputStream / reader / Writer

interface

1. 使用说明

接口使用interface来定义
在java中，接口和类时并列的两个结构
如果定义接口：定义接口中的成员
- JDK7及以前：只能定义全局常量和抽象方法
  - 全局常量：public static final的但是书写时可以省略不写
  - 抽象方法：public abstract的
- JDK8: 除了定义全局常量和抽象方法之外，还可以定义静态方法，默认方法
接口中不能定义构造器的！意味着接口不可以实例化
java开发中，接口通过让类去实现（implements）的方式来使用。

如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化

如果实现类没覆盖接口中所抽象方法，则此实现类仍为一个抽象类
java类可以实现多个接口 --->弥补了java单继承i性的局限性

格式：class AA extends BB implements CC,DD,EE
接口与接口之间可以继承，而且可以多继承
接口的具体使用，体现多态性
接口，实际上可以看作是一个规范

2. 举例

体会：

接口使用上也满足多态性
接口，实际上就是定义了一宗规范
开发中，体会面向接口编程！

3. 体会面向接口编程的思想

面向接口编程：我们在应用程序中，调用的结构都是JDBC中定义的接口，不会出现具体某一个数据库厂商的API。

4. java8中关于接口的新规范

接口中定义的静态方法，只能通过接口来调用
通过实现类的对象，可以调用接口中的默认方法，如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
如果子类（或实现类）继承的父类和实现类的接口中声明了同名同参数的默认方法，那么子类在设置此方法的情况下，默认调用的是父类中的同名同参数的方法。--->类优先原则
如果实现类实现了多个接口，而这多个接口中定义了同参数的默认方法，那么在实现类没重写此方法的情况下，报错。--->接口冲突。这就需要我们必须在实现类中重写此方法。

如果在子类（或实现类）的方法中，调用父类、接口中被重写的方法

public void myMethod(){
    method3();//调用自己定义的重写的方法
    super.method3();//调用的是父类中声明的
    //调用接口的默认方法
    CompareA.super.method3();
    CompareB.super.method3();
}

5. 面试题

抽象类和接口的异同？

相同点：不能实例化；都可以包含抽象方法的。

不同点：

把抽象类和接口（java7,java8,java9）的定义、内部接口解释说明
类：但继承性接口：多继承

类与接口：多实现

内部类

1. 定义

Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B为外部类

2. 内部类的对象

成员内部类（静态、非静态） vs 局部内部类（方法内、代码块内、构造器内）

3. 成员内部类的理解

一方面，作为外部类的成员：

调用外部类的结构
可以被static修饰
可以被4中不同的权限修饰

另一方面，作为一个类：

类内可以定义属性、方法、构造器等
可以被final修饰，表示此类不能被继承。言外一直，不使用final就可以被继承
可以被abstract修饰

4. 成员内部类

如果创建成员内部类的对象？（静态的，非静态的）

//创建静态的Dog实例（静态的成员内部类）：
Person. Dog dog = new Person.Dog();

//创建非静态的Bird实例（非静态的成员内部类）:
//Person.Bird bird = new Person.Bird();   错误的
Person p = new Person();
Person.Bird bird = p.new Bird();

如果在成员内部类中调用外部类的结构

class Person{
    String name = "小明";

//非静态成员内部类
class Bird{
    String name = "杜鹃";
    
    Bird(){
        
    }
    
    public void sing(){
        System.out.println("我是一只小小鸟");
        Person.this.eat(); //调用外部类的非静态属性
        eat();
        System.out.println(age);
    }
    
    public void display(String name){
        System.out.println(name); //方法的形参
        System.out.println(this.name); //内部类的属性
        System.out.println(Person.this.name); //外部类的属性
    }
    
}
}

5. 局部内部类的使用

//返回一个实现了Comparable接口的类的对象
public Comparable getComparable(){
    //创建一个实现了Comparable接口的类:局部内部类
    //方式一：
    //class MyComparable implements Comparable{
    //    public int compareTo(Object o){
    //        return 0;
    //    }
    //}
    //return new MyComparable();
    
    //方式二：
    return new Comparable(){
        public int compareTo(Object o){
            return 0;
        }
    };
}

总结：成员内部类和局部内部类，在编译以后，都会生成字节码文件

异常

1. 异常的体系结构

1.1 java.lang.Throwable

ava.lang.Error:一般不编写针对性的代码进行处理。
java.lang.Exception:可以进行异常的处理
- 编译时异常（checked）
  - IOException
    - FileNotFoundException
  - ClassNotFoundException
- 运行时异常（unchecked,RuntimeException）
  - NullPointerException
  - ArrayIndexOutOfBoundsException
  - ClassCastExeption
  - NumberFormatException
  - InputMismatchException
  - ArithmeticException

1.2 编译时异常和运行时异常

编译时异常：执行javac.exe命名时，可能出现的异常

运行时异常：执行java.exe命名时，出现的异常

1.3 常见的异常类型

NullPointerException
ArrayIndexOutOfBoundsException
ClassCastExeption
NumberFormatException
InputMismatchException
ArithmeticException

2. 异常的处理：抓抛模型

过程一：“抛":程序在正常执行的过程中,一旦出现问题，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出。一旦抛出对象以后，其后的代码就不再执行。

关于异常对象的产生：

系统自动生成的异常对象
手动生成一个异常对象，并抛出（throw）

过程二：“抓”:可以理解为异常的处理方式：

try-catch-finally
throws
?

2.1 异常的处理方式一：try-catch-fianlly

2.1.1 使用说明

try - catch - finally的使用

try{

? //可能出现异常的代码

}catch(异常类型1 变量名1){

? //处理异常的方式1

}catch(异常类型2 变量名2){

? //处理异常的方式2

}catch(异常类型3 变量名3){

? //处理异常的方式3

……

finally{

? //一定会执行的代码

说明：

finally是可以没有的。
使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch进行匹配。
一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前try-catch-finally。继续执行后面的代码
catch中的异常类型如果没子父类关系，则谁声明在上，谁声明在下无所谓

catch中的异常类型如果有子父类关系，则要求子类一定声明在父类的撒谎给你面，否则，报错
常用的异常对象处理的方式：1. String getMessage() 2. printStackTrace()
在try结构中声明的变量，再出了try结构以后，就不能再被调用
try-catch-finally结构可以嵌套

总结：如何看待代码中的编译时异常和运行时异常

体会1：使用try-catch-finally处理编译时异常，是得程序再编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了，针对编译时异常，我们说一定要考虑异常的处理。

2.1.2 finally的在说明：

finally时可以不写的。
finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中return语句，catch中return语句等情况。
像数据库链接、输入输出流、网络编程Socket等资源，JVM时不能自动回收的，我们需要自己搜东进行资源的释放。此时的资源释放，就需要声明再finally中。
?

2.1.3 面试题

fianl、finally、finalize三者的区别？

throw和throws的区别？

2.2 异常处理方式二：thorws + 异常类型

”throws + 异常类型“写在方法的声明处。知名此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码出生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码不再执行

2.3 对比两种处理方式

try-catch-finally：真正的见异常给处理掉了

throws的方式只是将异常抛给了方法的调用者，并没有真正将异常处理掉。

2.4 体会开发中应该如果选择两种处理方式

如果父类中被重写的方法没throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果子类重写的方法中异常，必须使用try-catch-finally方式出处理。
执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理，而执行的方法a可以考虑使用try-catch-finally方式进行处理。

3. 手动抛出异常

3.1 使用说明

在程序执行中，除了自动抛出异常对象的情况之外，我们还可以手动的throw一个异常类的对象。

3.2 面试题

throw 和 throws的区别：

throw表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内

throws属于异常处理的一种方法，声明在方法的声明处。

3.3 例题

4. 自定义异常类

如果自定义异常类？

继承于现的异常结构：RuntimeException、Exception
提供全局常量：serialVersionUID
提供重载的构造器

public class EcDef extends Exception {

    static final long serialVersionUID = -3387516934524229948L;

    public EcDef(){

    }

    public EcDef(String message) {
        super(message);
    }
}

多线程

1. 程序、进程、线程的理解

1.1 程序（programm）

概念：是为了完成特定任务、用某种语言编写的一组指令的结合。既指一段静态的代码，静态对象，

1.2 进程（process）

概念：是程序的一次执行过程，或是一个正在运行的一个程序。

说明：进程作为资源分配的单位，系统运行时会为每个进程分配不同的内存区域。

1.3 线程（thread）

概念：是一个程序内部的一条执行路径。

说明：线程作为调度和执行的单位，每个线程都拥有独立的运行栈和程序计数器(pc)。多个线程，共享同一个进程的结构：方法去、堆。

2. 并行与并发

2.1 单核CPU与多核CPU的理解

单核CPU其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。但是因为CPU时间单元特别短，所以感觉不出来。
如果是多核的化，才能更好的发挥多线程的效率。
一个java的应用程序java.exe，其实至少有3个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2.2 并行与并发的理解

并行：多个CPU同时执行多个任务。如果：多个人同时做不同的事。
并发：一个CPU（采用时间片）同时执行多个任务。

3. 创建多线程的两种方式

3.1 方法一：继承Thread的方式

创建一个继承于Thread类的子类
重写Thread类的run()-->将此线程执行的操作声明在run()中
创建Thread的子类的对象
通过此对象调用start()：1. 启动当前线程 2. 调用当前线程的run()

说明两个问题

问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。

问题二：如果再启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。

3.2 方法二：实现Runnable接口的方式

创建一个实现了Runnable接口的类
实现类去实现Runnable中的抽象方法：run()
创建实现类的对象
将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
通过Thread类的对象调用start()

3.3 两种方式的对比

开发中：优先选择：实现Runnable接口的方式

原因：

实现的方式没类的单继承性的局限性
实现的方式更适合来处理多个线程共享数据的情况。

联系：public class Tread implements Runnable

相同点：两种方式都需要重写run()，将线程要执行的逻辑声明再run()中。目前这两种方法，要想启动线程，都是调用的Thread类中的start()。

4. Thread类中的常用方法

start()：启动当前线程；调用当前线程的run()
run()：通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明再此方法中
currentThread()：静态方法，返回执行当前代码的线程
getName：获取当前线程的名字
setName：设置当前线程的名字
yield()：释放当前CPU的执行权
join()：在线程a中调用线程b的join()，此时线程a就进入了阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
stop：已过时，当执行方法时，强制结束当前线程。
sleep(long millitime)：让当前线程"睡眠"指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态。
isAlive()：判断当前线程是否存活。

线程的优先级：

MAX_PRIORITY:10
MIN_PRIORITY:1
NORM_PRIORITY:5 -->默认优先级

说明：高优先级的线程要抢占低优先级线程cpu的是执行权。但是知识从概率上讲，高优先级的线程高于低优先级的线程先被执行。并不意味着只有当高优先级线程执行完成之后，低优先级的线程才执行。

线程通信：wait（） / notify() / notifyAll() ；此三个方法定义在Object类中的。

补充：线程的分类

Java中的线程分为两类：一种是守护线程，一种是用户线程

它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
若JVM中都是守护线程，当前JVM将退出。

5. Thread的生命周期

图示：

说明：

生命周期关注两个概念：状态、相应的方法
关注：状态a--->状态b：哪些方法执行了（回调方法）

? 某个方法主动调用：状态a--->状态b
阻塞：临时状态，不可以作为最终状态
死亡：最终状态。

6. 线程的同步机制

6.1 背景

6.2 java解决方案

在java中，我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块

synchronized(同步监视器){

? //需要被同步的代码

说明：

操作共享数据的代码，即为需要被同步的代码。--->不能包含代码多了，也不能包含代码少了
共享数据：多个线程共同操作的变量
同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用同一把锁。
补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

方式二：同步方法。

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

关于同步方法的总结：

同步方法仍然涉及到同步监视器，知识不需要我们显式的声明。
非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类的本身

方式三：lock锁

面试题：synchronized与lock的异同？

相同：两者都可以解决线程安全的问题

不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器。lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()））

使用的优先顺序：

lock--->同步代码块（已经进入了方法体，分配了相应资源）--->同步方法（在方法体之外）

6.3 利弊

同步的方式，解决了线程的安全问题。---好处

操作同步代码时，只能一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。

6.4 死锁

6.5 面试题

面试题：java时如果解决线程安全问题的，有几种方式？并对比几种方式的不同

面试题：synchronized和lock方式解决线程安全问题的对比

相同：两者都可以解决线程安全的问题

7. 线程通信

7,1 线程通信涉及到的三个方法：

wait()：一旦执行此方法，当前线程就会进入阻塞状态，并设防同步监视器。
notify()：一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就会唤醒优先级高的那个。
notifyAll()：一旦执行此方法，就会唤醒所有被wait的线程。

7.2 说明

wait()，notify()，natifyAll()三个方法必须使用在同步代码块或同步方法中。
wait()，notify()，natifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现IllegalMonitorStateException异常
wait()，notify()，notifyAll()三个方法时定义在java.lang.Object类中的

7.3 面试题

sleep()和wait()的异同？

相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：
- 两个方法声明的位置不同：Thread类中声明sleep()，Object类中声明wait()
- 调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中
- 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

7.4 小结

释放锁的操作：

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

不释放锁的操作：

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

8. JDK5.0新增线程的创建方式

创建线程的方式三：实现Callable接口。 ----JDK 5.0新增

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

call()可以有返回值的。
call()可以抛出异常，被外面的操作捕获，获取异常的信息。
Callable是支持泛型的。

创建线程的方式四：使用线程池。 ----JDK 5.0新增

好处：

提高响应速度（减少了创建新线程的时间）
降低资源消耗（重复利用线程池中线程，不需要每次都创建）
便于线程管理

corePoolSize：核心池的大小

maximumPoolSize：最大线程数

keepAliveTime：线程没任务时最多保持多长时间后会终止

8.1 面试题

线程创建的方式有几种？

4种

JAVA常用类

1 String类

1.1 概述

String：字符串，使用一对“"引起来表示。

String声明为final的，不可被继承
String实现了Serializable接口：表示字符串是支持序列比的

String实现了Comparable接口：表示String可以比较大小
String内部定义了final cahr[] value用于存储字符串数据
通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在常量池中）。
字符串常量池中时不会存储相同内容(使用String类中的equals()比较，返回true)的字符串的。

1.2 String的不可变性

1.2.1 说明

String：代表不可变的字符序列。简称不可变性。

体现：

当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
当对现有的字符串进行连接操作时，也许需要重新指定内存区域赋值，不能使用原有的value进行赋值。
当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值。不能使用原有的value进行赋值。

1.2.2代码举例

String s1 = "helloworld";
        String s2 = "HelloWorld";
        System.out.println(s1.equals(s2));
        System.out.println(s1.equalsIgnoreCase(s2));

        String s3 = "abc";
        String s4 = s3.concat("def");
        System.out.println(s4);

        String s5 = "abc";
        String s6 = new String("abd");
        System.out.println(s5.compareTo(s6));  //涉及到字符串排序

        String s7 = "123456";
        String s8 = s7.substring(2);
        System.out.println(s7);
        System.out.println(s8);

        String s9 = s7.substring(2, 5);  //（左闭右开）
        System.out.println(s9);

1.2.3 图示

1.3 String实例化的不同方式

1.3.1 方式说明

方式一：通过字面量定义的方式

方式二：同通过new + 构造器的方式

1.3.2 代码举例

//通过字面量的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
String s3 = new String("javaEE");
String s4 = new String("javaEE");

System.out.println(s1 == s2); //true
System.out.println(s1 == s3); //false
System.out.println(s1 == s4); //false
System.out.println(s3 == s4); //false

1.3.3 面试题

String s = new String(”abc“);方式创建对象，在内存中创建了介个对象？

答：两个，一个是堆空间中new就结构，另一个是char[]对应的常量池中的数据：“abc”

1.3.3 图示

1.4 字符串凭借方式赋值的对比

1.4.1 说明

常量与常量的拼接结果在常量池。且常量池中不会存在想用内容的常量。
只要其中一个是变量，结果就在堆中。
如果拼接的结果调用inrern()，返回值就在常量池中

1.4.2 代码举例

1.5 常用方法

int length(): 返回字符串的长度: return value. Length
char charAt(int index): 返回某索引处的字符：return value[ index]
boolean isEmpty(): 判断是否是空字符串: return value. Length ==日
String toLowerCase(): 使用默认语言环境，将String中的所有字符转换为小写
String toUpperCase(): 使用默认语言环境，将String中的所有字符转换为大写
String trim(): 返回字符串的副本，忽略前导空白和尾部空白  (去除前后空格)
boolean equals(0bject obj):比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString): 与equals方法类似， 忽略大小写
String concat(String str): 将指定字符串连接到此字符串的结尾。等价于用“+”  (连接两个字符串)
int compareTo(String anotherString): 比较两个字符串的大小
String substring(int beginIndex): 返回- -个新的字符串，它是此字符串的从beginIndex开始截取
String substring(int beginIndex, int endIndex) :返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex（不包含）的一个子字符串   （左闭右开）

boolean endsWith(String suffix):测试此子付串是含以指定的后缀结宋
boolban startsWith(String prefix):测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始
boolean contains(CharSequence s): 当且仅当此字符串包含指定的char值序列时，返回true  (是否包含s这个字符串)
int indexOf(String str): 返回指定子字符串在此字符串中第次出现处的索引
int indexOf(String str, int fromIndex): 返回指定子字符串在此字符串中第一 次出现处的索引，从指定的索引开始
int lastlndexOf(String str): 返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex): 返回指定子字符串在此字符串中最后.次出现处的索引，从指定的索引开始反向搜索
注意：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
String replace(char oldChar, char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。
String replace(CharSequence target, CharSequence replacement): 使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement): 使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。   regex：正则表达式
String replaceFirst(String regex, String replacement): 使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配：
boolean matches(String regex): 告知此字符串是否匹配给定的正则表达式。
切片：
StringD] split(String regex):根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit):根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

1.6 String与其他结构之间的转换

1.6.1 与基本数据类型、包装类之间的转换

String 与基本数据类型、包装类之间的转换。
String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
基本数据类型、包装类 -->String：调用String重载的valueOf(xxx)
    
@Test
    public void test1(){
        String s1 = "123";  //在常量池里
        int num = Integer.parseInt(s1);
        String str2 = String.valueOf(num);
        String str3 = num + "";  //在堆里
    }

1.6.2 与字符数组之间的转换

String 与 char[]数组之间的转换
String --> char[]：调用String的toCharArray()
char[] -->String：调用String的构造器
    
@Test
    public void test2(){
        String str1 = "abc123";
        char[] charArray = str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }

        char[] arr = {'h', 'e', 'l', 'l', 'o'};
        String s = new String(arr);
        System.out.println(s);
    }

1.6.3 与字节数组之间的转换

/*
     * String 与 byte[]数组之间的转换
     * 编码：String --> byte[]：调用String的getBytes()
     * 解码：byte[] -->String：调用String的构造器
     * */
    @Test
    public void test3() throws UnsupportedEncodingException {
        String s1 = "abc123中国";
        byte[] b1 = s1.getBytes();  //使用默认的字符集进行转换
        System.out.println(Arrays.toString(b1));

        byte[] gbks = s1.getBytes("gbk");  //使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));

        String s2 = new String(b1);  //使用默认的字符集进行解码
        System.out.println(s2);
    }

1.6.4 与StringBuffer、StringBuilder之间的转换

String --> StringBuffer、StringBuilder：调用StringBuffer、StrngBuilder构造器
StringBuffer、StringBuilder --> String：
- 调用String构造器
- StringBuffer、StringBuilder的toString()

1.7 JVM中字符常量池存放位置说明

jdk1.6 ：字符串常量池存储在方法区（永久区）

jdk1.7 ：字符串常量池存储在堆空间

jdk1.8 ：字符串常量池存储在方法区（元空间）

1.8 常见算法题目的考查

模拟一个trim方法，去除字符串两端的空格。
将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg"反转为"abfedcg”
获取一个字符串在另-个字符串中出现的次数。比如:获取“ab"在“abkkcadkabkebfkabkskab"中出现的次数
获取两个字符串中最大相同子串。比如:str1 = "abcwerthelloyuiodef";str2 = "cvhellobnm"提示:将短的那个串进行长度依次递减的子串与较长的串比较。
对字符串中字符进行自然顺序排序。提示:

1)字符串变成字符数组。

2)对数组排序，选择，冒泡，Arrays. sort();3)将排序后的数组变成字符串。

2 StringBuffer、StringBuilder

2.1 String、StringBuffer、StringBuilder三者之间的对比

String：不可变的字符序列，底层使用char[]进行存储

StringBuffer：可变的字符序列：线程安全的，效率低，底层使用char[]进行存储
StringBuilder：可变的字符序列： JDK5.0新增的，线程不安全的，效率高，底层使用char[]进行存储

2.2 StringBuffer与StringBuilder的内存解析

源码分析：
String str = new String();  // new char[0];
String str1 = new String("abc");  //new char[]{'a','b','c'};
StringBuffer sb1 = new StringBuffer();  //new char[16];底层创建了一个长度为16的数组
sb1.append('a'); //value[0] = 'a’;
sb1.append('b'); //value[1] = 'b';
StringBuffer sb2 = new StringBuffer("abc"); //char[] value = new char["abc".length() + 16];
问题1：System.out.println(sb2.length)  //3
问题2：扩容问题：如果你要添加的数据底层数组盛不下了，那就需要扩容底层数组。
默认情况下，扩容为原来容量的2倍+2，同时将原有的数组复制到新的数组中。
开发中建议使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

2.3 对比String、StringBuffer、StringBuilder三者的执行效率

从高到低排列：StringBuilder > StringBuffer > String

2.4 StringBuffer、StringBuilder中的常用方法

StringBuffer append(xxx): 提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start, int end): 删除指定位置的内容
StringBuffer replace(int start, int end, String str): 把[start,end)位 置替换为strStringBuffer insert(int offset, xxx): 在指定位置插入xxx
StringBuffer reverse() :把当前字符序列逆转
public int indexOf(String str)
public String substring(int start, int end):返回一个从start开始到end结束的左闭右开的子字符串
public int Length()
public char charAt(int n )
public void setCharAt(int n , char ch)
                                                 总结：
增：append(xxx)
删：delete(int start, int end)
改：setCharAt(int n , char ch) 修改一个字符 / replace(int start, int end, String str)  修改一个字符串
查：charAt(int n)
插：insert(xxx)
长度：length()
遍历：for() + charAt()
反转：reverse()

3 JDK 8之前日期时间API

3.1 获取系统当前时间

System类中的currentTimeMillis()

long time = System.currentTimeMillis(); //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差称为时间戳

3.2 java.util.Date类与java.sql.Date类

 2.java.util.Date类
            |---java.sql.Date类

     2.1 两个构造器的使用
        >构造器一：Date()：创建一个对应当前时间的Date对象
        >构造器二：创建指定毫秒数的Date对象

     2.2 两个方法的使用
        >toString():显示当前的年、月、日、时、分、秒
        >getTime()：获取当前Date对象对应的毫秒数。（时间戳）

     3. java.sql.Date对应着数据库中的日期类型的变量
        >如果实例化
        >如果将java.util.Date对象转换为java.sql.Date对象
    @Test
    public void test2(){
        //构造器一：Date()：创建一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString()); //Wed Jan 12 16:57:52 CST 2022
        System.out.println(date1.getTime()); //1641977872247

        //构造器二：创建指定毫秒数的Date对象
        Date date2 = new Date(1641977872247L);
        System.out.println(date2.toString());

        //创建java.sql.Date对象
        java.sql.Date date3 = new java.sql.Date(1641977872247L);
        System.out.println(date3);

        //如果将java.util.Date对象转换为java.sql.Date对象
        //情况一：
        //Date date4 = new java.sql.Date(1641977872247L);
        //java.sql.Date date5 = (java.sql.Date)date4;
        //情况二
        Date date6 = new Date();
        java.sql.Date date7 = new java.sql.Date(date6.getTime());
    }
}

3.3 java.text.SimpleDataFormat类

SimpleDateFormat对日期Date类的格式化和解析

1 两个操作

```
 格式化：日期--->字符串
```

 解析：格式化的逆过程，字符串--->日期

2 SimpleDateFormat的实例化test

//**************按照指定的方式进行格式化和解析：调用带参的构造器***************************
    SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
    //格式化
    String format1 = sdf1.format(date);
    System.out.println(format1);
    //解析:要求字符串必须符合SimpleDateFormat识别的格式（通过构造器参数体现），否则抛异常
    String str1 = "2022-01-13 03:14:22";
    Date parse1 = sdf1.parse(str1);
    System.out.println(parse1);

}

小练习

//练习一：字符串"2020-09-08"转换为java.sql.Date
@Test
public void test3() throws ParseException {
    String birth = "2020-09-08";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    Date date = sdf.parse(birth);
    java.sql.Date date1 = new java.sql.Date(date.getTime());
    System.out.println(date1);
}

3.4 Calendar类

Calendar：（抽象类）日历类的使用

//1.实例化
//方式一： 创建其子类（GregorianCalender）的对象
//方式二： 调用其静态方法getInstance()
Calendar calendar = Calendar.getInstance();

//2. 常用方法
//get()
int days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);

//set()
calendar.set(Calendar.DAY_OF_MONTH,14);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);

//add()
calendar.add(Calendar.DAY_OF_MONTH,2);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);

//getTIme()
Date date = calendar.getTime();
System.out.println(date);

//setTime()
Date date1 = new Date();
calendar.setTime(date1);
days = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(days);

4 JDK8中新日期时间API

4.1 日期时间API的迭代

第一代：jdk 1.0 Date类

第二代：jdk 1.1 Calendar类，一定程度上替换Date类

第三代：jdk1.8 提出了新的一套API

4.2 前两代存在的问题举例

可变性

偏移性

格式化

线程不安全；不能处理闰秒

4.3 java8中新的日期时间API涉及到的包

4.4 本地日期、时间、日期时间的使用

4.4.1 说明

4.4.2 常用方法

  //方式一：now()：获取当前的日期、时间、日期+时间
    LocalDate localDate = LocalDate.now();
    LocalTime localTime = LocalTime.now();
    LocalDateTime localDateTime = LocalDateTime.now();
    System.out.println(localDate);
    System.out.println(localTime);
    System.out.println(localDateTime);

    //方式二：of()：设置指定的年、月、日、时、分、秒，没有偏移量
    LocalDateTime localDateTime1 = LocalDateTime.of(2022, 1, 13, 20, 18, 30);
    System.out.println(localDateTime1);

    //getXxx()
    System.out.println(localDateTime.getDayOfMonth());

    //体现不可变性  withXxx()：设置相关属性
    LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(22);
    System.out.println(localDateTime2);

    //plusXxx()：增加相关属性
    LocalDateTime localDateTime3 = localDateTime.plusDays(2);
    System.out.println(localDateTime3);

    //minusXxx()：减去相关属性
    LocalDateTime localDateTime4 = localDateTime.minusDays(2);
    System.out.println(localDateTime4);
}

4.5 时间点：Instant

4.5.1 说明：

时间上的一个瞬时点。从1970年1月1日0时0分0秒开始计时
类似于java.util.Date类

4.5.2 常用方法

* Instant的使用

* 类似于java.util.Date类
  @Test
  public void test2(){
    //now()：获取本初子午线对应的标准时间
    Instant instant = Instant.now();
    System.out.println(instant);

    //添加时间的偏移量
    OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(offsetDateTime);

    //获取对应毫秒是(1970.1.1(UTC))--->Date(getTime())
    long milli = instant.toEpochMilli();
    System.out.println(milli);

    //ofEpochMilli()：通过给定的毫秒数，获取Instant实例--->Date(long millis)
    Instant ofEpochMilli = Instant.ofEpochMilli(1642077535539L);
    System.out.println(ofEpochMilli);
  }

4.6 日期时间格式化类：DateTimeFormatter

4.6.1 说明

格式化或解析日期、时间
类似于SimpleDateFormat

4.6.2 常用方法


/*
* DteTimeFormatter：格式化或解析日期、时间
* 类似于SimpleDateFormat
* */
@Test
public void test3(){
    //方式一：预定义的标准格式。
    DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
    //格式化：日期-->字符串
    LocalDateTime localDateTime = LocalDateTime.now();
    String str1 = formatter.format(localDateTime);
    System.out.println(localDateTime);
    System.out.println(str1);

    //解析：字符串-->日期
    TemporalAccessor parse = formatter.parse("2022-01-13T20:55:08.507");
    System.out.println(parse);


    //方式二：本地化相关的格式。
    DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);
    //格式化
    String str2 = formatter.format(localDateTime);
    System.out.println(str2);

    //重点：
    //方式三：自定义的格式。如：ofPattern("yyyy-MM-dd hh:mm:ss")
    DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
    String str3 = formatter2.format(LocalDateTime.now());
    System.out.println(str3);
}

4.7 其他API的使用

5 Java比较器

5.1 Java比较器的使用背景

Java中的比较对象，正常情况下，只能进行比较：== 或者！=。不能使用> 或 < 的，但是在开发场景中。我们需要对多个对象进行排序，言外之意，就需要比较对象的大小，如果实现？使用两个接口中的任何一个：Comparable 或 Comparator。

5.2 自然排序：使用Comparable接口

5.2.1 说明

像String、包装类等实现了Comparable接口，重写了compareTo()，给出了比较两个对象大小的方法
重写compareTo()的规则：
- 如果当前对象this大于形参对象obj，则返回正整数，
- 如果当前对象this小于形参对象obj，则返回负整数，
- 如果当前对象this等于形参对象obj，则返回零，
对于自定义类来说，如果需要排序，我们可以让自定义类实现Comparable接口，重写compareTo()方法，

在compareTo(obj)方法中指明如何排序

5.2.2 自定义类代码举例

5.3 定制排序：使用Comparator接口

5.3.1 说明

背景：当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码或者实现了java.lang.Comparable接口的排序规则不适合当前的操作。那么可以考虑使用Comparator的对象来排序
重写compare(Object o1, Object o2)方法，比较o1和o2的大小：
- 如果方法返回正整数，则表示o1大于o2；
- 如果返回0，表示相等；
- 如果返回负整数，表示o1小于o2。

5.3.2 代码举例

public void test2(){
    String[] arr = {"AA", "CC", "KK", "MM", "GG", "JJ", "DD"};
    Arrays.sort(arr, new Comparator() {
        //按照字符串从大到小的顺序排序
        @Override
        public int compare(String o1, String o2) {
            if (o1 instanceof String && o2 instanceof String){
                String s1 = (String) o1;
                String s2 = (String) o2;
                return -s1.compareTo(s2);
            }
            throw new RuntimeException("输入的数据类型不一致");
        }
    });
}

5.3 两种排序方式的对比

Comparable接口方式一旦指定，保证Comparable接口实现类的对象在任何位置都可以比较大小
Comparator接口属于临时性的比较。

6 其他类

6.1 System类

6.2 Math类

枚举类与注解

枚举类的使用

1. 枚举类的说明

枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
当需要定义一组常量时，强烈建议使用枚举类
如果枚举类中只有一个对象，则可以作为单例模式的实现方式。

2. 如何自定义枚举类

//自定义枚举类
class Season{
    //1. 私有化Season对象的属性：private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2. 私有化类的构造器，并给对象赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //3. 提供当前枚举类的读个对象； public static final
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","夏日炎炎");
    public static final Season AUTUMN = new Season("秋天","秋高气爽");
    public static final Season WINTER = new Season("冬天","冰天雪地");

    //4. 其他诉求1：获取枚举类对象的其他属性


    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

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

3. jdk5.0 新增使用enum定义枚举类

//使用enum关键字定义枚举类
//说明：定义的枚举类默认继承于java.lang.Enum类
enum Season1{
    //1. 提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2. 私有化Season对象的属性：private final修饰
    private final String seasonName1;
    private final String seasonDesc1;

    //3. 私有化类的构造器，并给对象赋值
    private Season1(String seasonName,String seasonDesc){
        this.seasonName1 = seasonName;
        this.seasonDesc1 = seasonDesc;
    }

    //4. 其他诉求1：获取枚举类对象的其他属性

    public String getSeasonName1() {
        return seasonName1;
    }

    public String getSeasonDesc1() {
        return seasonDesc1;
    }

4. 枚举类的常用方法

values()：返回枚举类型的对象数组，该方法可以很方便的遍历所有的枚举值。

valueOf(String str)：可以把一个字符串转为对应的枚举类对象，要求字符串必须时枚举类对象
toString()：返回当前枚举类对象常量的名称

 Season1 spring = Season1.SPRING;
        //toString
        System.out.println(spring.toString());
        //values():
        Season1[] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
        //valueOf(String objName)：返回枚举类中对象名时objName的对象+
        //如果没有objName的枚举类的对象，则抛异常
        Season1 winter = Season1.valueOf("WINTER");
        System.out.println(winter);

5. 枚举类对象实现接口

实现接口，在enum类中是实现抽象方法
让枚举类的对象分别去实现接口中的方法

注解的使用

1. 注解的理解

jdk5.0 新增的功能
Annotation其实就是代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。

在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，逻辑警告等。

在javaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替了javaEE旧版中所遗留的繁冗代码和XML配置等。

框架 = 注解 + 反射机制 + 设计模式

2. 注解的使用示例

Annocation的使用示例

示例一：生成文档相关的注解
示例二：在编译时进行格式检查（JDK内置的三个基本注解）
- @Oberride：限定重写父类方法，该注解只能用于方法。
- @Deprecated：用于表示所修饰的元素（类，方法等）已过时。
- @SuppressWarnings：抑制编译器警告

3. 如何自定义注解

说明：如何自定义注解：参照@SuppressWarnings定义

```
      注解声明为：@interface
```

      内部定义成员，通常使用value表示

      可以指定成员的默认值，使用default定义

      如果自定义注解没有成员，表示是一种标识。

如果注解有成员，子啊使用注解时，需要知名成员的值。自定义注解配上注释的信息处理流程（使用反射）才有意义。自定义注解通常都会知名两个元注解：@Retention和@Target

代码举例：

4. 元注解

对现有的注解进行解释说明的注解。

@Retention：指定所修饰的Annotation的生命周期：SOURCE\CLASS(默认行为)\RUNTIME，只有声明为RUNTIME生命周期的注解，才能通过反射获取。

  @Target：用于指定被修饰的Annotation能用于修饰哪些程序元素

  @Documented：表示所修饰的注解在被javadoc解析时，会被保留下来

  @Inherited：被它修饰的注解具有继承性

5. 如何获取注解信息

通过反射获取注解信息

6. jdk 8 中注解的新特性

可重复注解、类型注解

6.1 可重复注解：

在MyAnnotation上证明@Repeatble，成员值为MyAnnotations.class

                  MyAnnotation的Target和Retetion等元注解和MyAnnotations相同

6.2 类型注解：

                  ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）

                  ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

Java集合

1. 数组与集合

1.1 集合与数组存储数据概述

集合、数组都是对多个数据进行存储操作的结构，简称java容器。

说明：此时的存储，主要指内存能层面的存储，不涉及持久化层面的

1.2 数组存储的特点

数据在存储多个数据方面的特点：

  一旦初始化以后，其长度就确定了。

  数组一定定义好，其元素的类型也就确定了，我们只能操作指定类型的数据了,

  比如：String[] arr ; int[] arr1 ; Object[] arr2;

1.3 数组存储的弊端

数组在存储多个数据方面的缺点：

  一旦初始化以后，其长度就不可修改。

  数组中提供的方法非常有限，对于添加、删除、插入等操作，非常不便，同时效率不高。

  获取数组中实际元素的个数的需求，数组没有现成的属性或犯法可用

  数组存储数据的特点：有序、可重复。对于无序、不可重复的，不能满足。

1.4 集合存储的优点

解决数组存储数据方面的弊端

2. Collection接口

2.1 单列集合框架结构

Collection接口：单列集合，用来存储一个一个的对象
- Lis接口：存储有序的、可重复的数据 ---> "动态"数组
- ArrayList、LinkedList、Vector
- Set接口：存储无序的、不可重复的数据
- HashSet、LinkedHashSet、TreeSet

对应图示：

2.2 Collection接口常用方法

void add(Object ele):添加一个元素
addAll(Collection coll)
void size()
void isEmpty()
void clear()
contains(Object obj)：判断当前集合中是否包含obj
containsAll(Collection coll1)：判断形参coll1中的所有元素是否都存在于当前集合中
remove(Object obj)：从当前结合中移除obj元素
removeAll(Collection coll1)：从当前集合中移除coll1中所有的元素
ratainAll(Collection coll1)：获取两个集合中相同的部分
equals(Object obj)：比较集合是否相等
hashCode()：返回当前对象的哈希值
toArray()
iterator()：返回Iterator接口的实例，用于遍历集合元素

2.3 Collection集合与数组间的转换

//集合--->数组：toArray()
Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}
//拓展：数组--->集合：调用Arrays的静态方法asList()
List