Modelado ascendente
1. ¿Qué es el modelado ascendente?
1. Modelado ascendente: la clase principal se refiere al objeto de la subclase.
1.1. Definición de modelado ascendente
- 1) El supertipo (clase principal) se refiere al objeto de la clase derivada (subclase).
- 2) Lo que se puede señalar mediante variables de referencia depende del tipo de referencia.
- 3) Nota: Algunos dichos se denominan transformación ascendente, que significa lo mismo.
- Antes de mirar las castañas de código, incluido el siguiente ejemplo, recuerde tres conceptos:
modelado ascendente : referencias de clase principal a
sobrecarga de objetos de subclases, el mismo nombre de método , La lista de parámetros es diferente, el nombre del
método es el mismo, la lista de parámetros es la misma, el cuerpo del método es diferente
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("我派生类（子类）");//超类方法被重写
}
}
- resultado de la operación
1.2. Suplemento de detalles de modelado ascendente
- En algunos libros, se denomina objeto de transformación superior. Pero la definición y la teoría son las mismas, solo use el código para dar una castaña para entender.
- Las características del objeto de transformación superior:
- 1. Puede operar herencia u ocultar variables miembro, y puede llamar a métodos de herencia o invalidación de subclase.
- 2. No se pueden operar las nuevas variables miembro de la subclase y no se puede llamar al nuevo método de la subclase.
- El ejemplo de código es el siguiente:
2. Método de reescritura y reescritura de reglas a seguir
2.1. Reescritura de métodos
- 2.1.1 Ocurre en la clase principal y secundaria, el nombre del método y la lista de parámetros son los mismos y el cuerpo del método es el mismo.
- 2.1.2 Cuando se llama al método de anulación, depende del tipo de objeto.
- Veamos las castañas:
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();
}
}
}
- resultado:
2.2. Reescribir reglas
- Siga: Principio "Dos iguales, dos pequeños, uno grande".
- Dos iguales: el nombre del método es el mismo y la lista de parámetros es la misma.
- Dos pequeños: el tipo de valor de retorno del método de la clase derivada (subclase) es menor o igual que el método de la superclase (clase principal).
- La segunda escuela primaria se refiere a:
- Cuando void no tiene valor de retorno, debe ser el mismo.
- El tipo de datos básico debe ser el mismo (es decir, el tipo de valor de retorno).
- Cuando se hace referencia a un tipo de datos, es menor o igual que la superclase (clase principal).
- La segunda escuela primaria se refiere a:
- La excepción lanzada por el método de la clase derivada (subclase) es menor o igual que el método de la superclase (clase principal).
- Uno grande:
- Los derechos de acceso del método de clase derivada (subclase) son mayores o iguales que el método de superclase (clase principal).
- Mira las castañas:
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. La diferencia entre reescribir y sobrecargar
3.1 Diferencia
-
Sobrecarga ---------- el nombre del método es el mismo, la lista de parámetros es diferente
-
Reescribir ---------- El nombre del método es el mismo, la lista de parámetros es la misma y el cuerpo del método es diferente
-
Mira un ejemplo, el siguiente código:
-
Sobrecarga para ver el tipo de parámetro, reescribe para ver el tipo de objeto, también puedes decir el nuevo objeto (¡énfasis! ¡Énfasis! ¡Énfasis! ¡Importante! Dilo tres veces)
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”
}
}
- Los resultados muestran que:
¡Tenga paciencia con el contenido de seguimiento y venga pronto! Escribir no es fácil, como 3Q
Si hay algún error, comente
La lista de capítulos está aquí: https://blog.csdn.net/qq_41254299/article/details/106638651
Indique la fuente para la reimpresión: https://blog.csdn.net/qq_41254299
Este artículo es de [Superclover_'s blog]