一.匿名内部类

没有名字的一个内部类

作用: 没有类本身作用,只为了重写一些抽象方法,方便调用这个方法 ,匿名内部类可以简化这种实现类。简化符合需求的实现类,子类->接口|抽象父类

public class Inner {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.smoking();
       //2)引用接收: 接口多态
        Smoke s = new Smoke(){  //匿名内部类的类体
            @Override
            public void smoking() {
                System.out.println("边吸烟边跳舞...");
            }
        };
        s.smoking();//边吸烟边跳舞...
        //1)匿名对象-> 无引用接收匿名内部类对象地址:  匿内部类对象的后面直接调用
        //创建一个Smoke接口的一个没名字的实现类(匿名内部类)的对象
        new Smoke(){  //匿名内部类的类体
            @Override
            public void smoking() {
                System.out.println("边吸烟边玩手机...");
            }
        }.smoking();//边吸烟边玩手机...
        //3)作为方法的实参
        test(new CH());
        test(new Demo());
        test(new Smoke() {
            @Override
            public void smoking() {
                System.out.println("边吸烟边笑...");
            }
        });
    }
​
    static void test(Smoke smoke){
        smoke.smoking();
    }
​
}
​
//吸烟接口
interface Smoke{
    void smoking();
}
//实现类 ,本身具类本身的含义
class CH implements Smoke{
    public String name;
    int age;
    @Override
    public void smoking() {
        System.out.println("边吸烟边敲代码");
    }
}
//实现类 : 本身没有自己的含义与作用,为了重写抽象方法smoking,便于调用
class Demo implements Smoke{
    @Override
    public void smoking() {
        System.out.println("边吸烟边吐烟圈...");
    }
}

二.lambda表达式

作用：该功能就是为了简化内部类结构，前提是内部类实现的是函数式接口。只存在一个必须被重写的抽象方法的接口就是函数式接口，可以利用 @FunctionalInterface 检查一个结口是否为函数式接口。

定义结构： （ ）-> { }

( ) : 重写的抽象方法的参数列表。

-> : lambda 符号，也称为箭头符号，具有上下文推导的作用。

{ } ：重写抽象方法的方法体。

public class Lambda {
    public static void main(String[] args) {
        Test01_Lambda.test();
    }
    static void test(){
        //lambda标准写法省略方法名
        Lmabda1 lmabda1 = ()->{ System.out.println("方法一"); };
        lmabda1.lambda1();
        //当lambda体中的语句体只有一句,前后的{}可以省略
        lmabda1 = () -> System.out.println("方法二");
        lmabda1.lambda1();
        //参数列表的数据类型可以省略
        Lmabda2 lmabda2 = (i) -> System.out.println("方法三"+i);
        lmabda2.lambda2(8);
        //如果参数只有一个,前后的()可以省略 ,如果参数个数为2~多个,前后()不能省略
        lmabda2 = i -> System.out.println("方法四单参数"+i);
        lmabda2.lambda2(9);
        Lmabda3 lmabda3 = (a,b) -> System.out.println("方法四多参数"+(a+b));
        lmabda3.lmabda3(6,6);
        //如果方法存在返回值,并且{}中语句体只有一句,为return 带出返回值语句,前后的{}与return关键字可以一起省略
        lmabda4 = (c,d) -> c+d;//方法五       
        System.out.println(lmabda4.lmabda4(11,22));//方法五的返回值
    }
}
interface Lmabda1{
    void lambda1();
}
interface Lmabda2{
    void lambda2(int i);
}
interface Lmabda3{
    void lmabda3(int i,int j);
}
interface Lmabda4{
    int lmabda4(int m,int n);
}

三.异常 Exception

1.意义

意义：异常就是程序出现了问题，程序一旦遇到异常,后面代码无法正常执行,这时控制台中展示异常的详细信息|细节问题,便于程序猿的调试。主要分为 Error 与 Exception 。

Error ：一般指由虚拟机生成并脱出的异常,无需程序员解决处理。

Exception : 异常，如果不处理,程序无法正常执行,需要程序员在代码层面上处理异常。分为 RuntimeException （运行时异常）：运行期间才会发生的异常；CheckedException （编译时异常|检查时异常）：编译期间发生的异常,不处理程序无法运行。

重点注意：

1）所有的异常都可以通过标准异常处理方案来处理。 2）运行时异常一般通过增强程序健壮性的代码就可以解决 -> if判断。 3）编译时异常只能通过异常处理方案来处理。

常见运行异常：

NullPointerException 空指针异常
    s = null;System.out.println(s.length());
ArithmeticException 数学异常
    System.out.println(5/0); 
ArrayIndexOutOfBoundsException 数组索引越界异常
    int[] arr = {1,2,3};System.out.println(arr[5]); 
NegativeArraySizeException 数组长度负数异常
    int[] arr = new  int[-3];
ClassCastException 类型转换异常
    Object obj = "张三";
    System.out.println((自定义类)obj);
NumberFormatException 转换格式异常
    String str = "123abc";
    System.out.println(Integer.valueOf(str));

2.异常的处理

异常抛出：throws ：把异常抛出到上一层，谁调用谁处理。

异常捕获：异常对象当场抓住捕获,直接处理。

try { 
    可能出现异常的代码//出现异常代码后直接执行catch，异常代码后的所有代码不再执行。
}  catch （ 异常类型  e ）{ 
    e.printStackTrace ( )； 
}  catch （Exception e）{
    e.printStackTrace ( )；//所有异常都可捕捉（接盘侠）接收区间最大，一般放在后面，捕获区间越大越放在后面。可放n个catch
}......finally { //无论怎样都会被执行，一般放在最后
    执行代码
}   

