Mal sehen, nachdem wir die Teile 1 und 2 gelesen haben. Suku. Ab diesem Zeitpunkt werde ich auf schwierige Teile wie Objektorientierung und Klassen eingehen. Lassen Sie uns also begeistert sein **
Java verwendet einen objektorientierten Typ, der für Anfänger ein Hindernis für das Verständnis darstellt. Aus dem Umriss geht die Idee hervor: "Sind nicht alle Dinge auf dieser Welt Objekte?" Um ein konkretes Beispiel zu geben: "Essen" ist ein abstraktes Konzept und es gibt viele Arten von Dingen, aber "Curry-Reis" existiert im Allgemeinen als feste Sache. Sie werden nur "Objekte" genannt.
Um die Objektorientierung zu beschreiben, beschreiben Sie zunächst den Umgang mit mehreren Dateien in Java. Dies liegt daran, dass ich grob beschreiben möchte, was ** für jede ** Datei beschrieben wird. Das folgende Programm berechnet die von der Tastatur gelesenen Zahlen (Standardeingabe), und die Dateien werden getrennt, und nur der Berechnungsprozess wird in einer separaten Datei gespeichert.
java/Main.java
//Eine Datei, die eine grobe Verarbeitung beschreibt
import java.io.*;
public class Main
{
public static void main(String[] args)throws IOException //Ausnahmebehandlung
{
BufferedReader br = //Du musst nicht brechen
new BufferedReader(new InputStreamReader(System.in));
int num1, num2; //Variablen, denen später Nummern zugewiesen werden
int ans; //Variable, um die Antwort zuzuweisen
System.out.println("Bitte geben Sie die beiden Nummern ein, die Sie hinzufügen möchten");
System.out.print("Der erste>"); //println bricht ab, print jedoch nicht
String str1 = br.readLine();
num1 = Integer.parseInt(str1);
System.out.print("Zweite>");
String str2 = br.readLine();
num2 = Integer.parseInt(str2);
System.out.println("mathematics.Rufen Sie Java an\n"); // \n ist der Code, der bricht
ans = math(num1, num2); //Überlassen Sie die Berechnung einer anderen Datei und ersetzen Sie sie
System.out.println("Berechnungsergebnis>" + ans);
br.close(); //Kündigungserklärung von br
}
}
Verarbeitung mit einer anderen Datei von hier
java/mathematics.java
class mathematics
{
int math(int num1, int num2) //Siehe unten für Details. Eine mathematische Funktion definieren
{
int ans;
ans = num1 + num2;
return ans; //return ist die Anweisung, die an die Originaldatei gesendet werden soll
//Sammle diese drei Zeilen und "kehre zurück"(num1 + num2);"Ist gut.()Es ist vielleicht nicht notwendig, aber es ist leicht zu verstehen, also beschreiben Sie es
}
}
Wenn Sie dies tun, sollten Sie das Ergebnis der Berechnung der beiden Zahlen sehen. Dieses Mal habe ich beim Trennen der Dateien die Syntax "public static void main (String [] args)" nicht in Mathematics.java geschrieben, da sie ** eine Datei darstellt, die der Ausführung gewidmet ist **. Main.java wird angegeben, da es sich um eine auszuführende Datei handelt.
Anschließend wird die Berechnung an die Datei übergeben. Sie kann jedoch ausgeführt werden, indem der Teil "int math (int num1, int num2)" aufgerufen wird, der in einer anderen Datei in der Hauptdatei geschrieben ist. Sie können es in der mathematischen Funktion aufrufen, indem Sie den Typ und den Namen des Typs, den Sie aufrufen möchten (verschiedene Namen sind möglich, nicht empfohlen), wie z. B. "int num", in eine separate Datei schreiben. Dies nennt man ** Argument **
Und "Zurück" am Ende der mathematischen Funktion ist der Vorgang, bei dem die Antwort auf die ursprüngliche Hauptfunktion zurückgegeben und der Prozess auf Haupt verschoben wird. Dieser Wert wird als ** Rückgabewert ** bezeichnet. Das erste int von "int math (int ...)" in math.java bedeutet ** Rückgabewert an int **.
Schauen Sie noch einmal zurück und schauen Sie sich die beiden Dateien an. Ich denke, die Syntax ist "sichtbarer" als beim ersten Mal.
Das ist das Hauptthema. Ein Objekt ist das Curry, das ich zuvor erwähnt habe. Sogar Udon und Tee sind alles Objekte. ** Objekte sind nicht auf Java beschränkt, sondern Objekte, mit denen Sie freie Typen erstellen und freie Werte wie Funktionen eingeben können. Dies ist sehr praktisch, da Sie eine Vielzahl von Verarbeitungsmöglichkeiten erstellen können. Zuerst aus der Syntax. Ab diesem Zeitpunkt gibt es grundsätzlich mehr als eine Java-Datei.
java/Car.java
public class Car
{
String carName; //Fahrzeugtyp
String companyName; //Name der Firma
double weight; //Gewicht
int number; //Nummer
Car(String carName, String companyName, double weight, int number) //Es gibt 4 Argumente
{
this.carName = carName; //Dazu später mehr.
this.companyName = companyName;
this.weight = weight;
this.number = number;
}
}
Bis zu diesem Punkt eine Java-Datei, die einen "Auto" -Typ erstellt. Erstellen Sie als Nächstes eine Hauptdatei, die ausgeführt werden kann.
java/Main.java
public class Main
{
public static void main(String[] args)
{
System.out.println("Rufen Sie nun den Typ "Auto" auf, um das NISSAN-Blatt zu erstellen");
String carName = "Blatt";
String companyName = "NISSAN";
double weight = 1600.0;
int number = 1234;
Car car1 = new Car(carName, companyName, weight, number);
//Auto in Autodatei(4 Argumente)
System.out.println(car1.Name + "Namens");
//Nach dem Variablennamen ".Schreiben Sie den Artikel, den Sie anrufen möchten, mit ""
}
}
Dieses Mal habe ich eine Syntax vorbereitet, um zu bestätigen, dass das Nissan-Blatt erstellt und aufgerufen wurde. Schauen wir uns jeden an.
Ich werde anhand der in Car.java geschriebenen Syntax erklären. Der Gegenstand, den Sie vorbereiten möchten, wird nach der Klasse Auto beschrieben. Das Wichtigste ist, dass danach in dem als Car () beschriebenen Teil "dies" beschrieben wird. Es hat einen ** Verweis auf sich selbst ** und wird verwendet, um zu unterscheiden, ob CarName ein Argument oder eine in Car.java vorbereitete Variable ist. In diesem Fall wird ** dies an die in Car.java vorbereitete Variable ** angehängt. ** Das Argument verschwindet, ohne gespeichert zu werden, wenn die Verarbeitung der Funktion abgeschlossen ist **, sodass es in der Funktion gespeichert wird.
Werfen wir einen Blick in die Hauptfunktion. Diesmal ist eine neue Syntax "neues Auto (weggelassen)" erschienen. Dies ist das "Objekt", das ich wiederholt erwähnt habe. Die Syntax lautet diesmal ** "Der Name und die Nummer des Fahrzeugtyps car1 werden von Car (weggelassen) festgelegt!" **. In dem Moment, in dem es aufgerufen wird, wird die Zuweisung in Car.java ausgeführt, der Prozess wird gespeichert und es wird zur Hauptfunktion ** zurückgekehrt.
Und hier gibt es eine Gefahr: "Wenn Sie nicht ** in der richtigen Reihenfolge schreiben **, wird es verschiedenen Variablen zugewiesen." In dem Moment, in dem Sie beispielsweise "neues Auto (Firmenname, Autoname, ...)" in Main schreiben, werden der Firmenname und der Autotyp umgeschaltet. Es muss in der gleichen Reihenfolge in Car.java beschrieben werden. Außerdem ** können derzeit "nur Autos mit vier Argumenten erstellt werden" **. Zum Beispiel kann man nicht sagen: "Das Gewicht des Autos ist mir egal! Ich werde es nicht schreiben!" Die einzige Möglichkeit, dies zu vermeiden, besteht darin, ** eine Syntax mit drei zusätzlichen Argumenten zu schreiben **.
... aber es ist nervig, nicht wahr? Ich schreibe absichtlich den Inhalt der ganzen Straße.
Wenn es sich nur um den Inhalt handelt, kann er bis zu einem gewissen Grad übersprungen werden. Banzai Es ist einfach zu machen. Siehe die Syntax unten.
java/Car.java
//Kürzung
//Die Syntax, die ich zuvor geschrieben habe
Car(String carName, String companyName, double weight, int number) //Es gibt 4 Argumente
{
this.carName = carName; //Dazu später mehr.
this.companyName = companyName;
this.weight = weight;
this.number = number;
}
Car(String carName)//Syntax, um vorerst nur das Modell zu bestimmen
{
this(carName, "nicht definiert", 0.0, 0); //Übergeben Sie die Verarbeitung an die Syntax mit vier Argumenten
}
Selbst wenn Car nur ein Argument hat, können Sie es auf diese Weise genießen, indem Sie den Teil von vier Argumenten im Inneren aufrufen (und Fehler reduzieren). Eine ** "typbestimmende Funktion" wie diese wird als "Konstruktor" ** bezeichnet, und das Aufrufen eines der Konstruktoren mit zwei oder mehr Kombinationen wird als "Überladung" ** bezeichnet. ..
--Was ist Objektorientierung?
Recommended Posts