今日内容

1.多态异常积累

多态异常
    多态的向下转型
        将父类引用强制转换为子类引用,使用不当会出现问题
            Java.lang.ClassException---运行时异常报错一类
                ---最终结果类型和堆内存中储存结果类型不一样
解决方案
    检查代码逻辑!

2.abstract关键字---抽象

抽象abstract---只是抽象事物变成了抽象类,定义了抽象方法,加了几个限制条件,其他均无变化!
    什么是抽象类
        具体事物的顶层次父类可以被定义为抽象!
            举例
                动物类中的成员方法--吃
                    ---并不像具体类狗---吃骨头!
                        ---单纯的吃,所以可以被定义为抽象方法,动物类可以被定义为抽象类
    抽象类
        格式
            class abstract 类名{
                ...
            }
        特点
            1)抽象类不能进行实例化!---不能创建面向对象
            2)抽象类的子类也是抽象类,不能实例化,一定会有一个最具体的子类来进行实例化!
                ---格式
                        抽象类名 对象名 = new 具体的子类名() ; ---抽象类多态
    抽象方法
        格式
            权限修饰符 abstract关键字 返回值类型 方法名(无参/有参) ;
                ---public abstract void 方法名(无参/有参) ;
                
    注意事项
        有抽象方法一定是抽象类,是抽象类不一定有抽象方法!
        父类是抽象类,子类没有方法重写,直接报错!
        
    abstract应用范围
        定义类--->抽象类
        定义方法--->抽象方法

//抽象类Animal,方便观察不添加构造方法和私有属性
abstract class Animal {
    //原来的写法 ---其实方法体内的"动物吃东西"完全没必要写,后面被子类重写!
    /*
    public void eat(){
        System.out.println("动物吃东西!");
    }
    */
    //抽象方法更像是声明了一个方法!---减少了代码冗余
    public abstract void eat() ;//抽象方法没有方法体!
    public abstract void sleep() ;
    //不是抽象方法
    public void show(){ //抽象类可以有非抽象方法!
        System.out.println("这不是一个抽象方法!");
    }
}
​
​
​
//方便观察不添加构造方法
public class Cat extends Animal {
    //父类是抽象方法,子类没有方法重写会直接报错!
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
​
    @Override
    public void sleep() {
        System.out.println("猫躺着睡");
    }
    //非抽象类没有被重写,不会报错,没事
    //特有功能
    public void playGame(){
        System.out.println("猫会玩逗猫棒!");
    }
}
​
​
​
public class AnimalTest {
    public static void main(String[] args) {
        //测试
        //抽象类不能实例化---不能创建面向对象
        //Animal animal = new Animal() ;//报错!
        //抽象类可以和具体子类进行抽象类多态
        Animal animal = new Cat() ;//抽象类多态
        animal.eat();//猫吃鱼
        animal.sleep();//猫躺着睡
        //调用Cat类的特殊方法---强制转换类型-引用类型版
        Cat cat = (Cat) animal ;
        cat.playGame();//猫会玩逗猫棒!
        //调用非抽象方法
        animal.show();//这不是一个抽象方法!
    }
}

抽象类的成员特点
    成员变量
        可以是变量
        可以是被final修饰的常量
    成员方法
        可以是抽象类方法---必须加abstract,不能带方法体!
    构造方法
        构造方法(有参/无参)都可以存在,构造方法先父类初始化,在子类初始化!

abstract和哪些关键字冲突
    不能和private一起用
        ---被private修饰的成员只能在本类中调用,而abstract强制子类重写--冲突!
    不能和final一起用
        ---被final修饰的成员方法不能被重写,而abstract强制子类重写--冲突!
    不能和static一起使用
        ---被static修饰的方法算不上重写,可以直接被类名调用!

2.1面试题

如果一个类没有任何抽象方法,把这个类定义为抽象类的意义?

意义是
    不让外界类直接创建面向对象(抽象类无法创建自己的面向对象)
        ---可以通过具体的子类进行实例化--创建面向对象!

3.接口

接口
    体现了事物本身没有的功能,额外的功能!
        举例
            狮子钻火圈
                狮子---本身不会钻火圈
                    ---后来人们教会了
                     ---具备了额外的功能
    格式
        interface 接口名{}
    特点---和抽象类很像
        1)接口的方法不能有方法体,只能是抽象方法
            ---定义抽象方法时,可以隐藏定义前缀--public abstract---不是没有,只是隐藏了!
        2)接口不能实例化--不能创建面向对象
        3)接口的实现类是一个抽象类,则不能实例化,一定会有一个具体的实现类来进行创建面向对象!
        
