面向对象16、17 and 异常01-03

接口

普通类：只有具体实现

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

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

接口就是规范，定义的是一组贵族

接口的本质是契约

声明类的关键字是class，声明接口的关键字是interface

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

内部类

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

1.成员内部类

public class Outer {
     private int id = 10;
     public void out(){
         System.out.println("这是外部类的方法");
     }
     public class Inner{
         public void in(){
             System.out.println("这是内部类的方法");
         }

         //获得外部内的私有属性
         public void getID(){
             System.out.println(id);
         }
     }
}

public class Application10 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();

        //通过外部内来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }
}

2.静态内部类

3.局部内部类

public class Outer {
//局部内部类
    public void method(){

        class Inner{
            public void in(){
                
            }

        }
    }
}

4.匿名内部类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类
        //不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService(){
            @Override
            public void hello() {

            }
        };//报错时需要重写内部的方法

    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

异常：exception

错误：Error

异常机制处理：

异常处理五个关键字：

try、catch、finally、throw、throws

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

        try { //try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){ //catch 捕获异常
            System.out.println("exception,变量b不能为0");
        }finally { //处理善后工作
            System.out.println("finally");
        }

    }
}
//try和catch必须存在
//finall可以不要，假设io流，资源关闭
//catch (xxx  e)     xxx——>捕获异常  其中的参数是想要捕获的异常类型,最高的是Throwable，包括error和exception
//可以捕获多个异常 ->要从小到大进行捕获
try{
    
}catch(Error e){
    
}catch(Exception e){
    
}catch(Throwavle e){
    
}finally {
    
}

代码块

try {
    
}

快捷键 ctrl+alt+T 选中需要捕获异常的语句

自定义异常

用户自定义异常，只需要继承exception类即可