自学Java用笔记

命令提示符

启动：win+R，输入cmd（按ctrl+shift+回车）
切换盘符：盘符名称：
进入文件夹：cd 文件夹名称
进入多级文件夹： cd 文件夹1\文件夹2\文件夹3
返回上一级： cd …
直接返回根目录： cd
查看当前内容： dir
清空屏幕： cls
退出： exit

Git

IDEA快捷键

Psvm+回车：快速生成main方法
Sout+回车：快速生成输出语句
Ctrl+shift+/：将选中内容变成注释
Ctrl+alt+L：格式化代码
Alt+回车：代码修正提升
Ctrl+D：向下复制一行
Ctrl+X：剪切当前行
Alt+shift+↑：上移当前行
Alt+shift+↓：下移当前行
Alt+insert：快速生成语句

输出中/+字母的特殊用法

/t：输出大空格
/n:输出换行

Debug的使用

如何加断点

选择要设置的代码行，在行号的区域后面单击鼠标左键即可

如何删除断点

再次点击断点或者使用停止按钮后方快捷键

如何运行加了断点的程序

在代码区域右键Debug执行

看哪里

看控制台

点哪里

点step Into（F7）这个箭头，也可以直接按F7
点Stop结束

编译和运行

编译：javac文件名.java
示例：javac HelloWorld.java
运行：java类名
示例：java HelloWorld

关键字

1. 字母全是小写
2. main不是关键字

常量

常量：在程序执行过程中，其值不会发生改变的量（数据）

变量

1， 变量名不允许重复定义
2， 一条语句可以定义多个变量，但是需要使用逗号进行分割
3， 变量在使用之前一定要赋值
4， 定义float和long类型变量的注意事项
定义float类型变量的时候：需要注意在数值后面加入F的标识，F可大写也可小写
定义long类型变量的时候：需要注意在数值后面加入L的标识，L可大写也可小写（一般建议小写）
5， 变量的作用域范围
变量的作用域：只在它所在的大括中有效（当一个大括中的代码执行完毕后，内部所⸢定义⸥的变量就会从内存中消失）

使用变量：（如图）

标识符

标识符：就是给类，方法，变量等起名字的符号
标识符由数字、字母、下划线（_）和美元符($)组成，不能是关键字，区分大小写，不能以数字开头

常见命名约定：
小驼峰命令法：方法、变量
约定1：标识符是一个单词的时候，首字母小写（范例：name）
约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写（范例：firstName）

大驼峰命令法：类
约定1：标识符是一个单词的时候，首字母大写（范例：Student）
约定2：标识符由多个单词组成的时候，每个单词首字母大写（范例：GoodStudent）

类型转换

隐式转换的过程：
隐式转换：将数据类型中，取值范围小的数据，给取值范围大的类型赋值，可以直接赋值

小的数据类型，和大的数据类型运算，小的会提升为大的之后，再进行运算

特殊关注：byte、short、char三种数据在运算的时候，不管是否有更高的数据类型，都会提升为int，然后再进行运算。

强制转换的过程：
强制转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名=（目标数据类型）值或变量
范例：int k = (int)88.88;

注意：强制类型转换，有可能会发生精度损失

字符串

字符串可以使用+号，跟任意数据类型拼接
当+操作中出现字符串时，这个+是字符串连接符，而不是算术运算。

println（“5+5=“+5+5）；//输出为5+5=55
println（“5+5=“+（5+5））；//输出为5+5=10

自增自减运算符

单独使用时，++和–无论在前在后，结果都一样，不能对常量进行操作。

赋值运算符

扩展的赋值运算符隐含了强制类型转换

逻辑运算符

逻辑运算符是用来连接关系表达式的运算符，也可以直接连接布尔类型的常量或者变量

短路逻辑运算符：

三元运算符

格式：关系表达式？表达式1：表达式2；
执行流程：首先计算关系表达式的值，如果值为true，取表达式1的值，如果值为false，取表达式2的值

流程控制语句

顺序结构语句

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

if语句

