第五周总结

进程和线程：

• 程序：就是一个编程语言编写的功能数据文件包，是一个静态的资源

• 进程：运行的程序 是程序运行的基本单位

• 线程：是进程的执行单位 一个进程可以有多个线程

总结：

​ 一个程序的运行至少需要一个进程，一个进程中可以包含多个线程。

​

并行和并发：

• 并发：指两个或多个事件在同一个时间段内发生【交替的发生 执行者是一个】。

• 并行：指两个或多个事件在同一时刻发生（同时发生 同时处理 执行者不是一个）。

java中的并发采用的抢占式执行方案【随机执行】

1、继承Thread类

• 方法介绍

方法名	说明
void run()	在线程开启后，此方法将被调用执行
void start()	使此线程开始执行，Java虚拟机会调用run方法()

run方法：给程指定具体事务

start方法：执行线程

• 实现步骤

  1、定义一个类继承Thread类
  2、重写run方法指定做的事情
  3、引入多线程的地方创建子类对象
  4、调用start方法启动线程

2、实现Runnable接口

• 方法介绍

方法名	说明
Thread(Runnable target)	分配一个新的Thread对象
Thread(Runnable target, String name)	分配一个新的Thread对象

解释：

Thread的构造方法创建对象的时候传入Runnable接口的对象，Runnable接口对象重写run方法指定线程任务
Runnable的对象称之为：`线程任务对象` 不是线程对象 必须要交给Thread线程对象

• 实现步骤

  1、定义一个类实现Runnable接口
  2、重写run方法
  3、创建Runnable实现类对象【线程任务对象】
  4、创建Thread对象，同时把线程任务对象传入
  5、调用start方法启动线程

3、实现Callable接口

• 方法介绍

方法名	说明
V call()	计算结果，如果无法计算结果，则抛出一个异常
FutureTask(Callable callable)	创建一个 FutureTask，一旦运行就执行给定的 Callable
V get()	如有必要，等待计算完成，然后获取其结果

• 实现步骤

1、定义一个类实现Callable接口
2、重写call方法
3、创建Callable实现类对象
4、创建Future的实现类FutureTask对象，并传入Callable实现类对象
5、创建Thread对象，同时把线程任务FutureTask对象传入
6、调用start方法启动线程	

任务对象FutureTask对象提供的功能：
	get()：获取返回在的数据

4、匿名内部类实现多线程

使用匿名内部类的方式替换了继承Thread类和实现Callable接口、Runnable接口的方式

getName、setName、currentThread【静态】

sleep【静态】 yield【静态】 interrupt getPriority setPriority
setDaemon isDaemon

构造：

Thread():创建一条没有具体事务的线程对象，线程名称默认【Thread-x x从0开始】
Thread(String name)：创建一条没有具体的线程对象，并指定线程名称
Thread(Runnable r):创建一条指定具体事务的线程对象，线程名称默认的
Thread(Runnable r，String name):创建一条指定具体事务的线程对象，并指定线程名称

线程名称方法：

方法名	说明
void setName(String name)	将此线程的名称更改为等于参数name
String getName()	返回此线程的名称
Thread currentThread()	返回对当前正在执行的线程对象的引用

线程休眠方法：

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数

线程礼让方法：【概率事件】

方法名	说明
static void yield()	线程礼让,暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程

线程API之线程优先级：

方法名	说明
final int getPriority()	返回此线程的优先级
final void setPriority(int newPriority)	更改此线程的优先级；线程优先级的范围是：1-10（默认是5）

线程中断方法【对线程的休眠 等待等情况的中断】：

方法名	说明
public void interrupt()	中断这个线程（打断等待、休眠等）

后台线程【守护线程】：

【守护线程为了保护执行线程而存在的，如果保护的执行线程已经消失，守护线程也会跟着消失】

方法名	说明
public final void setDaemon(boolean on)	将此线程设置为守护线程
isDaemon()	判断一个线程是否为守护线程 【垃圾回收线程】

问题描述：

​ 多线程同时操作一个数据时，由于Java的并发机制是抢占式，容易造成数据不同步的线程安全问题。

