抽象，接口，内部类，error和异常

abstract

抽象类：abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类。

抽象类中可以没有抽象方法，但是有抽象方法的类一点要声明为抽象类。

public abstract class Person {
    //抽象类
    //是一个约束，有人帮我们实现
    //抽象方法只有方法的名字，没有方法的实现
    public abstract void test();


    //1.抽象类不能创建对象，即new这个抽象类，只能靠子类来实现它
    //2.抽象方法必须在抽象类中 ，是一个约束
    //3.抽象类中可以写普通的方法

    //在抽象类中 可以有构造方法。
    //在抽象类中可以有构造方法，只是不能直接创建抽象类的实例对象，
    //但实例化子类的时候，就会初始化父类，不管父类是不是抽象类都会调用父类的构造方法，初始化一个类，先初始化父类。

    //抽象类的意义
    //1.可以把同一种类型的对象共性抽取出来后封装成抽象类，子类通过继承该抽象类达到代码编写简洁，易于维护的目的。
    //2.通过抽象类定义一系列规范，继承该抽象类的子类必须实现相应的抽象方法，使得该子类具有相应的规范性。
    //3.实现多态。
}

接口（interface）

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法，专业的约束，结束和实现分离：面向接口编程。接口的本质是契约

声明关键字：interface

实现关键字：implements

接口的定义：

public interface doSomethingService {
    //属性默认前缀是 public static final

    int age = 100;

    //接口里面的所有方法都是抽象的，默认前缀是public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

接口的实现：

//抽象类是单继承 extends
//实现接口用 implements，可以实现多个接口的实现，从而实现伪多继承
//实现了接口中的类就需要重新接口中的方法
public class doSomethingServiceImpl implements doSomethingService,UserService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void run() {

    }
}

作用：

作用：
    1. 约束
    2. 定义一些方法，让不同的人实现
    3. 方法：public abstract
    4. 属性：public static final
    5. 接口不能被实例化，接口中没有构造方法
    6. implements 可以实现多个接口
    7. 必须重写接口中的方法

内部类（扩展）

内部类：就是在一个类中再定义一个类，比如：A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

内部诶类分为：

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

//定义一个外部类Outer
public class Outer {
    private int a = 100;
    public void run(){
        System.out.println("外部类！");
    }

    //定义一个内部类

    //局部内部类
    public void Inner3(){
        class Inner03{
            public void hello(){

            }
        }
    }
    class In{
        public void go(){
            System.out.println("内部类！");
            //可调用外部类的属性和方法
            System.out.println(a);
            run();
        }

    }
    //静态内部类
    public static class Inner2{
        public void go(){
            System.out.println("静态内部类!");
        }
        //不可调用外部类的属性和方法，除非外部类的属性也是静态的
//        public void print_outer(){
//            System.out.println(a);
//            run();
//        }
    }
    //匿名内部类，实现见main方法


}
//一个文件里面只能与一个public class，但是可以有无数个class
class A{

}
interface UserService{
    void hello();
}

实现：

		Outer outer = new Outer();
        outer.run();//外部类
        //通过内部类实例化对象
        Outer.In in = outer.new In();
        in.go();//内部类，100，外部类

//        Outer.Inner2 inner2 = new Outer.Inner2();
//        inner2.print_outer();
        //匿名内部类的实现
        //没有名字初始化类，不用将实例保存到变量中
        new Outer().run();

        //需重写方法
        new UserService(){
            @Override
            public void hello() {

            }
        };

ERROR和异常（Exception）

异常指程序运行中出现的不期而至的各种状况，例如文件找不到，网络连接失败，非法参数等。

异常发生在程序运行期间，它影响了正常的程序执行流程。

分类：
	检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，只是程序无法预见的，如，打开不存在文件，异常发生，那么这异常不能忽略。
	运行时异常：运行时异常是可能被程序员避免的异常，运行时异常可以在编译时被忽略。比较致命。
	错误：错误不是异常，是脱离程序员控制的问题，在代码中通常被忽略，例如：栈溢出。更致命。

异常体系结构：

java把异常当做对象来处理，并定义一个java.lang.Throwable作为所有异常的超类。

在java API中已经定义了很多异常类，分为错误Error和Exception

Error

Error类对象是由虚拟机生成抛出，大多数错误与代码编写者所执行的操作无关

