抽象类，接口，内部类，异常

5.抽象类和接口

public class Action {
}

只要在前面加个 abstract 就变成了抽象类了

public abstract class Action {
    
}

 

package com.oop.Demo09;
    //abstract 抽象类， extends 单继承 但是 接口可以多继承
public abstract class Action {
    //约束，有人帮我们实现
    //abstract 用在方法上就是抽象方法，只有方法名，没有方法的实现
    public abstract void doSomething();
}
/*
1.抽象类不能new，只能靠子类实现 ：约束
2.抽象类里面可以写普通方法，
3.抽象方法必须在抽象类中
抽象的抽象： 约束
​
思考题
存在意义 就是 提高开发效率，后期可扩展性
 */

 

package com.oop.Demo09;
    //抽象类的所有方法，继承了它的子类。都必须要实现他的方法，除非子类也是抽象依次
public  class A extends Action{
    //重写
    @Override
    public void doSomething() {
​
    }

接口

接口只有规范 专业的约束！约数和实现分离，面向接口编程

接口的本质是契约，大家遵守

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

实现类命名：public class UserServiceImpl implements UserService , Timer. . . 多个类(多个接口).. .{

User业务

package com.oop.Demo10;
//接口定义 interface    接口都需另建实现类 以Impl结尾
public interface UserService {
    // 属性定义默认都是静态常量（public static final） 但不太在接口中定义
     int AGE =20;
    //接口中的所有定义都是抽象的 public abstract默认可以省略
    //且接口中只有定义，需另建实现类
    void run(String name);//可以定义参数
    void age(int S1);
    void grade(char A);
}

Time业务

package com.oop.Demo10;
​
public interface Timer {
    void time();
}

用户实施

package com.oop.Demo10;
// 一个类可以实现接口 implements，然后重写里面的方法
//抽象类中 extends 只能单继承，接口可以多继承
public class UserServiceImpl implements UserService, Timer {
​
    @Override
    public void run(String name) {
​
    }
​
    @Override                                       /*方法重写
    public void age(int S1) {
​
    }
​
    @Override
    public void grade(char A) {
​
    }
​
    @Override
    public void time() {
​
    }
}

接口作用

1.约束，

2.定义一些方法可以是不同的人使用 多个用户

3.方法都是 public ststic 常量都是 public static final

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

5.通过implements 实现多个接口 implements UserService, Timer...... 但必须重写方法

UserService接口

package com.oop.Demo10;
//接口定义 interface    接口都需另建实现类 以Impl结尾
public interface UserService {
    // 属性定义默认都是静态常量（public static final）
    // 但不太在接口中定义
     int AGE =20;
    //接口中的所有定义都是抽象的 public abstract默认可以省略
    //且接口中只有定义，需另建实现类
    void run(String name);//可以定义参数
    void age(int S1);
    void grade(char A);
}

Timer接口

package com.oop.Demo10;
​
public interface Timer {
    void time();
}

实现类 UserServiceImpl

 

package com.oop.Demo10;
//抽象类中 extends 只能单继承，接口可以多继承
// implements可以实现多接口 然后重写里面的方法
public class UserServiceImpl implements UserService, Timer {
​
    @Override
    public void run(String name) {
​
    }
​
    @Override
    public void age(int S1) {
​
    }
​
    @Override
    public void grade(char A) {
​
    }
​
    @Override
    public void time() {
​
    }
}

6.内部类

匿名内部类： new 类名( ) . 方法 不需要实例化

 

package com.oop.InterDemo11;
​
​
    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("可以获得外部类的私有属性以及方法");
         }
     }
     public static class JingTai{
            //静态内部类（先加载静态，其他都没出生）就不能得到外部类的的属性方法了
​
​
        }
​
}

异常

1.Exception 意外 避免异常

2.Error 虚拟机异常，AWT GUI图形界面异常 JVM错误{ 1.StackOverFlow栈溢出 2.OutOfMemory 内存溢出}

异常处理5个关键字

try，catch，finally，throw，throws

异常的

package com.Exception;
​
public class Demo01 {
    public static void main(String[] args) {
         int a =1;
         int b = 0;
        // 在认为可能出现异常的语句Ctrl+Alt +T 捕获异常
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印错误的栈信息
        } finally {
        }
//____________________________________________________________________
        //假设要捕获多个异常需要多个catch从小到大！
        try{        //监控区域
        System.out.println(a/b);
        // new Demoo1().math(); 也可以调用方法
        }catch (ArithmeticException x){    // catch(想要捕获的异常类型！)
            System.out.println("Exception");
        }catch(Error d){
            System.out.println("Error");
        }catch(Throwable d){
            System.out.println("Throwable");
​
        }finally { //做处理善后工作都运行
            System.out.println("系统出现问题");
        }// finally可以不要  但是以后的 IO 资源用完 关闭使用
    }
​
    public void a(){ b();}
    public void b(){ a();}
}

throw 主动抛出异常 一般在方法中使用

public class Demo01 {
    public static void main(String[] args) {
        new Demo01().text(1,0);
    }
    public void text(int a ,int b){
        if (b==0){
            throw new ArithmeticException();
        }
    }

throws 方法中处理不了，在方法上抛出异常

public class Demo01 {
    public static void main(String[] args) {
        try {
            new Demo01().text(1,0);
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
        }
    }                                    //假设方法中处理不了这个异常 方法主动抛出异常           
    public void text(int a ,int b) throws ArithmeticException{
        if (b==0){
            throw new ArithmeticException();
        }
    }

使用 try catch 捕获异常可以是程序不停止运行

自定义异常

1. 创建自定义异常类

2. 在方法中通过throw关键字抛出异常

3. 如果当前抛出异常的的方法中处理异常，可以使用try-catch语句捕获并处理，

   否则在方法中的声明通过throws是关键字指明要抛出刚给方法调用者的异常

4. 在出现异常方法的调用中捕获并处理异常

5.