if语句格式1：
if（关系表达式）{
语句体；
}
执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体
3. 如果关系表达式的值为false就不执行语句体
4. 继续执行后面的语句内容
   if语句注意事项：
5. if语句所控制的语句体，如果是一条语句，大括号可以省略不写
6. if语句的小括号后面，没有分号

if语句格式2：
if（关系表达式）{
语句体1；
}else{
语句体2；
}

执行流程：

1. 首先计算关系表达式的值
2. 如果关系表达式的值为true就执行语句体1
3. 如果关系表达式的值为false就执行语句体2
4. 继续执行后面的语句内容

if语句格式3：
if（判断条件1）{
语句体1；
}else if（判断条件2）{
语句体2；
}
…
else{
语句体n+1；
}

执行流程：
1.首先计算判断条件1的值
2.如果值为true就执行语句体1；如果值为false就计算判断条件2的值；
3.如果值为true就执行语句体2；如果值为false就计算判断条件3的值；
4….
5. 如果没有任何判断条件为true，就执行语句体n+1；
6. 继续执行后面的语句内容

Switch语句

格式：
switch（表达式）{
case值1：
语句体1；
break；
case值2：
语句体1；
break；
…
default:
语句体n+1；
break；
}

执行流程：

1. 首先计算表达式的值。
2. 依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行过程中，遇到break就会结束。
3. 如果所有case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉

For循环语句

格式：
for（初始化语句；条件判断语句；条件控制语句）{
循环体语句；
}

执行流程：

1. 执行初始化语句
2. 执行条件判断语句，看其结果是true还是false
   如果是false，循环结束
   如果是true，继续执行
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续

While循环语句

格式：
初始化语句；
While（条件判断语句）{
循环体语句；
条件控制语句；
}

执行流程：

1. 执行初始化语句
2. 执行条件判断语句，看其结果是true还是false
   如果是false，循环结束
   如果是true，继续执行
3. 执行循环体语句
4. 执行条件控制语句
5. 回到2继续

Do…while循环语句

格式：
初始化语句；
Do{
循环体语句；
条件控制语句；
}while（条件判断语句）；

执行流程：

1. 执行初始化语句
2. 执行循环体语句
3. 执行条件控制语句
4. 执行条件判断语句，看其结果是true还是false
   如果是false，循环 结束
   如果是true，继续执行
5. 回到2继续执行

三种循环的区别

跳转控制语句

Random的作用和使用步骤

数组定义格式

数组初始化

动态初始化

静态初始化

两种初始化的区别对比

Java内存分配

栈内存：方法运行时，进入的内存，局部变量都存放在这块内存当中
堆内存：new出来的内容都会进入堆内存，并且会存在地址值
方法区：字节码文件（.class文件）加载时进入的内存
本地方法栈：调用操作系统相关资源
寄存器：交给cpu去使用

数组内存图（单个）：

数组内存图（两个）：

注意：每new一次，在堆内存中，都是一块新的空间，堆内存中的空间地址不会出现重复的现象。

数组内存图（多个数组指向相同）：

数组常见操作

获取数组元素数量

格式：数组名.length
范例：arr.length

遍历

数组遍历：将数组中所有的数据取出来
遍历通用格式：

Int[ ] arr = {……};
For(int i = 0; i<arr.length;i++) {
	Arr[i];
}

方法

方法定义

方法调用

方法调用过程

带参数方法的定义和调用

形参和实参

带返回值方法的定义和调用

带返回值方法定义

带返回值方法调用

方法的通用格式

方法的注意事项

1. 方法不能嵌套定义
2. 方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以忽略return不写，如果要写return，后面不能跟具体的数据
3. Return语句下面，不能编写代码，因为永远执行不到，属于无效代码

方法重载

方法参数传递

进制

进制转换

原码反码补码

位运算符介绍

二维数组

二维数组也是一种容器，不同于一维数组，，该容器存储的都是一维数组容器

二维数组定义格式：
格式1：数据类型[ ][ ]变量名；
范例：int[ ][ ] arr;

