数组

数组是什么

例子

1
2
3
4


20,10,80,60,90
int[] arr = {20,10,80,60,90};
牛儿，西门，全蛋
String[] names = {"牛儿"，"西门"，"全蛋"}

新建方式

1
2
3


double[] scores = new double[] {99.5 ,88.0,75.5}
当然也可以直接写
int ages = [25,21,53]

数组遍历

1
2
3


for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}

封装

如何进行封装更好一般建议对成员变量使用private关键字进行修饰（只能在当前类中访问）每个成员变量提供配套public修饰的getter和setter方法这种不建议：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class student{
    int age;
}
public class Test{
    public static void main(String[] args) {
        Student s = new Student();
        s.age= -121;
        System.out.println(s.age); //-121
    }
}
不推荐x

正确做法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Student {
    private int age;
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age>=0 && age<=200){
            this.age = age;
        }else {
            System.out.println("请检查！");
        }
    }
}

JavaBean

也称为实体类，其对象可以用于在程序中封装数据标准JavaBean须蛮族如下书写要求：

成员变量使用private修饰
提供成员变量对于的getset方法
必须提供一个无参构造器；有参构造器可写可不写

ArrayList

集合与数组类似，也是一种容器用于存储数据。数组的特点是：数组定义完成并启动后，类型确定，长度固定。问题是，在个数不能确定，且要进行增删数据操作的时候，数组是不太合适的。集合的特点是：集合的大小不固定，启动后可以动态变化，类型也可以选择不固定 集合非常适合做元素个数不确定，且要进行增删操作的业务场景。 集合提供了许多丰富好用的功能，而数组的功能单一。

ArrayList集合的对象获取

public ArrayList() 创建一个空的集合对象

添加方法

1
2


public boolean add(E e) //将指定的元素添加到此集合的末尾
public void add(int index,E element) //在此集合中的指定位置插入指定的元素 

泛型概述

ArrayList:其实就是一个泛型类，可以在编译阶段约束集合对象只能操作某种数据类型比如： ArrayList:只能存字符串类型 ArrayList：只能存整数类型

Static

Static 即静态可以修饰成员变量和成员方法。 static修饰成员变量表示该成员变量只在内存中 只存储一份可以被共享访问、修改

成员变量可以分为2类

静态成员变量：常表示如在线人数信息，等需要被共享的信息，可以被共享访问类名.静态成员变量（推荐）对象.静态成员变量（不推荐）

成员方法

静态成员方法（static修饰，归属于类），建议用类名访问，也可以用对象访问实例成员方法（无static修饰，归属于对象），只能用对象触发访问

Static访问注意事项

静态方法只能访问静态的成员，不可以直接访问实例成员
实例方法可以访问静态成员，也可以访问实例成员
静态方法是不可以出现this关键字的

工具类

Util 类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。工具类定义时的其他要求: 由于工具里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有。

代码块

代码块的分类，作用

静态代码块

格式：static{} 特点：需要static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次。

构造代码块

（见得少，了解即可）格式：{} 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。

单例设计模式

单例模式

可以保证系统中，应用该模式的类永远只有一个实例，即一个类永远只能创建一个对象。

饿汉单例设计模式

在类获取对象的时候，对象已经提前为你创建好了。【我想吃包子的时候，包子已经做好了】

设计步骤

1
2
3
4
5
6
7
8
9


/** a.定义一个单例类 */
public class SingleInstance {
    // 定义一个静态变量存储一个对象即可；属于类，与类一起加载一次。
   public static SingleInstance instance = new SingleInstance();
    // 单例必须私有构造器
    private SingleInstance(){
        System.out.println("创建了一个对象")
        }
}

懒汉单例设计模式

在真正需要该对象的时候，才去创建一个对象（延迟加载对象）【真正饿的时候才去做饭】

设计步骤

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


