笔记_java_review_8_类型转换

类型转换

package com.mgg.review;

import java.util.ArrayList;
import java.util.List;

/**
 * 类型转换 
 */
class Animal {
    public void move() {
        System.out.println("移动");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("汪~汪~");
    }
    //重写
    @Override
    public void move() {
        System.out.println("狗会移动");
    }
}

class Bird extends Animal {
    public void fly() {
        System.out.println("鸟会飞！");
    }

}
//Animal是SingleDog的基类（可以理解为爷爷类）
class SingleDog extends Dog {

    public void danShen() {
        System.out.println("Single all the day！");
    }
}

interface Shape{}
class Circle implements Shape{}
class Square implements Shape{}

public class Demo8_TypeCasting {

    //※如果一个方法的参数是一个接口类型，可以传入实现了该接口的类的对象
    //接口是不能实例化的
    public static void test5(Shape s){}
    
    //如果一个方法的参数要求一个类对象，可以传入该类的对象
    public static void test1(Bird bird){} 
    public static void test2(SingleDog sd){}  
    //如果一个方法的参数要求一个类对象，可以传入该类的对象
    //也可以传入该类的派生类的对象
    public static void test3(Dog dog){}
    public static void test4(Animal animal){}

    public static void main(String[] args) {

        test1(new Bird());
        test3(new Dog());
        test3(new SingleDog());
        test4(new Dog());
        test4(new SingleDog());
        test4(new Bird());
        test4(new Animal());
        
        //byte, short, int, long
        //基本数据类型转换
        byte a1=10;
        //小范围->大范围 自动完成，隐式转换
        int a2=a1; 
        
        int b1=128;
        //大范围->小范围 强制转换，显式转换
        byte b2=(byte)b1; 
        System.out.println(b2);
        
        double c1=200.5;
        float c2=(float)c1;
        
        Dog d=new Dog();
        d.move();
        d.bark();
        
        //引用类型的转换
        Animal animal1=new Dog(); //派生类->基类 向上转型 自动完成 隐式转换
        //如果使用基类的引用变量引用派生类的对象
        //则通过该引用变量，只能调用对象继承的方法
        animal1.move();
        Animal animal2=new Bird(); //派生类->基类
        Animal animal3=new SingleDog(); //派生类->基类
        Dog dog=new SingleDog();
        
        Animal u=new Dog();
        //u本身引用的就是Dog的对象，所以可以转成Dog类型
        //引用类型转换的前提是两者存在继承关系
        Dog m=(Dog)u; //Animal->Dog 基类->派生类 向下转型，强制完成，显式转换
        m.bark();
        m.move();
    }
}