java虚拟机运行错误（VIrtual MachineError），当JVM不在继续执行操作所需的内存资源事，将出现OutofMemoryError。这些异常放生时，java虚拟机（JVM）一般会选择线程终止，一种错误一方生很可能造成不可挽回的后果。

还有发生在虚拟机试图执行应用时，如类错误（NoClassDefaultFoundError）、链接错误（LinkageError）。这些错误是不可查的，但都在可控的。

Exception

RuntimeException（运行时异常）是Exception一个重要的子分支

​ 如：ArrayIndexOutOfBoundsError（数组下标越界）

​ NullPointerException（空指针异常）

​ ArithmeticException（算术异常）

​ ClassCastException （类转换异常）

​ ClassNotFoundException（找不到类异常）等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。

这些异常一般是有程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生；

除了运行时异常其他的统称为非运行异常，非运性异常都是可检查的异常，可以进行处理和解决的。

Error和Exception的区别：

Error通常是灾难性的致命错误，是程序无法控制和处理的，但出现这种异常时，java虚拟机（JVM）一般会选择终止进程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。

异常处理

抛出异常，捕获异常

异常处理五个关键字

try, catch , finally, throw, throws

实例：

public class RunMain04 {
    public static void main(String[] args) {
        //异常处理
        int a = 1;
        int b = 0;

        //如果想捕获多个异常，需要从小到大进行捕获
        try {
            new RunMain04().test();
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }

        try {//try监控区域
            //new RunMain04().a();
            new RunMain04().chu(a ,b);
            //System.out.println(a/b);//抛异常快捷键(idea)选中Ctrl art+T
        } catch (ArithmeticException e) {//捕获处理，catch（想要捕获的异常类型！！！） 捕获异常
            System.out.println("被除数不能为0");
            //e.printStackTrace();//打印错误的栈信息
        } catch(Throwable e){//Throwable 包括所有的异常
            System.out.println("错误！！！");
        } finally {//处理善后工作，可以省略不写，主要用在IO流，资源关闭。
            System.out.println("finally无论怎么都会执行！！！");
        }
    }
   
    public void chu (int a,int b){
        if(b == 0){
            throw new ArithmeticException();//主动抛出异常，throw主要用在方法中。
        }

    } 
    //方法异常处理不了可以用throws抛出异常来处理
    public void test() throws ArithmeticException{
        System.out.println(1/0);
    }
    public void a(){b();}
    public void b(){a();}
}

自定义异常

Java内置中已经定义了很多中异常。自定义异常只要继承Exception类即可。

使用步骤：

1. 创建自定义类

2. 在方法中通过throw关键字抛出异常对象

3. 如果在当前抛出异常的方法中处理异常，可以是使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。

4. 在出现异常方法的调用者中捕获并处理异常。

实际运用中的总结

1. 处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
2. 在多重catch快后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3. 对于不确定的异常，也可以加上try-catch，处理潜在的异常
4. 尽量去处理异常，切忌只是简单的调用printStrackTrace()去打印输出
5. 具体如何处理异常，要根据不用的业务需求和异常类型去决定
6. 尽量添加finally语句快去释放占用的资源

//自定义异常类
public class MyException extends Exception {

    private int number;

    public MyException(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "MyException{" +"number=" + number +'}';
    }
}

import java.util.Scanner;

public class Test {
    public static void main(String[] args){

        testt();

//        try {
//            new Test().getNumber();
//        } catch (MyException e) {
//            System.out.println(e);
//        } finally {
//        }

    }
    //运用自定义抛异常
    public void getNumber() throws MyException {
        int a ;
        Scanner sc = new Scanner(System.in);
        a = sc.nextInt();
        if (a>10){
            throw new MyException(a);
        }
        System.out.println("ok");
        sc.close();
    }
    public static void testt(){
        Scanner sc = new Scanner(System.in);

        int a =0;
        boolean x = true;

        
        do {
            try {
                a = sc.nextInt();
                x = false;
            } catch (Exception e) {//处理输入的不是整数的结果
                System.out.println("输入的数只能为整数,请重新输入");
                x = true;
                String b =sc.nextLine();
            } 
        } while (x);//输入正确时x=false则结束循环

        sc.close();
        System.out.println(a);
    }


}