格式2：数据类型 变量名[ ][ ];
范例：int arr[ ][ ]；

格式3：数据类型[ ] 变量名[ ];
范例：int[ ] arr[ ];

二维数组初始化

动态初始化

静态初始化

面向对象基础

类和对象

类的定义

类的组成

类的定义步骤

1. 定义类
2. 编写类的成员变量
3. 编写类的成员方法

Public class 类名{
//成员变量
变量1的数据类型 变量1；
变量2的数据类型 变量2；
…
//成员方法
方法1；
方法2；
…
} 

对象的使用

创建对象：
格式：类名 对象名 = new 类名（）；
范例：phone p = new phone（）；

使用对象：

1. 使用成员变量
   格式：对象名.变量名
   范例：p.brand
2. 使用成员方法
   格式：对象名.方法名（）
   范例：p.call（）

成员变量和局部变量：
成员变量：类中方法外的变量
局部变量：方法中的变量

成员变量和局部变量的区别

封装

封装是面向对象三大特征之一（封装，继承，多态）

Private关键字

Private关键字是一个权限修饰符，可以修饰成员（成员变量和成员方法），作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

Set/get方法

使用案例：

package xiushichengyuanbianliang;
/*学生类*/
public class Student {
    private String name;
    private int age;

    public void setName(String n){
        name = n;
    }

    public String getName(){
        return name;
    }

