Java（day09）多态、异常、抽象类

多态

概念：多态是指的是面向对象的多种形态

多态的前提：继承+重写

父类引用指向子类对象，及创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存

编译看左边，运行看右边

子类重写方法，才能执行多态

package cn.tedu.oop3;
/*多态的入门案例*/
public class TestDemo {
    public static void main(String[] args) {

        Animal a2=new Cat();
        Animal a3=new Dog();
        a2.eat();
        a3.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("小动物Animal吃啥都行");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("🐱爱吃🐟");

    }
    public void jump(){
        System.out.println("🐱跳的快");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("🐕爱吃🥩");
    }
    public void run(){
        System.out.println("🐕跑的快");
    }
}
执行结果：
🐱爱吃🐟
🐕爱吃🥩

注意：多态主要针对方法，所以多态中，成员变量使用的是父类，方法使用的是子类

package cn.tedu.oop;

import javax.sound.midi.Soundbank;

//本类用于测试多态成员的使用情况
public class TestDemo2 {
    public static void main(String[] args) {
        Animal2 a=new Dog2();
        System.out.println(a.sum);
        a.eat();
    }
}
class Animal2{
    int sum=10;
    public void eat(){
        System.out.println("吃啥都行");
    }
    public static void play(){
        System.out.println("玩啥都行");
    }
}
class Dog2 extends Animal2{
    int sum=20;
    public void eat(){
        System.out.println("狗吃肉包子");
    }
}
运行结果：
10
狗吃肉包子

 异常

Error：目前我们的编码解决不了的问题

Exception：异常

编译异常：未运行代码就报错，强制要求处理

运行异常：运行代码才报错：可以通过编译，不强制要求处理

异常捕获

try｛可能会抛出异常的代码｝

catch（预先设想的异常名）｛捕获到了异常，进行处理的解决方案｝

package cn.tedu.oop;

import java.util.Scanner;

//异常的入门案例
public class ExceptionDemo {
    public static void main(String[] args) {
        //Method1();//调用暴露异常的方法
        Method2();//调用解决异常的方案1--捕获异常--自己解决
        //Method3();//调用解决异常的方案2--向上抛出--别人解决
    }
    private static void Method3() {

    }
    private static void Method2() {
        try {
            System.out.print("请输入一个值：");
            int a=new Scanner(System.in).nextInt();
            System.out.print("请输入一个值：");
            int b=new Scanner(System.in).nextInt();
            System.out.println((a/b));
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }
    }
    private static void Method1() {
        //10/0  ArithmeticException 算数异常，除数不能为0
        //10/3.4 InputMismatchException 输入不匹配异常
    }
}
运行结果：
请输入一个值：10
请输入一个值：0
除数不能为0

 万能的处理：Exception

package cn.tedu.oop;

import java.util.InputMismatchException;
import java.util.Scanner;

//异常的入门案例
public class ExceptionDemo {
    public static void main(String[] args) {
        //Method1();//调用暴露异常的方法
        Method2();//调用解决异常的方案1--捕获异常--自己解决
        //Method3();//调用解决异常的方案2--向上抛出--别人解决
    }
    private static void Method3() {

    }
    private static void Method2() {
        try {
            System.out.print("请输入一个值：");
            int a=new Scanner(System.in).nextInt();
            System.out.print("请输入一个值：");
            int b=new Scanner(System.in).nextInt();
            System.out.println((a/b));
        } catch (Exception e){                        //万能
            System.out.println("你输入的不对");
        }
    }
    private static void Method1() {
        
    }
}
执行结果：
请输入一个值：10
请输入一个值：0
你输入的不对

异常抛出

格式：在方法的小括号和大括号之间，写：throws 异常类型

如果有多个类型，用逗号分开

package cn.tedu.oop;

import java.util.InputMismatchException;
import java.util.Scanner;

//异常的入门案例
public class ExceptionDemo {
    public static void main(String[] args) {
        f();
    }
    private static void f() {
        try {
            Method3();
        }catch (Exception e){
            System.out.println("你的输入有误");
        }
    }
    private static void Method3() throws Exception {
        System.out.print("请输入一个值：");
        int a=new Scanner(System.in).nextInt();
        System.out.print("请输入一个值：");
        int b=new Scanner(System.in).nextInt();
        System.out.println((a/b));
    }
   
}
运行结果：
请输入一个值：20.2
你的输入有误

抽象abstract

1.被abstract修饰的方法是抽象方法，抽象方法没有方法体

2.被abstract修饰的类是抽象类，如果一个类包含了抽象方法，那么他必须是抽象类

3.当一个子类继承了抽象父类以后，有两种解决方案：

方案一：变成抽象子类

方案二：变成普通子类，子类需要实现父类中所有的抽象方法

4.抽象类不可以被创建对象，需要用多态创建对象

抽象类有构造方法，抽象类的构造方法不是为了自己使用，而是为了子类创建对象时使用super（）；

为什么要有抽象类？

因为不想让外界创建本类对象

package cn.tedu.oop2;

import org.jcp.xml.dsig.internal.dom.DOMUtils;

/*用于抽象类的成员测试*/
public class AbstractDemo3 {
    public static void main(String[] args) {
        Fruit f=new Bananer();
        f.eat();
        f.run();

    }
}
abstract class Fruit{
    int a;
    final int NAME=10;
    public void eat(){
        System.out.println("吃啥都行");
    }
    public abstract void run();
    
}
class Bananer extends Fruit{
    public void run(){
        System.out.println("香蕉很甜");
    }
}
运行结果：
吃啥都行
香蕉很甜