Que gérer cette fois
--Méthode --Héritage
Comme le précédent "Constructor", il est difficile à comprendre car c'est un lieu lié à l'orientation de l'objet. Je vais le décrire avec un exemple. Veuillez lire jusqu'à part3. Si vous pouvez comprendre cette partie, il sera plus facile de programmer dans une autre langue, ce qui est une façon de penser très pratique. Faisons de notre mieux.
Ici, je vais parler de la partie orientée objet et super importante, la méthode. Une méthode est une partie qui décrit «quel type de comportement» est donné à un objet créé par soi-même. Lorsqu'un objet appelé "notebook PC" est créé, le constructeur décrit l'objet lui-même comme "who", "color" et "hardware configuration". D'un autre côté, ** les méthodes peuvent définir des transitions comportement / état telles que "démarrer", "se connecter au réseau" et "compresser des fichiers" **.
java/Car.java
public class Car
{
int number;
String owner;
int speed;
public Car()
{
this(0000, "None", 0);
}
public Car(int number, String owner, int speed)
{
this.number = number;
this.owner = owner;
this.speed = speed;
}
void info()
{
System.out.println("nombre:" + this.number);
System.out.println("propriétaire:"+ this.owner);
System.out.println("la vitesse:"+ this.speed);
}
}
java/Main.java
public class Main
{
public static void main(String[] args)
{
Car car1 = new Car(1234, "Takahashi", 40);
car1.info();
Car car2 = new Car();
car2.info();
}
}
Cette fois, j'ai fait deux voitures. L'un est un simple propriétaire et l'autre est une voiture sans rien. "Void info ()" de Car.java est appelé par "~ .info ();" dans Main.java, et il est exécuté dans l'ordre, donc toutes les informations ont été affichées sous forme d'informations. Lorsqu'un objet appelle une méthode, comme "car1.info ()", ** décrivez la méthode que vous voulez appeler avec "." Après le nom de la variable et appelez-la. Comme pour le constructeur, si la méthode que vous appelez contient des ** arguments, incluez-les également **.
...
Je veux que vous attendiez un moment.
Revenons sur part3.
"Transfert du calcul vers un fichier, mais exécution en appelant la partie" int math (int num1, int num2) "écrite dans un autre fichier du fichier principal"
Oui, vous avez déjà écrit une "méthode avec une valeur de retour" **. L'intégration de l'orientation objet ne change rien. ** "Méthodes qui ne peuvent être exécutées que par des objets" ** Est-ce ** "Méthodes que la fonction principale elle-même exécute" ** Seulement changé.
Puisque la méthode est la partie qui décrit le comportement de l'objet, en un sens ** «caractéristiques», l'avantage est que le comportement est le même même s'il est appelé par plusieurs objets **. Cette partie est utile pour l'héritage et l'interface dont nous parlerons ensuite.
Je voulais vraiment écrire l'héritage tout de suite, mais je vais aborder quelque chose qui est vraiment utile pour faire de l'héritage avec une syntaxe intacte.
C'est un tableau. Je ne l'ai pas encore fait.
En tant que sens du mot, c'est "un groupe de séquences disposées en ligne du début à la fin". Cependant, il y a des parties ennuyeuses, alors je vais y aller poliment.
java/Array.java
public class Array
{
public static void main(String[] args)
{
int[] array = {1, 3, 5, 7, 9};
/*
↓ Faire la même chose en une seule ligne
int array[] = new int[5]; //Syntaxe des objets
array[0] = 1;
array[1] = 3;
array[2] = 5;
array[3] = 7;
array[4] = 9;
*/
for(int i = 0; i < array.length; i++) //array.length représente la longueur du tableau
{
System.out.println((i+1) + "Nombre d'objets:" + array[i]);
//L'instruction for tourne println pour 5 lignes
//array[i]Par, vous pouvez sortir depuis le début de l'élément
}
}
}
Les tableaux sont difficiles à comprendre car le premier nombre du ** numéro d'élément (tableau ** ** [?]) Est compris entre 0 et **. Je veux que vous le divisiez en une telle chose. La syntaxe est presque la même que celle de l'objet, mais la différence est que [] est ajouté au nom. ** Le type est simplement "int []" **. Bien sûr, il peut être double ou String, et ** des objets peuvent également être insérés **. Notez que si vous écrivez sur une ligne, "[]" sera attaché au motif.
Le contenu de l'instruction for veut simplement afficher le contenu du tableau. ** ".length" ** est utilisé pour éviter autant que possible les bogues. Cela signifie que ** Java s'en occupe sans spécifier la longueur du tableau **. Par exemple, lorsque vous souhaitez gérer des données à l'aide de plusieurs tableaux, la copie de la même syntaxe avec différents éléments est difficile à voir car le fichier devient long. Dans un tel cas, sachant cela, si vous la définissez comme une méthode, elle sera exécutée en tenant compte de tout en un seul coup. Pratique.
Avant d'expliquer l'héritage en Java, je transmettrai l'idée d'héritage.
** L'héritage signifie «donner son propre comportement et ses caractéristiques à son enfant» **. Plus précisément, la «voiture» parente peut fonctionner et rester immobile, elle est lourde et volumineuse. Et la "super voiture" héritée fonctionne très vite, et le poids est un peu plus léger et plus gros. De cette façon, ** un enfant qui a été amélioré tout en conservant certaines fonctions et caractéristiques est appelé une sous-classe, et son parent est appelé une superclasse **.
Je vais également créer une voiture cette fois-ci, et créer et expliquer une super voiture qui en hérite.
java/Car.java
public class Car
{
double weight;
int speed;
Car()
{
this(0.0, 0);
}
Car(double weight, int speed)
{
this.weight = weight;
this.speed = speed;
}
Car(int speed, double weight)
{
this(weight, speed);
}
void drive()
{
System.out.println("La vitesse" + this.speed + "Ran dans");
}
void info()
{
System.out.println("Pèse" + this.weight + "kg");
System.out.println("La vitesse est" + this.speed + "est");
}
}
java/SuperCar.java
public class SuperCar extends Car
{
int max_speed;
SuperCar()
{
this(0, 0, 0);
}
SuperCar(double weight, int speed, int max_speed)
{
super(weight, speed);
this.max_speed = max_speed;
}
void CarChase()
{
System.out.println("La vitesse" + max_speed + "Poursuite en voiture à");
}
void info()
{
super.info();
System.out.println("La vitesse maximale est" + max_speed + "est");
}
}
java/Main.java
public class Main
{
public static void main(String[] args)
{
Car normal = new Car(200.0, 40);
SuperCar superCar = new SuperCar(180.0, 50, 200);
superCar.drive(); //Vous pouvez l'appeler même si ce n'est pas écrit!
System.out.println("\n");
superCar.info();
}
}
Cette fois, nous avons hérité des éléments de la voiture dans la super voiture et appelé la méthode de la classe parente dans la sous-classe **. En Java (ou plutôt orienté objet), les enfants sont meilleurs que les parents. Il est également possible de créer des méthodes et des constructeurs uniques à la classe enfant et ** modifier le contenu de la classe parent pour la classe enfant **. Si vous voulez appeler le contenu de la classe parente tel quel, utilisez "super".
―― Qu'est-ce que l'héritage? -> Transmission de parent à enfant ―― Qu'est-ce qu'un parent? Qu'est-ce qu'un enfant? -> La classe transmise est "enfant" ―― Qu'est-ce que «super»? -> Obligatoire lorsqu'un enfant appelle un parent
Recommended Posts