    public void setAge(int a){
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

package xiushichengyuanbianliang;
/*学生测试类*/
public class StudentTest {
    public static void main(String[] args) {
     Student s = new Student();

        s.setName("张三");
        s.setAge(24);

        System.out.println(s.getName()+"---"+s.getAge());
    }
}

This关键字

1. This修饰的变量用于指代成员变量
   方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
   方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
2. 什么时候用this？解决局部变量隐藏成员变量
3. This代表所在类的对象引用
   记住：方法被哪个对象调用，this就代表哪个对象

构造方法

标准类的制作

字符串

String

String类在java.lang包下，所以使用的时候不需要导包
String类代表字符串，Java程序中的所有字符串文字（例如“abc”）都被视为此类的实例，也就是说，java程序中所有的双引号字符串，都是String类的对象

字符串的特点

1. 字符串不可变，它们的值在创建后不能被更改
2. 虽然String的值是不可变的，但是它们可以被共享
3. 字符串效果上相当于字符数组（char[ ]）,但是底层原理是字节数组（byte[ ]）

注意：键盘录入String类型时，同时使用nextLine（）和nextInt（）会导致nextLine（）录入失败，应使用next（）录入

String构造方法

注意：推荐使用直接赋值的方式得到字符串对象

范例：

/*String构造方法*/
public class test2 {
    public static void main(String[] args) {
        //public String():创建一个空白字符串对象，不含任何内容
        String s1 = new String();
        System.out.println("s1:"+s1);

        //public String(char[] chs):根据字符数组的内容来创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println("s2:"+s2);

        //public String(byte[] bys):根据字节数组的内容来创建字符串对象
        byte[] bys = {97,98,99};
        String s3 = new String(bys);
        System.out.println("s3:"+s3);

        //String s = "abc";直接赋值的方式创建字符串对象，内容就是abc
        String s4 = "abc";
        System.out.println("s4:"+s4);
    }
}

String对象的特点

1. 通过new创建的字符串对象，每一次new都会申请一个内存空间，虽然内容相同，但是地址值不同

char[] chs = {'a','b','c'};
 String s1 = new String(chs);
 String s2 = new String(chs);

上面代码中，JVM会首先创建一个字符数组，然后每new一次的时候都会有一个新的地址，只不过s1和s2参考的字符串内容是相同的

2.以""方式给出的字符串，只要字符序列相同（顺序和大小写），无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护

 String s3 = "abc";
 String s4 = "abc";

在上面代码中，针对第一行代码，JVM会建立一个String对象放在字符串池中，并给s3参考；
第二行则让s4直接参考字符串池中的String对象，也就是说他们本质上是同一个对象

字符串的比较

使用 == 做比较
基本类型：比较的是数据值是否相同
引用类型：比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫：equals（）
public boolean equals(Object anObject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串

用户登录案例：

import java.util.Scanner;

/*用户登录案例
* 需求：已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示*/
public class test3 {
    public static void main(String[] args) {
        //已知用户名和密码
        String username = "zy";
        String password = "123";
        //用for循环提供三次机会
        for (int i = 1;i <= 3; i++) {
            //键盘录入要登录的用户名和密码，用Scanner实现
            Scanner sc = new Scanner(System.in);
            
            System.out.println("请输入用户名");
            String n = sc.nextLine();
            
            System.out.println("请输入密码");
            String p = sc.nextLine();
            //用输入的用户名密码和已知用户名密码对比
            if ((username.equals(n) == true) & (password.equals(p) == true)) {
                System.out.println("登录成功！");break;
            } else {
                System.out.println("用户名或密码错误,您还有"+(3-i)+"次机会");
            }
        }
    }
}

import java.util.Scanner;

/*遍历字符串*/
public class test4 {
    public static void main(String[] args) {
        //键盘录入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要遍历的内容:");
        String a = sc.nextLine();
        //使用for循环遍历字符串
        for (int i = 0; i <a.length() ; i++) {
            System.out.println(a.charAt(i));
        }
    }
}

String[] split(String regex): 根据传入的字符串作为规则进行切割，将切割后的内容存入字符串数组中，并将字符串数组返回。

String方法小结

常用API

API:应用程序编程接口
Java API：指的就是JDK中提供的各种功能的Java类
键盘录入字符串：

import java.util.Scanner;

/*键盘录入字符串*/
public class test1 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.println("请输入：");
        String line = sc.nextLine();

        System.out.println("你输入的是:" + line);

    }
}

注意：
调用方法的时候，如果方法有明确的返回值，我们用变量接受可以手动完成，也可以使用快捷键的方式完成（Ctrl+Alt+V）

StringBuilder

StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是StringBuilder对象中的内容是可变的

StringBuilder和String的区别：
String的内容是不可变的，而StringBuilder的内容是可变的

StringBuilder构造方法

StringBuilder sb = new StringBuilder();
StringBuilder sb = new StringBuilder("hello");

StringBuilder的添加和反转方法

StringBuilder sb = new StringBuilder("hello");
sb.append("world");
//输出结果是：helloworld

sb.reverse();
//输出结果是：dlrowolleh

StringBuilder和String相互转换

1. StringBuilder转换为String：
   public String toString():通过toString()就可以实现把StringBuilder转换为String

StringBuilder sb = new StringBuilder();
sb.append("hello");
String = sb.toString();

2. String转换为StringBuilder：
   publicStringBuilder(String s):通过构造方法就可以实现把String转换为StringBuilder

String s = "hello";
StringBuilder = new StringBuilder(s);

Object类

一个类要么默认继承了object类，要么间接继承了object类，object类是Java中的祖宗类。
object类的方法是一切子类都可以直接使用的。

object类的常用方法

Object的toString方法：

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

问题引出：

1. 开发中直接输出对象，默认输出对象的地址其实是毫无意义的。
2. 开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息。

toString存在的意义：

父类toString（）方法存在的意义就是为了被子类重写，以便返回对象的内容信息，而不是地址信息。

Object的equals方法：

方法名	说明
public Boolean equals（Object o）	默认是比较当前对象与另一个对象的地址是否相同，相同返回true，不同返回false

问题引出：

直接比较两个对象的地址是否相同完全可以用“==”替代equals。

equals存在的意义：

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

Objects类

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

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

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

Objects的常用方法

方法名	说明
public static boolean equals（Objects a，Objects b）	比较两个对象，底层会先进行非空判断，从而可以避免空指针异常，再进行equals比较
public static boolean isNull（Object o）	判断变量是否为null，为null则返回true，反之则返回false

源码：

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

Math类

包含执行基本数字运算的方法，Math类没有提供公开的构造器。

Math类的采用方法

System类

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

System类的常用方法

BigDecimal类

用于解决浮点型运算失真的问题。

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

public static BigDecimal valueOf(double val):	包装浮点数成为BigDecimal对象

BigDecimal常用API

将BigDecimal转为double

double a = b.doubleValue();

日期与时间

Date类

Date类的对象在Java中代表的是当前所在系统的此刻日期时间

Date的构造器

Date的常用方法

Date类记录时间的2中形式

时间毫秒值->日期对象

总结

SimpleDateFormat类

SimpleDateFormat的构造器

SimpleDateFormat的格式方法

SimpleDateFormat解析字符串成为日期对象

Calendar

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

Calendar日历类创建日历对象的方法

Calendar常用方法

注意：calendar是可变日期对象，一旦修改后其对象本身表示的时间将产生变化。

JDK8新增日期类

LocalTime/LocalDate/LocalDateTime

Instant

DateTimeFormatter

Period/Duration

ChronoUnit

集合

集合和数组的特点对比

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以发生改变

注意：集合中只能存储引用类型数据，如果要存储基本类型数据可以选用包装类。

集合和数组的区别：
共同点：都是存储数据的容器
不同点：数组的容量是固定的，集合的容量是可变的
如果存储的数据，长度经常发生改变，推荐使用集合

集合类体系结构

Collection集合体系及特点

集合对于泛型的支持

Collection集合常用API

Collection集合的遍历方式

方式一：迭代器

迭代器代码：
总结

方式二：foreach/增强for循环

方式三：lambda表达式

Collection集合存储自定义类型的对象

List系列集合

List集合特点、特有API

List集合特点

List集合特有方法

List集合的遍历方式小结

ArrayList集合

ArrayList集合常用方法

ArrayList集合底层原理

LinkedList集合

集合的并发修改异常问题

Set系列集合

HashSet元素无序的底层原理：哈希表

HashSet元素去重复的底层原理

注意：

实现类：LinkedHashSet

LinkedHashSet集合概述和特点

实现类：TreeSet

TreeSet集合概述和特点

自定义排序规则

可变参数

可变参数的作用：

注意事项：

集合工具类Collections

Collections常用API

Collections排序相关API

static静态关键字

static是静态的意思，可以修饰成员变量和成员方法。
static修饰成员变量表示该成员变量只存储一份，可以被共享访问、修改。

成员变量的分类

静态成员变量（有static修饰，属于类，内存中加载一次）：常表示如在线人数信息等需要被共享的信息，可以被共享访问。

public class User{
//静态成员变量
public static String onlineNumber = 161;
}

可以使用以下方法访问：
类名.静态成员变量。（推荐）

User.onlineNumber

对象.静态成员变量。（不推荐）

User u = new User();
u.onlineNumber;

实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age等属于每个对象的信息。

public class User{
	private String name;
	private int age;
}

可以使用以下方法访问：
对象.实例成员变量。

User u = new User();
u.name;
u.age;

成员方法的分类

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

注意：
表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
如果该方法是以执行一个共用功能为目的，则可以申明成静态方法。

static访问注意事项：

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

static应用知识

工具类

工具类：类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的的，这个类用来给系统开发人员共同使用的。

工具类不需要创建对象，建议工具类的构造器私有化处理。

public class A{
	private A(){}
}

代码块

代码块是类的5大成分之一（成员变量，构造器，方法，代码块，内部类），定义在类中方法外。

在java类下，使用{ }括起来的代码被称为代码块。

构造代码块

构造块：定义在类中的代码块（不加修饰符），也叫实例代码块，一般用于初始化实例成员变量

范例：

{
this.age = 12；
System.out.println(age)；
}

格式：{ }
特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行
使用场景：初始化实例资源。

静态代码块

使用static定义的代码块，一般用于初始化静态成员属性
范例：

Static{
age = 10；
}

注意：静态化代码块不管生成多少个对象，都只会执行一次，且是最先执行的
静态化代码块执行完毕后，实例化代码块执行，再然后是构造函数执行

格式：static{ }
特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次
使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。

单例设计模式

什么是设计模式：

在开发中经常遇到一些问题，一个问题通常有n种解法的，但其中肯定有一种解法是最优的，这个最优解法被人总结出来了，称之为设计模式。

单例模式

可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
例如：任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。

饿汉单例设计模式

在用类获取对象的时候，对象已经提前为你创建好了。

设计步骤：

1. 定义一个类，把构造器私有
2. 定义一个静态变量存储一个对象

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

懒汉单例设计模式

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

设计步骤：

1. 定义一个类，把构造器私有。
2. 定义一个静态变量存储一个对象
3. 提供一个返回单例对象的方法

//定义一个单例类
public class SingleInstance {
	//定义一个静态变量存储一个对象即可：属于类，与类一起加载一次
	public static SingleInstance instance;//null
	
