Voyons voir après avoir lu les parties 1 et 2. Suku. À partir de ce moment, je vais aborder des parties difficiles telles que l'orientation des objets et les classes, alors soyons enthousiastes **
Java utilise un type orienté objet, ce qui constitue un obstacle à la compréhension des débutants. D'après les grandes lignes, l'idée est: "Toutes les choses de ce monde ne sont-elles pas des objets?" Pour donner un exemple concret, ** «nourriture» est un concept abstrait et il existe de nombreuses sortes de choses **, mais ** «riz au curry» existe généralement comme une chose fixe **. Ils sont simplement appelés "objets".
Pour décrire l'orientation des objets, décrivez d'abord comment gérer plusieurs fichiers en Java. C'est parce que je veux diviser grossièrement ce qui est décrit ** pour chaque ** fichier. Ce qui suit est un programme qui calcule les nombres lus par le clavier (entrée standard), et les fichiers sont séparés et seul le processus de calcul est enregistré dans un fichier séparé.
java/Main.java
//Un fichier qui décrit un traitement approximatif
import java.io.*;
public class Main
{
public static void main(String[] args)throws IOException //Gestion des exceptions
{
BufferedReader br = //Tu n'as pas à casser
new BufferedReader(new InputStreamReader(System.in));
int num1, num2; //Variables auxquelles les numéros seront attribués ultérieurement
int ans; //Variable pour attribuer la réponse
System.out.println("Veuillez saisir les deux chiffres que vous souhaitez ajouter");
System.out.print("Le premier>"); //println s'arrête, mais pas l'impression
String str1 = br.readLine();
num1 = Integer.parseInt(str1);
System.out.print("Seconde>");
String str2 = br.readLine();
num2 = Integer.parseInt(str2);
System.out.println("mathematics.Appeler java\n"); // \n est le code qui casse
ans = math(num1, num2); //Laissez le calcul dans un autre fichier et remplacez
System.out.println("Résultat du calcul>" + ans);
br.close(); //Déclaration de résiliation de br
}
}
À partir de là, traitement avec un autre fichier
java/mathematics.java
class mathematics
{
int math(int num1, int num2) //Voir ci-dessous pour plus de détails. Définition d'une fonction mathématique
{
int ans;
ans = num1 + num2;
return ans; //return est la déclaration à envoyer au fichier d'origine
//Collectez ces trois lignes et «retournez»(num1 + num2);"C'est bien.()Ce n'est peut-être pas nécessaire, mais c'est facile à comprendre, alors décrivez-le
}
}
Lorsque vous faites cela, vous devriez voir le résultat du calcul des deux nombres. Cette fois, lors de la séparation des fichiers, je n'ai pas écrit la syntaxe "public static void main (String [] args)" dans mathématique.java car elle représente ** un fichier dédié à l'exécution **. Main.java est spécifié car il s'agit d'un fichier à exécuter.
Ensuite, le calcul est passé au fichier, mais il peut être exécuté en appelant la partie "int math (int num1, int num2)" écrite dans un autre fichier du fichier principal. Vous pouvez l'appeler dans la fonction mathématique en écrivant le type et le nom du type que vous souhaitez appeler (différents noms sont possibles, non recommandés), comme "int num" dans un fichier séparé. Cela s'appelle ** argument **
Et «retour» à la fin de la fonction mathématique est le processus de retour de la réponse à la fonction principale d'origine et de déplacement du processus vers Main. Cette valeur est appelée ** valeur de retour **. Le premier entier de "int math (int ...)" écrit en mathématique.java signifie ** retourne la valeur à int **.
Revenez en arrière et regardez les deux fichiers. Je pense que la syntaxe est plus "visible" que lorsque vous l'avez vue pour la première fois.
--Jouez Java avec plusieurs fichiers
C'est le sujet principal. L'objet est le curry que j'ai mentionné plus tôt. Même l'udon et le thé sont tous des objets. Non limité à Java, les objets ** sont des objets qui vous permettent de créer des types libres et de saisir des valeurs libres de la même manière que les fonctions, ce qui est très pratique car vous pouvez créer une large gamme de traitements. D'abord de la syntaxe. À partir de ce moment, il existe essentiellement plus d'un fichier Java.
java/Car.java
public class Car
{
String carName; //Type de véhicule
String companyName; //Nom de la compagnie
double weight; //poids
int number; //nombre
Car(String carName, String companyName, double weight, int number) //Il y a 4 arguments
{
this.carName = carName; //Plus à ce sujet plus tard.
this.companyName = companyName;
this.weight = weight;
this.number = number;
}
}
Jusqu'à présent, un fichier java qui crée un type "voiture". Ensuite, créez un fichier principal qui peut être exécuté.
java/Main.java
public class Main
{
public static void main(String[] args)
{
System.out.println("Appelez maintenant le type "voiture" pour créer la feuille NISSAN");
String carName = "Feuille";
String companyName = "NISSAN";
double weight = 1600.0;
int number = 1234;
Car car1 = new Car(carName, companyName, weight, number);
//Voiture dans le fichier de voiture(4 arguments)
System.out.println(car1.Name + "Appelé");
//Après le nom de la variable, ".Écrivez l'élément que vous souhaitez appeler avec ""
}
}
Cette fois, j'ai préparé une syntaxe pour confirmer que la feuille Nissan a été créée et appelée. Regardons chacun d'eux.
Je vais expliquer à partir de la syntaxe écrite en Car.java. L'élément que vous souhaitez préparer est décrit après la classe Voiture. L'important est après cela, dans la partie décrite comme Car (), "ceci" est décrit. Il a une ** référence à lui-même ** et est utilisé pour distinguer si CarName est un argument ou une variable préparée dans Car.java. Dans ce cas, ** ceci est attaché à la variable ** préparée dans Car.java. ** L'argument disparaît sans être sauvegardé lorsque le traitement de la fonction est terminé **, il est donc sauvegardé dans la fonction.
Jetons un coup d'œil à l'intérieur de la fonction Main. Cette fois, une nouvelle syntaxe "nouvelle voiture (omise)" est apparue. C'est l '«objet» que j'ai mentionné à plusieurs reprises. Expliquant cette fois, la syntaxe est ** "Le nom et le numéro du type de voiture car1 est décidé par Car (omis)!" **. Ensuite, ** au moment où il est appelé, l'affectation est effectuée dans Car.java, le processus est enregistré et il revient à la fonction Main **.
Et il y a un piège ici: "Si vous n'écrivez pas ** dans l'ordre **, il sera affecté à différentes variables." Par exemple, au moment où vous écrivez "new Car (companyName, carName, ...)" dans Main, le nom de la société et le modèle de voiture changent. Il doit être décrit dans le même ordre dans Car.java. De plus, ** à ce stade, "seules les voitures avec quatre arguments peuvent être créées" **. Par exemple, vous ne pouvez pas dire: "Je me fiche du poids de la voiture! Je ne l'écrirai pas!" Le seul moyen d'éviter cela est de ** écrire une syntaxe avec trois arguments supplémentaires **.
... mais c'est ennuyeux, non? J'écris volontairement le contenu de toute la rue.
S'il ne s'agit que du contenu, il peut être ignoré dans une certaine mesure. Banzai C'est facile à faire. Voir la syntaxe ci-dessous.
java/Car.java
//réduction
//La syntaxe que j'ai écrite plus tôt
Car(String carName, String companyName, double weight, int number) //Il y a 4 arguments
{
this.carName = carName; //Plus à ce sujet plus tard.
this.companyName = companyName;
this.weight = weight;
this.number = number;
}
Car(String carName)//Syntaxe pour décider uniquement du modèle pour le moment
{
this(carName, "indéfini", 0.0, 0); //Passer le traitement à la syntaxe à quatre arguments
}
De cette façon, même si Car n'a qu'un seul argument, vous pouvez en profiter en appelant la partie des quatre arguments à l'intérieur (et réduire les erreurs). Une ** "fonction de détermination de type" comme celle-ci est appelée un "constructeur" **, et appeler l'un des constructeurs avec deux combinaisons ou plus est appelé une "surcharge" **. ..
Recommended Posts