Java的学习简化要点，带你快速过一遍java（1）
学习要求
1.学会idea的基础操作，建立项目，moudle，package，class类
2.学会创建数组，能够编写几个基础的排序算法。
3.学会创建方法，调用方法，了解什么是方法的重载
4.学会面向对象编程，能够debug调试代码，了解对象的内存存储方式
5.学会关键字static的用法，学会关于static方法的调用，掌握可变参数使用方法
6.了解面向对象的三大特征封装，继承，多态
多态
1.知道多态的前提
2.知道怎么用多态的方式new对象
3.知道多态的前提下，成员变量的访问特点
4.知道多态的好处
5.知道如何向下转型（将父类类型转成子类类型->强转）
前提
a.必须有父类继承关系或者接口实现关系
b.必须有方法的重写，没有方法的重写，多态没有意义（多态专门玩的就是重写方法）
c.父类引用执行子类对象
父类类型 对象名 = new 子类对象（）
d.弊端不能直接调用子类特有功能
使用方法
1.定义一个父类
2.定义一个子类继承父类，重写父类方法
3.new 对象的时候：父类引用指向子类对象
4.重写调用方法
多态的好处
1.不仅仅是体现在new对象上，而是体现在方法参数传递上
原始方法：
好处：既能调用自己特有的，还能调用重写的，还能调用父类的
坏处：扩展性差
多态方式：
好处：扩展性强
弊端：不能直接调用子类特有功能
多态中的转型
向上转型： 多态默认的，父类引用指向子类对象。 父类类型 对象名 = new 子类对象()
向下转型
子类类型 对象名 = （子类类型）对象名
转型的时候注意：ClassCastException -> 类型转换异常 -> 等号左右两边类型不一致
判断类型 instanceof
a 使用
对象名 instanceof 类型
b 含义
判断对象是否属于关键字后面的类型
c 结果 boolen类型
fianl关键字
用法
a。修饰一个类
final修饰的类不能被继承，final不能用abstract同时使用
b.修饰一个方法
final修饰的方法不能被重写
final和abstract不能同时使用
c.final修饰局部变量
修饰局部变量后，局部变量的值不能改变
d.final修饰对象
格式 final 类型 对象名 = new 类名()
特点 被final修饰i的对象，地址值不能改变，但是对象的属性仍然可以修改
e.final修饰成员变量
final 数据类型 变量名 = 值
特点 被final修饰的成员变量，不能被二次赋值
权限修饰符
java提供四种访问权限，使用不同的而去那先修饰符修饰时，被修饰的内容会有不同的访问权限
a.public 公共的，最高权限，被public修饰的成员，在哪里都能访问
b.protected 受保护的
c.默认的，注意 不限权限修饰符，就是默认的
d.private 私有的，只能在自己的类中直接访问
lombok
lombok通过增加一些“处理程序”，可以让java变得简洁，快速
lombok能以注解形式来简化java代码，提高开发效率，开发中经常需要写javabean，都需要花时间去添加
lombok 属于第三方工具
jar包，说白了就是第三方提供我们的压缩包 ***.jar
jar包中包含了此技术中所有类对应的clss文件
使用lombok准备工作
a.在idea中下载lombok插件
b.在当前模块下导入lombok的jar包
1.在当前模块下创建文件夹 右键—new----directory----取名为lib或者libs
2.将要使用的jar包粘贴到lib或者libs下
3.解压jar包，将jar包加入到当前模块环境下
对着jar包或者lib文件夹右键–add as library----level 选择moudle–name栏变空了不要管 点击ok
接口
概述 接口时Java中的一个引用的数据类型，是一套标准规范
接口中的成员单一
a.jdk8之前
抽象方法，不写abstract默认值也有
必修是stastic final修饰的成员变量–不写static final默认也有
b.jdk8 多了两个成员
默认方法 修饰符default，返回值类型 方法名(参数){}
静态方法 和之前定义的静态方法一样
c.jdk9 多了一个成员
私有方法private
关键字：
interface 接口
implement 实现
接口的使用步骤：
1.定义接口 ---- interface
2.定义实现类 ---- implements
3.重写抽象方法
4.创建实现类对象（接口也不能new）
5.调用重写的方法
定义方法
默认方法
1.格式:
修饰符 default 返回值类型 方法名（参数）{
方法体
renturn 结果
}
default定义方法只能在接口中使用
使用：
a.创建实现类，实现接口
b.默认方法可以重写，也可以不重写
c.创建实现类对象，调用默认方法
静态方法
1.格式
修饰符 static 返回值类型 方法名（参数）{
方法体
return 结果
}
2.使用
接口名直接调用
定义成员变量
1.格式
public static final 数据类型 变量名 = 值
2.特点
即使不屑static final默认也有
3.使用
接口名直接调用使用
4.注意：
接口中的变量需要手动赋值
习惯上，我们会将static final修饰id变量名用大写
接口的特点
1.继承的特点
继承支持单继承
继承支持多层继承
一个父类可以有多个子类
2.接口的特点
接口可以多继承
public interface interfaceA extends interfaceB，interfaceC{}
接口可以多实现—一个实现类可以实现一个或多个接口
public class interfaceimpA implements interfaceB,interfaceC{}
一个子类可以继承一个父类的同时，实现一个或多个接口
public class zi extends fu implements interfaceB，interfaceC{}
注意 如果一个类实现多个接口，必须要重写掉所有接口中的抽象方法
当一个类实现多个接口时，如果接口中的抽象方法重名且参数一样的，只需要重写一次
接口和抽象类的区别
相同点：
a.都位于继承体系的顶端
b.都不能new
c.都有抽象方法，继承或者实现以后都要重写这些抽象方法
不同点
a.抽象类成员比较丰富，可以有私有属性，构造，普通方法，抽象方法等，一般作为实体类使用
b.接口成员比较单一，一般抽取的
内部类
什么时候使用内部类
当一个事物的内部，还有一个部分需要完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类
当以个类内部的成员也需要要用属性和行为描述时，就可以定义成一个内部类了
在Java中运行一个类的定义位于另外一个类的内部，前者就称为内部类，后者称之为外部类
分类
1.成员内部类（静态，非静态）
2.局部内部类
3.匿名内部类（重点）
静态成员内部类
格式
public class 外部类{
static class 内部类{
}
}
注意
a.内部类中可以定定义属性，方法，构造
b.静态内部类可以被final或者abstract修饰
给final修饰，不能被继承
给abstrac不能new
c.静态内部类不能调用外部的非静态成员（静态不能直接调用非静态）
d.内部类还可以被四种权限修饰符修饰
创建静态内部类的方法
外部类类名.内部类类型 对象名 = new 外部类类名。内部类类名（）
非静态成员内部类
格式
public class 外部类{
class 内部类{
}
}
注意
a.内部类中可以定定义属性，方法，构造
b.静态内部类可以被final或者abstract修饰
给final修饰，不能被继承
给abstrac不能new
c.静态内部类不能调用外部的非静态成员（静态不能直接调用非静态）
d.内部类还可以被四种权限修饰符修饰
创建静态内部类的方法
外部类类名.内部类类型 对象名 = new 外部类类名().new 内部类类名()
匿名内部类
匿名内部类其实时内部类的简化方法，他的本质就是一个“带具体实现的”，“父类或者父接口的”，“匿名的”，“子类对象”，开发中，最常用的内部类就是匿名内部类，以接口为例，当我们使用一个接口时，写如下几步：
a.定义一个实现类，实现接口
b.重写接口中的抽象方法
c.创建实现类对象
d.调用重写的方法
2.如果的那春的调用一下这个抽像方法，我们不得不做以上四部操作，那么我们可以为了简单，使用匿名内部类完成，匿名内部类可以将上面的四部合成一步实现----四合一
格式1：
new 接口/抽象类(){
重写方法
}.重写方法();
格式2:
接口/抽象类 对象名 = new 接口/抽象类(){
重写方法
}；
对象名。重写的方法（）；
注意，匿名内部类时一种格式代表了一个接口或者抽象类的实现类或者子类对象
匿名方法的两种复杂用法
1.当参数传递
public static void method(USB usb){
usb.open();
}
package niming;
public class test01{
public static void main(String[] args) {
method(new USB(){
@Override
public void open(){
System.out.println("鼠标开启");
}
});
}
public static void method(USB usb){
usb.open();
}
}
2.当返回值传递
public static USB method01(){
return new USB(){
@Override
public void open() {
System.out.println("鼠标开启");
}
};
}
Object的介绍
概述 object 类时所有类的父类（根本）
任何类都会直接或者间接继承这个object类
如果一个类没有明确的写出extends ***，那么此类的父类为object
常用的几个快捷方式
ctrl+点击调用方法，快速跳到此方法上
ctrl+n 查询类
alt+7查看当前类的成员
equals
如果调用equals想比较对象的内容，就重写equals
怎么重写alt+insert----equals and hashCode—啥都不要管，一直下一步
本地方法
1.native：关键字---- 代表的本地方法
2.本地方法是有方法体的：c语言编写，本地方法的方法体没有对我们开源，所以我们看不到方法体，简单理解为本地方法就是对java语言的扩展，比如：后面io流部分，很多功能java本身没有，比如读写，那么就需要调用本地方法进行读写
3.位置：在本地方法栈中运行
4.意义：跟系统打交道
1.registernative（）用于注册本地方法的，可以将本地方法注册到Java中来，在Java的世界中就可以直接使用本地方法了
2.本地方法主要是为了Java语言不具备的功能进行扩充
3.运行在本地方法栈中
4.native方法是由c语言编写，c语言没有对我们开源，所以本地方法的方法体我们看不到
异常
1.异常的概述：代码出现了不正常的现象
2.异常体系
throwable
a.error : 错误-----代码出现严重事故，相当于人得了绝症，需要大改
b.Exception:异常------代码出现了不正常现象，相当于人得了感冒，可以治
编译时期异常：Exception以及子类（除了runtimeexception之外），都是编译时期异常
代码一写，本身没有错误，但是编译就爆红
运行时期异常：runtimeexception以及子类，都是运行时期异常
创建异常
格式
throw new Exception(“”)
异常处理方式（重点）
1.异常处理方式之一 throws 异常
格式 在方法的参数后面，左半个大括号前面。
throws 异常
本质 也是往上抛，针对编译时期可能造成的异常
2.抛多个异常
格式 throws 异常1，异常2
注意
a 如果我们处理的多个异常之间有子父类继承关系，那么我们可以直接throws 父类异常
b 如果我们不知道将来要处理什么具体的异常，我们就直接throws Exception（所有异常的父类）
c throws 后面跟的是异常类，不是普通的类，所以我们不能直接跑object
3.异常处理方式之二 try…catch…
格式
try{
可能出现异常的代码
} catch（异常 对象名）{
处理异常的代码-----将异常信息打印到日志文件中
}
注意事项
如果catc的多个异常之间有父类继承关系，可以直接捕获子类异常
异常处理多个catch
try{
可能出现异常的代码
} catch（异常 对象名）{
处理异常的代码-----将异常信息打印到日志文件中
}try{
可能出现异常的代码
} catch（异常 对象名）{
处理异常的代码-----将异常信息打印到日志文件中
}try{
可能出现异常的代码
} catch（异常 对象名）{
处理异常的代码-----将异常信息打印到日志文件中
}…
try catch最大的优势在于出现错误捕捉后可以继续执行接下来的代码
finally关键字
概述：代表是一定会执行的代码
使用：都是和try…catch结合使用
格式：
try{
可能出现异常的代码
}catch（异常 对象名）{
异常处理方案----一般的方案都是将来开发都是将异常信息打印到日志文件中
}finally{
一定会执行的代码
}
finally的使用场景：做释放资源使用
将来有很多对象无法被gc回收，所以我们需要手动回收，所以只要是gc回收不了的对象创建出来，后续不管是否操作成功，我们都是手动回收此对象，所以我们可以放到finally中，回收此对象。
1.父类中的方法抛异常了，子类重写之后要不要抛那？
可抛可不抛
2.父类中的方法没有抛异常，子类重写之后要不要抛异常那？
不能抛
try_catch和throws的使用时机
如果处理异常之后，还想让后续的代码正常执行，我们使用try catch
如果方法之间是递进关系，我们可以先throws，但是到了最后需要用try…catch做一个统一的异常约束
自定义异常
格式：
1.创建一个类
继承 Exception ----编译时期异常
继承 RuntimeException-----运行时期异常
2.提供构造方法-----方便设置异常信息
打印异常信息的三个方法
1.throwable中的三个方法
String toString（） ----异常类型+异常信息
String getMessage() ----异常信息
void printStackTrace ----最常用，默认
lambad表达式定义格式
1.面向对象思想：new对象（过程）点方法（目的）
2.jdk8之后，函数式编程思想—强调的是目的，不是强调过程
lambda表达式格式
（）->{}
例 method(() -> {System.out.println(“usb开启了”);});
a.() 代表重写方法的参数位置
b. -> 将参数传递到方法体
c.{} 代表重写方法的方法体
lambda表达式使用前提
1.前提 函数式接口做方法参数传递
2.什么是函数式接口
必须有，且只能由一个抽象方法的接口
3.验证
在接口上方写上 @FunctionalInterface
lambda表达式书写教程
a.先观察，是否是函数式接口做方法参数传递
b.如果是，考虑用lambda表达式
c.调用方法，实参以匿名内部类的形式传递
d.从new接口开始到重写方法的方法名结束，选中，删除（别忘记删除一个右半个大括号）
e.在重写方法的阐述后面方法体的前面加上 ->
lambda的简化
1.重写方法的参数类型可以省略
2.如果重写方法的参数只有一个，所在的小括号也可以省略、
3.如果重写方法的方法体中只有一句话，所在的大括号以及分号可以省略
4.如果重写方法的方法体中只有一句话，且是带retur的，那么所在的大括号，return关节字都可以省略
Supplier接口
java.utils.function.Supplier 接口，他意味着”供给“—>我们想要什么就给什么
方法 T.get()
泛型
<引用数据类型>-----规定了我们操作的数据是什么类型
<>中只能写引用数据类型，不能写基本的数据类型
示例
public class suppliertst {
public static void main(String[] args) {
method(new Supplier<Integer>() {
@Override
public Integer get() {
int[] arr = {2,5,8,4,9};
Arrays.sort(arr);
return arr[arr.length-1];
}`-0
});
lambda格式
method(() -> {
int[] arr = {2,5,8,4,9};
Arrays.sort(arr);
return arr[arr.length-1];
}
);
}
public static void method(Supplier<Integer> supplier){
Integer result = supplier.get();
System.out.println("最大的数为"+result);
}
}
Consumer接口
java.util.function.Consumer-------消费型接口
方法：
void accept(T t)，意为消费一个指定泛型的数据
消费 即使 操作
ackage c_lambda;
import java.util.function.Consumer;
public class Consumer_test {
public static void main(String[] args) {
method(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s.length());
}
},"abdiahnlei");
System.out.println("======lambda表达式=========");
method(s ->System.out.println(s.length()),"abdiahnlei");
}
public static void method(Consumer<String> consumer,String s){
/*
* 将s传递到accept方法中去消费
* 至于怎么消费操作，就看重写方法accept之后，怎么实现了
* */
consumer.accept(s);
}
}
Function接口
java.utils.function.Function<T,R>接口用来根据一个类型的数据得到另一个类型的数据，转换接口
方法：
R apply（T t)根据类型T参数获取类型R的结果
package c_lambda;
import java.util.function.Function;
public class test_Function {
public static void main(String[] args) {
method(new Function<Integer, String>() {
@Override
public String apply(Integer integer) {
//加上空串是为了转换为字符串类型
return integer+"";
}
},10000000);
System.out.println("======lambda表达式==========");
method(integer ->integer+"",1111111);
method(integer -> integer+"",10000000);
}
public static void method(Function<Integer,String> function,Integer i){
String apply = function.apply(i);
System.out.println(apply+"1");
}
}
Predicate接口
Java.utils.function.Predicate接口。 ----判断形接口
boolean test（T t）----用于判断的方法，返回值为boolean形式
package c_lambda;
import java.util.function.Predicate;
public class test_Predicate {
public static void main(String[] args) {
method(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.length() == 3;
}
},"ssssssszxs");
System.out.println("=====lambda表达式======");
method(s -> s.length() == 3,"ssssssss");
}
public static void method(Predicate<String> predicate,String s){
boolean test = predicate.test(s);
System.out.println("test = "+ test);
}
}