1 内部类

Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。

内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

内部类的使用规则:
（1）声明内部类如同在类中声明方法或变量一样，一个类把内部类看作是自己的成员。
（2）外嵌类的类体中可以用内部类声明的对象，作为外嵌类的成员。
（3）外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。
（4）内部类的类体中不可以声明类变量和方法。
（5）外嵌类和内部类在编译时，生成两个.class文件。

例如:某种类型的农场饲养了一种特殊种类的牛，但不希望其他农场饲养这种特殊种类的牛，那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。
下面的例子1(Example1.1.java)中有一个RedCowForm(红牛农场)类，该类中有一个名字为RedCow (红牛)的内部类。

RedCowForm.java

public class RedCowForm {
    static String formName;
    RedCow cow;  //内部类声明对象

    RedCowForm() {
    }

    RedCowForm(String s) {
        cow = new RedCow(150, 112, 5000);
        formName = s;
    }

    public void showCowMess() {
        cow.speak();
    }

    class RedCow {  //内部类的声明
        String cowName = "红牛";
        int height, weight, price;

        RedCow(int h, int w, int p) {
            height = h;
            weight = w;
            price = p;
        }

        void speak() {
            System.out.println("偶是" + cowName + ",身高:" + height + "cm 体重:" + weight + "kg,生活在" + formName);
        }
    }    //内部类结束
}

Example1.1.java

public class Example1_1 {
    public static void main(String[] args) {
        RedCowForm form = new RedCowForm("红牛农场");
        form.showCowMess();
        form.cow.speak();
    }
}

需要特别注意的是，Java编译器生成的内部类的字节码文件的名字和通常的类不同，内部类对应的字节码文件的名字格式是“外嵌类名$ 内部类名”，例如，例子1中内部类的字节码文件是RedCowForm$RedCow.class。因此，当需要把字节码文件复制给其他开发人员时，不要忘记了内部类的字节码文件。
内部类可以被修饰为static 内部类，例如，例子1中的内部类声明可以是static classRedCow。类是一种数据类型，那么static内部类就是外嵌类中的一-种静 态数据类型，这样一来，程序就可以在其他类中使用static内部类来创建对象了。但需要注意的是，static 内部类不能操作外嵌类中的实例成员变量。

假如将例子1中的内部类RedCow更改成static内部类，就可以在例子1的Example1_ 1
主类的main方法中增加如下的代码。

RedCowForm.RedCow redCow = new RedCowForm.RedCow(180,119,6000);
        redCow.speak();

注意：非内部类不可以是static类

2 匿名类

2.1 和子类有关的匿名类

创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称作匿名类。

假设Bank是类，那么下列代码就是用Bank的一个子类(匿名类)创建对象:

new Bank() {
	匿名类的类体
};

和子类有关的匿名类：
（1）匿名类是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。
（2）匿名类可以继承父类的方法也可以重写父类的方法。
（3）使用匿名类时，必然是在某个类中直接用匿名类创建对象，以此，匿名类一定是内部类。
（4）匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以声明static成员变量和static方法。
（5）由于匿名类是一个子类，但没有类名，所以在用匿名类创建对象时，要直接使用父类的构造方法。

例子2:该类共有4个类: (Example2_1. java)、ShowBoard类、
OutputAlphabet类型、 OutputEnglish. java 。该匿名类的对象负责输出希腊字母表。

OutputAlphabet.java

abstract class OutputAlphabet {
    public abstract void output();
}

OutputAlphabet .java

public class OutputEnglish extends OutputAlphabet { //输出英文字母子类
    public void output(){
        for (char c='a';c<='z';c++){
            System.out.printf("%3c",c);
        }
    }
}

ShowBoard .java

public class ShowBoard {
    void showMess(OutputAlphabet show) { //参数show是OutputAlphabet类型的对象
        show.output();
    }
}

Example2_1.java

