API使用，内部类，Lambda，异常

今天的内容：学会API的使用，Arrays包中几个重要方法的调用，内部类的了解，匿名内部类的使用，Lambda的使用，了解异常；

1、API（Application Programming Interface，应用程序编程接口）：）

是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件的以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。API 文档详细说明了 Java 中常用类和方法的功能，开发者可以通过查阅 API 文档，调用应用程序接口（API）来编程。
查询 API 的一般流程是：找包→找类或接口→查看类或接口→找方法或变量 如String类和Arrays类

2、java.util.Arrays（Arrays 操作数组的工具类）

此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。
几个常用方法(此处全部引用int类型数组)：
Arrays.copyOf​(int[] original, int newLength)
使用零复制指定的数组，截断或填充（如有必要），以使副本具有指定的长度。
Arrays.copyOfRange​(int[] original, int from, int to)
将指定数组的指定范围复制到新数组中。
Arrays.equals​(int[] a, int[] a2)
如果两个指定的int数组彼此 相等 ，则返回 true 。
Arrays.deepEquals​(Object[] a1, Object[] a2)
如果两个指定的数组彼此 深度相等 ，则返回 true 。
Arrays.toString​(int[] a)
返回指定数组内容的字符串表示形式。

内部类

内部类分为：
成员内部类、静态内部类、私有内部类、局部内部类、匿名内部类；

1. 成员内部类：
   成员变量处定义一个内部类
   具有类的特点,继承,实现…
   成员内部类具有成员的特点,被成员修饰符修饰
   注意：
   在成员内部类中不能定义静态内容除了静态常量，静态内部类才能定义
   在外部类中可以跟随成员内部类的对象使用成员内部类的成员
   成员内部类的对象需要通过外部类对象构建外部类名.内部类类名 引用 = new 外部类().new 内部类();
   跟随内部类的对象使用内部类的成员,注意访问权限

2. 静态内部类
   静态内部类定义在类中，任何方法外，用static定义。
   静态内部类中的静态内容 : 外部类类名.内部类类名.静态内容
   静态内部类中的成员内容: new 外部类类名.内部类类名(); 通过内部类对象调用它成员

3. 私有内部类
   只能在当前外部类中通过内部类对象使用

4. 局部内部类
   1.不能被成员修饰符等修饰(public,private,protected,static)
   2.局部内部类中不能定义静态内容,除了静态常量
   3.局部内部类中可以直接使用外部类成员,可以使用所在方法中的局部变量
   4.局部内部类智能在当前所在的方法中通过内部类对象使用,其他位置无法使用
   5.在局部内部类中使用了所在方法中的局部变量|形参,这个局部变量会默认被final修饰
   jdk8开始默认被final修饰
   jdk7及之前需要显示被final修饰

5. 匿名内部类(*****)
   作用: 用来简化没有本身自己作用的实现类|子类
   上层 : 接口 | 抽象类

package com.yjx.inner01;
/*
    匿名内部类
        作用: 用来简化没有本身自己作用的实现类|子类
            上层 : 接口 | 抽象类

 */
public class Class007_Outer {
    public static void main(String[] args) {
        //匿名对象 : 只能在当前行使用一次
        new String();
        //创建 实现类对象调用重写后的抽象方法
        new Demo().smoking();
        //匿名内部类
        //1) 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
        new Smoke() {//实现类的类体
            @Override
            public void smoking() {
                System.out.println("一边哈哈笑一边吸烟...");
            }
        }.smoking();
        //2. 引用指向的匿名内部类对象 : 通过引用后续使用多次
        Smoke s =  new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        };
        s.smoking();
        s.smoking();
        //3.匿名内部类对象作为实参传递
        test( new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        });
        //通过匿名 内部类简化子类
        Car car = new Car(){
            @Override
            void run() {
                System.out.println("run....");
            }
        };
        car.run();
    }

    static void test(Smoke smoke){
        smoke.smoking();
    }
}
//抽象类
abstract class Car{
    abstract void run();
}
//接口
interface Smoke{
    void smoking();
}
//实现类 ,重写抽象方法
class Demo implements Smoke{
    @Override
    public void smoking() {
        System.out.println("一边呲着牙一边吸烟...");
    }
}

Lambda表达式

作用：用来简化匿名内部类
语法：()->{}
（）：要重写的抽象方法的参数列表
->：箭头符号
｛｝：要重写的抽象方法的方法体

Lambda表达式在不同的使用情况下有不同的写法

public class Class001_Lambda {
    public static void main(String[] args) {
        //匿名内部类对象
       /* Run r =  new Run(){

            @Override
            public void run() {
                System.out.println("run....");
            }
        };*/

        //lambda写法1 : ()->{}
      /*  Run r = ()->{
            System.out.println("run....");
        };

        r.run();*/

        //lambda写法2: 当方法体只有一句 ,前后的{}可以省略
        /*Run r = ()->System.out.println("跑....");

        r.run();*/

        //lambda写法3: 当方法具有参数,参数的类型可以省略
        /*Run r = (a,b)->System.out.println("跑...."+(a+b));

        r.run(1,2);*/

        //lambda写法4: 当方法的参数只有一个 ,前后的()可以省略
        /*Run r = a -> System.out.println("跑...."+(a));

        r.run(1);*/

        //lambda写法5: 当方法存放返回值,并且{}中的语句体只有一句,就是return语句,前后的{}与return关键字可以一起省略
        Run r = a -> a>0;

        r.run(1);

        test(new Run() {
            @Override
            public boolean run(int x) {
                return false;
            }
        });

        //注意: 当方法的形参为一个函数式接口,实参可以为lambda表达式
        test((i)->{return i>18;});
        test(i->i>18);
    }

    static void test(Run run){
        run.run(1);
    }
}

@FunctionalInterface
interface Run{
    boolean run(int x);
    static void test(){}
}

异常（Throwable）

程序无法正常执行完毕
API搜索Throwable
异常体系Throwable:

1. Error:编译时异常（CheckException）
2. Exception:运行时异常（RuntimeException）
   常见异常：

        //数学异常ArithmeticException
        double test3=5/0;
        //类型转换异常
        Object obj=new String();
        Type test2=(Type)obj;
        //数组下标越界异常ArrayIndexOutOfBoundsException
        int[] test1=new int[3];
        System.out.println(test1[5]);
        //数组长度负数异常NegativeArraySizeException
        int y=-3;
        int[] wuhu=new int[y];
        //空指针异常NullPointerException
        String x=null;
        System.out.println(x.length());