多态
--1、概念
同一对象，在不同时刻具有不同的形态。它是面向对象程序设计（OOP）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
--2、特点
--前提： 发生继承关系 + 方法重写
--口诀1：父类引用指向子类对象
--Animal a = new Dog();
--口诀2：多态中，编译看左边，运行看右边
--编译看左边：想要保存成功，使用父类提供的功能
--运行看右边：想要结果，找子类
案例：
package cn.tedu.multi;
//这类用来 测试 多态
public class Test2_Multi {
public static void main(String[] args) {
//创建子类对象测试
Dog d = new Dog();
d.eat(); //狗吃肉
//创建多态对象测试
Animal a = new Dog() ; //口诀1：父类引用 指向 子类对象，多态 / 向上转型
a.eat() ; // 口诀2：编译看左边，运行看右边
//2、编译看左边：意思是 想要保存成功 必须 使用 左边也就是父类 提供的功能！！！
//3、运行看右边： 意思是 最终的执行结果 以子类的 实现为准！！
//4、多态的好处：是用来统一调用的标准！！！标准就是父类！！！！如果父类没提供就不能用！！
}
}
//1、多态前提：继承 + 重写
class Animal{
public void eat() {
System.out.println("吃啥都行") ;
}
}
class Dog extends Animal{
//方法重写
public void eat() {
System.out.println("狗吃肉");
}
}
--3、好处
--1、好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。
--2、统一调用标准，一切向父类看齐。
--3、提高了程序的扩展性和可维护性。
--4、多态的使用
1、成员变量：由于不存在重写，所以直接使用父类的
2、成员方法：由于存在重写，所以调用了父类的 方法声明 ，使用了 子类的 方法体
3、静态资源：由于不存在重写，所以直接使用父类的 方法声明 和方法体
案例：
package cn.tedu.multi;
//这类用来测试 多态的使用
//1、成员变量：由于不存在重写，所以直接使用父类的
//2、成员方法：由于存在重写，所以调用了父类的 方法声明 ，使用了 子类的 方法体
//3、静态资源：由于不存在重写，所以直接使用父类的 方法声明 和方法体
public class Test3_Multi {
public static void main(String[] args) {
// 创建多态对象测试
Fu f= new Zi() ; //父类引用 指向 子类对象
//3、编译看左边，只要想用的功能，必须是父类提供的。
//运行看右边，多指发生了方法重写后，使用右边的也就是子类的方法体。
//1、成语方法的使用，一定是使用父类的(方法声明)，但是，方法体，由于可以重写，所以用子类的方法体。
f.study(); //我爱java，
//2、成员变量的使用，一定是使用父类的，由于不存在重写，所以执行的也是父类的。
System.out.println( f.name ); // jack，
//3、静态方法，可以存在重写吗？ -- 不可以！！！
f.play(); //由于静态资源根本不存在重写，所以直接执行父类的方法声明和方法体。即使子类有一个和父类一模一样的方法也不是重写！！！
}
}
class Fu{
String name = "jack" ;
public void study() {
System.out.println("爸爸正在学习");
}
static public void play() {
System.out.println("爸爸正在玩儿");
}
}
class Zi extends Fu{
String name = "xiongda" ;
//方法重写
public void study() {
System.out.println("我爱java");
}
static public void play() {//这个是子类特有的，不是重写！
System.out.println("儿子正在玩儿");
}
}
异常
概述
用来封装错误信息的对象。
组成结构：类型，提示，行号。
异常的继承结构
Throwable - 顶级父类
-- Error：系统错误，无法修复
-- Exception：可修复的错误
--RunTimeException
--ClassCastException
--ClassNotFoundException
异常处理
两种方式：
捕获异常并处理
直接向上抛出
package cn.tedu.exception;
import java.util.InputMismatchException;
import java.util.Scanner;
//这个类用来测试 异常
public class Test4_Exception {
public static void main(String[] args) {
// method() ; //暴露异常：这个过程，咱们自己测试就可以了，千万不要让用户看见！！
// method2() ; // 异常处理：捕获
try {
method3() ; // 异常处理：抛出
} catch (Exception e) {//多态，把子类当父类来看，写出通用代码
// e.printStackTrace();
System.out.println("输入有误！！");
}
}
//2、抛出：在方法声明上添加， throws 异常类型1,异常类型2,异常类型3
// public static void method3() throws ArithmeticException,InputMismatchException{
public static void method3() throws Exception{//多态，把子类当父类来看，写出通用代码
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a / b);
}
//1、捕获异常： try{ ...... }catch(异常类型 变量名){ 合理的解决方案 }
public static void method2() {
try {
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
System.out.println(a / b);
}catch(ArithmeticException a) {//异常类型1
System.out.println("第二次输入不能为0！");//合理的解决方案1
}catch(InputMismatchException b){//异常类型2
System.out.println("请输入两次整数！");//合理的解决方案2
}catch(Exception a) {
//2、参数Exception就是多态，不关心具体的子类类型是谁，会把所有子类当父类来看，写出通用代码
System.out.println("请输入正确数据！");
}
}
//0、暴露异常
public static void method() {
// 1、接收用户输入的两个整数
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
// 2、做除法运算
System.out.println(a / b);
}
}