2023/7/2

今天学习了两种类型转换，首先是向上转型，就是用父类的对象来引用子类，这种转型是安全的，注意父类的对象不能访问子类中的属性和方法。然后是向下转型，这种转型是不安全的，父类对象不能直接赋值给子类对象，要实现向下转型需要借助强制类型转换: 子类类型 子类对象=(子类类型) 父类对象。

package 类型转换;

public class 父类 {
    int num=4;
    public void show()
    {
            System.out.println(2);
    }
}
package 类型转换;

public class 向上类型转换 extends 父类{
    int java=3;
    public static void main(String[] args)
    {
        父类 a=new 向上类型转换();//父类类型的对象可以引用子类类型的对象
        System.out.println(a.num);
        a.show();
        //a.show2();
        //System.out.println(a.java);父类的对象无法调用子类的属性或者方法
    }
    public void show2()
    {
            System.out.println(5);
    }
}

package 类型转换;

public class 父类 {
    int num=4;
    public void show()
    {
            System.out.println(2);
    }
}
package 类型转换;

public class 向下类型转换 extends 父类{
    public static void main(String[] args)
    {
        //向下类型转换 a=new 父类();报错
        /*
        父类 a=new 向下类型转换();
        向下类型转换 b=(向下类型转换)a;
        */
        //
        /*
         * 子类类型 子类对象=(子类类型) 父类对象
         */
        父类 a=new 父类();
        向下类型转换 b=(向下类型转换)a;//编译虽然没问题,但是控制台还是会提示错误信息
        b.show();
    }
    void show2()
    {
        System.out.println("子类");
    }

}

然后就是instanceof关键字，这是判断父类对象是否为子类对象的实例的关键字

package 判断对象类型;

public class jipengdaole {

}
package 判断对象类型;

public class kemuyi {

}
package 判断对象类型;

public class kemuer extends kemuyi{

}
package 判断对象类型;

public class inOf {
    public static void main(String[] args)
    {
        kemuyi a=new kemuer();
        kemuer b=new kemuer();
        kemuyi c=new kemuyi();
        System.out.println(a instanceof kemuyi);
        System.out.println(a instanceof kemuer);//前类对象是后类的一个实例，支持向上兼容，所以都是true
        System.out.println(b instanceof kemuyi);
        System.out.println(c instanceof kemuer);//类向下不兼容所以为false
        //用于判断父类对象是否为子类对象的实例，也可以判断该对象是否属于一个类
        //System.out.println(a instanceof jipengdaole);没有继承关系不能用instance关键字进行比较
    }
}

package 判断对象类型;

public class bird {

}
package 判断对象类型;

public class chicken extends bird{
    public static void main(String[] args)
    {
        chicken a=new chicken();
        System.out.println(a instanceof bird);//鸡可以作为bird的实例所以为true
    }
}

最后是方法的重载，和C++一样，重载是根据参数的类型和个数来调用不同的同名方法

package 方法重载;
import java.util.Scanner;
public class clothes {
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        if(a<2)//控制台，通过传递不同的参数来调用不同的函数
        {
            pay(1.0);
        }
        else pay(a);
    }
    static void pay(int x)
    {
        Scanner sc=new Scanner(System.in);
        double a=0;
        while(x!=0)//判断是否输入完成
        {
            System.out.println("请输入衣服的单价:");
            double b=sc.nextDouble();
            a+=(b*0.8);
            x--;
        }
        System.out.printf("总价为:%.2f\n",a);
    }
    static void pay(double x)
    {
        System.out.println("请输入衣服的单价:");
        Scanner sc=new Scanner(System.in);
        double a=sc.nextDouble();
        System.out.printf("总价为:%.2f\n",a);
    }
}

package 方法重载;
import java.util.Scanner;
public class daxiaoxie {
    public static void main(String[] args)
    {
        System.out.println("请输入一个在65~90间的数:");
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt();
        char b;
        b=print(a);
        print(b);
    }
    static char print(int a)//输入大写并传递小写
    {
        char b=(char)a;
        System.out.println(b);
        return (char)(a+32);
    }
    static void print(char a)
    {
        System.out.println(a);
    }
}