1.抽象类

由abstract修饰，可以修饰方法也可以修饰类，约束作用，继承了抽象类，子类就必须要实现抽象类里面的抽象方法。

public class A extends Action {
    @Override
    public void doSomething() {
        System.out.println("dada");
    }
}
public abstract class Action {
    //abstract 抽象类 :所有里面的抽象方法的实际应用都必须由子类实现，即子类必须要重写父类
    //约束~ 需要别人帮我们实现
    //相当于如果写了抽象方法 抽象方法只能写声明，在子类才是去实现它的
    public abstract void doSomething();
}

抽象小结

1.抽象类不能new出来，只能靠子类去实现它 2.抽象类中可以写普通方法 3.抽象方法必须在抽象类中 4.子类继承抽象类，那么久必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

2.接口

接口类由interface修饰，不用写class，只有规范，自己无法写方法~专业的约束！约束和实现分离：面向接口编程

public interface TimeService {
    void timer();
}
public interface UserService {//定义关键字是interface
    //接口中的所以定义的方法默认都是public抽象的
    void add(String name);//即是public abstract void add（）；
    void delete(String name);//删除
    void update(String name);//修改
    void query(String name);//查找
    //所以定义的属性都是常量
    int AGE=100;
}
public class UserServicelmpl implements UserService,TimeService {
//实现接口类就要重写接口里的所以方法  实现接口使用implements关键字
    //可以实现多个接口,通过逗号排序
    @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 timer() {
    }
}

接口小结

接口作用：
   1.约束
   2.定义一些方法，让不同的人实现~
   3.接口方法都默认带了public abstract，即是可以直接写返回值类型个人方法名来声明就可以了，不需要写修饰符。
   4.接口里写的属性都默认是public static final，即是常量
   5.接口都不能被实际化，接口中没有构造方法
   6.implements可以实现多个接口
   7.实现接口必须要重写接口中的方法。

3.内部类

字面意思一个类里再定义一个类，比如A类里定义B类，B类对于A类来说就是内部类

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    //局部内部类 :方法内写的(不能写public)
    public void run(){
        class B{
        }
    }
    public class Inner{//成员内部类
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public  void getID(){
            System.out.println(id);
        }
        public void diaoyong(){
            out();
        }
    }
}
class A{
    //一个java文件只能有一个public类，但是class类可以多个
}
public class Application {
    public static void main(String[] args) {
        Outer out=new Outer();
        //通过外部类的引用变量来实际化内部类
        Outer.Inner inner=out.new Inner();
        inner.in();
        inner.getID();//能获取外部类的私有属性
        inner.diaoyong();//能在内部类里面的方法调用外部类的方法（都不是直接调用，间接使用）
        new Outer().out();//匿名类，只使用一次，没有名字的类，不用将实例保存到变量中
    }
}

内部类暂时了解

4.异常

Error类

Error类对象由java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- java虚拟机运行错误，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，java虚拟机一般会选择线程终止。
- 还有发生在JVM试图执行应用时，如类定义错误、链接错误。这些错误是不可查的，因为他们在应用程序的控制和处理能力外，而且绝大多数程序运行的时候不允许出现这些状况

Exception类

在Exception分支有一个重要的子类（运行时异常）RuntimeException
- 空指针异常、算术异常、丢失资源、、、
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
Error和Exception的区别：Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常的时候，JVM一般会终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

public class Test {
    public static void main(String[] args) {
        int b=0;
        int a=1;
        try{//try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch是捕获 （）这里面的参数是想要捕获的类型
            System.out.println("程序出现异常，变量b不能为0");
        }catch (Throwable t){//可以连续捕获，但是最大的异常得最后面！！
            //假设捕获多个异常：从小到大

        } finally {//程序无论出不出异常，都会调用finally里面的内容(一般是用来善后工作的)
            System.out.println("finally");
            //finally可以不用， 假设是IO流的操作，资源关闭需要
        }
    }
}

day.13