	//单例必须私有构造器
	private SingleStance(){}
	//必须提供一个方法返回一个单例对象
	public static SingleInstance(){
		...
		return ...;
	}
}

继承

Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

public class Student extends People{}

Student称为子类（派生类），People称为父类（基类或超类）。

继承的作用：当子类继承父类之后，就可以直接使用父类公共的属性和方法了。
继承的好处：提高代码的复用性。

继承设计规范：子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的属性和行为应该定义在子类自己里面。

继承的特点

1. 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器（构造方法）
2. Java是单继承模式：一个类只能继承一个直接父类
3. Java不支持多继承、但是支持多层继承
4. Java中所有的类都是object类的子类

继承后：成员变量、成员方法的访问特点

	在子类方法中访问成员（成员变量、成员方法）满足：就近原则
	1. 先在子类局部范围找
	2. 然后子类成员范围找
	3. 然后父类成员范围找，如果父类范围没有找到则报错

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类，可以通过super关键字，指定访问父类的成员。
格式：

super.父类成员变量/父类成员方法

方法重写

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

应用场景：

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

重写注解

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

方法重写注意事项和要求

1. 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
2. 私有方法不能被重写
3. 子类重写父类方法时，访问权限必须大于或等于父类（暂时了解：缺省）
4. 子类不能重写父类的静态方法，如果重写会报错

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

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

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。

子类在初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

子类构造器的第一行语句默认都是：super（），不写也存在

继承后：子类构造器访问父类有参构造器

super调用父类有参数构造器的作用： 初始化继承自父类的数据

如果父类中没有无参数构造器，只有有参构造器，则子类会报错，因为子类默认是调用父类无参构造器的。

子类构造器中可以通过书写super（…，…）手动调用父类的有参数构造器。

this和super详情

this（...）和super（...）使用注意点：
	
