面向对象（二）：抽象类，内部类，接口，异常

Java面向对象（二）

抽象类

• abstract 修饰的方法和类为抽象类和抽象方法
• 抽象类可以没有抽象方法，有抽象方法的类必须声明为抽象类
• 继承抽象类的子类必须实现抽象类的方法
• 抽象类不能使用new ，必须靠子类实现
• 抽象类中可以有普通方法
• 抽象类可以有构造方法，构造方法作用可以初始化变量，另一个是实例化变量。抽象类不能实例化，但可以初始化

接口

• 接口只有抽象方法的定义，定义一组规则。声明类的关键字：class.声明接口的关键字：interface
• 接口中的所有方法都是抽象的，默认有public abstract修饰
• 接口都需要有实现类，实现接口的类需要重写接口中的所有方法，关键字：implements
• 接口实现多继承
• 接口中可以定义变量，int age = 99; ==> public static final int age = 99,定义为常量，不推荐
• 接口没有构造方法，因为接口不是类

public interface Service{
	void test();
}

public class ServiceImp implements Service {
    public void test() {
        
    }
}

内部类

• 内部类是在一个类的内部定义一个类。有成员内部类，静态内部类，局部内部类，匿名内部类

public class TestInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getAge();

        //没有变量名初始化类
        new Outer().run();
        //匿名内部类
        UserService userService = new UserService() {
            @Override
            public void t1() {

            }
        };
    }
}

//外部类与内部类
class Outer {
    private int age = 10;
    public void run() {
        System.out.println("外部类方法");
    }

    public void test() {
        class Inner2 {//局部内部类
            public void inTest() {

            }
        }
    }

    public class Inner {
        public void runIn() {
            System.out.println("内部类方法");
        }

        //访问外部类的私有属性
        public void getAge() {
            System.out.println(age);
        }
    }
}

//定义接口
interface UserService {
    void t1();
}

异常

• 主要有三类：检查性异常，运行时异常，错误

• Java把异常当作对象处理，有一个基类 java.lang.Throwable作为所有异常的超类，包括Error和Exception.Error为致命性错误，JAVA虚拟机（JVM）会终止线程，Exception通常可以被程序处理

• 异常处理机制：抛出异常，捕获异常

• 五个关键字：try,catch,finally,throw,throws

public class ExceptionDemo {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        int c = 0;

        try {
            new ExceptionDemo().test(a,b);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
        //Ctrl + Alt + t
        try {
            if(b == 0) {
                throw new ArithmeticException();//主动抛出异常,一般使用在方法中
            }
            int d = b/c;
        } catch (Exception e) {
            e.printStackTrace();//输出异常信息
        } finally {
        }

        try{//try表示监控区域
            System.out.println(a/b);
        }catch (Exception e) {//捕获异常，catch(想要捕获的异常类型)，最高为 Throwable e
            System.out.println("错误");
        }catch (Throwable t){//捕获多个异常，需要从小到大
            System.out.println("Throwable");
        }finally {//无论有没有异常，都会执行，可以不用finally，IO，资源关闭常用
            System.out.println("finally");
        }
    }

    //假设方法中，处理不了这个异常，在方法上抛出异常
    public void test(int a, int b) throws ArithmeticException {
        if(b == 0) {
            throw new ArithmeticException();//主动抛出异常
        }
    }
}

自定义异常

用户自定义异常，只需要继承 Exception类即可，步骤如下：

1. 创建自定义异常类
2. 在方法中通过throw 关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4. 在出现异常方法的调用者中捕获并处理异常

异常处理经验

• 处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
• 多重catch块后面，可以加上一个catch(Exception)来处理可能会遗漏的异常
• 对于不确定的代码，也可加上try-catch，处理潜在的异常
• 尽量去处理异常，切忌知识简单调用printStackTrace()输出
• 具体如何处理异常，根据不同的业务需求和异常类型决定
• 尽量添加finally语句块去释放占用的资源