Java基础笔记 day4

一、抽象类abstract

抽象abstract 对事物的抽象,对类抽象包括属性行为,通过extends去实现
1.抽象类中可以有构造方法，用于子类访问父类时的数据初始化
2.不能与final（方法、变量不可修改）、static（无意义）、private（不能继承，无法重写）共存
3.类中有抽象方法则类为抽象类，抽象类不一定有抽象方法
4.抽象类不能重写，由具体的子类进行实例化，类中有抽象方法则类为抽象类，子类必须重写父类的所有抽象方法，子类为抽象类可不重写父类的所有抽象方法
5.定义了一个类，如果没有继承任何父类，则在默认情况下就继承了Object类

package com.clouds.demo04_polymorphic;
//抽象abstract 对事物的抽象,对类抽象包括属性行为,通过extends去实现
// 不能与final（方法、变量不可修改）、static（无意义）、private（不能继承，无法重写）共存
//类中有抽象方法则类为抽象类，抽象类不一定有抽象方法
//抽象类不能重写，由具体的子类进行实例化
public abstract class Animal {
    private  String name;
    private int age;
    private int weight;

    //类中有抽象方法则类为抽象类，子类必须重写父类的所有抽象方法，子类为抽象类可不重写父类的所有抽象方法
    //抽象方法无方法体，因此不能与static共存，无法调用，无意义
    public abstract void eat();

    public abstract void work();
    //抽象类中不一定有抽象方法，也可以定义非抽象方法
    public void show(){
        System.out.println("我是"+name+",今年"+age+"岁了，现在"+weight+"斤重了");
    }

    //抽象类中可以有构造方法，用于子类访问父类时的数据初始化
    public Animal() {
        /*System.out.println(1);*/
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Animal(String name, int age, int weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
        /*System.out.println(2);*/
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public int getAge() {
        return age;
    }

    public int getWeight() {
        return weight;
    }
}

 类中有抽象方法则类为抽象类，子类必须重写父类的所有抽象方法：

package com.clouds.demo04_polymorphic;

public class Dog extends Animal {
    //子类必须重写父类的所有抽象方法，子类为抽象类可不重写父类的所有抽象方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void work() {
        System.out.println("狗的工作是看门");
    }

    public Dog() {
    }

    public Dog(String name, int age, int weight) {
        super(name, age, weight);
    }

    public void dogVoice() {
        System.out.println("汪汪汪");
    }
}

子类为抽象类可不重写父类的所有抽象方法： 

package com.clouds.demo04_polymorphic;

//子类为抽象类可不重写父类的所有抽象方法
public abstract class Cat extends Animal {
    /*//子类必须重写父类的所有抽象方法，子类为抽象类可不重写父类的所有抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void work() {
        System.out.println("猫的工作是抓老鼠");
    }*/
    /*//抽象类中不一定有抽象方法，也可以定义非抽象方法
    public void catVoice() {
        System.out.println("喵喵喵");
    }*/
}

 二、多态

多态：成员变量：编译、运行看左边
      成员方法：编译看左边，运行看右边
* 有继承或者实现的关系
* 方法的重写
* 父类的引用指向子类 父类引用指向子类对象 向上转型（多态机制）从子到父
* 向下转型（强制转换）从父到子 父类引用转为子类对象 就可调用子类的属性和方法

* instance of （体现多态，可以判断强行转换是否可以）通过返回一个布尔值来指出某个对象是否是某个特定类或者是该特定类的子类的一个实例
即instanceof就是用来判断该对象是否是右边的类或者右边类的子类所创建的，如果是则返回true，否则返回false
* 编译时 class可以是object对象的父类、自身类和子类
* 运行时 class可以是object对象的父类、自身类、Object（返回true），不能是子类（不报错但返回false）
即在运行状态下，class可以是实际对象类型的父类、自身类、子类。
比自己等级高的包括自身类都返回true，属于自己的子类或者兄弟类的都返回false。

例子为继承的多态：

package com.clouds.demo04_polymorphic;

/*多态：成员变量：编译、运行看左边
       成员方法：编译看左边，运行看右边
* 有继承或者实现的关系
* 方法的重写
* 父类的引用指向子类 */
/**/

//ctrl+alt 点击方法或者类进行跳转
public class Test {
    public static void main(String[] args) {
        //抽象类不能重写，由具体的子类进行实例化
        //父类引用指向子类对象 向上转型（多态机制）从子到父
        Animal dog1 = new Dog();
        dog1.eat();
        //向下转型（强制转换）从父到子 父类引用转为子类对象 就可调用子类的属性和方法
        Dog dog3 = (Dog) dog1;
        dog3.dogVoice();
        //子类引用本身
        Dog dog2 = new Dog();
        dog2.eat();
        Animal dog4 = new Dog("大黄狗",5,20);
        dog4.show();
        //instance of 通过返回一个布尔值来指出某个对象是否是某个特定类或者是该特定类的子类的一个实例
        //编译时 class可以是object对象的父类、自身类和子类
        if(dog1 instanceof Dog){
            System.out.println("dog1是Dog类型");
        }
        else{
            System.out.println("dog1不是Dog类型");
        }
    }
}

三、运行结果

狗吃骨头
汪汪汪
狗吃骨头
我是大黄狗,今年5岁了，现在20斤重了
dog1是Dog类型