多态 异常 接口

异常

异常：代码在运行是出现的错误
异常的问题：程序会终止运行。（如果代码出现了异常，那么后面的代码就不会再执行了）

异常的分类:

1、 编译时异常： 代码还没运行，就出现了问题

SQLException：操作数据库时查询表可能发生的异常
     * IOException：操作文件时发生的异常
     * FileNotFoundException：操作不存在文件是发生的异常
     * ClassNotFoundException：加载类而类不存在时发生的异常
     * EOFException：操作文件到文件末尾发生异常
     * IllegalArguementException: 参数异常
     * 2、 运行时异常：代码在正常的运行过程中出现的问题
     * NullPointerException:参数异常
     * ArithmeticException: 数学运算异常，当出现异常的运算条件时抛出此异常
     * ArrayIndexOutOfBoundsException:数组下标越界异常，用非法索引访问你数组时抛出的异常
     * ClassCastException: 类型转换异常，当试图将对象强制转换为不是实例的子类时抛出该异常
     * NumberFormatException:数字格式不正确异常，当应用程序试图将字符串转换为一种数值类型，但该字符传不能转换为适当格式时抛出该异常

常规异常处理方式

     * try...catch...finally
     * try 捕获异常
     * catch 处理异常
     * finally  不管有没有异常都会执行，一般用来释放资源
     * throws/throw 关键字
     * throw 生成一个异常
     * throws 抛出一个异常，谁调用我，我就抛给谁，异常最终抛给了JVM

异常示例代码

public static void main(String[] args) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            System.out.println("透你妈没事了");
        }

        int i = new Scanner(System.in).nextInt();
        if (i > 10) {
            throw new RuntimeException("i不能大于10");
        }
    }

    public void a() throws InterruptedException{
        Thread.sleep(5000);

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

接口

interface 主要是用来定义规范

	 * 1、 接口中的方法都是抽象方法，经常省略public abstract
     * 2、 和类一样，也是一种引用数据类型
     * 3、 接口中的成员变量都是常量。public static final 可以省略不写（这个以后在开发中用的不多）
     * 4、 接口是用来被实现的，而且一个类可以实现多个接口。 implements（类和接口的关系）

接口和类的关系：

 	 * 1、 接口不能有构造方法。所以也不能实例化对象。
     * 2、 接口里面不能有普通方法，只能有抽象方法。
     * 3、 接口是不能被类继承的（但是能被接口继承）， 但是可以被类实现。


     * 注意：java是单继承的吗？
     *      java中类和类之间是单继承的，但是接口和接口之间是多继承的。
     * 接口和抽象类的区别：
     *      1、抽象类可以有构造方法，普通成员变量，静态成员变量，静态普通法，抽象法。

示例代码

接口页

public interface Alarm {
    void alarm();
}

父类

public abstract class Door {

    public void open(){
        System.out.println("开门");
    }
    public void close(){
        System.out.println("关门");
    }
    public abstract void lock();
}

实体类

public class GlassDoor extends Door{
    @Override
    public void lock() {
        System.out.println("拿钥匙锁起来");
    }
}

子类

public class IronDoor extends Door implements Alarm{
    @Override
    public void alarm() {
        System.out.println("用铁锁锁起来");
    }

    @Override
    public void lock() {
        System.out.println("有人来了，报警");
    }
}

main方法页

public static void main(String[] args) {
        GlassDoor glassDoor = new GlassDoor();
        glassDoor.open();
        glassDoor.lock();
        glassDoor.close();

        IronDoor ironDoor = new IronDoor();
        ironDoor.open();
        ironDoor.close();
        ironDoor.lock();
        ironDoor.alarm();
    }

多态

同一个对象，在不同时刻表现出来的不同形态

多态存在的三个必要条件：

1、要有继承或者是西安关系
2、要有方法重写
3、要有父类引用指向子类对象 引用就是变量，子类对象就是值 （向上转型）

多态注意事项：

1、 子类重写了父类的方法以后，执行的是自己的方法。
2、 子类没有，父类有的方法，子类可以通过继承直接使用
3、 子类有，父类没有，调用的时候直接报错。（报错解决办法：向下转型）

向上转型：

子类往上，变成父类类型。
父类

public  class  ElectricAppliance {
    public void quantity() {
        System.out.println("使用电量");
    }
    public void life(){
        System.out.println("寿命");
    }

}

子类继承

public class Computer extends ElectricAppliance{
    public void quantity(){
        System.out.println("电脑使用电量10V");
    }
    public void life(){
        System.out.println("电脑的寿命5年");
    }
}

子类继承

public class WashingMachine extends ElectricAppliance{
    public void quantity(){
        System.out.println("洗衣机使用电量4V");
    }
    public void life(){
        System.out.println("洗衣机的寿命10年");
    }
}

向上展示

  public static void main(String[] args) {
        ElectricAppliance computer = new Computer();
        ElectricAppliance washingMachine = new WashingMachine();
        computer.quantity();
        washingMachine.quantity();
        System.out.println("向上展示");

向下展示

 Computer computer1 = (Computer) computer;
        computer1.life();
        WashingMachine washingMachine1 = (WashingMachine) washingMachine;
        washingMachine1.life();
        System.out.println("向下展示");
        Manage manage = new Manage();
        manage.query(computer);
        manage.query(washingMachine);

向下转型：

父类往下，变成子类类型。

1 强制类转换，可能会出现类型转换异常
2 向下转型之前，必须向上转型
3 为了避免类型转换异常，可以使用instanceof关键字进行判断

多态使用例

instanceof   对象  instanceof  类型  判断对象是否是这个类型

形参和实参：

形参：方法声明时，方法小括号里的参数
实参：方法调用时，方法小括号里的参数

示例代码

父类

public class Animal {

    public void bark(){
        System.out.println("动物叫");
    }
    public void eat(){
        System.out.println("动物吃东西");
    }
}

子类继承

public class Cat extends Animal{
    public void bark(){
        System.out.println("喵喵喵");
    }
}

子类继承

public class Dog extends Animal{
    @Override
    public void bark() {
        System.out.println("汪汪汪");
    }
    public void bite(){
        System.out.println("狗咬人");
    }
}

main方法

 public static void main(String[] args) {
  Master master = new Master();
        Cat cat = new Cat();
        Dog dog = new Dog();
        master.feed(cat);
        master.feed(dog);


        Horse horse = new Horse();
        master.feed(horse);

    }
}