Für alle, die Java als neuer Mitarbeiter studiert haben Ich möchte es unregelmäßig aktualisieren.
Das Thema dieses Mal ist "Wie man eine Klasse schreibt".
Erstens ist die Grundform der Klasse. Betrachten Sie als Beispiel eine Klasse, die eine "Person" darstellt.
public class Person {
/**Vollständiger Name*/
private String name;
/**Alter*/
private int age;
/**
*Konstrukteur
* @Param Name vollständiger Name
* @param Alter Alter
*/
public Person(String name, int age) {
this.name = name;
this.age = age;
}
/**
*Alter bekommen
*/
public int getAge() {
return this.age;
}
/**
*Werde ein Jahr alt
*/
public void countUpAge() {
this.age++;
}
/**
*Vorstellen
*/
public void introduction() {
System.out.println("Hallo ich" + this.name + ", " + this.age + "Ich bin alt.");
}
}
Nicht beschränkt auf die diesmal eingeführten Klassen Die Klassen sind grob in drei Abschnitte unterteilt.
Name der öffentlichen Klasse{
Feld
Konstrukteur
Methode
}
In der Person-Klasse bezieht es sich auf die folgenden Teile.
/**Vollständiger Name*/
private String name;
/**Alter*/
private int age;
Felder sind ** Variablen **, die überall in der Klasse verwendet werden können. Mit anderen Worten, Sie können mit verschiedenen Methoden innerhalb derselben Klasse auf dieselbe Variable verweisen.
In der Person-Klasse bezieht es sich auf den folgenden Teil.
/**
*Konstrukteur
* @Param Name vollständiger Name
* @param Alter Alter
*/
public Person(String name, int age) {
this.name = name;
this.age = age;
}
Übrigens lautet der Code beim Initialisieren dieser Personenklasse wie folgt.
Person person = new Person("Taro", 10);
Auf diese Weise wird der Konstruktor verwendet, um bestimmte Aktionen zu Beginn auszuführen.
Bei der Initialisierung eines Objekts wird der Konstruktor immer aufgerufen Es wird häufig zum Festlegen von Feldwerten verwendet.
In der Person-Klasse bezieht es sich auf den folgenden Teil.
/**
*Alter bekommen
*/
public int getAge() {
return this.age;
}
/**
*Werde ein Jahr alt
*/
public void countUpAge() {
this.age++;
}
/**
*Vorstellen
*/
public void introduction() {
System.out.println("Hallo ich" + this.name + ", " + this.age + "Ich bin alt.");
}
Die Methode beschreibt den auszuführenden Prozess.
Die Methode wird verwendet, um einen Prozess zusammenzustellen.
Sie können die gesamte Verarbeitung zusammenstellen, Es ist für die Leute einfacher zu sehen, ob Sie jedes Verfahren einzeln aufteilen.
Sie können der Methode also einen Namen geben Es ist wichtig, sie gut nach dem Zweck und den zu behandelnden Variablen zu unterteilen.
Die Grundform des Verfahrens ist wie folgt.
Zugriffsqualifizierer Rückgabetyp Methodenname(Argument 1,Argument 2, ...) {
wird bearbeitet
return Rückgabewert;
}
Erinnerst du dich, das Wort "Funktion" während der Mathematikzeit gehört zu haben?
f(x) = x + 1
Wenn dies in eine Java-Methode konvertiert wird, lautet die Beschreibung wie folgt.
public void func(x) {
return x + 1;
}
Beide sind "return durch Hinzufügen von 1 zum Argument x".
Tatsächlich sind "Methoden" und "Funktionen" sehr nahe beieinander und beziehen sich fast auf dasselbe. In der Sprache C wird die folgende Beschreibung beispielsweise als Funktion bezeichnet.
int func(x) {
return x + 1;
}
In objektdenkenden Sprachen wie Java wird die Beschreibung einer in einer Klasse beschriebenen Funktion als Methode bezeichnet.
Ich möchte den genauen Unterschied zwischen Funktionen und Methoden zu einem anderen Zeitpunkt erklären.
Der Zugriffsmodifikator definiert, inwieweit auf das Feld oder die Methode zugegriffen werden kann. Es wird als öffentlich oder privat angegeben.
Wenn öffentlich gegeben wird, ist es von außerhalb der Klasse zugänglich, Mit prvate können Sie nur innerhalb dieser Klasse darauf zugreifen.
Im folgenden Fall wird beispielsweise eine Methode namens ** getAge ** definiert, die ** int (numerischer Wert) ** zurückgibt.
public int getAge() {
return this.age;
}
Durch Angabe des Typs dieses Rückgabewerts ist der Aufrufer dieser Methode Sie können erkennen, dass "diese Methode einen int-Typ zurückgibt".
//Sie können das Alter einer solchen Person ermitteln
int himAge = person.getAge();
//Dies führt zu einer Typinkongruenz und einem Fehler
String himAge = person.getAge();
Wenn es keinen Rückgabewert gibt, setzen Sie das Zeichen "void" im Rückgabewertteil. void bedeutet "leer / nichts".
Wenn für den Rückgabewert void angegeben ist, wird kein Wert zurückgegeben, sodass die Rückgabe nicht beschrieben werden muss.
/**
*Werde ein Jahr alt
*/
public void countUpAge() {
this.age++;
//Sie können die "Rückkehr" weglassen, die hier sein sollte.
}
Fügen wir nun die "Methode zum Festlegen des Namens" hinzu.
Vornamen umfassen Vor- und Nachnamen und manchmal Zweitnamen. Erstellen wir eine entsprechende Namenseinstellungsmethode.
/**
*Unterstützungsmethode für Vor- und Nachnamen
* @param lastName Nachname
* @param Vorname Vorname
*/
public void setName(String lastName, String firstName) {
this.name = lastName + " " + firstName;
}
/**
*Methode für den zweiten Vornamen
* @param lastName Nachname
* @param Vorname Vorname
* @param middleName zweiter Vorname
*/
public void setName(String lastName, String firstName, String middleName) {
this.name = firstName + "・" + middleName + "・" + lastName;
}
Lassen Sie uns nun jedes dieser Schritte ausführen.
person.setName("Sato", "Taro");
// ->"Taro Sato"
person.setName("Sato", "Christina", "Taro");
// ->"Taro, Christina, Sato"
Auf diese Weise können Sie mit derselben Methode namens "setName" verschiedene Dinge tun.
Dies wird als ** "Methodenüberladung" ** bezeichnet.
Überladen kann verwendet werden, wenn Sie mehrere Argumente für denselben Zweck haben.
Ich denke, es gibt einige Leute, die sagen: "Ich verstehe nicht, weil es so viele Dinge in der Klasse gibt."
Es gibt jedoch nicht viele Regeln, an die man sich erinnern muss.
Der Quellcode ist einfacher zu lesen, wenn Sie ihn in die drei diesmal eingeführten Elemente aufteilen.
Ohne plötzlich alles zu lesen Ist es nicht der erste Schritt zum Verständnis, Stück für Stück getrennt zu denken?
Recommended Posts