	· 子类通过this（...）去调用本类的其他构造器，本类其他构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器的。
	· this（...）super（...）都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。

包

· 包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
· 建包的语法格式：package公司域名倒写.技术名称。报名建议全部英文小写，且具备意义。

package com.itheima.javabean;
public class Student{
}

· 建包语句必须在第一行，一般IDEA工具会帮助创建。

导包

1. 相同包下的类可以直接访问

2. 不同包下的类必须导包才可以使用。

3. 如果一个类中使用不同包下的相同的类名，此时默认只能导入一个类的包，另一个要使用全名访问。

    导包格式：import 包名.类名；
   

权限修饰符

权限修饰符：用来控制一个成员能够被访问的范围。
可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受限制。

权限修饰符的分类和具体作用范围

有四种作用范围由小到大：private-->缺省-->protected-->public

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

建议：
1. 成员变量一般私有
2. 方法一般公开
3. 如果该成员只希望本类访问，使用private修饰
4. 如果该成员只希望本类，同一个包下的其他类和子类访问，使用protected修饰

final

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

final修饰变量注意：

1. final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
2. final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生改变的。

常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。

常量的好处和作用：可以用于做系统的配置信息，方便程序的维护，同时也能提高可读性。

public class Constant{
	public static final String SCHOOLO_NAME = "A";
}