public class Example2_1 {
    public static void main(String[] args) {
        ShowBoard board = new ShowBoard();
        board.showMess(new OutputEnglish());//向参数传递OutputAlphabet的子类OutputEnglish的对象

        board.showMess(new OutputAlphabet() {   //向参数传递OutputAlphabet的匿名子类的对象
            @Override
            public void output() {
                for (char c = 'α'; c <= 'ω'; c++)  //输出希腊字母
                    System.out.printf("%3c", c);
            }
        });//分号在这里
    }
}

2.2 和接口有关的匿名类

和接口有关的匿名类
假设Computable是一个接口，那么，Java允许直接用接口名和一个类体创建一个匿名对象，此类体被认为是实现了Computable接口的类去掉类声明后的类体，称作匿名类。

下列代码就是用实现了Computable接口的类(匿名类)创建对象:

new Computable(){
	实现接口的匿名类的类体
};

下面例子演示了和接口有关的匿名类的用法：

interface SpeakHello {
    void speak();
}

class HelloMachine {
    public void turnOn(SpeakHello hello) {
        hello.speak();
    }
}

public class Example7_3 {
    public static void main(String[] args) {
        HelloMachine machine = new HelloMachine();
        machine.turnOn(new SpeakHello() {
            @Override
            public void speak() {
                System.out.println("hello,you are welcome!");
            }
        });
        machine.turnOn(new SpeakHello() {
            @Override
            public void speak() {
                System.out.println("你好，欢迎光临!");
            }
        });
    }
}

3 异常类

所谓异常就是程序运行时可能出现一些错误，比如试图打开一个根本不存在的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。程序运行出现异常时，Java运行环境就用异常类Exception的相应子类创建一个异常对象，并等待处理。异常对象可以调用如下方法得到或输出有关异常的信息:

异常对象可以调用如下方法得到或输出有关异常的信息：

public String getMessage();
public void printStackTrace();
public String toString();

3.1 try-catch语句

Java使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch语句的try部分，将发生异常后的处理放在catch部分。
try-catch语句的格式如下:

try{
	包含可能发生异常的语句
}
catch(ExceptionSubClass1 e){
	...
}
catch(ExceptionSubClass2 e){
	...
}

下面一个例子给出了try-catch语句的用法：

public class Example3_1 {
    public static void main(String[] args) {
        int n = 0, m = 0, t = 1000;

        try {
            m = Integer.parseInt("8888");
            n = Integer.parseInt("ab89"); //发生异常,转向catch
            t = 7777;  //t没有机会被赋值
        } catch (NumberFormatException e) {
            System.out.println("发生异常:" + e.getMessage());
        }
        System.out.println("n=" + n + ",m=" + m + ",t=" + t);

        try {
            System.out.println("故意抛出I/O异常！");
            throw new java.io.IOException("我是故意的");
            //System.out.println("这个输出语句肯定没有机会执行,所以必须注释掉，否则编译出错");
        } catch (java.io.IOException e) {
            System.out.println("发生异常:" + e.getMessage());
        }
    }
}

带finally子语句的try~catch语句，语法格式如下:

try{ }
catch(ExceptionSubClass e){ }
finally{}

其执行机制是在执行try~catch语句后，执行finally 子语句，也就是说，无论在try部分是否发生过异常，finally 子语句都会被执行

3.2 自定义异常类