/** a.定义一个单例类 */
public class SingleInstance {
    // 定义一个静态变量存储一个对象即可；属于类，与类一起加载一次。
    // 私有化，可以避免挖坑。
   private static SingleInstance instance ; //null
    // 单例必须私有构造器
    private SingleInstance(){
        }
    public static SingleInstance getInstance(){
        if(instance == null){
            //第一次拿对象，此时需要创建对象。
            instance = new SingleInstance();
        }
        return instance;
    }
}

继承

关键字 extends

1

public class Student extends People {}

student 称为子类，People称为父类提高代码复用性，减少代码冗余，增强类的功能扩展性子类继承父类，子类可以得到父类的属性和行为，子类可以使用

继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
Java是单继承模式；一个类只能继承一个父类；
java不支持多继承、但是可以支持多层继承（儿子继承爸爸，爸爸继承爷爷）
java中所有的类都是object类的子类。

在子类方法中访问成员（成员变量，成员方法）满足：就近原则

现在子类局部范围找
然后在子类成员范围找
然后父类成员范围找，如果父类范围还没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，如果一定要找父类的怎么办？使用super关键字

方法重写

在继承体系中，子类出现了和父类中一模一样的方法声明，就称子类的方法是重写的方法。

应用场景

当子类需要父类的功能，但父类的功能不完全满足自己的需求时。
子类可以重写父类中的方法。

@Override 重写注解

是放在重写后的方法上，作为重写是否正确的校验注解。
加上该注解后如果重写错误，编译阶段会出现错误提示。

子类继承父类后构造器的特点

子类所有的构造器默认会先访问父类中的无参构造器，再执行自己

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

子类访问父类有参构造器

super（参数）；

权限修饰符

是用来控制一个成员能够被访问的范围。

Final

final 关键字的意思是最终修饰类：表明该类是最终类，不能被继承修饰方法：表明方法是最终方法，不能被重写。修饰变量：表示该变量第一次赋值后，不能再次被赋值（有且仅能被赋值一次）

常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行过程中值不能被改变。作用和好处：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。常量的命名规范：英文单词全部大写，多个单词下划线连接起来

1
2
3
4
5


public class Constant {
    public static final String SCHOOL_NAME = "传智教育";
    public static final String LOGIN_NAME = "admin";
    public static final String PASS_WORD = "123456";
}

常量的执行原理：在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。

枚举

作用：是为了做信息的标志和信息的分类

1
2
3


public enum Season{
    SPRING,SUMMER,AUTUMN,WINTER;
}

选择常量做信息标志和分类，虽然可以实现可读性，但是入参值不受约束，代码不够严谨枚举做信息标志和分类，代码可读性好，入参约束严谨，代码优雅，是最好的信息分类技术，建议使用。

抽象类

在java中abstract是抽象的意思，可以修饰类、成员方法。抽象方法只有方法签名，不能声明方法体。一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

抽象类总结

1.抽象类的基本作用是啥？

作为父类，用来被继承的。

2.继承抽象类要注意的点：

一个类如果继承了抽象类，那么这个类必须重写完抽象类的==全部抽象方法==，否则这个类也必须定义为抽象类。

==最重要的特征：==

得到了抽象方法，失去了创建对象的能力。（有得有失）

Final 和 abstract 是什么关系？

互斥关系
abstract 定义的抽象类作为模板让子类继承，final定义的类不能被继承。

接口

声明了一个接口：体现一种规范，规范一定是公开的。

接口的定义和特点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public interface InterfaceDemo{
    //1.常量
    public static final String SCHOOL_NAME="Heima";
    //2.抽象方法
    // 注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以用省略不写。
    void run();
    // public abstract void run();
    void eat();
    // public abstarct void eat();

}

接口的用法

接口是用来被类实现（Implements)的，实现接口的类称为实现类。实现类可以理解为所谓的子类。

1
2
3
4


修饰符 class 实现类 implements 接口1,接口2,接口3{

}
实现的关键字：implements

从上面可以看出，接口可以被类单实现，也可以被类多实现。