	常量命名规范：英文单词全部大写，多个单词下划线连接起来。

常量的执行原理

1. 在编译阶段会进行“宏替换”，把使用常量的地方全部替换成真实的字面量。
2. 这样做的好处是让使用常量的程序的执行性能与直接使用字面量是一样的。

常量做信息标志和分类

代码可读性好，实现了软编码形式。

枚举

枚举是Java中一种特殊类型，作用是：做信息标志和分类。

定义枚举的格式：

修饰符 enum 枚举名称{
	第一行都是罗列枚举实例的名称。
}

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

枚举的特征

1. 枚举类都是继承了枚举类型：java.lang.Enum
2. 枚举类都是最终类，不可以被继承
3. 枚举类的构造器都是私有的，枚举对外不能创建对象。
4. 枚举类的第一行默认都是罗列枚举类对象名称的
5. 枚举类相当于是多例模式

选择常量做信息标志和分类：
虽然可以实现可读性，但是入参值不受约束，代码相对不够严谨

枚举做信息标志和分类：
代码可读性好，入参约束严谨。

抽象类

在Java中abstract是抽象的意思，可以修饰类、成员方法。

修饰符 abstract class 类名{
	修饰符 abstract 返回值类型 方法名称(形参列表);
}

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

注意：
抽象方法只有方法签名，不能声明方法体。
一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。
当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具体实现交给子类去完成，此时这个类就可以声明成抽象类

特征和注意事项

类有的成员（成员变量、方法、构造器）抽象类都具备
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
不能用abstract修饰变量、代码块、构造器
不能创建对象。

最重要的特征：得到了抽象方法，失去了创建对象的能力。

final和abstract是互斥关系

abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
抽象方法定义通用功能让子类重写，final定义的方法子类不能重写

抽象类应用知识：模板方法模式

当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候，使用模板方法模式。

模板方法实现步骤：

