Was sind die Verwendungszwecke und Prinzipien von Java-Polymorphismus und abstrakten Klassen?

Wir kennen die drei Hauptmerkmale von Java: Kapselung, Vererbung und Polymorphismus. Die ersten beiden wurden bereits in Einführung in Java (6) erwähnt. Lassen Sie uns nun über die Funktion des Polymorphismus sprechen.

Was ist Polymorphismus?

Polymorphismus bedeutet, wie der Name schon sagt, mehrere Formen

Die Bedeutung von Polymorphismus in Java:

• Senden Sie eine Nachricht an ein Objekt und lassen Sie das Objekt selbst entscheiden, mit welchem ​​Verhalten es auf die Nachricht reagieren soll

• Unterklasse Die Referenz des Objekts wird der Referenzvariablen der übergeordneten Klasse zugewiesen, um dynamische Methodenaufrufe zu implementieren

Die Voraussetzung für Polymorphismus in Java:

• Vererbung

• Umschreiben der Methoden der übergeordneten Klasse

• Aufwärtstransformation

Meine Erklärung zum Polymorphismus:

Wir sind zum Beispiel Menschen, Studenten und junge Menschen, ich kann als Student Studententickets kaufen oder als junger Mensch Studententickets kaufen leistet Wohltätigkeit, damit wir auf unterschiedliche Weise verschiedene Dinge tun können. Ist das besser verstanden?

Hinweis:

Polymorphismus-Voraussetzung: Es muss eine Klassenbeziehung zwischen Kind und Eltern bestehen.

Wenn eine Methode mithilfe einer polymorphen Referenzvariablen der übergeordneten Klasse aufgerufen wird, wird die überschriebene Methode der Unterklasse aufgerufen.

Das Definitions- und Verwendungsformat des Polymorphismus:

Variablenname der übergeordneten Klasse = neuer Unterklassentyp ();

Eigenschaften von Mitgliedern im Polymorphismus:

• Polymorphe Mitgliedsvariablen: Schauen Sie beim Kompilieren und Ausführen auf die linke Seite

• Polymorphe Member-Methoden: Schauen Sie beim Kompilieren nach links und beim Ausführen nach rechts : Polymorphismus selbst Es ist der Prozess der Aufwärtstransformation. oder mit Die Funktionen der übergeordneten Klasse können die entsprechenden Vorgänge abschließen.

Abwärtstransformation: Ein nach oben transformiertes Unterklassenobjekt kann das erzwungene Typkonvertierungsformat verwenden, um den Referenztyp der übergeordneten Klasse in die Referenztypen der Unterklasse zu konvertieren

• Verwenden Sie das Format: Variablenname des Unterklassentyps = (Unterklassentyp) Variable vom Typ der übergeordneten Klasse;

• Anwendbares Szenario: Wenn Sie die eindeutigen Funktionen der Unterklasse verwenden möchten.

• Code-Erklärung:

  public class Person {     //人类，作为父类使用
      public void speak(){
          System.out.println("我们都是一个人");
      }
  }
  
  
  
  public class Student extends Person{    //继承父类，相当于我们是学生，有人的方法
      @Override
      public void speak(){
          System.out.println("我是人类中的学生");
      }
  }
  
  
  
  public class Child extends Person{   //继承父类，相当于我们是孩子，有孩子的行为
      @Override
      public void speak(){
  
          System.out.println("我是人类中的孩子");
      }
  }
  
  
  
  
  //测试类
  public class TestMain {
      public static void main(String[] args) {
  
  		//父类类型 变量名=new 子类类型();
          Person p = new Student();   //子类对象的引用赋值给父类 
          p.speak(); //多态 相当于这里使用的是Student的方法。输出我是人类中的学生
          //我作为人，我用学生的身份，说出：我是人类中的学生
  
  
  		Person p = new Child(); 
  		p.speak();  //输出：我是人类中的孩子
  		//我作为人，用孩子的身份，说出我是人类中的孩子
  
      }
  }
  
  //这段代码，我们用到了 继承，重写，向上转型，因为多态本来就是向上转型的过程

  Die Rolle des Polymorphismus:
• Was nützt der Polymorphismus nach der Einführung des Polymorphismus? Warum Polymorphismus als die drei Hauptmerkmale von Java angesehen werden kann. Es muss einen Grund geben:

• Verbessern Sie die Wiederverwendbarkeit des Codes

• Reduzieren Sie die Kopplung zwischen Modulen

• Hier möchte ich Ihnen vorstellen, was der polymorphe Mechanismus ist? Wie implementiert die Java-Sprache Polymorphismus? (Es ist vielleicht etwas schwierig zu verstehen, und ich verstehe den Inhalt nicht vollständig, aber das ist auch eine Frage im Interview)
  Der sogenannte Polymorphismus bezieht sich auf den spezifischen Typ, auf den die in definierte Referenzvariable zeigt Das Programm und die über die Referenzvariable ausgegebene Methode. Der Aufruf wird nicht während der Programmierung, sondern während der Ausführung des Programms bestimmt, d. h., auf welches Klasseninstanzobjekt eine Referenzvariable zeigt, und der von der Referenz ausgegebene Methodenaufruf Welche Variable in welcher Klasse implementiert werden muss, kann im laufenden Programm entschieden werden. Da die spezifische Klasse nur bestimmt wird, wenn das Programm ausgeführt wird, kann die Referenzvariable an verschiedene Klassenimplementierungen gebunden werden, ohne den Quellprogrammcode zu ändern, wodurch sich die durch die Referenz aufgerufene spezifische Methode entsprechend ändert, das heißt, dies ist nicht erforderlich Der Programmcode kann den an das Programm gebundenen spezifischen Code während der Ausführung ändern, wodurch das Programm mehrere Ausführungszustände auswählen kann. Dies ist Polymorphismus. Der Polymorphismus wird in Polymorphismus zur Kompilierungszeit und Polymorphismus zur Laufzeit unterteilt. Unter ihnen ist der Polymorphismus zur Bearbeitungszeit statisch und bezieht sich hauptsächlich auf die Überladung von Methoden. Nach der Bearbeitung gibt es keinen Polymorphismus. Laufzeitpolymorphismus ist dynamisch und wird durch dynamische Bindung erreicht, die wir Polymorphismus nennen.