解决方案：同步代码块、同步方法、Lock锁

• 同步代码块

  格式：
  	synchronized(锁对象) { 
  		原子操作的代码;【有可能出现线程安全问题的代码】
  	}
  	
  锁对象：
  	1.必须是引用数据类型对象 
      2.可以是任何引用类型的对象
      3.锁对象一旦被确定下来要保证唯一性
  

• 同步方法

  同步成员方法:
        修饰符 synchronized 返回值类型 方法名(方法参数) { 
        		方法体；
        }
  
  同步静态方法:
        修饰符 static synchronized 返回值类型 方法名(方法参数) { 
        		方法体；
        }
        
  锁对象：
  	1. 普通同步方法的锁对象是 this
  	2. 静态同步方法的锁对象是 类名.class【Class类类型的对象 -- 反射类对象】
  

• Lock锁

  概述：
  	JDK5以后提供了锁对象Lock，Lock是接口不能直接实例化，用实现类ReentrantLock来实例化。
  	可以直观的看到`加锁`和`解锁`的位置
  
  构造：
  	ReentrantLock()：创建一个ReentrantLock的锁对象
      	【ReentrantLock是Lock接口的实现类】
          
  方法：
  	void lock()：获得锁【加锁】
      void unlock()：释放锁【解锁】
  

概述

死锁,指两个或者多个线程互相持有对方所需要的锁资源，导致这些线程都处于等待状态，无法继续执行。

图示：

死锁现象：

命令：

jps ：查看进程的pid号
jstack 进程的pid(进程识别号)

位置：

1、命令行窗口
2、idea提供了快捷方式：左下角Terminal窗口

效果图示：

图示：

状态说明：

线程状态	具体含义
NEW	一个尚未启动的线程的状态。也称之为初始状态、开始状态。线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread()只有线程象，没有线程特征。
RUNNABLE	当我们调用线程对象的start方法，那么此时线程对象进入了RUNNABLE状态。那么此时才是真正的在JVM进程中创建了一个线程，线程一经启动并不是立即得到执行，线程的运行与否要听令与CPU的调度，那么我们把这个中间状态称之为可执行状态(RUNNABLE)也就是说它具备执行的资格，但是并没有真正的执行起来而是在等待CPU的度。
BLOCKED	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
WAITING	一个正在等待的线程的状态。也称之为等待状态。造成线程等待的原因有两种，分别是调用Object.wait()、join()方法。处于等待状态的线程，正在等待其他线程去执行一个特定的操作。例如：因为wait()而等待的线程正在等待另一个线程去调用notify()或notifyAll()；一个因为join()而等待的线程正在等待另一个线程结束。
TIMED_WAITING	一个在限定时间内等待的线程的状态。也称之为限时等待状态。造成线程限时等待状态的原因有三种，分别是：Thread.sleep(long)，Object.wait(long)、join(long)。
TERMINATED	一个完全运行完成的线程的状态。也称之为终止状态、结束状态

方法：

getState():获取线程当前的状态值

概述：
	多线程操作同一个资源或同一件事的时候，使用锁对象完成相互交流执行，达到人为控制执行顺序的多线程执行方案
	
前提：
	多线程操作同一个资源，必须先同步【加锁】再通信
	
流程：
   借助锁对象来完成【就是锁对象的行为（等待和唤醒行为的交互执行）】
       使用Object中提供的功能：
           wait():无限等待 必须要notify或者notifyAll方法来进行唤醒
           wait(long timeout):定时等待 
               时间范围内可以使用notify或者notifyAll方法来进行唤醒
               也可以等待时间值到了自动唤醒
           notify():唤醒等待的单条线程重新执行
           notifyAll():唤醒所有等待的单条线程重新执行

案例：吃货吃包子，包子铺做包子。

• 概述：

线程池，可以看做成一个池子容器，在该池子中存储固定个数的线程对象，提供给外界使用，提高性能。

线程池执行过程：
	线程池在启动的时，会创建大量空闲线程，向线程池提交任务的时，线程池就会启动一个线程对象来执行该任务。在任务执行完毕后，线程并不会死亡，而是再次返回到线程池中重新变为空闲状态，等待下一次任务的执行。

