Java -day7

编译先加载静态（static）方法，程序执行的时候静态方法可以调用静态方法。

没加static的是动态方法，必须要创建对象才能调用方法。

一个类被final修饰过之后就不能被继承。

5.9 抽象类 abstract

//abstract 抽象类
public abstract class Action {
    //abstract 抽象类里的抽象方法 只有方法名字 没有具体方法实现
    public abstract void doSomething();

    //new Action();
    /*
    1.不能new抽象类 只能靠子类去实现它（约束）
    2.抽象类中可以写普通方法
    3.抽象方法必须卸载抽象类中
    抽象 ~ 有人帮我们实现
     */
}

//继承了抽象类的子类 必须实现抽象类里的方法 除非继承的类也是抽象类 （下面注释是idea报错自己加的）
public class A extends Action {
    @Override
    public void doSomething() {
    }
}

5.10 接口

 

接口作用
1.是一种约束，定义一些方法,方法类型public abstract，让不同的人实现
2.常量用public static final int AGE = 10; 定义
3.接口不能被实例化，因为接口中没有构造方法
4.implements 可以实现多个接口
5.实现接口必须要重写里面的方法

public interface UserService {
    //接口中的所有定义都是抽象发的 看不到的  public abstract
    //接口中能定义方法 但是不实现 有单独的实现类 同名impl文件用来实现接口中的方法
    public abstract void run();  //public abstract是灰色

    //常量 一般不这么用
    //public static final int AGE = 10;

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

//抽象类：通过extends继承单个
//实现类 可以时间接口 implements 接口
//alt 鼠标放到红线 出红灯泡 点进去自动实现方法
//接口类 用interface来定义方法  实现类Impl用来实现接口中定义的方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void run() {
    }
    @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() {
    }
}

5.11 内部类

 

 

 

 

匿名内部类

 

 六 异常机制

6.1 Error Exception

分类

 

 

 

 

6.2 捕获和抛出异常

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
    try{ //try监控区域
        System.out.println(a/b);
    } catch (Error e){  //catch 想要捕获的异常类型
        System.out.println("Error");
    }catch (Exception e){
        System.out.println("Exception");
    }catch (Throwable t){
        System.out.println("Throwable");
    }finally { //处理善后工作 最后一定会执行 可以不要
        System.out.println("finally");
    }
     
    }
}

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

        //ctrl + alt + T 自动嵌入

        try {
            if(b==0){
                throw new ArithmeticException();//主动抛出异常，一般在方法中使用
            }
            System.out.println(a/b);   //ctrl + alt + T 自动嵌入
        } catch (Exception e) {
            System.exit(1);
            e.printStackTrace();//打印错误的栈信息
            throw new RuntimeException(e);
        } finally {
        }

    }
}

 

 6.3 自定义异常

 

 

//自定义的异常类
public class MyException extends Exception{
    //传递数字 》10 抛出异常
    private int detail;

    public MyException(int a){
        this.detail = a;
    }

    //toString  打印异常信息 alt+insert
    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

public class Test {
    //可能会存在异常的方法
    static void test(int a) throws MyException {

        System.out.println("传递的参数为" + a);

        if (a>10){
            throw new MyException(a); //抛出
        }
        System.out.println("ok");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException>>" + e);  //消息
        }
    }
}