Dieser Artikel bietet Ihnen eine Einführung in die Verwendung der Aufwärts- und Abwärtstransformation von Java. Ich hoffe, dass er für Freunde hilfreich ist.
1 Aufwärtstransformation (Unterklasse zur übergeordneten Klasse)
Beispiel:
package a.b;
public class A {
public void a1() {
System.out.println("Superclass");
}
}
A的子类B：
package a.b;
public class B extends A {
public void a1() {
System.out.println("Childrenclass"); //覆盖父类方法
}
public void b1(){} //B类定义了自己的新方法
}
C类：
package a.b;
public class C {
public static void main(String[] args) {
A a = new B(); //向上转型
a.a1();
}
}Wenn Sie C ausführen, ist die Ausgabe eine Superklasse oder eine Kinderklasse? Nicht die Superklasse, die Sie ursprünglich erwartet hatten, sondern die Kinderklasse. Dies liegt daran, dass a tatsächlich auf ein Unterklassenobjekt verweist. Natürlich müssen Sie sich keine Sorgen machen, die Java Virtual Machine erkennt automatisch und genau, welche spezifische Methode aufgerufen werden soll. Aufgrund der Aufwärtstransformation verliert das a-Objekt jedoch Methoden, die sich von der übergeordneten Klasse unterscheiden, z. B. b1(). Manche Leute fragen sich vielleicht: Ist das nicht unnötig? Wir können definitiv so schreiben:
B a = new B();
a.a1(
Tatsächlich! Dadurch gehen jedoch die abstraktionsorientierten Programmierfunktionen verloren und die Skalierbarkeit wird verringert. Darüber hinaus kann die Aufwärtstransformation auch den Programmieraufwand reduzieren. Schauen wir uns die folgende Monitorklasse Monitor an:
package a.b;
public class Monitor{
public void displayText() {}
public void displayGraphics() {}
}
液晶显示器类LCDMonitor是Monitor的子类：
package a.b;
public class LCDMonitor extends Monitor {
public void displayText() {
System.out.println("LCD display text");
}
public void displayGraphics() {
System.out.println("LCD display graphics");
}
}
阴极射线管显示器类CRTMonitor自然也是Monitor的子类：
package a.b;
public class CRTMonitor extends Monitor {
public void displayText() {
System.out.println("CRT display text");
}
public void displayGraphics() {
System.out.println("CRT display graphics");
}
}
等离子显示器PlasmaMonitor也是Monitor的子类：
package a.b;
public class PlasmaMonitor extends Monitor {
public void displayText() {
System.out.println("Plasma display text");
}
public void displayGraphics() {
System.out.println("Plasma display graphics");
}
}
现在有一个MyMonitor类。假设没有向上转型，MyMonitor类代码如下：
package a.b;
public class MyMonitor {
public static void main(String[] args) {
run(new LCDMonitor());
run(new CRTMonitor());
run(new PlasmaMonitor());
}
public static void run(LCDMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
public static void run(CRTMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
public static void run(PlasmaMonitor monitor) {
monitor.displayText();
monitor.displayGraphics();
}
}
可能你已经意识到上述代码有很多重复代码，而且也不易维护。有了向上转型，代码可以更为简洁：
package a.b;
public class MyMonitor {
public static void main(String[] args) {
run(new LCDMonitor()); //向上转型
run(new CRTMonitor()); //向上转型
run(new PlasmaMonitor()); //向上转型
}
public static void run(Monitor monitor) { //父类实例作为参数
monitor.displayText();
monitor.displayGraphics();
}
}
我们也可以采用接口的方式，例如：
package a.b;
public interface Monitor {
abstract void displayText();
abstract void displayGraphics();
}
将液晶显示器类LCDMonitor稍作修改：
package a.b;
public class LCDMonitor implements Monitor {
public void displayText() {
System.out.println("LCD display text");
}
public void displayGraphics() {
System.out.println("LCD display graphics");
}
}2 Downcast (übergeordnete Klasse in Unterklasse umgewandelt)
A类：
package a.b;
public class A {
void aMthod() {
System.out.println("A method");
}
}
A的子类B：
package a.b;
public class B extends A {
void bMethod1() {
System.out.println("B method 1");
}
void bMethod2() {
System.out.println("B method 2");
}
}
C类：
package a.b;
public class C {
public static void main(String[] args) {
A a1 = new B(); // 向上转型
a1.aMthod(); // 调用父类aMthod()，a1遗失B类方法bMethod1()、bMethod2()
B b1 = (B) a1; // 向下转型，编译无错误，运行时无错误
b1.aMthod(); // 调用父类A方法
b1.bMethod1(); // 调用B类方法
b1.bMethod2(); // 调用B类方法
A a2 = new A();
B b2 = (B) a2; // 向下转型，编译无错误，运行时将出错
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}
}
从上面的代码我们可以得出这样一个结论：向下转型需要使用强制转换。运行C程序，控制台将输出：
Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at
a.b.C.main(C.java:14)
A method
A method
B method 1
B method 2Tatsächlich ist B b2 = (B) nach dem Downcast-Code bei a2 Die Kommentare bereits weisen darauf hin, dass ein Laufzeitfehler auftreten wird. Warum ist der Abwärtstransformationscode im ersten Satz in Ordnung, der Code im zweiten Satz jedoch falsch? Dies liegt daran, dass a1 auf ein Objekt der Unterklasse B zeigt, sodass das Instanzobjekt b1 der Unterklasse B natürlich auch auf a1 zeigen kann. Und a2 ist ein übergeordnetes Klassenobjekt, und das untergeordnete Klassenobjekt b2 kann nicht auf das übergeordnete Klassenobjekt a2 verweisen. Wie kann ich also eine Laufzeit-ClassCastException vermeiden, wenn ich einen Downcast durchführe? Verwenden Sie einfach die in Abschnitt 5.7.7 erlernte Instanz. Ändern wir den Code der Klasse C:
A a2 = new A();
if (a2 instanceof B) {
B b2 = (B) a2;
b2.aMthod();
b2.bMethod1();
b2.bMethod2();
}Nach der Verarbeitung auf diese Weise müssen wir uns keine Sorgen mehr machen, dass während der Typkonvertierung eine ClassCastException auftritt.
Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung der Aufwärts- und Abwärtstransformation von Java (mit Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
