day14 引用数组类型

向上造型           是自动类型转换

计算机   编译过程 和运行过程

Pet pet = new Cat(); 

图中 pet.eat()为父类构造方法 、  pet.catchMouse（）为子类方法

向上造型构成对象不能调用子类独有方法  

出现方法重写会调用子类方法

向下造型       是强制类型转换

//父类型的指向子类型的对象的引用赋值给子类型的引用 

Cat cat1 = (Cat)new Pet   这种形式错误，不应出现

正确向下造型应该是

Pet pet = new Cat();

Cat cat2 = (Cat)pet;                

这时可以应用子类方法

引用类型的数组类型对象

Dog[] dog = new Dog[2];
dog[0] = new  Dog("大巴",5,"蓝色");
dog[1] = new Dog("大黑",6,"蓝噻");
for (int i = 0; i < 2; i++) {
    System.out.println(dog[i]);
}
for (Dog dog1 : dog) {
    System.out.println(dog1.name+dog1.coatColor+dog1.age);
}
public class Dog  {
    String name;
    int age;
    String coatColor;



    public Dog() {
    }

    public  Dog(String name, int age, String coatColor) {
        this.name = name;
        this.age = age;
        this.coatColor = coatColor;
    }
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 getCoatColor() {
    return coatColor;
}

public void setCoatColor(String coatColor) {
    this.coatColor = coatColor;
}

引用类数组类型的  定时创建  随机子类对象

package com.poloymorphic.extendsx;

//import com.oracleday14.Dog;

import java.util.Arrays;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;

/**
 * 多态
 * 向上造型
 */
public class ExtendsDemo {

//        Cat cat = new Cat();
//
//        /**
//         *   创建对象时，编译首先  读到  Pet  pet
//         *   确定声明创建是一个Pet类型的对象
//         *   然后检查后面实际创建的类与声明创建的类是否有继承关系
//         *   有继承关系时编译通过  不会去管具体实际创建的子类到底是哪些
//         *   也就不知道有哪些子类具体的独有方法
//         *   只会调用继承了的父类的方法
//         *
//         */
//        Pet pet = new Cat();
//        //父类型的引用调用子类型的对象 叫做向上造型
//        pet.eat();
        pet.catchMouse();
//        //调用子类方法
//        //调用不了子类独有的方法
//
//
        Cat cat1 = (Cat)new Pet(); //类型不匹配异常
//        //子类型的引用指向父类型的对象  向下造型
//        Pet pet1 = new Pet();
//        Cat cat2 = (Cat)  pet;

//        Pet pets[] = {
//                new Cat(),
//                new Rabbits(),
//                new Dog(),
//                new Cat(),
//                new Dog(),
//                new Rabbits(),
//        };

//        for (int i = 0; i < pets.length; i++) {
//            if (pets[i] instanceof Dog) {
//                Dog dog = (Dog)pets[i];
//                dog.eat("骨头");
//            }else if (pets[i] instanceof Cat) {
//                Cat cat = (Cat)pets[i];
//                cat.eat("猫粮");
//            }else if (pets[i] instanceof Rabbits){
//                Rabbits rabbits = (Rabbits) pets[i];
//                rabbits.eat("萝卜");
//            }
//        }

        private Pet pets[] = {};     //自定义数组长度
//        Pet pets[] = new Pet[20];
    public Pet[] creatPets(){
        Arrays.copyOf(pets,pets.length+1);
        //每次调用creatPet数组  数组长度加1   创造一个新的pet对象
        Random random = new Random();
        for (int i = 0; i < pets.length; i++) {
            int n = random.nextInt(20);
            if (n <= 4){
                pets[i] = new Dog();
            }else if( n<= 12){
                pets[i] = new Rabbits();
            }else if (n <= 19){
                pets[i] = new Cat();
            }
        }
        //遍历for循环给声明的pet类型创建一个子类对象

        return pets;
        //creatPets给定一个返回值
    }

    /**
     *   遍历循环输出数组
     */
        public void printPet(Pet petss[]){
        for (Pet pet : petss) {
            System.out.println(petss);
        }
    }




    public static void main(String[] args) {
            ExtendsDemo exdemo = new ExtendsDemo();

            //创建定时器对象
        Timer timer = new Timer();

        timer.schedule(new TimerTask(){
            @Override
            public void run(){
                exdemo.creatPets();
                exdemo.printPet(exdemo.pets);
            }



        },0,1000);
    }


}





class Pet {
    String name;
    int age;
    String color;

    public void eat() {
        System.out.println("在吃东西");
    }
}


class Cat extends Pet {
    public void catchMouse() {
        System.out.println("抓老鼠");
    }


    public void eat(String food) {
        System.out.println("吃"+food);
    }
}


class Dog extends Pet {

    public void bark() {
        System.out.println("叫唤");
    }
    public void eat(String food) {
        System.out.println("狗子吃" + food);
    }
}

class Rabbits extends Pet {

    public void eat(String food) {
        System.out.println("兔子吃" + food);
    }
}

---

---

instanceof

1.a instanceof b 

判断a和b是否兼容(a是否是b类型，b是否继承a)

2.向下造型常用来判断是否兼容

3.返回值结果是boolean类型