• Executors创建线程池：

1. 概述

概述 : 
 JDK对线程池也进行了相关的实现，在实际开发中，一般很少自定义线程池，而是使用JDK中自带的线程池。
理解：
  提前准备好一定数量的线程对象的一个容器---得到线程池就相当于得到了线程对象
使用Executors中所提供的`静态`方法来创建线程池
	1.static ExecutorService newCachedThreadPool() 创建一个默认的线程池【多例】
	2.static newFixedThreadPool(int nThreads)	创建一个指定最多线程数量的线程池
    3.static newSingleThtreadExecutor()  创建只有一个线程对象的线程池【单例】    

2. ExecutorService

使用：
    1、准备线程任务【Runnable  Callable】
    2、把线程任务提交给线程池【自动委派内部的线程对象来执行】    
功能：
	submit(Runnable r):提交线程任务到线程池执行
	submit(Callable  c)：提交线程任务到线程池执行
	shutdown():关闭线程池
	shutdownNow():关闭线程池

• 总结步骤：

固定步骤：
	1、通过Executors工具类的相关方法获取对应线程池对象【ExecutorService的对象】
	2、创建线程任务对象【Runnable对象或者Callable对象】
	3、线程池对象调用submit方法提交线程任务对象到线程池
	4、关闭线程池对象

• 概述：

单例模式 : 在整个系统中,一个类型,只有一个唯一对象,所有的场景下使用的都是同一个对象单例
    	 【单例模式其实就是一个只能创建单个对象的类】
    
模式的案例 : 
	1)回收站,因为整个系统中只有一个回收站, 在任何的场景下删除文件,都是进入到这一个回收站中
    2)任务管理器 : 系统中的所有的进程都在一个任务管理器中管理和展示

• 设计思路：【确保对象唯一】

1.私有构造方法  ----- 限制外界创建对象
2.在本类中创建出一个唯一的私有对象  --- 避免外界修改
3.为其他的外类提供唯一对象的公共访问方式

• 分类：

饿汉式：直接创建私有对象【空间换时间】
懒汉式：使用时再创建私有对象【时间换空间】
老汉式：私有构造--->唯一对象用final修饰【特殊的饿汉式】

• 概述：

​ 枚举：本质是一种的特殊的类，对象能够穷举的特殊类。【所有枚举类继承于Enum类的子类】

​ 枚举项：就是枚举的对象【默认被public static final 修饰】

• 格式：

public enum s { 
	枚举内容
}

枚举内容：【通常只有枚举项】
	1、枚举项
		注意事项：
			1、必须写在第一行
			2、枚举项之间使用，隔开
			3、只有枚举项内容 ; 可以省略
		格式:
			枚举项名(实参)、枚举项名、枚举项名(实参){重写抽象方法}
	    访问：枚举名.枚举项名
	2、成员变量【属性】
	3、方法【普通方法 静态方法  抽象方法（`抽象方法必须在枚举项重写`）】
	4、构造方法【必须私有，默认也是私有】

• 方法

方法名	说明
String name()	获取枚举项的名称
int ordinal()	返回枚举项在枚举中的索引值
int compareTo(E o)	比较两个枚举项，返回的是索引值的差值
String toString()	返回枚举常量的名称
values()	获得所有的枚举项

• 网络编程三要素：IP地址、端口、协议

• IP地址

  IP地址：在同一个计算机网络中，为每台计算机指定一个唯一的标识号
  
  	Ipv4:32位的二进制数标识  转变为 4 段十进制的数字表示
              [0.0.0.0 ~ 255.255.255.255]
      Ipv6:128位的二进制数标识  转变为8个十六进制数进行表示
              比如：fe80::dbe:ef9b:911f:d09a
              
  	InetAddress类：
  		常用方法：
  			static InetAddress getByName(String host) : 确定主机名称的IP地址。
  				主机名称可以是机器名称,也可以是IP地址 
  			InetAddress  getLocalhost(ip的地址或者主机的名称)
              String getHostName()  : 获取此IP地址的主机名                               
              String getHostAddress() :返回文本显示中的IP地字符串  
              
  

