** Table des matières **
L'idée de base de l'orientation des objets est qu'il vaut mieux avoir un faible degré de connexion entre les objets. En utilisant l'interface en java, il est possible de rendre inutile pour le côté utilisant la classe concrète d'en être conscient.
interface
Screen.java
interface Screen {
public void view();
}
** Classe de béton **
TopScreen.java
public class TopScreen implements Screen {
public void view() {
System.out.println("l'écran supérieur");
}
}
LoginScreen.java
public class LoginScreen implements Screen {
public void view() {
System.out.println("Écran de connexion");
}
}
** Utilisateur **
Client.java
public class Client {
public void displayTopScreen() {
Screen top = new TopScreen()
top.view();
}
public void displayLoginScreen() {
Screen login = new LoginScreen()
login.view();
}
}
À première vue, il ne semble y avoir aucun problème, mais dans la partie qui instancie chaque classe, Haut de l'écran = nouveau TopScreen () '' et Connexion à l'écran = nouveau LoginScreen () Il faut absolument être conscient de la classe concrète.
Cela va à l'encontre de l'idée qu'un degré de couplage inférieur est meilleur, et si vous modifiez le constructeur que vous utilisez, vous devrez modifier toutes les pièces instanciées.
Ce problème est résolu en créant une classe qui crée une instance appelée classe d'usine '', mais cette classe d'usine '' est également plus flexible en la divisant en une classe abstraite et une classe concrète. Ce modèle consiste à créer une nouvelle fabrique de génération d'objets.
Il fournit une interface pour créer des groupes d'objets liés ou dépendants les uns des autres sans clarifier leurs classes concrètes.
-Définir l'interface qui génère la classe AbstractFactory AbstractProduct -Définir l'interface qui génère la classe ConcreteFactory ConcreteProduct -AbstractProduct Une classe abstraite qui extrait les parties communes des parties générées ・ Pièces générées par le béton ・ Utilisateur client
Voici l exemple de code. Nous mettrons en place une usine qui fabrique les pièces nécessaires à la voiture et présenterons le véhicule au concessionnaire dans le flux suivant.
Le concessionnaire demande le véhicule au constructeur-> Le constructeur demande les pièces automobiles à l'usine-> L'usine renvoie diverses pièces au constructeur-> Le constructeur assemble la voiture et la renvoie au concessionnaire-> Le véhicule est présenté chez le concessionnaire.
Classe d'usine de fabrication de pièces automobiles
CarFactory.kt
package abstractfactory
open class CarFactory {
open fun makeEngine(displacement: Int): Engine {
return Engine(displacement)
}
open fun makeTire(position: Int): Tire {
return Tire(position)
}
open fun makeSteering(weight: Int): Steering {
return Steering(weight)
}
}
Classe de moteur
Engine.kt
package abstractfactory
open class Engine(displacement: Int) {
open val type = "Moteur ordinaire"
val displacement = displacement
}
Classe de pneu
Tire.kt
package abstractfactory
open class Tire(position: Int) {
open val type = "Pneu ordinaire"
val position = position
}
Classe de poignée
Steering.kt
package abstractfactory
class Steering(weight: Int) {
val type = "Poignée ordinaire"
val weight = weight
}
Classe de voiture
Car.kt
package abstractfactory
open class Car(type: String, engine: Engine, tire: Tire, steering: Steering) {
val type = type
val engine = engine
val tire = tire
val steering = steering
fun getConstitution(): String {
return "[Type de véhicule]:" + type + "," +
"【moteur】:" + engine.type + "," +
"【pneu】:" + tire.type + "," +
"【manipuler】:" + steering.type
}
}
Classe de constructeur automobile
Maker.kt
package abstractfactory
class Maker {
/**
*Fabrication de voitures ordinaires
*/
fun getCar(): Car {
return make("Voiture familiale", CarFactory())
}
/**
*Fabrication
*/
private fun make(type: String, factory: CarFactory): Car {
val engine = factory.makeEngine(1000)
val tire = factory.makeTire(1)
val steering = factory.makeSteering(100)
return Car(type, engine, tire, steering)
}
}
Classe de concessionnaire automobile
AutomobileDealer.kt
package abstractfactory
class AutomobileDealer {
val cars = mutableListOf<Car>()
init {
openingUp()
}
/**
*Liste des voitures chez le concessionnaire
*/
fun showCars() {
cars.forEach {
println(it.getConstitution())
}
}
/**
*Ouverture du magasin
*/
private fun openingUp() {
val maker = Maker()
cars.add(maker.getCar())
}
}
Si vous appelez AutomobileDealer # showCars (), le véhicule affiché (spec) sera sorti.
[output]
[Type de véhicule]: Voiture familiale,[Engine]: moteur ordinaire,[Pneu]: pneu ordinaire,[Handle]: poignée ordinaire
Il a été complété par ce qui précède, mais soudain, le président a dit qu'il devrait construire une usine qui peut également fabriquer des pièces pour les super voitures sur la même ligne tout en conservant la ligne de production existante.
Classe d'usine de fabrication de pièces de voiture Super
SuperCarFactory.kt
package abstractfactory
class SuperCarFactory: CarFactory() {
override fun makeEngine(displacement: Int): Engine {
return HiPerformanceEngine(displacement)
}
override fun makeTire(position: Int): Tire {
return HiGripTire(position)
}
}
Classe de moteur haute puissance
HiPerformanceEngine.kt
package abstractfactory
class HiPerformanceEngine(displacement: Int): Engine(displacement) {
override val type = "Moteur haute puissance"
}
Classe de pneus haute adhérence
HiGripTire.kt
package abstractfactory
class HiGripTire(position: Int): Tire(position) {
override val type = "Pneu haute adhérence"
}
Ajoutez une méthode de fabrication de super voiture au fabricant.
Classe de fabricant
Maker.kt
package abstractfactory
class Maker {
/**
*Fabrication automobile
*/
fun getCar(): Car {
return make(CarFactory())
}
/**
*Fabrication de super voitures
*/
fun getSuperCar(): Car {
return make("Super voiture", SuperCarFactory())
}
/**
*Fabrication
*/
private fun make(type: String, factory: CarFactory): Car {
val engine = factory.makeEngine(1000)
val tire = factory.makeTire(1)
val steering = factory.makeSteering(100)
return Car(type, engine, tire, steering)
}
}
Le concessionnaire exige un nouveau véhicule (super voiture) du constructeur.
AutomobileDealer.kt
package abstractfactory
class AutomobileDealer {
val cars = mutableListOf<Car>()
init {
openingUp()
}
/**
*Liste des voitures chez le concessionnaire
*/
fun showCars() {
cars.forEach {
println(it.getConstitution())
}
}
/**
*Ouverture du magasin
*/
private fun openingUp() {
val maker = Maker()
cars.add(maker.getCar())
cars.add(maker.getSuperCar())
cars.add(maker.getSuperCar())
}
}
Si vous appelez AutomobileDealer # showCars (), vous pouvez voir que les supercars sont nouvellement affichées.
[output]
[Type de véhicule]: Voiture familiale,[Engine]: moteur ordinaire,[Pneu]: pneu ordinaire,[Handle]: poignée ordinaire
[Type de véhicule]: Super voiture,[Engine]: moteur haute puissance,[Pneu]: pneu à adhérence élevée,[Handle]: poignée ordinaire
[Type de véhicule]: Super voiture,[Engine]: moteur haute puissance,[Pneu]: pneu à adhérence élevée,[Handle]: poignée ordinaire
Avec ce qui précède, nous avons pu répondre à la demande du président.
Recommended Posts