Das letzte Mal schrieb ich einen Artikel "Ich interessiere mich für Webprogrammierung, also werde ich lernen", aber diesmal ist es Java: Sonnenbrille: Ich hatte mehr als zwei Jahre in einer Universitätsklasse Java studiert, aber ich habe es überhaupt nicht verstanden, also habe ich nur die notwendigen Teile als Notizbuch zusammengefasst. Ich habe in diesem Artikel auch über Objektorientierung geschrieben, aber ich denke, dass dies wichtig ist, da es auch ** zu einem Verständnis der Objektorientierung in PHP und JavaScript ** führt. Na dann, danke: information_desk_person:
Eine Klasse ist eine Sammlung von Prozessen, die zum Ausführen eines Programms erforderlich sind. Schreiben Sie den Anfang und das Trennzeichen des Wortes in Groß- und Kleinschreibung und Nomenklatur. Der Status und das Verhalten der Klasse werden im Teil des Ausführungsprozesses definiert. Die Art und Weise, es zu schreiben, ist wie folgt.
Klasse Klassenname{
Ausführungsverarbeitung...
}
In Java sind eine Datei und eine Klasse das Prinzip. Im Folgenden wird so geschrieben, dass eine Datei mehrere Klassen enthält. Wenn Sie den Code jedoch tatsächlich schreiben, trennen Sie sie bitte. (Warum nur 1 öffentliche Klasse in der Java-Datei)
Eine Mitgliedsvariable definiert den Status einer Klasse und kann Variablen vom Basistyp, Klassentyp und Array-Typ deklarieren.
Die Reihenfolge der Deklaration von Mitgliedsvariablen lautet "Name des Variablentyps".
Grundtyp: int id;
Klassentyp: Test a = neuer Test;
Array-Typ: int a []; oder int [] a;
Zu den Mitgliedsvariablen gehören Klassenvariablen und Instanzvariablen. Klassenvariablen sind Typen mit "statisch" vor sich. Instanzvariablen sind Variablen, die nicht "statisch" sind.
public class Test{
int id = 1; //Mitgliedsvariable (Instanzvariable)
static int value = 200; //Mitgliedsvariable (Klassenvariable)
void student(){ //Dies ist eine Methode
System.out.println(id);
System.out.println(value);
}
}
Darüber hinaus können Mitgliedsvariablen von jeder Methode oder jedem Konstruktor referenziert werden, der versucht, auf den Status dieser Klasse zu verweisen. Lokale Variablen, bei denen es sich um Variablen handelt, die den Status jeder Methode und jedes Konstruktors definieren, können jedoch nur innerhalb jeder Methode und jedes Konstruktors referenziert werden.
public class Student{
int grade = 1; //Mitgliedsvariablen
void student1(){
int id_1 = 7; //Lokale Variablen
System.out.println(grade); //Kann referenziert werden, da es sich um eine Mitgliedsvariable handelt
System.out.println(id_1); //Kann referenziert werden, da es sich um eine in student1 deklarierte lokale Variable handelt
System.out.println(id_2); //Kann nicht referenziert werden, da es sich um eine in student2 × deklarierte lokale Variable handelt
}
void student2(){
int id_2 = 1000;
System.out.println(grade); //Kann referenziert werden, da es sich um eine Mitgliedsvariable handelt
System.out.println(id_1); //Kann nicht referenziert werden, da es sich um eine in student1 × deklarierte lokale Variable handelt
}
}
Eine Methode definiert das Verhalten innerhalb einer Klasse. Es besteht aus den folgenden Formaten.
Modifikator Rückgabewert Datentyp Methodenname (Argumenttyp Argumentname)....）{
Methodenkörper
}
Der Rückgabewert ist der Wert, der an den Aufrufer der Methode zurückgegeben werden soll. Wenn kein Wert zurückgegeben wird (es gibt keinen Rückgabewert), wird er als ungültiger Typ beschrieben. Ein Beispiel ist unten geschrieben.
public class Return {
public static void print() { //Da es sich um einen ungültigen Typ handelt, wird kein Rückgabewert zurückgegeben
System.out.println("It all returns to nothing");
}
public static int add(int x) {
int result = x + 1999;
return result; //Die return-Anweisung gibt den Wert des Ergebnisses zurück.
}
public static void main(String[] args) {
int result = add(1); //Geben Sie aus Gründen der Übersichtlichkeit die Variable mit demselben Typ wie den von return zurückgegebenen Wert an
print(); //Ausgabe "Alles kehrt zu nichts zurück"
System.out.println(result); //Ausgabe als "2000"
}
}
Beschreiben Sie das Argument, wenn der Wert in der Methode geerbt werden muss. Wie zu schreiben ist (Argumenttyp formaler Argumentname ....)
Der Argumenttyp repräsentiert den Typ des zu vererbenden Werts, und der formale Argumentname repräsentiert den Variablennamen, auf den nur in der Methode verwiesen werden kann. Wenn kein zu erbender Wert vorhanden ist, wird nur () verwendet.
Die Methode zum Lesen der Methode mit Argumenten lautet Methodenname (Wert 1, Wert 2, ...);, und beim Lesen ändert sich der Name von ** formalem Argument ** zu ** tatsächlichem Argument **.
public class Argument {
public static void main(String[] args){
rabbithouse("Tomono Kafu"); //← Aktuelles Argument
rabbithouse("Hoto Shinai");
rabbithouse("Riyo Tenzenza");
amausaan("Chiya Ujimatsu");
fleur_du_lapin("Kirima Saji");
}
public static void rabbithouse(String name){ //← Formelles Argument
System.out.println("Kaninchenhaus:"+ name);
}
public static void amausaan(String name){
System.out.println("Kantoan:" + name);
}
public static void fleur_du_lapin(String name){
System.out.println("Fleur de Lapin:" + name);
}
}
Das Ausführungsergebnis wird so sein.
Kaninchenhaus:Tomono Kafu
Kaninchenhaus:Hoto Shinai
Kaninchenhaus:Riyo Tenzenza
Kantoan:Chiya Ujimatsu
Fleur de Lapin:Kirima Saji
Es gibt die folgenden Arten von Java-Modifikatoren. (Ich habe ziemlich viel weggelassen)
public: Keine Einschränkungen, kann von überall aus referenziert werden
protected: Nur von derselben Klasse, innerhalb desselben Pakets oder seiner Unterklassen zugänglich
privat: Kann nur aus derselben Klasse referenziert werden. Mitgliedsvariablen sind oft "privat", um aus der Kapselung zu lernen.
None: Sagen Sie Paket privat. Es kann nur von innerhalb des Pakets frei zugegriffen werden, wobei der Zugriffsmodifikator weggelassen wird.
②static Gibt an, dass es sich um eine Klassenvariable handelt. Sie können darauf zugreifen, ohne die Klasse zu instanziieren, sodass Sie mit "class name.member name" darauf zugreifen können.
③final Wenn Sie es für eine Klasse deklarieren, können Sie die Klasse nicht erben. Wenn sie an eine Methode angehängt ist, kann die Unterklasse die Methode nicht überschreiben.
Von hier aus werde ich auf die Objektorientierung eingehen.
Stellen Sie sich eine Klasse als Bild als Entwurfszeichnung, ein Objekt als Objekt (z. B. einen Menschen oder ein Auto) und eine Instanz als eine auf der Entwurfszeichnung erstellte Entität vor. .. ..
Die Instanz wird im folgenden Format erstellt.
Klassenname Variablenname = neuer Klassenname (Argument);
Es gibt zwei Möglichkeiten, auf eine Instanz zu verweisen.
Variablenname.Mitglied Variablenname;
Variablenname.Methodenname;
** Aktualisiert am 8. Juni ** In Java gibt es eine Namenskonvention, nach der alle Mitgliedsvariablen (Felder) und Methodennamen niedriger sind, und bei zusammengesetzten Zeichen ist das Trennzeichen höher. Es wird gesagt, dass es sich um einen Kamelfall handelt, aber er bemerkte, dass dies eine allgemeine Beschreibungsmethode ist. .. !! Im Folgenden wird der Variablenname auf "A" usw. gesetzt, aber er ist nicht üblich. Ich würde es begrüßen, wenn Sie ihn vervollständigen könnten ...: bow_tone1:
Ein Beispiel ist unten geschrieben.
class Instance {
String name = "Zerstörer vom Typ Weißtau "Yutachi""; //Mitgliedsvariablen
void shipType(){ //Methode
System.out.println("Zerstörer");
}
}
class MainClass{
public static void main(String[] args) {
Instance A = new Instance();
System.out.println(A.name); //Hier als "Weißtau-Zerstörer" Yutachi "ausgeben"
A.shipType(); //Geben Sie hier "Destroyer" aus
}
}
Ich habe oben ein wenig über die Mitgliedsvariablen (Felder) und Modifikatoren gesprochen, aber ich werde sie hier genauer erläutern.
Methoden und Variablen mit statischer Aufschrift werden in Nachschlagewerken und im Internet auf verschiedene Weise erwähnt, z. B. "statische Methode", "statische Methode", "Klassenmethode" und "Klassenvariable". Lass dich nicht durcheinander bringen: ängstlich: Umgekehrt werden Methoden und Variablen, die nicht statisch sind, als "Instanzmethoden", "nicht statische Methoden" und "Instanzvariablen" bezeichnet.
Da die statische Methode eine Methode der Klasse ist, kann sie von anderen statischen Methoden, Instanzmethoden oder einer anderen Klasse aufgerufen werden, ohne eine Instanz mit ** new ** zu erstellen.
Wenn Sie jedoch Ihre eigene Klasse aufrufen, können Sie method name (); verwenden. Wenn Sie jedoch eine andere Klasse aufrufen, müssen Sie class name.method name (); verwenden.
Außerdem werden statische Methoden von dieser Klasse gemeinsam genutzt und verwendet. Daher ändert sich der Prozess nicht, unabhängig davon, wo Sie ihn aufrufen. Wenn das Design also einen gemeinsamen Prozess oder Daten enthält, ist die statische Methode gut.
Eine Methode, die für jedes Objekt identifiziert wurde, das mit dem neuen Operator instanziiert wurde. Daher ** müssen Sie immer eine Instanz erstellen und aufrufen. ** ** **
Zusammenfassung
class Method1 {
//statische Methode, statische Methode, Klassenmethode
static void staticMethod1() {
// instanceMethod();Das ist nicht gut!Sie können nicht (direkt) über statische Methoden auf Instanzmethoden (in derselben Klasse) zugreifen.
Method1 a = new Method1(); //Erstellen Sie eine Instanz der Klasse
a.instanceMethod(); //Sie können über die Instanz auf Instanzmethoden mit indirektem Zugriff zugreifen.
}
//statische Methode / statische Methode
static void staticMethod1_1() {
staticMethod1(); //Da es sich um einen Anruf aus Ihrer eigenen Klasse handelt, benötigen Sie keinen Klassennamen.
Method1.staticMethod1(); //Sie können es immer noch nennen.
}
//Instanzmethode / nicht statische Methode
void instanceMethod() {
staticMethod1(); //Aufrufen einer statischen Methode von einer Instanzmethode(Zugriff)Auch ohne Klassennamen ok
Method1.staticMethod1(); //Sie können es immer noch nennen.
}
}
//Eine andere Klasse
class Method2 {
static void staticMethod2() {
// staticMethod1();Das ist nicht gut!
Method1.staticMethod1(); //Beim Aufruf aus einer anderen Klasse der Klassenname.statischer Methodenname
// instanceMethod();Das ist nicht gut!
Method1 b = new Method1(); //Wenn Sie auf eine Instanzmethode einer anderen Klasse zugreifen, greifen Sie über die Instanz auf die Instanzmethode zu
b.instanceMethod();
Method2 c = new Method2(); //Der Zugriff auf Instanzmethoden in Ihrer Klasse ist der gleiche.
c.instanceMethod2();
}
void instanceMethod2() {
Method1.staticMethod1_1(); //Ein Klassenname ist erforderlich, wenn eine statische Methode einer anderen Klasse von einer Instanzmethode aufgerufen wird!
staticMethod2();
Method3.staticMethod3();
}
}
class Method3 extends Method1{
static void staticMethod3() {
staticMethod1(); //Wenn es geerbt wird, kann es aufgerufen werden, ohne dass ein Klassenname erforderlich ist
//instanceMethod();Dies ist nicht gut für die Vererbung. Stellen Sie sicher, dass Sie eine Instanz der Klasse erstellen und über diese zugreifen
Method1 d = new Method1();
d.instanceMethod();
}
void instanceMethod3() {
staticMethod1();
}
}
Ein Konstruktor wird ausgeführt, wenn eine Instanz einer Klasse erstellt wird. Mit diesem Prozess können Sie die Werte von Elementvariablen ermitteln und initialisieren.
Um den Konstruktor aufzurufen, ist die Methode mit demselben Klassennamen wie beim Erstellen der Instanz mit Klassenname Variablenname = neuer Klassenname (Argument); der Konstruktor **.
Mit anderen Worten, es kann auch ausgedrückt werden als "Klassenname Variablenname = neuer Konstruktorname (Argument)".
public class Constructor1{
String name = "Aoyama Blue Mountain";
public Constructor1(){
System.out.println(name);
}
}
class Main{
public static void main(String[] args) {
Constructor1 cs = new Constructor1();
}
}
Das Ausführungsergebnis ist wie folgt.
Aoyama Blue Mountain
public class Constructor2{
public Constructor2(String str){
System.out.println(str);
}
}
class Main{
public static void main(String[] args){
Constructor2 A = new Constructor2("Hello");
}
}
Das Ausführungsergebnis ist wie folgt.
Hello
Verwenden Sie "this", wenn die Variablennamen der Mitgliedsvariablen (Felder) und der lokalen Variablen identisch sind. Wenn dies nicht hinzugefügt wird, haben die in der Methode definierten lokalen Variablen Vorrang, und auf die Elementvariablen (Felder) wird nicht verwiesen.
class ThisClass{
private int number;
public void setNumber(int number){ //Lokale Variablen(Streit)Der Wert von number ist eine Mitgliedsvariable(Falten)Ersetzen der Anzahl von
this.number = number + 100;
}
public int getNumber(){
return this.number;
}
}
class Main{
public static void main(String[] args) {
ThisClass A = new ThisClass();
A.setNumber(1);
System.out.println(A.getNumber()); //Es wird als 101 ausgegeben.
}
}
Im Vergleich zu der in der obigen Überschrift "Über Mitgliedsvariablen (Felder)" geschriebenen Schülerklasse mit oder ohne "dies", je nachdem, ob die Variablennamen der Mitgliedsvariablen (Felder) und der lokalen Variablen identisch sind. Bitte urteilen.
Verwenden Sie this (), wenn Sie die allgemeine Verarbeitung in nur einem Konstruktor beschreiben und diese Verarbeitung von einem anderen Konstruktor aus aufrufen möchten. Es unterscheidet sich von dem in ① geschriebenen.
class ThisConstructor {
private String ShopName;
private String CharacterName;
public ThisConstructor(String shopName , String CharacterName){
this.ShopName = shopName;
this.CharacterName = CharacterName;
}
//Festlegen des Standardwerts
public ThisConstructor(){
this("Kaninchenhaus" , "Tomono Kafu");
}
//Feldinitialisierung
public void print(){
System.out.println(ShopName+" : "+CharacterName);
}
}
class Main{
public static void main(String[] args) {
ThisConstructor tc1 = new ThisConstructor();
tc1.print();
ThisConstructor tc2 = new ThisConstructor("Kaninchenhaus" , "Riyo Tenzenza");
tc2.print();
}
}
Recommended Posts