一个类实现接口，必须重写完全部接口的抽象方法，否则这个类需要定义成抽象类。

接口与接口的关系

多继承，一个接口可以继承多个接口。

接口多继承的作用

规范合并，整合多个接口为同一个接口，便于子类实现。

JDK8开始新增的方法

第一种默认方法

类似之前写的普通实例方法：必须用default修饰

1
2
3


default void run(){
    System.out.println("开始跑");
}

第二种静态方法

默认会public修饰，必须static修饰。

注意：接口的静态方法必须用本身的接口名来调用。

1
2
3


Static void run(){
    System.out.println("开始跑");
}

第三种私有方法

就是私有的实例方法，必须使用private修饰，从jdk1.9开始有的
只能在本类中被其他的默认方法或者私有方法访问

1
2
3


private void run(){
    System.out.println("开始跑");
}

注意

1.接口不能创建对象。 2.一个类实现多个接口，多个接口中有同样的静态方法不冲突。 3.一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。 4.一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。 5.一个接口多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

多态

同类型的对象，执行同一个行为，会表现出不同的行为特征。

1
2


父类类型 对象名称 = new 子类构造器；
接口 对象名称 = new 实现类构造器；

多态中成员访问特点

方法调用：编译看左边，运行看右边。
变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

多态的优势

在多态形式下，右边对象可以实现解耦合，便于扩展和维护。
Animal a = ==new Dog();==
a.run(); // 后续业务行为随对象而变，后续代码无需修改。
定义方法的时候，使用父类型作为参数，该方法就可以接受这父类的一切子类对象，体现出多态的扩展性和便利。

多态下会产生的一个问题

多态下不能实现子类的独有功能。

自动类型转换（从子到父）

子类对象赋值给父类类型的变量指向。

强制类型转换（从父到子）

此时必须进行强制类型转换：子类对象变量 = （子类）父类类型的变量
作用：可以解决多态下的劣势，可以实现调用子类独有的功能。
注意：如果转换后的类型和对象真实类型不是同一种类型，那么在转换的时候会出现ClassCastException

1
2


Animal t = new Tortoise();
Dog d = (Dog) t; //出现异常 ClassCastException

Java建议强制转换前使用instanceof判断当前对象的真实类型，再进行强制转换。

1
2


变量名 instanceof 真实类型
//判断关键字左边的变量指向的对象的真实类型，是否是右边的类型或者是其子类类型，是则返回true，反之。

内部类

1
2
3
4
5
6


public class People{
    //内部类
    public class Heart{

    }
}

内部类的使用场景、作用

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
内部类通常可以方便访问外部类的成员，包括私有的成员、
内部类为了提供更好的封装性，本身就可以用protected，private修饰本身。

静态内部类

有static修饰。属于外部类本身

1
2
3
4
5
6
7
8
9


public class Outer{
    //静态成员内部类
    public static class Inner{

    }
}
//静态内部类创建对象的格式：
外部类名.内部类名 对象名= new 外部类名.内部类构造器;
Outer.Inner in = new Outer.Inner();

成员内部类

无static修饰，属于外部类的对象。 JDK16之前，成员内部类不能定义静态成员，JDK16开始也可以定义静态成员了。

1
2
3
4
5
6


public class Outer{
    //成员内部类
    public class Inner{

    }
}

成员内部类创建对象的格式：

1
2


格式：外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();
Outer.Inner in = new Outer().new Inner();

注意：在成员内部类中访问所在外部类对象，格式：外部类名.this

匿名内部类【重点】

本质上是一个没有名字的局部内部类，定义在方法汇总、代码块中、等。
作用：方便创建子类对象，最终目的为了简化代码编写。

格式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


new 类|抽象类名|或者接口名() {
    重写方法;
};


Emplyee a  = new Employee(){
    public void work(){

    }
};
a.work();

特点总结：

匿名内部类是一个没有名字的内部类。
匿名内部类写出来就会产生一个匿名内部类对象。
匿名内部类的对象类型相当于是当前new的那个类型的子类类型。