• 端口

  端口：程序【进程】的唯一标识号，使用2个字节的正整数数字进行表示。
  	取值范围是0~65535.其中0~1023之间的端口号用于一些知名的网络服务和应用。
  	常用端口：
  		mysql：3306    
          QQ：4000    
          tomcat：8080
          
  

• 协议【网络编程过程数据传输遵守的规则】

  • UDP协议

    1.用户数据报协议(User Datagram Protocol) 
    2.UDP是无连接通信协议,即在数据传输时,数据的发送端和接收端不建立逻辑连接.简单来说,
    	 当一台计算机向另外一台计算机发送数据时,发送端不会确认接收端是否存在,就会发出数据,
    	 同样接收端在收到数据时,也不会向发送端反馈是否收到数据.  
    3.使用UDP协议消耗系统资源小,通信效率高。通常都会用于音频、视频和普通数据的传输. 
    4.例如视频会议通常采用UDP协议,因为这种情况即使丢失一两个数据包,也不会对接收结果产生太大影响.
    	 但是在使用UDP协议传送数据时,由于UDP的面向无连接性,
    	 不能保证数据的完整性,因此在传输重要数据时不建议使用UDP协议. 
    	 
     总结： 
         UDP协议面向无连接的通信协议，数据传输占用的资源少效率高，不能保证数据的完整性
         不安全软件： 聊天软件  视屏会议软件 等
    

  • TCP协议

     1.传输控制协议 (Transmission Control Protocol) 
     2.TCP协议是面向连接的通信协议,即传输数据之前,在发送端和接收端建立逻辑连接,
     	 然后再传输数据,它提供了两台计算机之间可靠无差错的数据传输.
     	 在TCP连接中必须要明确客户端与服务器端,由客户端向服务端发出连接请求,
     	 建立连接的创建都需要经过“三次握手”.  
     3.三次握手:TCP协议中,在发送数据的准备阶段,客户端与服务器之间的三次交互,以保证连接的可靠   
         1)第一次握手,客户端向服务器端发出连接请求,等待服务器确认   
         2)第二次握手,服务器端向客户端回送一个响应,通知客户端收到了连接请求  
         3)第三次握手,客户端再次向服务器端发送确认信息,确认连接 
     4.完成三次握手,连接建立后,客户端和服务器就可以开始进行数据传输了.
     	  由于这种面向连接的特性,TCP协议可以保证传输数据的安全,所以应用十分广泛.
          例如上传文件、下载文件、浏览网页等
          
        总结： 
          	TCP协议是面向连接的通信协议
          	明确客户端与服务器端  效率低 但是数据比较安全
    

• 概述

	UDP是一种不可靠的网络协议,在通信的两端各建立一个UDP协议下的套接字对象【DatagramSocket类对象】,但是这两个套接字只是发送、接收数据的对象,没有客户端和服务器的概念.

• 构造方法

DatagramSocket()：创建数据报套接字对象	【一般用于发送端】
DatagramSocket(int port)：创建数据报套接字对象，并绑定指定的端口【一般用于接收端】

DatagramPacket(byte[] buf,int len,InetAddress add,int port)：
		创建数据包,发送长度为len的数据包到指定主机的指定端口
DatagramPacket(byte[] buf,int len)：创建数据包,用于接收端 用来接收发送过来的数据的

• 常用方法

套接字[DatagramSocket]的方法 ：	
    void send(DatagramPacket p)     发送数据报包                         
    void close()                    关闭数据报套接字                     
    void receive(DatagramPacket p)  从此套接字接受数据报包 
    
数据报包[DatagramPacket]的方法 ：	
    byte[]  getData() :返回数据缓冲区     
    int  getLength()  :返回要发送的数据的长度或接收的数据的长度 
    int  getPort()	  :返回发送端的端口号
    InetAddress	 getAddress() :返回发送端的IP地址

• 发送数据

  1、创建套接字对象
  2、使用数据报包对象封装要发送的数据以及接收端的ip和端口
  3、调用send方法发送
  4、关闭套接字对象
  

