J'améliore constamment mon code hérité, mais je ne travaille que sur l'amélioration de mon code hérité, donc j'aimerais en savoir plus sur l'orientation des objets et publier cet article.
Combinaison des processus nécessaires pour réaliser le système en plusieurs parties
--Problèmes d'écriture de code
Le processus devient trop long et l'esprit humain ne sait pas ce qu'il fait. Même si vous pouvez faire quelque chose qui fonctionne, lorsque vous faites de la maintenance, etc. Quand je l'ai relu, je ne sais pas ce que je fais et où. → Le premier goulot d'étranglement du développement
――Où et quelle fonction ――Comment créer un système en combinant les fonctions
L'idée d'assembler le processus de développement d'un logiciel en plusieurs parties
Par exemple, quand il y a une chose (objet) appelée un train Pensez à quel type de mouvement est un train.
--Le train bouge --Le train s'arrête
Comme mentionné ci-dessus, quand j'ai pensé à faire quelque chose qui s'appelle un train Pensez au type de traitement qui en fera un train
Nous utiliserons les trois éléments majeurs ci-dessus pour réfléchir à la manière de créer des objets (processus) et de les lier, et non à ce que fait chaque ligne du programme.
J'expliquerai chacun des trois éléments majeurs.
En supposant qu'il existe une classe Vehicle comme la suivante, une méthode appelée moveOn est préparée.
Ce type de construction est appelé encapsulation.
Vehicle.java
public class Vehicle {
private Boolean isMove = false;
public void moveOn() {
this.isMove = true;
System.out.println("Le véhicule bouge");
}
public void stop() {
this.isMove = false;
System.out.println("Le véhicule s'arrêtera");
}
}
L'encapsulation est implémentée en limitant la lecture et l'écriture aux champs et aux appels aux méthodes, de sorte que les changements à l'intérieur de l'objet provoqueront des interférences inattendues et un impact sur l'extérieur, ce qui rendra difficile la rupture.
Le contrôle d'accès comprend les quatre étapes suivantes.
| Force de restriction(Les étoiles les plus noires, les plus sévères) | Nom | Méthode de description | Plage d'autorisation d'accès |
|---|---|---|---|
| ★★★★ | private | Décrit comme privé | Seulement ma propre classe |
| ★★★☆ | package private | N'écris rien | Classes appartenant au même package que vous |
| ★★☆☆ | protected | Décrit comme protégé | Classes enfants qui appartiennent au même package que vous ou héritent de vous |
| ★☆☆☆ | public | Décrit comme public | Toutes les classes |
Il existe une classe Véhicule et une classe Train qui en hérite comme indiqué ci-dessous. Dans ce cas, il peut être appelé comme suit.
--Vehicle: classe parent, super classe --Train: classe enfant, sous-classe
En gros, l'héritage de la classe parent s'appelle l'héritage.
Dans le Train ci-dessous, moveOn est remplacé et implémenté indépendamment, mais stop utilise la méthode de la classe parent.
Vehicle.java
public class Vehicle {
protected Boolean isMove = false;
public void moveOn() {
this.isMove = true;
System.out.println("Le véhicule bouge");
}
public void stop() {
this.isMove = false;
System.out.println("Le véhicule s'arrêtera");
}
public void setIsMove(Boolean isMove) {
this.isMove = isMove;
}
public void info() {
System.out.println("véhicule(Vehicle)est");
}
}
Train.java
public class Train extends Vehicle {
private Boolean isOpenDoor;
@Override
public void moveOn() {
if (this.isOpenDoor) {
throw new RuntimeException("Erreur d'exception");
}
super.moveOn();
}
public void closeDoor() {
this.isOpenDoor = false;
}
public void openDoor() {
if (super.isMove) {
throw new RuntimeException("Erreur d'exception");
}
System.out.println("J'ai ouvert la porte");
}
public void info() {
System.out.println("Train électrique(Train)est");
}
}
Je vais vraiment le déplacer.
Main.java
public class Main {
public static void main(String[] args) {
Train train = new Train();
train.closeDoor();
train.moveOn();
train.stop();
}
}
【résultat】
Puisqu'il hérite du véhicule, on peut voir que l'arrêt peut être appelé sans aucun problème.
Le véhicule bouge
Le véhicule s'arrêtera
Process finished with exit code 0
Le polymorphisme est le traitement de différentes choses de la même manière en prenant les choses en grand. En termes simples, traitez les trains qui sont apparus jusqu'à présent comme des véhicules.
Créez une nouvelle classe de voiture et traitez-la comme un véhicule. (* Réutiliser le train et le véhicule utilisés pour l'héritage ...)
Car.java
public class Car extends Vehicle {
private Boolean isStartEngine = false;
private String gearMode = "NEUTRAL";
@Override
public void moveOn() {
if (!isStartEngine) {
throw new RuntimeException("Le moteur ne tourne pas");
}
if (gearMode.equals("NEUTRAL")) {
throw new RuntimeException("Je ne peux pas procéder en neutre");
}
super.moveOn();
}
public void setGear(String mode) {
switch (mode) {
case "NEUTRAL":
case "DRIVE":
case "BACK":
gearMode = mode;
default:
throw new RuntimeException("Le mode spécifié n'existe pas");
}
}
public void info () {
System.out.println("voiture(Car)est");
}
}
Main.java
public class Main {
public static void main(String[] args) {
Vehicle vehicle = new Vehicle();
Vehicle vehicleCar = new Car();
Vehicle vehicleTrain = new Train();
vehicle.info();
vehicleCar.info();
vehicleTrain.info();
}
}
[Résultat] Puisque Vehicle est la classe parente, Car / Train peut être traité comme Vehicle, et on peut dire qu'il satisfait le polymorphisme.
--Facile à changer le programme
--Type de procédure à écrire comme instructions dans l'ordre depuis le début du programme ――Il est orienté objet de penser le programme à réaliser par parties et de diviser le traitement.
J'ai senti qu'il était très important de connaître les bases de l'orientation objet afin d'écrire du code facile à voir, à comprendre et à sécuriser afin de créer un système qui continuerait à être utilisé.
J'ai décrit le plan sans utiliser de mots difficiles, mais lors de l'écriture du code source, il y a des règles pour chaque fonction, donc j'aimerais les utiliser tout en les vérifiant.