Zum Verständnis des Polymorphismus können Sie sich auch auf einen Codeabschnitt beziehen:

class People{     //父类
    public void eat(){
        System.out.println("我们会吃饭");
    }
}


class Student extends People{  //继承父类
    @Override
    public void eat(){
        System.out.println("我会吃肉");
    }
    public void study(){
        System.out.println("我们要好好学习");
    }
}


class Teacher extends People{     //继承父类
    @Override
    public void eat(){
        System.out.println("老师会吃蔬菜");
    }
    public void teach(){
        System.out.println("老师要认真上课");
    }
}

//测试类：
public class TestMain {
    public static void main(String[] args) {
        People p=new Stu();      //子类对象的引用赋值给父类 
        p.eat();       //输出： 我会吃肉
    }
}

Abstrakte Klasse:

Was ist eine abstrakte Klasse?

Eine gemeinsame Klasse ist eine vollständige Funktionsklasse, die instanziierte Objekte direkt generieren kann und Konstruktoren, allgemeine Methoden, statische Methoden, Konstanten, Variablen usw. in einer gemeinsamen Klasse enthalten kann. Abstrakte Klassen beziehen sich auf Komponenten, die der Struktur gewöhnlicher Klassen abstrakte Methoden hinzufügen.

• Abstrakte Methode:
  Bei allen gewöhnlichen Methoden gibt es ein „{}“, das den Methodenkörper darstellt. Methoden mit Methodenkörpern können definitiv direkt vom Objekt verwendet werden. Abstrakte Methoden beziehen sich auf Methoden ohne Methodenkörper, und abstrakte Methoden müssen auch mit dem Schlüsselwort abstract geändert werden. Mit anderen Worten, die abstrakte Methode in der abstrakten Klasse muss nicht geschrieben und nach der Vererbung neu geschrieben werden.
• Abstraktes Klassendeklarationsschlüsselwort: abstracat
  Definieren Sie eine abstrakte Klasse:

public abstract class studnet{//定义一个抽象类
	
	public void study(){                         //普通方法
		System.out.println("我会学习");
	}
	
	public abstract void eat();         //抽象方法，没有方法体，有abstract关键字做修饰
	
}

//注意： 有抽象方法，这个类必须是抽象的！！！

Beispielerklärung:

Die Formklasse Shape muss Methoden zur Berechnung von Fläche und Umfang bereitstellen, aber die Form selbst wurde nicht bestimmt. Anschließend wird der Umfang berechnet Die Summen- und Flächenmethode kann derzeit nicht bestimmt werden. Wir müssen abstrakte Klassen und abstrakte Methoden verwenden.

由于Shape类计算周长和面积的方法无法确定，那么就可以将这样的方法声明为抽象的，以便在具体的子类中进行实现。

//定义一个shape类，但是没有具体的形状，所以我们定义成抽象类
public abstract class Shape {
    
    private int a;
    public abstract void area(){}     //求面积的方法
    public abstract void perimeter();   //求周长的方法

    public Shape() {    //无参构造
    }

    public Shape(int a) {
        this.a = a;
    }
}

//计算圆形面积的子类

public  abstract class shape {    //有抽象方法的类，则一定是抽象类，需要关键字abstract修饰

        private int a;
        public abstract void area();     //求面积的方法，没有方法体的方法，需要关键字abstract修饰
        public abstract void perimeter();   //求周长的方法
}


//创建计算圆面积和周长的子类，并继承抽象类shape,并重写shape内的方法
public class Circle extends shape{

    public static double pi = 3.14;
    private double r;  //半径


    @Override
    public void area() {
        System.out.println("圆的面积："+Circle.pi*this.r*this.r);
    }

    @Override
    public void perimeter() {
        System.out.println("圆的周长为："+2*Circle.pi*this.r);
    }

    public Circle() {
    }

    public Circle(double r) {  //
        this.r = r;
    }

}


//测试类：
public class TestMain {
    public static void main(String[] args) {
        Circle c = new Circle(5);        //传入半径为：5
        c.area();
        c.perimeter();

    }

}

//输出结果： 圆的面积：78.5
// 圆的周长为：31.400000000000002

抽象方法和抽象类的注意事项：

• 抽象类中是可以有构造函数的，并且构造函数的写法和其它类没有区别，只不过它真正跑起来是因为子类构造函数的super调用，毕竟我们没办法new一个抽象类对象出来，只能把抽象类的构造函数交给子类的构造函数去使用。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。

• 抽象类的子类，必须重写父类中所有的抽象方法，如果有一个抽象方法没有重写，都会出现编译错误不给过，这时也可以把子类也声明为抽象类，报错就会消失。

Das obige ist der detaillierte Inhalt vonWas sind die Verwendungszwecke und Prinzipien von Java-Polymorphismus und abstrakten Klassen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!