• 接收数据

  1.创建接收端的DatagramSocket对象
  2.创建一个数据包,用于接收数据【DatagramPacket】
  3.调用DatagramSocket对象的receive方法接收数据
  4.解析数据包,并把数据在控制台显示【getXxx方法】
  5.关闭接收端
  

​

• UDP的广播和组播：

广播：	
	发送端的信息发送到一个的ip为255.255.255.255接收端,端口号固定
	接收端只需要公开对应的端口
	
组播：
	1、套接字变为MulticastSocket对象
	2、发送端发送信息的ip必须在224.0.0.0 ~ 239.255.255.255
	3、接收端正常接收，但是接收前加入发送端的组【发送端发送的ip对象】
	
	MulticastSocket类【组播套接字】：是DatagramSocket的子类
		构造：
			MulticastSocket()：创建组播套接字
			MulticastSocket(int port)：创建组播套接字，并绑定到特定端口
		常用方法：
			joinGroup(InetAddress mcastaddr)：加入组播

​

• 概述：

	TCP协议是一种面向连接的、可靠的、基于字节流的传输层通信协议。
	区分客户端(Client)与服务端(Server)，Java为客户端提供了Socket类,为服务器端提供ServerSocket类.

• 构造：

方法名	说明
Socket(InetAddress address,int port)	创建流套接字并将其连接到指定IP指定端口号
Socket(String host, int port)	创建流套接字并将其连接到指定主机上的指定端口号
ServerSocket(int port)	创建绑定到指定端口的服务器套接字

• 常用方法：

方法名	说明
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流
Socket accept()	监听要连接到此的套接字并接受它
void close()	关闭资源

• 发送和接收数据

  1.[服务端]启动,创建ServerSocket对象,等待连接.
  2.[客户端]启动,创建Socket对象,请求连接.
  3.[客户端]Socket对象,获取OutputStream,向服务端写出数据.
  4.[服务端]接收连接,调用accept方法,并返回一个Socket对象.
  5.[服务端]Scoket对象,获取InputStream,读取客户端发送的数据.
  

• 概述

  加载类的原理：

  把字节码文件数据以对象的形式加载到内存中创建一个Class的对象
  对象中维护的是Field对象、Method对象、Contructor对象等
  

  类加载原理图：

  new对象原理图：

• 类加载过程

  当程序要使用某个类时,如果该类还未被加载到内存中,系统会通过加载,连接,初始化三步来实现对这个类的加载.
      1)加载 
          就是指将class文件读入内存,并为之创建一个Class对象.
      2)连接
          验证是否有正确的内部结构,并和其他类协调一致
          准备负责为类的静态成员分配内存,并设置默认初始化值
          解析将类的二进制数据中的符号引用替换为直接引用
      3)初始化 
      	 就是初始化步骤
  

• 时机【类被使用时加载】

  总结：类被使用的才会被加载

  1.创建类的实例
  2.类的静态成员使用
  3.类的静态方法调用
  4.使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
  5.初始化某个类的子类
  6.直接使用java.exe命令来运行某个主类

概述

概述：
   类加载器其实是jvm用来加载字节码数据到内存的一个工具，在java中使用类体现这个工具
   
作用：
   类加载器是负责加载类的对象,将class文件(硬盘)加载到内存中,并为之生成对应的
   java.lang.Class对象.

分类

1.Bootstrap ClassLoader 引导类加载器【根类加载器】
	也被称为根类加载器,负责Java核心类的加载,比如System,String等.
2.Extension ClassLoader 扩展类加载器
	负责JRE的扩展目录中jar包的加载,在JDK中JRE的lib目录下ext目录.
3.Application ClassLoader 系统类加载器
	负责在JVM启动时加载来自java命令的class文件,以及classpath环境变量所指定的jar包和类路径.
4.自定义类加载器
	通过继承java.lang.ClassLoader类的方式实现自定义类加载器,以满足一些特殊的需求.
	
类加载器之间的继承关系
    引导类加载器【BootStrapClassLoader】 -----  jdk的核心类
         扩展类加载器【ExtensionClassLoader】----  jre中的扩展类
             系统类加载器【ApplicationClassLoader】--- 第三方类

