Day04

抽象类

package com.oop.demo08;
//abstract  抽象类:  类  extends： 单继承   （接口可多继承）
public abstract class Action {
    //约束~有人帮我们实现
    //abstract  抽象方法   只有方法名字，没有方法实现
    public abstract void doSomething();
    //1.不能new这个抽象类，只能靠子类去实现他，约束~！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    public void ride(){
        System.out.println("ride");
    }

    //抽象类的存在   提高了代码开发效率
}

package com.oop;

public class Application {
//        new Action();//这里不能new一个抽象类 abstract



}

package com.oop.demo08;

public class A extends Action{

    @Override//这里必须重写父类的方法才能使用
    public void doSomething() {

    }

}

接口

普通类： 只有具体实现

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

接口：只有规范！

接口就是规范，定义的是一组规则，体现了现实世界中的的“如果你是……则必须能……”的思想。如果你是天使，则必须能飞 如果你是汽车则必须能跑 如果你是好人 则必须干掉好人 如果你是坏人 则必须欺负好人

接口的本质是契约，就像人间的法律一样，制定好之后大家必须遵守

OO的精髓，是对对象的抽象，最能体现这点的就是接口。 为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如 c++、Java c#等）就是因为设计模式研究的，实际上就是如何合理的去抽象

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

package com.oop.demo09;
//interface 定义的关键字 接口都系要实现类
public interface UserService {
    int age=99;//定义常量   public static final
//接口中的所有定义方法都是抽象类   public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

package com.oop.demo09;

public interface TimeService {
    void time();

}

package com.oop.demo09;
//抽象类：extends
//类可以实现接口 用到 implements接口    接口可实现多继承
//实现了接口的类，就必须重写接口的方法
public class UserServiceImpl implements UserService,TimeService {
    @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 time() {

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GjdNpUBN-1613780522242)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210201140752840.png)]

作用

1. 约束

2. 定义一些方法让不同的人实现

3. public static final
   

4. public abstract
   

5. 接口不能被实例化，接口中没有构造方法

6. implement可以实现多个接口

7. 必须重写接口中的方法

一个java文件中可以有多个class类，但只能有一个 public class A{

}

异常 Exception

异常处理框架

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tQIP9s2O-1613780522244)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210201144552331.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uoxS13ne-1613780522247)(C:\Users\lcj\AppData\Roaming\Typora\typora-user-images\image-20210201144936668.png)]

package com.exception;

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


        int a=1;
        int b=0;


        try {
            try {//这是一个监控区域，

                new Test().a();
                System.out.println(a/b);//  ctrl+alt +t
            }catch (Error c){//catch(想要捕获的异常类型)捕获异常
                System.out.println("Error");

            }catch (Exception c){
                System.out.println("Exception");
            }catch (Throwable c){
                System.out.println("Throwable");
            }
            finally {   //用于善后工作，  个人理解：类似不管程序是否异常，运行结束时关闭资源的的总用把  可以不用finally
                System.out.println("这句话始终要输出");
            }
        } catch (Exception e) {
            e.printStackTrace();//打印栈信息
        } finally {
        }

    }
    public void a(){
        b();
    }
    public void b(){
        a();    }
}

package com.exception;

public class Test2 {
    double a;
    double b;

    public static void main(String[] args) {
        try {
            new Test2().test(1,0);
        } finally {

        }

    }

    //假设这个方法中处理不了这个异常， 方法上抛出异常
    public double test(double a,double b) throws ArithmeticException{
        if (b==0){//throw  throws
            throw new ArithmeticException();//主动抛出异常  一般在方法中使用
        }
        System.out.println(a/b);
        return 0;
    }

}

笔试刷题 leetcode