2021-05-08

Object类
Object所有类的父类。
如果一个类没有特别指定父类，那么默认则继承自Object类。
1.toString方法
public String toString():返回该对象字符串表示
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
2.如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。
StringBuilder类
1.String类的对象内容不可改变，所以每当进行字符串拼接。总会在内存中创建一个新的对象。但这样会消耗很多内存空间，且字符串是常量，它们的值在创建后不能更改。
2.StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串，还可以对字符串进行各种操作，它的内部拥有一个数组用来储放字符串的内容。
构造方法

public stringBuilider()://构造一个空的stringBuilider容器。
public stringBuilider(String str)://构造一个stringBuilider容器，并将字符串添加进去。

常用方法
StringBuilder常用的方法有2个：
public StringBuilder append(…)//添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString():将当前StringBuilder对象转换为String对象。
toString方法
通过toString方法，StringBuiler对象将会转换为不可变的String对象

public boolean equals(Object obj);指示其他某个对象是否与此对象"相等"

主要比较什么呢？
1.默认地址比较
2.对象内容比较（要重写equals方法）

第一章异常
1.异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致jvm的非正常停止。
1.2异常体系：异常的根类就是Throwable，它的子类是Error和Exception，平常指的异常就是Exception

Error：严重错误，无法通过处理的错误
Exception：表示异常，可以通过代码处理

Throwable中的常用方法：
printStackTrace（）打印异常的详细信息。
getMessage（）打印异常原因。
toString() :获取异常的类型和异常描述信息(不用)。

1.3异常的分类：根据在编译时期还是运行时期去检查异常？

1编译时期异常：在编译时期，就会检查，如果没有处理异常，则编译失败
2运行时期异常：在运行时期，检查异常。

处理异常
关键字：try，catch，finally，throw，throws

1.抛出异常操作：

throw new 异常类名();
//例如：
throw new NullPointerException("要访问的arr数组不存在");

声明异常throws

1.声明异常：将问题标识出来，报告给调用者。
1.2声明异常格式：

修饰符 返回值类型 方法名（参数） throws 异常类名1，异常类名2...{}

2.捕获异常：try…catch
捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

try{
 编写可能会出现异常的代码
}catch(异常类型 e){
处理异常的代码
}
try：该代码块中编写可能产生异常的代码
catch：用来进行某种异常捕获，实现对捕获的异常进行处理

自定义异常
1.为什么需要自定义异常类呢？
因为在开发中总是有些异常情况是SUN没有定义 好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

2.异常类如何定义：
1.2自定义一个编译期异常：自定义类 并继承Exception。
1.3自定义一个运行时期的异常类：自定义类 并继承RuntimeException。

public class RegisterException extends Exception{
	public RegisterException(){
	//异常提示
	}
	public RegisterException(String message){
	super(message);
	}
}

第二章多线程
1并发：指两个或多个事情在同一时间段内发生。
2.并行：指两个或多个事情在同一时刻发生（同时发生）
#当系统只有一个cpu时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
3.线程与进程

3.1进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建，运行到消亡的过程。
3.2线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中可以有多个线程，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度
1.分时调度
所有线程轮流使用cpu的使用权，平均分配每个线程占用CPU的时间。
2.抢占式调度
优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个。
创建线程类
1.Thread类代表线程，所有的线程对象都必须是Thread类或者其子类的实例。每个线程的作用是完成一定的任务。实际上就执行一段顺序执行的代码。Java使用线程体来代表这段程序流。
2.创建并启动多线程步骤：
1.子类继承Thread类，并重写run方法
2.创建线程对象
3.对象调用start()方法启动方法