​
实现类---创建接口需要被用,用接口的类就是实现类!
    使用接口的格式
        class 实现类名 implements(实现) 接口名{
            ...
        }

接口的成员特点
    成员变量
        只能是常量!
            ---存在默认修饰 public static final (可以被隐藏)
    成员方法
        只能是抽象方法
            ---存在默认修饰 public abstract (可以被隐藏)
    构造函数
        接口没有构造方法!!!

//接口,实现跳这个功能,通过具体的实现类来实现谁跳!
public interface Jump { //接口方法必须方法重写,不然报错
    //只能是常量,抽象方法,没有构造函数!
    public abstract void Jump() ;//前面的灰色字体表示可被隐藏!
}
​
​
​
//动物类,顶层父类---抽象类!
public abstract class Animal {
    //私有属性
    private String name ;
    private int age ;
    private String color ;
    private char sex ;
    //set/get方法
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
​
    public char getSex() {
        return sex;
    }
​
    public void setSex(char sex) {
        this.sex = sex;
    }
​
    //构造方法
    public Animal() {//无参构造方法
    }
​
    public Animal(String name, int age, String color, char sex) {//有参构造方法
        this.name = name;
        this.age = age;
        this.color = color;
        this.sex = sex;
    }
    //抽象方法
    public abstract void eat() ;//吃方法
    public abstract void sleep() ;//睡觉方法
}
​
​
​
//猫类继承动物类---抽象类,猫会干的事
public abstract class Cat extends Animal {
    //构造方法
​
    public Cat() {//无参
    }
​
    public Cat(String name, int age, String color, char sex) {//有参
        super(name, age, color, sex);
    }
    //猫类都会的方法
    public abstract void playDouMaoBang() ;
}
​
​
​
//狗类继承动物类---抽象类,狗会干的事
public abstract class Dog extends Animal {
    //构造方法
​
    public Dog() {//无参
    }
​
    public Dog(String name, int age, String color, char sex) {//有参
        super(name, age, color, sex);
    }
    //狗会干的事
    public abstract void playBall() ;
}
​
​
​
//具体实现类,猫会干的事!
public class JumpCat extends Cat implements Jump {
    //构造方法
​
    public JumpCat() {
    }
​
    public JumpCat(String name, int age, String color, char sex) {
        super(name, age, color, sex);
    }
​
    @Override
    public void eat() { //Animal类中的方法
        System.out.println("猫吃鱼!");
    }
​
    @Override
    public void sleep() { //Animal类中的方法
        System.out.println("猫躺着睡!");
    }
​
    @Override
    public void playDouMaoBang() { //Cat类中的方法
        System.out.println("猫会玩逗猫棒!");
    }
​
    @Override//接口方法必须方法重写,不然报错
    public void Jump() { //接口方法
        System.out.println("猫会跳!");
    }
}
​
​
​
//具体实现类,狗会干的事!
public class JumpDog extends Dog implements Jump {
    //构造方法
​
    public JumpDog() {
    }
​
    public JumpDog(String name, int age, String color, char sex) {
        super(name, age, color, sex);
    }
​
    @Override
    public void eat() { //Animal类中的方法
        System.out.println("狗吃骨头!");
    }
​
    @Override
    public void sleep() { //Animal类中的方法
        System.out.println("狗趴着睡!");
    }
​
    @Override
    public void playBall() { //Dog类中的方法
        System.out.println("狗会玩球!");
    }
​
    @Override//接口方法必须方法重写,不然报错
    public void Jump() { //接口方法
        System.out.println("狗会钻圈!");
    }
}
​
​
​
/*
    猫和狗--->属性:姓名,年龄,颜色,性别
            吃和睡的行为
            部分猫和部分狗 会 "跳高"
​
    使用面向对象编程方式----完成猫和狗属性访问进行测试
 */
public class interfaceTest {
    public static void main(String[] args) {
        //测试猫
        JumpCat jumpCat = new JumpCat() ;
        jumpCat.eat();//猫吃鱼!
        jumpCat.sleep();//猫躺着睡!
        jumpCat.playDouMaoBang();//猫会玩逗猫棒!
        jumpCat.Jump();//猫会跳!
        System.out.println("---------------------------");
        //测试狗
        JumpDog jumpDog = new JumpDog() ;
        jumpDog.eat();//狗吃骨头!
        jumpDog.sleep();//狗趴着睡!
        jumpDog.playBall();//狗会玩球!
        jumpDog.Jump();//狗会钻圈!
    }
}

4.代码分析及书写

分析代码
    从最具体--->最抽象
书写代码
    从最抽象--->最具体