（1）异常的声明
➢一个方法不处理它产生的异常，而是沿着调用层次向上传递,由调用它的方法来处理这些异常，叫声明异常.
➢声明异常的方法:
在产生异常的方法名后面加上要抛出(throws)的异常的列表:
如: void compute(int x) throwsAri thmeticException
{//这里有异常发生，但是并没有处理…}

（2）我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操
作，即用相应的异常类创建对象，并使用throw关键字抛出该异常对象，导致该方法结束执行。

（3）通常情况下，计算两个整数之和的方法不应当有任何异常放出，但是，对某些特殊应程序，可能不允许同号的整数做求和运算，比如当一个整数代表收入，一个整数代表支出时，这两个整数就不能是同号。

例子 (Example3_2. java)中，Bank类中有一个income(int in, int out)方法，对象调用该方法时，必须向参数in传递正整数、向参数out传递负数，并且int+out必须大于等于0，否则该方法就抛出异常( BankException. java )。因此，Bank类在声明income(int in, int out)方法时，使用throws关键字声明要产生的异常。
BankException.java

public class BankException extends Exception {
    String message;

    public BankException(int m, int n) {
        message = "入账资金" + m + "是负数或支出" + n + "是正数，不符合系统要求.";
    }

    public String warnMess() {
        return message;
    }
}

Bank.java

public class Bank {
    private int money;

    public void income(int in, int out) throws BankException {
        if (in <= 0 || out >= 0 || in + out <= 0) {
            throw new BankException(in, out); //方法抛出异常，导致方法结束
        }
        int netIncome = in + out;
        System.out.printf("本次计算出的纯收入是:%d元\n", netIncome);
        money = money + netIncome;
    }

    public int getMoney() {
        return money;
    }
}

Example3_2.java

public class Example3_2 {
    public static void main(String[] args) {
        Bank bank = new Bank();
        try {
            bank.income(200, -100);
            bank.income(300, -100);
            bank.income(400, -100);
            System.out.printf("银行目前有%d元\n", bank.getMoney());
            bank.income(200, 100);
            bank.income(99999, -100);
        } catch (BankException e) {
            System.out.println("计算收益的过程出现如下问题:");
            System.out.println(e.warnMess());
        }
        System.out.printf("银行目前有%d元\n", bank.getMoney());
    }
}

4 断言

➢断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用，这样就可以发现一些致命的错误，当程序正式运行时就可以关闭断言语句，但仍把断言语句保留在源代码中，如果以后应用程又需要调试，可以重新启用断言语句。
➢使用关键字assert声明一条断言语句，断言语句有以下两种格式:
assert booleanExpression;
assert booleanExpression:messagelException;

❷启用与关闭断言语句
当使用Java解释器直接运行应用程序时，默认地关闭断言语句，在调试程序时可以使用-ea启用断言语句，例如:
java -ea mainClass

例子4中，使用一个数组放着某学生5门课程的成绩，程序准备计算学生的成绩的总和。在调试程序时使用了断言语句，如果发现成绩有负数，程序立刻结束执行。程序调试开启断言语句运行效果如图4.1，关闭断言语句运行效果如图4.2。

import java.util.Scanner;
public class Example4 {
  public static void main (String args[ ]) {
       int [] score={-120,98,89,120,99};
       int sum=0;
       for(int number:score) {
          assert number>0:"负数不能是成绩";
          sum=sum+number;
       } 
       System.out.println("总成绩:"+sum);    
   }
}

图4.1

图4.2

5 综合案例

下面的例子5中模拟向货船上装载集装箱，如果货船超重，那么货船认为这是一个异常将拒绝装载集装箱，但无论是否发生异常，货船都需要正点启航

DangerException.java

public class DangerException extends Exception {
    final String message = "超重";
    public String warnMess() {
        return message;
    }
}

CargoBoat.java

public class CargoBoat {
    int realContent;  //装载的重量
    int maxContent;   //最大装载量
    public void setMaxContent(int c) {
        maxContent = c;
    }
    public void loading(int m) throws DangerException {
        realContent += m;
        if(realContent>maxContent) {
            throw new DangerException();
        }
        System.out.println("目前装载了"+realContent+"吨货物");
    }
}

Example5.java

public class Example5 {
    public static void main(String[] args) {
        CargoBoat ship = new CargoBoat();
        ship.setMaxContent(1000);
        int m =600;
        try{
            ship.loading(m);
            m = 400;
            ship.loading(m);
            m = 367;
            ship.loading(m);
            m = 555;
            ship.loading(m);
        }
        catch(DangerException e) {
            System.out.println(e.warnMess());
            System.out.println("无法再装载重量是"+m+"吨的集装箱");
        }
        finally {
            System.out.printf("货船将正点启航");
        }
    }
}

异常概念：

1、如果某个方法不能按照正常的途径完成任务，就可以通过另一种路径退出方法。在这种情况下 会抛出一个封装了错误信息的对象。此时，这个方法会立刻退出同时不返回任何值。另外，调用 这个方法的其他代码也无法继续执行，异常处理机制会将代码执行交给异常处理器。

2、Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception

Error

1. Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果 出现了这样的错误，除了告知用户，剩下的就是尽力使程序安全的终止。

Exception（RuntimeException、CheckedException）

2. Exception 又 有 两 个 分 支 ， 一 个 是 运 行 时 异 常 RuntimeException ， 一 个 是 CheckedException。

RuntimeException 如 ： NullPointerException 、 ClassCastException ； 一 个 是 检 查 异 常 CheckedException，如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是 那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException，那么一 定是程序员的错误

检查异常 CheckedException：一般是外部错误，这种异常都发生在编译阶段，Java 编译器会强 制程序去捕获此类异常，即会出现要求你把这段可能出现异常的程序进行 try catch，该类异常一 般包括几个方面：

1》 试图在文件尾部读取数据

2》 试图打开一个错误格式的 URL

3》 试图根据给定的字符串查找 class 对象，而这个字符串表示的类并不存在

3、Throw 和 throws 的区别：

位置不同

1》 throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的 是异常对象。

功能不同：

2》throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方 式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并 将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语 句，因为执行不到。

3》throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常， 执行 throw 则一定抛出了某种异常对象。 两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异 常，真正的处理异常由函数的上层调用处理。

看图理解：

4、上面介绍了异常的一些概念，下面介绍如何自定义异常，并且异常如何统一格式响应出去

自定义异常以及统一异常格式响应出去很简单，分为以下几步：

（1）首先自定义一个异常类（2）再写一个全局异常捕获类（3）再封装一个通用响应对象，完成以上3步就ok了

具体实现方法往下看：

1》自定义异常首先要先自己新建一个异常类继承运行时异常RuntimeException ，然后再定义一个异常码和消息的枚举类配合使用，代码如下：

自定义异常类：
/**
 * 自定义异常类格式
 * @date 2019-06-10 10:09
 */

public class TestException extends RuntimeException{

    private String code;

    public TestException(String code) {
        this.code = code;
    }

    public TestException(String code, Object message) {
        super(message.toString());
        this.code = code;
    }

    public String getCode() {
        return this.code;
    }


}


异常枚举类：
public enum ActivityException {


    PARAMETER_ERROR("10100", "系统异常，入参错误"),

    GET_ACTIVITY_LIST("10000", "系统异常，查询活动列表异常"),

    private String code;
    private String message;

    ActivityException(String code, String message) {
        this.code = code;
        this.message = message;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

2》自定义异常好了之后使用的时候就可以new 一个自定义的异常抛出去了比如：throw new TestException("枚举code","枚举message");但是只有这些还不够，上面仅仅是把自己想要响应的异常定义出来了，那怎么统一格式响应给前端呢？那就需要全局异常捕获，捕获到自定义的异常然后封装成自己想要的格式，响应格式可以按自己需求封装异常code、message、path、time等

全局异常捕获类：

/**
 * 全局异常捕获类(作用是异常信息统一格式输出)
 * @date 2019-06-10 10:25
 */
@RestControllerAdvice//切面注解不能少
public class TestResponseBodyAdvice {
    private static final Logger log = LoggerFactory.getLogger(TestResponseBodyAdvice.class);

    public TestResponseBodyAdvice() {
    }

    /**
     * 全局异常Exception捕获类
     * @param e
     * @return
     */
    @ExceptionHandler({Exception.class})
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public Response uniteExceptionHandler(Exception e) {
        log.error("系统异常", e);
        return Response.builderFail("999", "error");
    }

    /**
     * 全局自定义异常TestException捕获类
     * @param e
     * @return
     */
    @ExceptionHandler({TestException.class})
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)//响应状态码500
    public Response businessExceptionHandler(TestException e) {
        log.error(e.getCode(), e.getMessage());
        log.error("系统异常", e);
        return Response.builderFail(e.getCode(), e.getMessage());
    }


    /**
     *  Dto字段属性校验全局异常类
     * 用法：
     *  @ApiModelProperty(value = "规则模板名称")
     *  @NotNull
     *  @Length(max = 50, message = "名称不得超过50" ,groups = {InsertGroup.class, UpdateGroup.class})
     *  private String templateName;
     *  controller中参数加@Valid注解即可
     */
    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public Response uniteExceptionHandler(org.springframework.web.bind.MethodArgumentNotValidException e) {
        log.error("系统异常", e);
        return Response.builderFail("999", e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
    }

}

可能还需要封装一个统一响应对象

@ApiModel("通用响应对象")
@JsonSerialize(
        include = JsonSerialize.Inclusion.NON_NULL
)
public class Response<T> implements Serializable {
    private static final long serialVersionUID = -4505655308965878999L;
    private static final String successCode = "0";
    @ApiModelProperty("返回的业务对象")
    private T data;
    @ApiModelProperty(
            value = "错误代码，0--成功，其他失败",
            example = "0"
    )
    private String code = "0";
    @ApiModelProperty(
            value = "返回信息描述",
            example = "success"
    )
    private Object msg = "success";

    private Response() {
    }

    private Response success(T data) {
        this.data = data;
        return this;
    }

    private Response fail(String code, Object msg) {
        this.code = code;
        this.msg = msg;
        return this;
    }

    public static Response builderSuccess(Object o) {
        return (new Response()).success(o);
    }

    public static Response builderFail(String code, Object msg) {
        return (new Response()).fail(code, msg);
    }

    public T getData() {
        return this.data;
    }

    public String getCode() {
        return this.code;
    }

    public Object getMsg() {
        return this.msg;
    }

    public void setData(T data) {
        this.data = data;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public void setMsg(Object msg) {
        this.msg = msg;
    }

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        } else if (!(o instanceof Response)) {
            return false;
        } else {
            Response<?> other = (Response)o;
            if (!other.canEqual(this)) {
                return false;
            } else {
                label47: {
                    Object this$data = this.getData();
                    Object other$data = other.getData();
                    if (this$data == null) {
                        if (other$data == null) {
                            break label47;
                        }
                    } else if (this$data.equals(other$data)) {
                        break label47;
                    }

                    return false;
                }

                Object this$code = this.getCode();
                Object other$code = other.getCode();
                if (this$code == null) {
                    if (other$code != null) {
                        return false;
                    }
                } else if (!this$code.equals(other$code)) {
                    return false;
                }

                Object this$msg = this.getMsg();
                Object other$msg = other.getMsg();
                if (this$msg == null) {
                    if (other$msg != null) {
                        return false;
                    }
                } else if (!this$msg.equals(other$msg)) {
                    return false;
                }

                return true;
            }
        }
    }

    protected boolean canEqual(Object other) {
        return other instanceof Response;
    }

//    @Override
//    public int hashCode() {
        int PRIME = true;
//        int result = 1;
//        Object $data = this.getData();
//        int result = result * 59 + ($data == null ? 43 : $data.hashCode());
//        Object $code = this.getCode();
//        result = result * 59 + ($code == null ? 43 : $code.hashCode());
//        Object $msg = this.getMsg();
//        result = result * 59 + ($msg == null ? 43 : $msg.hashCode());
//        return result;
//    }

    @Override
    public String toString() {
        return "Response(data=" + this.getData() + ", code=" + this.getCode() + ", msg=" + this.getMsg() + ")";
    }
}

5、这样有自定义的异常类，还有全局统一异常捕获类，在运行出错的时候程序要抛出自定义异常，全局异常捕获会自动捕获自定义的异常然后取出异常里面的信息再封装成响应实体对象响应出去，以此达到统一异常响应