向上造型
一、什么是向上造型?
1.向上造型：父类引用指向子类的对象
1.1.向上造型的定义
- 1）超类型（父类）引用指向派生类（子类）的对象。
- 2）引用变量 能点出什么，看引用类型。
- 3）注：有的说法叫向上转型，同一个意思。
- 看代码栗子前，包括看下个例子也是，先记住三个概念：
向上造型 ------父类引用指向子类的对象
重载----------方法名相同，参数列表不同
重写----------方法名相同，参数列表相同，方法体不相同
public class UploadDemo {
public static void main(String[] args) {
Aoo o1 = new Aoo();
o1.a = 1;
o1.show();
Boo o2 = new Boo();
o2.a = 1;
o2.b = 2;
o2.show();
//超类型引用指向派生类的对象
Aoo o3 = new Boo();
o3.a = 1;
o3.show();
//o3.b = 2; //报错！向上造型：能点出什么，看引用的类型。
//若要使它不报错，得在父类加不是私有变量b
}
}
class Aoo{
int a;
void show() {
System.out.println("我是超类（父类）");
}
}
class Boo extends Aoo{
int b;
void show() {
System.out.println("我派生类（子类）");//超类方法被重写
}
}
- 运行结果
1.2.向上造型细节补充
- 有的书籍上，称之为上转型对象。但是定义，理论是一样的，用代码举个栗子就明白了。
- 上转型对象的特点：
- 1.可以操作继承或隐藏成员变量，能调用子类继承或重写的方法。
- 2.不能操作子类新增的成员变量，不能调用子类新增的方法。
- 代码例子如下：
2.方法的重写 和 重写需遵循的规则
2.1.方法的重写
- 2.1.1 发生在父子类中，方法名和参数列表相同，方法体相同。
- 2.1.2 重写方法被调用时，看对象的类型。
- 我们来看栗子：
package oop.day04;
class Dongwu {
//父类
protected String name;
protected int age;
public Dongwu(String name, int age){
this.name = name;
this.age = age;
}
public void runing(){
System.out.println(name+"今年"+age);
}
}
class Cat extends Dongwu{
//子类
int weight; //重量
public Cat(String name, int age, int weight){
super(name,age);
this.weight = weight;
}
public void runing(){
System.out.println(name+"今年"+age+",重量"+weight+"KG");
}
}
class Dog extends Dongwu{
//子类
int size; //大小
public Dog(String name, int age, int size){
super(name,age);
this.size = size;
}
public void runing(){
System.out.println(name+"今年"+age+",大小"+size+"KG");
}
}
public class Test3 {
public static void main(String[] args) {
Dongwu[] dw = new Dongwu[3];
dw[0] = new Cat("加菲猫",8,50);
dw[1] = new Dog("阿拉斯加",15,70);
dw[2] = new Dog("英短猫",13,80);
for(int i=0; i<dw.length; i++) {
System.out.println(dw[i].name);
dw[i].runing();
}
}
}
- 结果：
2.2.重写遵循的规则
- 遵循：“两同两小一大”原则。
- 两同：方法名相同，参数列表相同。
- 两小：派生类（子类）方法的返回值类型小于等于超类（父类）方法的。
- 二小，指的是：
- void 无返回值时，则必须相同。
- 基本数据类型是，必须相同（即返回值类型）。
- 引用数据类型时，小于或等于超类（父类）。
- 二小，指的是：
- 派生类（子类）方法抛出的异常小于或等于超类（父类）方法。
- 一大：
- 派生类（子类）方法的访问权限大于或等于超类（父类）方法。
- 看栗子：
package oop.day04;
//重写
public class OverrideDemo {
public static void main(String[] args) {
}
}
class Coo{
void test() {
}
int then() {
return 0;
}
double show() {
return 0.0;
}
Doo say() {
return null;
}
}
class Doo extends Coo{
//int test() {return 5;} //编译错误，void时必须相同
//int then() {return 1.1;} //编译错误，返回值类型必须小于或等于超类。不能返回double型1.1
//int show() {return 0;} //编译错误，基本数据类型必须相同，即返回值类型相同。show()方法定义了double型了
//Coo say() {return null;} //编译错误，引用类型时必须小于或等于超类
Doo say() {
return null;} //超类大于派生类（这里指代的访问权限即访问修饰符）
//访问修饰符的讲解，将在下一篇内容提到。感谢阅读者的支持
}
3.重写与重载的区别重点
3.1 区别
-
重载----------方法名相同，参数列表不同
-
重写----------方法名相同，参数列表相同，方法体不相同
-
来看个例子，如下代码：
-
重载看参数类型，重写看对象类型，也可以说new出的对象（重点！重点！重点！重要的说三遍）
package oop.day04;
//重写与重载
public class OverrideOverloasDemo {
public static void main(String[] args) {
//重载看参数类型，重写看对象类型，也可以说new出的对象（重点！重点！重点！重要的说三遍）
Goo goo = new Goo();
Eoo o = new Foo(); //向上造型 ------父类引用指向子类的对象。
goo.test(o);
Eoo foo = new Eoo();//当前new对象是Eoo
foo.show();
}
}
class Goo{
//重载-------方法名相同，参数列表不同,方法体不同
void test(Eoo o) {
System.out.println("超类型参数");
o.show();
}
void test(Foo o) {
System.out.println("派生类型参数");
o.show();
}
}
class Eoo{
void show() {
System.out.println("超类show");
}
}
class Foo extends Eoo{
void show() {
System.out.println("派生类show");//show()方法被重写，若没被重写，则调用超类的方法“超类show”
}
}
- 结果显示：
后续的内容请耐心等等，马上就来！写作不易请点个赞3Q
若有错误之处，请各位点评下
章节目录在此处：https://blog.csdn.net/qq_41254299/article/details/106638651
转载请注明出处：https://blog.csdn.net/qq_41254299
本文出自【Superclover_的博客】