向上造型
一、什么是向上造型?
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_的博客】