双亲委派机制

 1.双亲委派机制是指当一个类加载器收到一个类加载请求时,该类加载器首先会把请求委派给父类加载器.每个类加载器都是如此,只有在父类加载器加载不了该类时,才会返回给子类加载器加载，子类加载成功就请求完成，失败就会报错.

 2.双亲委派模型工作过程:
	1)当Application ClassLoader收到一个类加载请求时,将请求委派给父类加载器Extension ClassLoader完成 
	2)当Extension ClassLoader收到一个类加载请求时,将请求委派给父类加载器Bootstrap ClassLoader去完成 
	3)当Bootstrap ClassLoader收到一个类加载请求时，就开始尝试加载类，
		如果Bootstrap ClassLoader加载失败,就会让子类Extension ClassLoader尝试加载. 
	4)如果Extension ClassLoader也加载失败,就会使用Application ClassLoader加载. 
	5)如果Application ClassLoader也加载失败,就会使用自定义加载器去尝试加载. 
	6)如果均加载失败,就会抛出ClassNotFoundException异常.

总结：
	加载类的时候：子类没有加载 优先委派给父类  父类加载不了返回给子类  都加载不了则报错

ClassLoader类【类加载器】

功能：
	static ClassLoader getSystemClassLoader():返回系统类加载器
	ClassLoader getParent():返回父类加载器

1. 反射机制的概述

   步骤：
       1、获取操作资源所在类的Class对象【反射对象】
       2、通过反射对象得到操作元素的对应类对象
       3、调用相关的方法操作元素
       
   作用：
   	程序在运行的过程，完成对程序元素的操作、扩展,增强程序的灵活性。
   	
   注意：
   	Class... parameterTypes：为可变参数，表示方法形参列表的类型。
   

2. 获取Class类对象的三种方式

   获取：
       1)类名.class属性
       2)对象名.getClass()方法
       3)Class.forName(全限定类名)方法
   
   功能：
   	newInstance()：返回用空参构造实例化的对象
       	 【底层：先获取空参构造，再执行空参构造的newInstance】
   

3. 反射获取构造方法并使用【Constructor对象】

   获取：
   	Constructor[] getConstructors()：返回所有公共构造方法对象
   	Constructor[] getDeclaredConstructors()：返回所有构造方法对象
   	Constructor getConstructor(Class... parameterTypes)：返回单个公共构造方法对象		
   	Constructor getDeclaredConstructor(Class...parameterTypes):返回单个构造方法对象
   
   功能：
   	T newInstance(Object...initargs) 根据指定的构造方法创建对象，并传入构造方法的实参
   

4. 反射获取成员变量并使用【Field对象】

   获取：
   	Field[] getFields():返回所有公共成员变量对象
   	Field[] getDeclaredFields():返回所有成员变量对象
   	Field getField(String name):返回单个公共成员变量对象
   	Field getDeclaredField(String name):返回单个成员变量对象
   
   功能：
   	set(Object obj, Object value): 用于给obj对象的指定成员变量,赋value值
   	get(Object obj): 用于获取obj对象的指定成员变量值
   

5. 反射获取成员方法并使用【Method对象】

   获取：
      Method[] getMethods():返回所有公共成员方法对象，包括继承的（父类、超类）
      Method[] getDeclaredMethods():返回所有成员方法对象，不包括继承的
      Method getMethod(String methodName， Class...parameterTypes):
   			返回单个公共成员方法对象
      Method getDeclaredMethod(String methodName, Class...parameterTypes):
   			返回单个成员方法对象
   
   功能：
   	Object invoke(Object obj, Object...values):
   			调用obj对象的成员方法,实参是values,返回值是Object类型.
   

6. 暴力反射

   概述：	
   	通过getDeclaredXXX方法: 可以获取类中的所有声明的成员(属性、方法、构造)
   	Declared获取的元素对象在执行的时候会发生权限不够的异常
   	通过setAccessible(true)：true的值表示抑制权限
   	
   步骤：
       1、暴力获取执行的元素对象
       2、压制暴力获取的对象的权限
       3、调用对应的方法进行执行
   

• 概述

jdk8之前：
	规则的集合体，只有抽象方法
