Java第十天：多态 异常处理

多态 异常处理

1. 多态【重点】

父类的引用指向子类的对象，或者接口的引用指向遵从接口的类对象，这就是多态

最主要的作用就是拓宽方法的参数范围！！！
拓宽方法的返回值范围！！！

package com.qfedu.a;

class Animal {}

class Dog extends Animal {}

class Cat extends Animal {}

class Tiger extends Animal {}

/*
Animal 是目前代码中的一个基类
Dog， Cat， Tiger都是Animal的子类
同时我们可以认为 Dog, Cat, Tiger都是动物
 */
public class Demo1 {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Cat cat = new Cat();
        Tiger tiger = new Tiger();

        giveMeAnimal(animal);
        giveMeAnimal(dog);
        giveMeAnimal(cat);
        giveMeAnimal(tiger);
        System.out.println();

        // Animal类的引用去保存其他Animal类或者Animal对应的子类对象
        Animal animal1 = returnAnimal();
        System.out.println("返回" + animal1.getClass());
    }

    /**
     * 这里是需要一个动物类对象的方法
     *
     * @param animal 需要的是Animal类对象
     */
    public static void giveMeAnimal(Animal animal) {
        System.out.println("获取" + animal.getClass());
    }

    /**
     * 返回一个动物类对象
     *
     * @return 返回的是一个Animal类对象，动物类对象
     */
    public static Animal returnAnimal() {
        return new Tiger();
    }
}

package com.qfedu.a;

/**
 * USB接口，要求所有的USB设备完成connect方法
 */
interface USB {
    void connect();
}

/**
 * 键盘是USB设备，需要遵从USB接口，完成USB接口规定的方法
 */
class Keyboard implements USB {

    @Override
    public void connect() {
        System.out.println("键盘噼里啪啦写代码~~~");
    }
}

/**
 * HHKB是键盘类的子类，同时也可以认为是USB设备
 */
class HHKB extends Keyboard {
    @Override
    public void connect() {
        System.out.println("HHKB 让程序员快乐的键盘~~~");
    }
}

/**
 * 鼠标是USB设备，需要遵从USB接口，完成USB接口规定的方法
 */
class Mouse implements USB {

    @Override
    public void connect() {
        System.out.println("鼠标点点点~~~");
    }
}

/**
 * Logi类是鼠标类的子类，同时也是USB设备
 */
class Logi extends Mouse {
    @Override
    public void connect() {
        System.out.println("Logi MX Master 2S");
    }
}

/**
 * 电脑类，不是USB设备，但是可以使用USB接口
 */
class PC {
    /**
     * 电脑类使用USB接口的方法，这里需要的参数是USB接口
     * @param usb USB接口
     */
    public void useUSBInterface(USB usb) {
        // USB接口的方法，是规定USB设备需要完成的方法。
        usb.connect();
    }
}

public class Demo2 {
    public static void main(String[] args) {
        PC pc = new PC();

        Keyboard keyboard = new Keyboard();
        Mouse mouse = new Mouse();

        // 电脑使用USB接口，传入USB设备键盘
        pc.useUSBInterface(keyboard);

        // 电脑使用USB接口，传入USB设备鼠标
        pc.useUSBInterface(mouse);

        // 传入一个HHKB的匿名对象，同时也是USB设备
        pc.useUSBInterface(new HHKB());

        // 传入一个Logi的匿名对象，同时也是USB设备
        pc.useUSBInterface(new Logi());
    }
}

2. 异常处理

2.1 生活中的异常

生病了~~~
医生： 你怎么了
我: 我难受
医生：你那里南里
我: 我头疼
医生：为什么头疼。吃什么东西了，多长时间了
我: 昨天完成喝了两斤江小白，4升果粒橙，10杯扎啤
医生小声嘀咕: 该

错误，异常都是有前因后果的！！！

Debug而生
写bug

3000+BUG ~ 20BUG

2.2 Throwable类

Throwable Java中所有异常和错误的基类
--| Exception 异常 可以处理的
--| Error 错误 GG思密达

需要学习的方法：
	构造方法：
		Throwable();
			创建一个Throwable类对象，Throwable类对象内错误或者异常信息为
			null
		Throwable(String message);
			创建一个Throwable类对象，并且使用message作为错误或者异常信息
	成员方法：
		String toString(); 
			当前异常或者错误的简要信息描述
		String getMessage();
			获取当前异常或者错误信息
		void printStackTrice();
			展示错误或者异常的前因后果

package com.qfedu.b_throwable;