	1. 把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。
	2. 模板方法中不能决定的功能定义成抽象方法让具体子类去实现。

模板方法是给子类直接使用的，不是让子类重写的，一旦让子类重写了模板方法，则模板方法就失效了，因此用final修饰可以防止子类重写模板方法。

接口

接口是一种规范，规范一定是公开的。

接口的定义与特点

JDK8之前接口中只能是抽象方法和常量，没有其他成分了。

接口的格式：

接口用关键字interface来定义
public interface 接口名{
		//常量
		//抽象方法
}

注意： 由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以省略不写。

接口的基本使用

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

修饰符 class 实现类 implements 接口1，接口2，接口3，......{
}
实现的关键字:implements

接口可以被类单实现，也可以被类多实现。

实现接口注意事项：

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

接口与接口的关系：多继承

类和类的关系：单继承
类和接口的关系：多实现
接口与接口的关系：多继承，一个接口可以同时继承多个接口。

接口多继承的作用：整合多个接口为同一个接口，便于子类实现。

JDK8开始接口新增方法

1. 默认方法
类似之前写的普通实例方法：必须用default修饰
默认会public修饰。需要用接口的实现类的对象来调用

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

2. 静态方法
默认会public修饰，必须static修饰。
注意：接口的静态方法必须用本身的接口名来调用。

static void inAddr(){
	System.out.println("ABC");
}

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

private void go(){
	System.out.println("--准备--");
}

接口的注意事项

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

多态

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

多态的常见形式

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

多态中成员访问特点
方法调用：编译看左边，运行看右边。
变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

多态的前提
有继承/实现的关系；有父类指引指向子类对象；有方法重写。

多态的优势

在多态形式下，右边对象可以实现解耦合，便于扩展和维护。
定义方法的时候，使用父类类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。

注意：多态下不能使用子类的独有功能。

多态下引用数据类型的类型转换

1. 自动类型转换（从子到父）： 子类对象赋值给父类类型的变量指向
2. 强制类型转换（从父到子）：
此时必须进行强制类型转换：

子类 对象变量 = （子类） 父类类型的变量
Animal d = new Dog();
Dog d1 = (Dog)d;

作用：可以解决多态下的劣势，可以实现调用子类独有的功能。
注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCaseException（Java建议强制转换前使用instanceof判断当前对象的真实类型，再进行强制转换）

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

内部类

内部类是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class Peole{
	public class Heart{
	}
}

内部类的使用场景、作用

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

静态内部类

有static修饰，属于外部类本身。
 它的特点和使用与普通类是完全一样的，类有的成分它都有，只不过位置在类里面而已。

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

静态内部类创建对象的格式：

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

静态内部类的访问拓展：

1. 静态内部类中可以直接访问外部类的静态成员，因为外部静态成员只有一份且可以被共享访问
2. 静态内部类中不可以直接访问外部类的实例成员，因为外部类的实例成员必须用外部类对象访问。

成员内部类

无static修饰，属于外部类的对象。
JDK16之前，成员内部类中不能定义静态成员。

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

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

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

成员内部类的访问拓展：

1. 成员内部类中可以直接访问外部类的静态成员，因为外部类的静态成员只有一份且可以被共享访问。
2. 成员内部类的实例方法中可以直接访问外部类的实例成员，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

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

局部内部类

局部内部类放在方法、代码块、构造器等执行体中。
局部内部类的类文件名为：外部类$N内部类.class。

匿名内部类

本质上是一个没有名字的局部内部类，定义在方法中、代码块中、等。
作用是方便创建子类对象，最终目的是为了简化代码编写。
匿名内部类写出来就会产生一个匿名内部类对象。
匿名内部类的对象类型相当于是当前new的那个类型的子类类型。
匿名内部类可以作为方法的实际参数进行传输。

格式：

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

例如：

Employee a = new Employee(){
	public void work(){
	}
};
a.work();

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

包装类

自动装箱： 基本类型的数据和变量可以直接赋值给包装类型的变量。

自动拆箱： 包装类型的变量可以直接赋值给基本类型的变量。

包装类特有功能

注意：也可以用valueOf（）把字符串类型的数据转化成真实的数据类型。

int a = Integer.valueOf(number);
double b = Double.valueOf(score);

正则表达式

正则表达式可以用一些规定的字符来制定规则，并用来校验数据格式的合法性。

正则表达式的匹配规则

正则表达式在字符串方法中的使用

正则表达式支持爬取信息

Arrays类

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

Arrays类常用API

注意：二分搜索的前提是数组必须排好序才支持，否则出bug。

Arrays类对于Comparator比较器的支持

自定义排序规则
设置Comparator接口对应的比较器对象，来定制比较规则。

默认排序规则（升序）：
如果认为左边数据 大于 右边数据 返回正整数
如果认为左边数据 小于 右边数据 返回负整数
如果认为左边数据 等于 右边数据 返回0

注意：Comparator比较器只支持引用类型的比较。

//降序
Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                /*if (o1>o2){
                    return -1;
                }else if (o1
                return o2-o1;

				return Double.compare(o2.getHeigth(),o1.getHeigth());//（降序）比较浮点型可以这样写
            }
        });

常见算法

选择排序

二分查找

Lambda表达式

Lambda表达式的简化格式

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

Lambda表达式的简化Comparator接口的匿名形式

Lambda表达式的省略规则

常见数据结构

数据结构是计算机底层存储、组织数据的方式。是指数据相互之间是以什么方式排列在一起的。
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。

栈数据结构的执行特点

队列数据结构的执行特点

数组数据结构

链表数据结构

链表的特点

链表的种类

二叉树、二叉查找树

二叉树特点

二叉查找树

二叉查找树又称二叉排序树或者二叉搜索树。

二叉查找树添节点

二叉查找树存在的问题

平衡二叉树

平衡二叉树的要求

任意节点的左右两个子树的高度差不超过1，任意节点的左右两个子树都是一颗平衡二叉树。

红黑树

红黑规则

添加节点

泛型

自定义泛型类

自定义泛型方法

自定义泛型接口

泛型通配符、上下限