Detaillierte Analyse der Java-Schlüsselwörter this und super
Dieser Artikel vermittelt Ihnen relevantes Wissen über Java. Er stellt hauptsächlich die damit verbundenen Themen und Super-Schlüsselwörter sowie einige ihrer Unterschiede vor. Ich hoffe, dass er für alle hilfreich ist.
Empfohlenes Lernen: „Java-Video-Tutorial“
1. Die Verwendung des Schlüsselworts „dieses“
1 Übersicht
- dieses Was ist das?
In Java ist das Schlüsselwort
this
schwer zu verstehen. Seine Funktion kommt seiner Bedeutung sehr nahe, was „aktuell“ bedeutet.this
关键字比较难理解,它的作用和其词义很接近,表示“当前”的意思。
2. 作用
this
关键字可以用来修饰、调用:属性、方法、构造器。this
关键字只能在方法内部使用。
它在方法内部使用,即这个方法所属对象的引用;
它在构造器内部使用,表示该构造器正在初始化的对象。
3. 使用
- 什么时候使用this关键字呢?
当在方法内需要用到调用该方法的对象时,就用
this
。具体的:我们可以用this
来区分属性和局部变量。比如:this.name = name;
3.1 修饰属性和方法
this
理解为:当前对象或当前正在创建的对象
在类的方法中,我们可以使用this.属性
或this.方法
的方式,调用当前对象属性或方法。但是,通常情况下,我们都选择省略this.
。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用this.变量
的方式,表明此变量是属性,而非形参。
使用this
访问属性和方法时,如果在本类中未找到,会从父类中查找。
代码演示:
class Person{ // 定义Person类 private String name ; private int age ; public Person(String name,int age){ this.name = name ; this.age = age ; } public void getInfo(){ System.out.println("姓名:" + name) ; this.speak(); } public void speak(){ System.out.println(“年龄:” + this.age); } }
3.2 调用构造器
在类的构造器中,我们可以使用
this.属性
或this.方法
的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都选择省略this.
。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用this.变量
的方式,表明此变量是属性,而非形参。
我们在类的构造器中,可以显式的使用
this(形参列表)
的方式,调用本类中指定的其它构造器。
构造器中不能通过
this(形参列表)
方式调用自身的构造器。
如果一个类中有n个构造器,则最多有 n - 1个构造器中使用了
this(形参列表)
规定:
this(形参列表)
必须声明在当前构造器的首行。
构造器内部,最多只能声明一个
this(形参列表)
,用来调用其它的构造器。
除构造器之外,编译器禁止在其它任何方法中调用构造器。
代码演示:
class Person{ // 定义Person类 private String name ; private int age ; public Person(){ // 无参构造器 System.out.println("新对象实例化") ; } public Person(String name){ this(); // 调用本类中的无参构造器 this.name = name ; } public Person(String name,int age){ this(name) ; // 调用有一个参数的构造器 this.age = age; } public String getInfo(){ return "姓名:" + name + ",年龄:" + age ; } }
3.3 返回当前对象
代码演示:
public class Leaf { int i = 0; Leaf increment(){ i++; return this; } void print(){ System.out.println("i = "+i); } public static void main(String args[]){ Leaf x = new Leaf(); x.increment().increment().increment().print();//i = 3 }}
二、“ super ”关键字的使用
1. 概述
(1)
super
理解为:父类的
(2)在Java类中使用super来调用父类中的指定操作:
super
可用于访问父类中定义的属性。
super
可用于调用父类中定义的成员方法。super
可用于在子类构造器中调用父类的构造器。
尤其当子父类出现同名成员时,可以用super
表明调用的是父类中的成员,super
的追溯不仅限于直接父类。super
和this
的用法相像,this
代表本类对象的引用,super
2. Funktion
dieses
-Schlüsselwort kann zum Ändern und Aufrufen von Eigenschaften, Methoden und Konstruktoren verwendet werden. Das Schlüsselwortthis
kann nur innerhalb einer Methode verwendet werden.
Es wird innerhalb einer Methode verwendet, d. h. als Referenz auf das Objekt, zu dem diese Methode gehört.
Es wird innerhalb eines Konstruktors verwendet und gibt das Objekt an, das vom Konstruktor initialisiert wird. 🎜🎜🎜3. Verwenden Sie 🎜🎜🎜🎜Wann sollten Sie dieses Schlüsselwort verwenden? 🎜🎜🎜🎜🎜Wenn Sie das Objekt verwenden müssen, das die Methode innerhalb einer Methode aufruft, verwenden Siethis
. Konkret: Wir könnenthis
verwenden, um Eigenschaften und lokale Variablen zu unterscheiden. Zum Beispiel:this.name = name;
🎜🎜3.1 Änderungseigenschaften und -methoden
🎜🎜this
wird verstanden als: das aktuelle Objekt oder das Objekt wird gerade erstellt
In Klassenmethoden können wirthis.property
oderthis.method
verwenden, um die Eigenschaften oder Methoden des aktuellen Objekts aufzurufen. Normalerweise entscheiden wir uns jedoch dafür,this.
wegzulassen. In besonderen Fällen, wenn der formale Parameter der Methode denselben Namen hat wie das Attribut der Klasse, müssen wir explizitthis.variable
verwenden, um anzugeben, dass die Variable ein Attribut und kein formaler Parameter ist.
Wenn Siethis
für den Zugriff auf Eigenschaften und Methoden verwenden und diese nicht in dieser Klasse gefunden werden, werden sie in der übergeordneten Klasse durchsucht. 🎜🎜🎜🎜Codedemonstration: 🎜🎜public class Person { private String name; private int age; private Date birthDate; public Person(String name, int age, Date d) { this.name = name; this.age = age; this.birthDate = d; } public Person(String name, int age) { this(name, age, null); } public Person(String name, Date d) { this(name, 30, d); } public Person(String name) { this(name, 30); } }public class Student extends Person { private String school; public Student(String name, int age, String s) { super(name, age); school = s; } public Student(String name, String s) { super(name); school = s; }// 编译出错: no super(),系统将调用父类无参数的构造器。 public Student(String s) { school = s; } }Nach dem Login kopierenNach dem Login kopieren3.2 Aufruf des Konstruktors
🎜🎜 Im Konstruktor einer Klasse können wirthis.property
oderthis.method verwenden
-Methode zum Aufrufen der Eigenschaften oder Methoden des Objekts, das gerade erstellt wird. Normalerweise entscheiden wir uns jedoch dafür,this.
wegzulassen. In besonderen Fällen, wenn der formale Parameter des Konstruktors denselben Namen wie eine Eigenschaft der Klasse hat, müssen wir explizitthis.variable
verwenden, um anzugeben, dass die Variable ein Attribut und kein formaler Parameter ist. 🎜🎜🎜🎜Im Konstruktor einer Klasse können wirthis (formale Parameterliste)
explizit verwenden, um andere in dieser Klasse angegebene Konstruktoren aufzurufen. 🎜🎜🎜🎜Der Konstruktor kann seinen eigenen Konstruktor nicht über die Methodethis (formale Parameterliste)
aufrufen. 🎜🎜🎜🎜 Wenn es n Konstruktoren in einer Klasse gibt, dann kann höchstens n - 1 haben 🎜diese (formale Parameterliste)
wird im Konstruktor verwendet 🎜🎜🎜🎜 legt fest:diese (formale Parameterliste)
muss in der ersten Zeile des aktuellen Konstruktors🎜 deklariert werden. 🎜🎜🎜🎜 Innerhalb des Konstruktors kann höchstens einenthis (formale Parameterliste)
deklarieren, der zum Aufrufen anderer Konstruktoren verwendet wird. 🎜🎜🎜🎜 Mit Ausnahme des Konstruktors verbietet der Compiler den Aufruf des Konstruktors in jeder anderen Methode. 🎜🎜🎜🎜Code-Demonstration: 🎜🎜rrreee3.3 Gibt das aktuelle Objekt zurück
🎜🎜Code-Demonstration: 🎜🎜rrreee🎜 2. Verwendung des Schlüsselworts „super“ 🎜🎜🎜1. Übersicht🎜🎜🎜🎜( 1)super
wird verstanden als: 🎜🎜🎜🎜 der übergeordneten Klasse (2) Verwenden Sie super in einer Java-Klasse, um die angegebene Operation in der übergeordneten Klasse aufzurufen:super Kann verwendet werden, um auf <span style="color:red"> Attribute 🎜 zuzugreifen, die in der übergeordneten Klasse definiert sind. 🎜🎜<code>super
kann verwendet werden, um Member-Methoden🎜 aufzurufen, die in der übergeordneten Klasse definiert sind.super
kann verwendet werden, um den -Konstruktor🎜 der übergeordneten Klasse im Unterklassenkonstruktor aufzurufen.
Besonders wenn ein Mitglied mit demselben Namen in einer untergeordneten oder übergeordneten Klasse erscheint, können Sie mitsuper
angeben, dass Sie ein Mitglied der übergeordneten Klasse aufrufen. Die Ablaufverfolgung vonsuper
ist nicht auf die direkte übergeordnete Klasse beschränkt.super
ähneltthis
.this
stellt eine Referenz auf ein Objekt dieser Klasse dar, undsuper
stellt den übergeordneten Bezeichner des Speicherplatzes der Klasse dar. 🎜🎜🎜2. Verwenden Sie 🎜🎜🎜, um die Struktur der übergeordneten Klasse in der Unterklasse explizit aufzurufen. 🎜
3.使用
3.1 调用属性和方法
我们可以在子类的方法或构造器中。通过使用"
super.属性
“或”super.方法
“的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,我们习惯省略”super.
"。
当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显式的使用"
super.属性
"的方式,表明调用的是父类中声明的属性。
当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"
super.方法
"的方式,表明调用的是父类中被重写的方法。
3.2 调用构造器
(1)子类中所有的构造器默认都会访问父类中空参数的构造器。
(2)当父类中没有空参数的构造器时,子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器,否则编译出错。同时,只能”二选一”,不能同时出现,且必须放在构造器的首行。
(3)在类的多个构造器中,至少有一个类的构造器中使用了"super(形参列表)",调用父类中的构造器。
代码演示:
public class Person { private String name; private int age; private Date birthDate; public Person(String name, int age, Date d) { this.name = name; this.age = age; this.birthDate = d; } public Person(String name, int age) { this(name, age, null); } public Person(String name, Date d) { this(name, 30, d); } public Person(String name) { this(name, 30); } }public class Student extends Person { private String school; public Student(String name, int age, String s) { super(name, age); school = s; } public Student(String name, String s) { super(name); school = s; }// 编译出错: no super(),系统将调用父类无参数的构造器。 public Student(String s) { school = s; } }
三、this和super的区别
No. | 区别点 | this | super |
---|---|---|---|
1 | 访问属性 | 访问本类中的属性,如果本类没有此属性则从父类中继续查找 | 直接访问父类中的属性 |
2 | 调用方法 | 访问本类中的方法,如果本类没有此方法则从父类中继续查找 | 直接访问父类中的方法 |
3 | 调用构造器 | 调用本类构造器,必须放在构造器的首行 | 调用父类构造器,必须放在子类构造器的首行 |
四、子类对象实例化的全过程
(1)从结果上来看:(继承性)
子类继承父类以后,就获取了父类中声明的属性或方法。
创建子类的对象,在堆空间中,就会加载所有父类中声明的属性。
(2)从过程上来看:
当我们通过子类的构造器创建子类对象时,我们一定会直接或间接的调用其父类的构造器,进而调用父类的父类的构造器,…直到调用了java.lang.Object
类中空参的构造器为止。正因为加载过所有的父类的结构,所以才可以看到内存中有父类中的结构,子类对象才可以考虑进行调用。
(3)明确:虽然创建子类对象时,调用了父类的构造器,但是自始至终就创建过一个对象,即为
new
的子类对象。
推荐学习:《java视频教程》
Das obige ist der detaillierte Inhalt vonDetaillierte Analyse der Java-Schlüsselwörter this und super. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

Video Face Swap
Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Leitfaden zur perfekten Zahl in Java. Hier besprechen wir die Definition, Wie prüft man die perfekte Zahl in Java?, Beispiele mit Code-Implementierung.

Leitfaden für Weka in Java. Hier besprechen wir die Einführung, die Verwendung von Weka Java, die Art der Plattform und die Vorteile anhand von Beispielen.

Leitfaden zur Smith-Zahl in Java. Hier besprechen wir die Definition: Wie überprüft man die Smith-Nummer in Java? Beispiel mit Code-Implementierung.

In diesem Artikel haben wir die am häufigsten gestellten Fragen zu Java Spring-Interviews mit ihren detaillierten Antworten zusammengestellt. Damit Sie das Interview knacken können.

Java 8 führt die Stream -API ein und bietet eine leistungsstarke und ausdrucksstarke Möglichkeit, Datensammlungen zu verarbeiten. Eine häufige Frage bei der Verwendung von Stream lautet jedoch: Wie kann man von einem Foreach -Betrieb brechen oder zurückkehren? Herkömmliche Schleifen ermöglichen eine frühzeitige Unterbrechung oder Rückkehr, aber die Stream's foreach -Methode unterstützt diese Methode nicht direkt. In diesem Artikel werden die Gründe erläutert und alternative Methoden zur Implementierung vorzeitiger Beendigung in Strahlverarbeitungssystemen erforscht. Weitere Lektüre: Java Stream API -Verbesserungen Stream foreach verstehen Die Foreach -Methode ist ein Terminalbetrieb, der einen Vorgang für jedes Element im Stream ausführt. Seine Designabsicht ist

Anleitung zum TimeStamp to Date in Java. Hier diskutieren wir auch die Einführung und wie man Zeitstempel in Java in ein Datum konvertiert, zusammen mit Beispielen.

Kapseln sind dreidimensionale geometrische Figuren, die aus einem Zylinder und einer Hemisphäre an beiden Enden bestehen. Das Volumen der Kapsel kann berechnet werden, indem das Volumen des Zylinders und das Volumen der Hemisphäre an beiden Enden hinzugefügt werden. In diesem Tutorial wird erörtert, wie das Volumen einer bestimmten Kapsel in Java mit verschiedenen Methoden berechnet wird. Kapselvolumenformel Die Formel für das Kapselvolumen lautet wie folgt: Kapselvolumen = zylindrisches Volumenvolumen Zwei Hemisphäre Volumen In, R: Der Radius der Hemisphäre. H: Die Höhe des Zylinders (ohne die Hemisphäre). Beispiel 1 eingeben Radius = 5 Einheiten Höhe = 10 Einheiten Ausgabe Volumen = 1570,8 Kubikeinheiten erklären Berechnen Sie das Volumen mithilfe der Formel: Volumen = π × R2 × H (4

Java ist eine beliebte Programmiersprache, die sowohl von Anfängern als auch von erfahrenen Entwicklern erlernt werden kann. Dieses Tutorial beginnt mit grundlegenden Konzepten und geht dann weiter zu fortgeschrittenen Themen. Nach der Installation des Java Development Kit können Sie das Programmieren üben, indem Sie ein einfaches „Hello, World!“-Programm erstellen. Nachdem Sie den Code verstanden haben, verwenden Sie die Eingabeaufforderung, um das Programm zu kompilieren und auszuführen. Auf der Konsole wird „Hello, World!“ ausgegeben. Mit dem Erlernen von Java beginnt Ihre Programmierreise, und wenn Sie Ihre Kenntnisse vertiefen, können Sie komplexere Anwendungen erstellen.