public class Demo1 {
    public static void main(String[] args) {
        Throwable throwable = new Throwable("因为穷，所以异常");

        System.out.println(throwable.getMessage());
        System.out.println(throwable.toString());
        throwable.printStackTrace();

        System.out.println();

        test();
    }

    public static void test() {
        new Throwable("前因后果").printStackTrace();
    }
}

2.3 Exception 和 Error

Exception 异常 处理异常
Error 错误 无法处理！！！只能避免错误！！！

/*
java.lang.OutOfMemoryError
    内存溢出错误！！！
 */
// long[] array = new long[1024 * 1024 * 1024];
/*
java.lang.NullPointerException
    空指针异常！！！
 */
int[] array = null;
array[10] = 10;

2.4 如何处理异常

2.4.1 捕获异常

使用的结构
    	try {
            // 有可能出现异常的代码
        } catch (/* 对应的异常类型 */) {
            // 对应当前异常类型处理方式，目前只能打印printStackTrace
        }

package com.qfedu.b_throwable;

/*
try catch使用注意事项:
    1. 代码中出现异常，从异常位置开始，代码会终止运行
    2. 使用try catch捕获异常之后，JVM认为当前代码中不存在任何异常，可以继续运行
    3. 在try 代码块中如果发现代码的异常类型有多种情况，这里需要在添加对应当前异常
    的catch块
    4. 在try代码块中，有且只会发生一种异常，从异常位置开始，代码不会继续运行，进入
    catch块处理
    5. catch块使用Exception是允许的，但是是用于最终的处理方案，防止有异常被漏掉。
    不能作为所有异常的处理方式！！！异常处理，做到对症下药！！！
 */
public class Demo3 {
    public static void main(String[] args) {
        test(1, 1, null);
    }

    public static void test(int num1, int num2, int[] arr) {
        // 这个代码有可能存在异常，这里采用捕获操作
        int ret = 0;

        try {
            ret = num1 / num2;
            arr[0] = 10;
        } catch (Exception e) {
            System.out.println("所有的异常他爹");
            e.printStackTrace();
        }

        System.out.println("ret : " + ret);
    }
}
// Alt + Enter

2.4.2 抛出异常

高级版参数合法性判断。
如果方法运行前，发现参数是不符合要求的，这里终止方法运行，并且给予用户错误提示。

throw
	在方法中指定条件下抛出对应的异常。
throws
	在方法的声明位置告知调用者，当前方法有哪些异常抛出。

package com.qfedu.b_throwable;

/*
抛出异常注意事项:
    1. 代码中只要指定了throw 抛出异常，从抛出异常位置开始，代码就不在执行，之后的代码
    都是无效代码
    2. 如果代码中存在多个异常需要抛出，需要对症下药针对不同的情况抛出
    3. 一个方法抛出多个异常，可以在方法声明位置throws之后使用逗号隔开
    4. 调用一个带有异常抛出的方法，需要在调用方法位置对于当前抛出的异常进行处理
    可以选择抛出，可以选择捕获！！！

    在开发过程中你可以选择抛出，可以选捕获，但是到了用户层面记得一定是捕获！！！
 */
public class Demo4 {
    public static void main(String[] args) throws ArithmeticException, NullPointerException {
        try {
            test(1, 0, null);
        } catch (ArithmeticException e) {
            // 捕获算术异常，展示效果
            System.out.println("算术异常");
        } catch (NullPointerException e) {
            System.out.println("数组异常");
        }

        System.out.println();

        test(1, 0, null);
    }

    /**
     * @param num1
     * @param num2
     * @throws ArithmeticException 告知调用者这里存在一个算术异常抛出
     * @throws NullPointerException 数组空指针异常
     */
    public static void test(int num1, int num2, int[] array)
            throws ArithmeticException, NullPointerException {
        /* 参数合法性判断
        if (0 == num2 || null == array || array.length == 0) {
            System.out.println("Input Parameter is invalid!");
            return;
        }*/

        if (0 == num2) {
            // 当前方法中参数不合法，抛出一个算术异常
            throw new ArithmeticException("算术异常 / by zero");
        }

        if (null == array || array.length == 0) {
            throw new NullPointerException("数组异常");
        }

        int ret = num1 / num2;
    }
}

2.5 自定义异常

Java中异常类型非常的多，但是也不能满足我们生活
例如：
	没有对象异常
	穷异常
	没有流量异常

格式:
	class 自定义异常类名 extends Exception {
		一般情况下完成一个无参数构造方法和一个String类型参数的构造方法
		以及你现在不会写的一些针对与当前异常的处理方式方法，
	}

希望大家关注我一波,防止以后迷路,有需要的可以加我Q讨论互相学习java ,学习路线探讨,经验分享与java Q:2415773436