JAVA面向对象 多态 异常 异常解决方案

1 多态

1.1概念

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

可以把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

比如，你的女盆友让你买点水果回来，不管买回来的是苹果还是西瓜，只要是水果就行，这个就是生活中多态的体现

再比如，小猫、小狗、小猪我们可以把他们都归纳成小动物，但是每种小动物爱吃的东西不一样，具体的小动物有具体的食物，如下代码所示：

class Animal{//1.定义父类Animal
	....eat(){syso("吃啥都行")}
}
class Cat extends Animal{//2.1定义子类Cat
	....eat(){syso("吃小鱼干")}
}
class Dog extends Animal{//2.2定义子类Dog
	....eat(){syso("吃肉骨头")}
}
class Pig extends Animal{//2.3定义子类Pig
	....eat(){syso("吃菜叶子")}
}
main(){
	//3.创建子类对象
	Cat c = new Cat();//小猫是小猫
	Dog d = new Dog();//小狗是小狗
	Pig p = new Pig();//小猪是小猪
	//4.创建多态对象(父类引用指向子类对象/编译看左边,运行看右边)
	Animal a1 = new Cat();//小猫是小动物
	Animal a2 = new Dog();//小狗是小动物
	Animal a3 = new Pig();//小猪是小动物
}

1.2 特点

1. 多态的前提1：是继承
2. 多态的前提2：要有方法的重写
3. 父类引用指向子类对象,如：Animal a = new Cat();
4. 多态中，编译看左边，运行看右边
   

1.3 多态的好处

1. 多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法
2. 提高了程序的可扩展性和可维护性

1.4 多态的使用

1. 成员变量: 使用的是父类的
2. 成员方法: 由于存在重写现象,所以使用的是子类的
3. 静态成员: 随着类的加载而加载,谁调用就返回谁的

1.5 练习：多态成员使用测试

/**本类用于多态中的元素测试*/
public class TestDemo2 {
	public static void main(String[] args) {
		//7.创建子类对象进行测试
		Dog2 d = new Dog2();
		System.out.println(d.sum);//20
		d.eat();//小狗要吃肉骨头
		d.play();//小狗爱打滚儿~~~
		
		//10.创建多态对象进行测试
		/**口诀1:父类引用指向子类对象*/
		/**口诀2:编译(保存)看左边,运行(测试)看右边*/
		Animal2 a = new Dog2();
		/**2.多态中,成员变量使用的都是父类的*/
		System.out.println(a.sum);//10
		/**3.多态中,成员方法使用的是父类的声明,子类的实现*/
		a.eat();
		/**4.多态中,如果父子类都有静态方法,使用的是父类的*/
		a.play();//玩啥都行
	}
}

//1.创建父类
class Animal2{
	//2.创建成员变量
	int sum = 10;
	//3.创建成员方法
	public void eat() {
		System.out.println("吃啥都行");
	}
	//8.父类中定义静态方法play()
	public static void play() {
		System.out.println("玩啥都行");
	}
}
/**1.多态的前提:继承+重写*/
//4.定义子类Dog2
class Dog2 extends Animal2{
	//5.定义子类的成员变量
	int sum = 20;
	//6.重写父类的eat()
	/**@Override 这个注解加在方法上,表示这是一个重写的方法*/
	@Override //注解--标签
	public void eat() {
		System.out.println("小狗要吃肉骨头");
	}
	
	//9.定义子类的静态方法play()
	//@Override --不是重写,不能加这个注解
	public static void play() {
		System.out.println("小狗爱打滚儿~~~");
	}
}
	/**注意!!!静态资源属于类,不存在重写现象,只是两个类中有同样声明的方法而已,不属于重写*/

1.6 拓展

1.6.1 静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

1.6.2 向上转型和向下转型

在JAVA中，继承是一个重要的特征，通过extends关键字，子类可以复用父类的功能，如果父类不能满足当前子类的需求，则子类可以重写父类中的方法来加以扩展。
在应用中就存在着两种转型方式，分别是：向上转型和向下转型。
比如：父类Parent,子类Child
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
//其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。

2 异常

2.1 概述

异常是一些用来封装错误信息的对象
它由异常的类型、提示信息、报错的行号提示三部分组成

2.2 异常的继承机构

2.3 异常的处理方式

当程序中遇到了异常,通常有两种处理方式:捕获或者向上抛出
当一个方法抛出异常,调用位置可以不做处理继续向上抛出,也可以捕获处理异常
大家可以结合生活中的例子:如果工作中遇到了问题,我们可以选择自己处理(捕获),或者交给上级处理(抛出)
捕获方式：

抛出方式：
对于不想现在处理或者处理不了的异常可以选择向上抛出
方式：在方法上设置异常的抛出管道，即：
在可能会会发生异常的方法上添加代码：
throws 异常类型
例如：void method1 throws Exception1,Exception2,Exception3{ }
TIPS:方法上有默认的异常管道：RuntimeException

2.4 拓展

程序错误分为三种：
编译错误(checked异常)；
运行时错误（unchecked异常）；
逻辑错误；

1. 编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是大家在刚接触编程语言最常遇到的问题。
2. 运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。
3. 逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

其实我们还可以手动针对逻辑错误执行异常的抛出动作，大家可以理解成方法return,只不过此处我们返回的是异常，格式：
if(逻辑错误有异常){
AException e = new AException(“提示消息”);
throw e;
}

import java.util.Scanner;

public class TestThrow {
    public static void main(String[] args) {
        method4();
    }

    public static void method4(){
        //1.复写刚刚可能会发生异常的代码
        System.out.println("请输入您要计算的第一个数据:");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入您要计算的第二个数据:");
        int b = new Scanner(System.in).nextInt();
        try{
            double result = divide(a,b);
            System.out.println(result);
            //System.out.println(a/b);
        }catch (ArithmeticException e){
            System.out.println("不能除0是我们的错，请鞭笞我们吧！");
        }
    }

    private static double divide(int a,int b) {
        if(b == 0){
            ArithmeticException e = new ArithmeticException("/ by zero");
            throw e;//类似于return e;
        }
        return a/b;
    }

}

throws 与 throw 的区别
throws
用在方法声明处，其后跟着的是异常类的名字
表示此方法会抛出异常，需要由本方法的调用者来处理这些异常
但是注意：这只是一种可能性，异常不一定会发生

throw
用在方法的内部，其后跟着的是异常对象的名字
表示此处抛出异常，由方法体内的语句处理
注意：执行throw一定抛出了某种异常