匿名内部类可以作为方法的实际参数进行传输。

开发中不是我们去主动定义匿名内部类的，而是别人需要我们写或者我们可以写的时候才会使用，匿名内部类的代码可以实现代码的进一步简化。

常用API

API（Application Programing Interface）

Object类

一个类要么默认继承了Object类，要么间接继承，Object类是java中的祖宗类

Object 类的常用方法

方法名	说明
public string toString()	默认返回当前对象在堆内存中的地址信息：类的全限名@内存地址
public Boolean equals(Object o)	默认是比较当前对象与另一个对象的地址是否相同，相同ture，不同false

toString方法

public String toString（）默认是返回当前对象在堆内存中的信息：类的全限名@内存地址

真正的意义：让子类重写，以便返回子类对象的内容。 IDEA中自动生成的重写tostring的方法，可以输出对象内容。可以在敲代码时快捷输入tos，回车回车。

equals方法

默认是比较当前对象与另一个对象的地址是否相同，返回true或false

equals存在的意义父类equals方法存在的意义就是为了被子类重写，以便于子类自己来定制比较规则。

Obejcts

Objects类与Object还是继承关系，从jdk1.7后开始有的。

IDEA在进行字符串比较时，没有对象自己的equals方法，而是选择了Objects的equals方法来比较两个对象。

方法名	说明
public static boolean equals(Object a,Object b)	比较两个对象的，底层会进行非空判断，从而可以避免空指针异常，再进行equals比较
public static boolean inNull(Object obj)	判断变量是否为null，是返回true

1
2
3
4
5
6
7


@Override
public boolean equals(Object o){
    if(this == o) return true;
    if(o == null || this.getClass()!= o.getClass()) return false;
    Student student = (Student)  o;
    return sex == student.sex && age ==student.age && Objects.equals(name,student.name);
}

Objects的equals方法比较的结果是一样的，但是更安全。

例子：

1
2
3
4


String s1 = null;
String s2 = new String("it");
//System.out.println(s1.equals(s2)) 有隐患，可能出现空指针异常
System.out.println(Objects.equals(s1,s2)); //更安全

在java源代码中，Objects的equals源码：

1
2
3


public static boolean equals(Object a,Object b){
    return(a==b)|| (a!=null && a.equals(b));
}

isNull:

1
2
3


System.out.println(Objects.isNull(s1));
//等同于
System.out.println(s1==null);

StringBuilder

概述

StringBuilder 是一个可变的类字符串，我们可以把他看做一个容器。作用：提高字符串的操作效率，如拼接、修改等。

StringBuilder构造器

名称	说明
public StringBuilder（）	创建一个空白的可变的字符串对象，不包含任何内容
public StringBuilder（String str）	创建一个指定字符串内容的可变字符串对象

StringBuilder 常用方法

方法名称	说明
public StringBuilder append（任意类型）	添加数据并返回StringBuilder对象本身
public StringBuilder reverse（）	将对象的内容反转
public int length（）	返回对象内容长度
public String toString（）	通过toString（）就可以实现转换成String

为什么拼接、反转字符串建议使用StringBuilder？

String：内容是不可变的、拼接字符串性能差。
StringBuilder：内容是可变的、拼接字符串性能好、代码优雅。
定义字符串使用String
拼接、修改等操作字符串使用StringBuilder

Math类

包含基本执行数字运算的方法，Math类没有提供公开的构造器。 如何使用类中的成员呢？看类的成员是否都是静态的，如是，通过类名就可以直接调用。

System类

System功能是通用的，直接调用类名即可，所以System不能被实例化。

BigDecimal类

用于解决浮点型运算精度失真的问题
double c = 0.1+0.2 输出结果为0.30000000000000004

使用步骤

创建对象BigDecimal封装浮点型数据（最好的方式是调用方法）

1

public static BigDecimal valueOf (double val); //包装浮点数称为BigDecimal对象。

日期与时间

Date类