public class Demo01 { public static void main(String[] args) { //创建自定义线程对象 MyThread mt = new MyThread("新的线程！"); //开启新线程 mt.start(); //在主方法中执行for循环 for (int i = 0; i < 10; i++) { System.out.println("main线程！"+i); } } }

Thread类
1.构造方法：
public Thread();//分配一个新的线程对象。
public Thread(string name)//分配一个指定名字的新的线程对象
public Thread(Runnable target)//分配有一个带有指定目标新的线程对象
public Thread(Runnable,target,String name)//分配一个带有指定目标新的线程对象并指定名字。
2.常用方法
public string getName()//获取当前线程名称
public void start()//导致此线程开始执行；Java虚拟机调用此线程的run方法
public void run()//此线程要执行的任务在此定义代码
public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停
public static Thread currentThread()//返回对当前正在执行的线程对象的引用

创建线程方式二
//Runnable接口
创建步骤：
1.定义Runnable接口的实现类，并重写run方法
2.创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象
3.线程对象调用start()方法来启动线程

Thread和Runnable的区别
实现Runnable接口比继承Thread类所具有的优势：
1.适合多个相同的程序代码的线程去共享一个资源
2.避免Java单继承的局限性
3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4.线程池只能方入实现Runnable或callable类线程，不能直接放入继承Thread的类

public class NoNameInnerClassThread {
	public static void main(String[] args) {
	new Runnable(){
	public void run(){
	for (int i=0;i<20;i++){
	sout("张宇"+i)
	}
	}
	
	};//--这个整体 相当于new MyRunnable()
	Runnable r=new Runnable(){
	public void run(){
		for(int i=0;i<20;i++){
		sout("张宇："+i);

}
	}

};
new Thread(r).start();
for(int i=0;i<20;i++){
 sout("费玉清："+i);
}
}
}

线程同步
三种方式同步
1.同步代码块
2.同步方法
3.锁机制

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式：

Object lock=new Object();//先创建锁对象
synchronized(lock){
需要同步操作的代码
}

同步方法
1.同步方法：是使用synchronized修饰的方法，就叫做同步方法
格式：

public synchronized void method(){
可能会产生线程安全问题的代码
}

Lock锁
lock锁也称同步锁

public void lock()//加同步锁
public void nulock()//释放同步锁

**新的一章：集合**
1.Collection 中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 
2.Map 中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的 值。
3.Collection 中的集合称为单列集合， Map 中的集合称为双列集合。 
4.需要注意的是， Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

**Map（是一个接口）常用的子类**
HashMap集合，LinkedHashMap集合都是Map的子类
HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
LinkedHashMap：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链 表结构可以保证元素的存取顺序一致；
1.of()方法只是Map，List，Set这三个接口的静态方法，其父接口和子类实现并没有这类方法，如HashSet，ArraList等等；

*第二章 List集合*
1.List和Set的接口都是Collection接口的子类
List集合中允许出现重复的元素和元素有序
List的子类有ArrayList和LinkedList集合

其中ArrayList集合元素增删慢，但查询快。而LinkedList（双向链表）集合方便添加，删除元素

**Set接口**
1.Set接口与List接口不同的是，Set接口中元素无序，元素不会出现重复
2.HashSet集合是Set接口的一个实现类（元素唯一性，没有重复）
HashSet集合储存数据的结构（哈希表）
哈希表底层采用数组+链表实现。
3.LinkedHashSet集合：保持元素的唯一性和顺序性。
4.Comparator比较器

```java
public static <T> void(List<T> list):将集合中元素按照默认规则排序。但这是储存的是字符串类类型

5.简述Comparable和Comparator两个接口的区别。
Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法 被称为它的自然比较方法。
Comparator：强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。

等待唤醒机制
1.1线程间通信
概念：多个线程在处理同一资源，但处理的动作却不同。
1.2什么是等待唤醒机制：这是多个线程的一种协作机制，就是在一个线程进行了规定操作后，就进入等待状态（wait()）,等待其他线程执行完他们的指定代码后，再将唤醒(notify());再有多个线程进行等待，可以使用notifyAll()来唤醒所有的等待线程。

线程池概念
线程池：其实就是一个容纳多个的容器，其中的线程可以反复使用。
合理利用线程池能够带来三个好处：
1.减低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.提高响应速度
3.提高线程的可管理性

Lambda表达式

//核心代码
（）->Sout("多线程执行")

Lambda标准格式
格式由三部份组成:1.一个参数，2一个箭头，3一段代码
Lambda表达式的标准格式为：
（参数类型 参数名称）->{代码语句}

1.使用Lambda表达式的前提：
1.1.使用Lambda表达式必须要有接口，且要求接口中有且只有一个抽象方法
1.2使用Lambda表达式必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使Lambda作为该接口的实例
2.注意：有且仅有一个抽象方法的接口，称为为“函数式接口”

集合概述
1.集合：集合是Java中提供的一种容器，可以用来储存多个数据。
2.集合和数组都是容器，那他们有什么区别？
2.1数组的长度是固定，集合的长度是可变的。
2.2数组中储存的是同一类型的元素，可以储存基本数据类型值。集合储存的都是对象。
Iterator迭代器
2.1Iterator接口主要用来遍历Collection中的元素
迭代：是集合Collection集合元素的通用获取方式
Iterator接口的常用方法：

public E next():返回迭代的下一个元素
public boolean hasNext()://如果仍有元素可以迭代，则返回truezeng

3.增强for：
它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

for(元素的数据类型 变量：Collection集合or数组){
//写操作代码
}

泛型
泛型：可以在类中或方法中预支使用未知的类型
使用泛型的好处：
1.将运行时期的ClassCastException，转移到了编译时期变成了编译 失败。
2.避免了类型强转的麻烦。
三.定义和使用含有泛型的类

//定义格式
修饰符 class 类名<代表泛型的变量>{}

使用泛型：即什么时候确定泛型
在创建对象的时候确定泛型

例如
ArrayList<String> list=new ArrayList<String>();

四：含有泛型的方法
定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){}

五：含有泛型的接口

修饰符 interface 接口名 <代表泛型的变量>{}

六：始终不确定泛型的类型，直到创建对象时，确定泛型的类型

七.泛型通配符
当使用泛型类或者接口，传递的数据，泛型类型不确定，可以通过符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类的共性方法，集合中元素自身方法无法使用。。
通配符的基本使用
泛型的通配符：不知道使用什么类型来接收的时候。此时可以使用？。但此时只能接收数据，不能往该集合中储存数据。

通配符高级使用—受限泛型
泛型也有上限和下限。
上限：

格式：类型名称<? extends 类> 对象名称
意义：只能接收该类型及其子类

下限：

格式：类型名称<? super 类> 对象名称
意义：只能接收该类型及其子类型