jdk8：
	默认方法
	静态方法
jdk9：
	私有方法

• 默认方法

概述：
	被关键字 default 修饰的方法就是默认方法，是接口特有的方法。
	
格式：
	修饰符 default 返回值类型  方法名 (参数列表){方法体}
	
使用原则：
	1、实现类中的其他方法调用：接口名.super.默认方法名(实参)【调用的是接口的默认方法】
	2、实现类对象调用：对象名.默认方法名
		实现类没有重写：【调用的是接口的默认方法】
		实现类已经重写：【调用的是实现类重写后的方法】

• 静态方法

概述：
	被static修饰的方法就是静态方法。属于接口本身，实现类对象没有访问的权利，只能接口名调用方法
	
使用原则：
	1、直接使用接口名调用
	2、不同的接口中可以定义方法名相同的静态方法，互不影响
	3、静态方法`主要`提供给接口的默认方法和私有方法使用

• 私有方法

概述：
	被private修饰的方法就是私有方法，是jdk9新增的方法。
    私有方法不能被实现类直接调用或重写修改，只能提供给接口的静态方法和默认方法使用。
	
使用原则：
    普通私有方法：只能提供给默认方法调用使用
	静态私有方法：默认方法和静态方法都可以调用
    【私有方法`只能`提供给接口的默认方法和私有方法使用】

​

• 概述

是java对函数式的一种体现形式,代表匿名内部类的对象，但本身不是对象。

• 前提

1、有且只有一个抽象方法的接口
2、必须要有上下文推断

• 格式【三个一】

(抽象方法的参数列表)->{抽象方法的重写方法体}

• 本质

就是一个数据值

• 省略原则

 1、小括号中的参数的所有的数据类型直接省略
 2、小括号有且只有一个参数可以省略小括号
 3、大括号有且只有一条执行语句的时候：同时省略return 分号  大括号

​

• 概述

java对函数式的一种体现形式，理解为Lambda表达式的孪生兄弟。

• 前提

1、有且只有一个抽象方法的接口
2、必须有上下文推断
3、引用的方法必存在

• 格式

普通方法：
        对象 :: 方法名
静态方法：
        类名 :: 方法名
构造方法：
        类名 :: new

• 本质

就是一个数据值

• 概述：

有且只有一个抽象方法的接口就是函数式接口
	 比如：jdk中熟悉的函数式接口 ：Runnable   Callable

• 常用函数式接口

1、Consumer：消费型接口  有个一可以消费任意数据类型的数据的方法	
2、Supplier：供给型接口  有一个可以提供任意数据类型数据的方法
3、Function：函数型接口  有一个可以把任意数据乐行转换为其他任意数据类型的方法
4、Predicate：断言型接口  有一个可以对任意数据进行判断的方法指定定义了功能		

• 特点：

通常被注解@FunctionalInterface标记
作用：定义函数接口的时候需要在接口上面增加这个注解，方便编译的时候判断该接口是不是函数式接口

功能：
	accept(T t)：消费使用掉任意的一个数据
作用：
	当某个函数可以接收一个数据，并且处理这个数据，处理完成之后，不需要返回任何数据，就使用消费型接口

功能：
	T get()：提供返回任意类型数据的规则
作用：
	当某个函数可以提供一个数据，就使用供给型接口

功能：
	R apply(T t)：抽象方法提供把一个数据类型转换为另一个数据类型规则
	andThen(Function f)：连接两个Function对象的不同转换规则，按照连接顺序依次执行[默认方法]
注意事项：
	1、同时调用andThen方法和apply方法时andThen方法必须在前apply方法必须在最后
	2、多个andThen方法连接转换规则时，上一个规则的转换结果的数据类型一定要和下一个规则要转换的数据类型一致

功能：
	boolean test(T t)：抽象方法
        判断对给定的数据是否符合某个条件
    Predicate and (Predicate p)：
        把两个断言型接口的判断规则判断的结果进行逻辑且【与】的处理
    Predicate or (Predicate p)：
        把两个断言型接口的判断规则判断的结果进行逻辑【或】的处理
    Predicate negate()：
        取判断结果的反向结果