记录时间的2种形式

1.日期对象

1
2


Date d = new Date();
System.out.println(d);

2.时间毫秒值

指的是从1970年1月1日 00:00:00 走到此刻的总毫秒数

1
2


long time = d.getTime();
System.out.println(time);

SimpleDateFormat 类

可以把Date对象或时间毫秒值格式化为我们喜欢的时间形式。
也可以把字符串的时间形式解析成日期对象。

1.SimpleDateFormat可以格式化哪些形式？

1
2
3


SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String rs1 = sdf.format(date);
String rs2 = sdf.format(time);

2.SimpleDateFormat如何进行字符串时间的解析？

1
2


SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(("2021-08-04 11:11:11"));

转换的时间格式必须与要被解析的时间格式完全一致，否则会报错。

Calendar 类

Calendar代表了此刻日期对应的日历对象。
Calendar是一个抽象类，不能直接创建对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 拿到系统此刻日历对象。
Calendar cal = Calendar.getInstance();
System.out.println(cal);
// 获取日历的信息public int get（int field），取日期的某个字段信息
int year = cal.get(Calendar.YEAR);
System.out.println(year);
int month = cal.get(Calendar.MONTH) + 1 ;
System.out.println(month) ;
// public void set (int field,int value) 修改日历的某个字段信息
cal.set(Calendar.HOUR,12);

JDK8 新增日期类

LocalDate:不包含具体时间的日期。 LocalTime:不含日期的时间。 LocalDateTime:包含了日期及时间。 Instant:代表的是时间戳。 DateTimeFormatter用于做时间的格式化和解析的 Duration:用于计算两个“时间”间隔 Period:用于计算两个“日期”间隔

日后用到可以去查用法。

Instant 时间戳

JDK8获取时间戳特别简单，Instant类由一个静态的工厂方法now（）可以返回当前时间戳

1
2
3


Instant instant = Instant.now()
System.out.println("当前时间戳是"+instant);//世界标准时间
instant.atZone(ZoneId.systemDefault());//输出系统默认时区时间

DateTimeFormatter

1
2
3
4
5
6


LocalDateTime ldt = LoaclDateTime.now();
System.out.println(ldt);//2021-03-01T15:09:17.4419900000

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String ldtStr = ldt.format(dtf);
System.out.println(ldtstr);//2021-03-01 15:09:17

Period m

计算日期间隔差异：java.time.Period 主要是getYears(),getMonths(),getDays()来计算，只能精确到年月日。 Period period = Period.between(birthDate,today) //判断出生日期到今天，可以用上面的三个方法算差值。

Duration

计算时间间隔差异：java.time.Duration 提供了使用基于时间的值测量时间量的方法。用于LocalDateTime之间的比较，也可用于INstant之间的比较。

包装类

其实就是8中基本数据类型对应的引用类型。

基本数据类型	引用数据类型
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

为什么提供包装类？

Java为了实现一切皆对象，为8中基本类型提供了对应的引用类型。
后面的集合和泛型只支持包装类型，不支持基本数据类型。
自动装箱：基本类的数据和变量可以直接复制给包装类型的变量。
自动拆箱：包装类型的变量可以直接赋值给基本数据类型的变量。

1
2
3
4
5
6


int a= 10;
Integer a1 = 11;
Integer a2 = a;// 自动装箱。

Integer it=100;
int it1 = it; // 自动拆箱。

包装类的特有功能

包装类的变量默认值可以是null，容错率更高。
可以把基本类型的数据转换成字符串类型。(用处不大)

1
2
3
4


Integer i3 = 23;
String rs = i3.toString();

String rs1 = Interger.toString(i3);

调用toString（）方法得到字符串结果。

调用Integer.toString(基本类型的数据)

可以把字符串类型的数值转换成真实的类型数据(有用)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


String number ="23";

// int age = Interger.parseInt(number);
int age = Interger.valueOf(number);
System.out.println(age+1);