注意：

1.异常一旦处理,不影响程序的继续执行 2.try中代码可能出现异常,可能不会出现异常,如果没有出现异常,try{}中的代码执行完毕,try...catch结束。 try中代码一旦异常，try后面的代码不会执行，直接执行catch的判断，从上到下一次判断,判断当前的catch是否能够捕获出现的异常对象,如果能,执行后面的{}中的代码，如果不能匹配，继续向下判断，如果所有的都不能匹配,当前的异常对象没有处理,中止程序的执行。 3.一个try后面可以跟1~n个catch。 4.如果一个异常已经通过catch处理不影响后面代码的执行。 5.接收范围较大的异常的catch,需要定义在后面。 6.finally 最终的，无论try中是否会出现异常,finally中的代码肯定最后会执行一般会定义一些资源的关闭等代码。

public class Class002_Exception {
    public static void main(String[] args){
        //编译时期异常
        //InputStream is = new FileInputStream("");
        try {
            System.out.println("try开始了....");
            test();//出现异常直接执行catch，下面代码不再执行。
            System.out.println(5/0);
            System.out.println("try结束了....");
        } catch (FileNotFoundException e) {
            System.out.println("出现了文件未找到异常, 捕获异常...");
            e.printStackTrace();
        } catch (Exception e) {//一般定义在最后用来确定异常可以被捕获。
            System.out.println("接盘侠");
            e.printStackTrace();
        } finally {
            System.out.println("最后肯定会执行的代码");
        }
        System.out.println("main方法结束了....");
    }
    static void test() throws FileNotFoundException,NullPointerException {
        InputStream is = new FileInputStream("D://aaa.txt");//抛出异常
    }
}

3.自定义异常

异常类也是类：需要直接或者间接的继承自Exception，如果是运行时期异常必须直接或者间接的继承 RuntimeException。通过 throw 制造异常:。

public class Test01_AgeException {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        User user = new User();
        System.out.print("请输入姓名：");
        user.setName(scanner.nextLine());
        try {
            System.out.print("请输入年龄：");
            user.setAge(scanner.nextInt());
        } catch (AgeException e) {
            e.printStackTrace();
        }
        if(user.getAge()>18&&user.getAge()<80){
            System.out.println("创建成功"+user);
        }else {
            System.out.println("创建失败，年龄不合法");
        }
    }
}
//创建异常类
class AgeException extends Exception{
    public AgeException(){
        //空构造器
    }
    public AgeException(String massage){
        super(massage);
    }
}
​
//用户类
class User{
    private String name;
    private int age;
​
    public User() {
        //空构造器
    }
​
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) throws AgeException {
        if(age<18||age>65){
            throw new AgeException(age+"年龄不合法");
        }
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

四. String 字符串类

1.意义

本身是一个不可变长字符序列，String类表示字符串。 Java程序中的所有字符串文字（例如"abc" ）都实现为此类的实例。常见的如"abc" 是一个字符串常量存在于字符串常量池中（方法区），也可以创建：new String() 存在于方法堆中。

存储方式：

1）在 jdk11 中使用字节数组存储字符串数据 private final byte[] value;

2）在 jdk8 中使用字符数组存储字符串数据 private final char[] value;

2.String类中的常用方法

public class String_Method{
    public static void main(String[] args){
        String str1 = "abcdefghijklmn";
        String str2 = "Abcdefghijklmn";
        //char charAt(int index) 返回指定索引处的 char值。
        System.out.println(str.charAt(4));//e
        //int codePointAt(int index) 返回指定索引处的字符（Unicode代码点）。
        System.out.println(str1.codePointAt(4));//101
        //int compareTo(String anotherString) 按字典顺序比较两个字符串。
        System.out.println(str1.compareTo(str2));//32
        //int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，忽略大小写差异。
        System.out.println(str1.compareToIgnoreCase(str2));//0
        //String concat(String str) 将指定的字符串连接到此字符串的末尾。
        System.out.println(str1.concat(str2));//abcdefghijklmnabcdefghijklmnAbcdefghijklmnAbcdefghijklmn
        //boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时，才返回true。
        System.out.println(str1.contains("tian"));//false
        //boolean equals(Object anObject) 将此字符串与指定的对象进行比较。
        System.out.println(str1.equals(str2));//false
        //boolean equalsIgnoreCase(String anotherString) 将此 String与另一个 String比较，忽略了大小写。
        System.out.println(str1.equalsIgnoreCase(str2));//true
        //boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。
        System.out.println(str1.endsWith("klmn"));//true
        //static String copyValueOf(char[] data) 相当于 valueOf(char[]) 。把一个字符数组转为字符串
        String str3 = String.copyValueOf(new char[]{'a','b','c'});
        System.out.println(str3);//abc
        //void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将此字符串中的字符复制到目标字符数组中。
        char[] ch = new char[10];
        System.out.println(Arrays.toString(ch));//[ ,  ,  ,  ,  ,  ,  ,  ,  ,  ]
        str1.getChars(3,11,ch,1);
        System.out.println(Arrays.toString(ch));//[ , d, e, f, g, h, i, j, k,  ]
        //int indexOf(String str) 返回指定子字符串第一次出现的字符串中的索引。
        System.out.println(str1.indexOf("efg"));//4
         //int indexOf(String str, int fromIndex) 从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
        System.out.println(str1.indexOf("efg",5));//18
        //int lastIndexOf(int ch) 返回指定字符最后一次出现的字符串中的索引。
        System.out.println(str1.lastIndexOf("efg"));//18
        //int lastIndexOf(int ch, int fromIndex) 返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向后搜索。
        System.out.println(str1.lastIndexOf("efg",5));//4
    }
}