String number1="99.9";
// double score = Double.parseDouble(number1);
double score = Double.valueOf(number1);
System.out.println(number1+0.1);

正则表达式

Java的API文档中：Pattern 匹配规则

有解释说明。

字符类（默认匹配一个字符）

[abc] 只能是a或b或c [^abc] 除了abc以外的都可以 [a-zA-Z] 从a到z，A到Z （包含范围） [a-d[m-p]] 从a到d，或m到p [a-z&&[^bc]] a到z 除了b和c [a-z&&[^m-p]] a到z，除了m到p

预定义的字符类

. 任意字符 \d 一个数字:[0-9] \D 非数字：相当于[^0-9] \s 一个空白字符：[\t\n\xOB\f\r] \S 非空白字符：[^\s] \w 字母、数字、下划线[a-zA-Z_0-9] \W 一个非单词字符 [^\w]

贪婪量词

X? X,一次或根本不 X* X，零次或多次 X+ X,一次或多次 X{n} X,正好n次 X{n,} X，至少n次 X{n,m} X,至少n但不超过m次

例子: 判断手机号格式是否正确？正则表达式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public static void checkPhone(){
    Scanner sc = new Scanner(System.in);
    while(true) {
        System.out.println("请输入您的手机号");
        String phone = sc.next();
        if(phone.matches("1[3-9]\\d{9}")){
            System.out.println("格式正确！");
            break;
        }else{
            System.out.println("格式错误！");
        }
    }
}

Array类

数组操作工具类，专门用于操作数组元素。

1.返回数组内容 toString

1
2


int[] arr = {10,2,55,23,25,100};
System.out.prinln(Arrays.toString(arr));

2.排序的API 默认自动对数组元素进行升序排序

1
2


Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); 

3.二分搜索技术（必须已经排好序的数组）

1
2


Arrays.binarySearch(arr,55);
System.out.println(index);// 输出4 如果元素不存在，会输出 -(应该插入的位置索引 +1)

自定义数组排序规则 Comparator

Lambda表达式

是从JDK8开始一种新语法形式
为了简化匿名内部类的代码写法

1
2
3


(匿名内部类被重写方法的形参列表) -> {
    被重写方法的方法体代码
}

注意：Lambda表达式只能简化函数式接口的匿名内部类写法形式。

什么是函数式接口？

首先必须是接口、其次接口中有且仅有一个抽象方法的形式。
通常我们会在接口上加一个@FunctionalInterface注解，标记该接口必须是满足函数式接口。

数组

数组是什么

数组遍历

封装

JavaBean

ArrayList

ArrayList集合的对象获取

添加方法

泛型概述

Static

成员变量可以分为2类

成员方法

Static访问注意事项

工具类

代码块

代码块的分类，作用

静态代码块

构造代码块

单例设计模式

单例模式

饿汉单例设计模式

设计步骤

懒汉单例设计模式

设计步骤

继承

继承的特点

方法重写

应用场景

@Override 重写注解

子类继承父类后构造器的特点

子类访问父类有参构造器

权限修饰符

Final

常量

枚举

抽象类

抽象类总结

接口

接口的定义和特点

接口的用法

接口与接口的关系

JDK8开始新增的方法

第一种 默认方法

第二种 静态方法

第三种 私有方法

注意

多态

多态中成员访问特点

多态的优势

多态下会产生的一个问题

自动类型转换（从子到父）

强制类型转换（从父到子）

内部类

内部类的使用场景、作用

静态内部类

成员内部类

匿名内部类 【重点】

常用API

Object类

Object 类的常用方法

toString方法

equals方法

Obejcts

StringBuilder

概述

StringBuilder构造器

StringBuilder 常用方法

Math类

System类

BigDecimal类

使用步骤

日期与时间

Date类

SimpleDateFormat 类

Calendar 类

JDK8 新增日期类

Instant 时间戳

DateTimeFormatter

Period m

Duration

第一种默认方法

第二种静态方法

第三种私有方法

匿名内部类【重点】