Définition du pont: sépare l'abstraction et le comportement, et combine chacun indépendamment mais dynamiquement.
Pourquoi utiliser le mode Bridge
Généralement, lorsqu'une classe ou interface abstraite a plusieurs implémentations en béton (sous-classe en béton), la relation entre ces bétons peut être la suivante:
1. Ces implémentations spécifiques sont parallèles.
2. En application pratique, il est souvent possible de se chevaucher conceptuellement parmi ces multiples classes concrètes. Ensuite, nous devons séparer le résumé commun et le comportement commun.
Par exemple, par exemple, il existe deux types de café: les tasses moyennes et grandes, et il existe également différents types de lait et de lait. Si un simple héritage est utilisé, il y a un concept de concept entre ces quatre implémentations spécifiques (million de tasses avec du lait) car il y a des tasses moyennes avec du lait, et il y a des tasses moyennes sans lait. Il est également dans la coupe du milieu. Ensuite, nous utilisons le mode Bridge pour l'implémenter.
Comment implémenter le mode Bridge
Le café mentionné ci-dessus est un exemple. Nous avons initialement prévu de concevoir une seule interface (classe abstraite).
Jetons un coup d'œil au code d'interface de la partie abstraite:
La copie de code est la suivante:
COFFEMPS DE CLASSE ABRAIT PUBLIC {
Coffeeimp Coffeeimp;
public void setCoffeeImp () {
this.coffeeImp = CoffeeImsingleton.getTheCoffeImp ();
}
Public CoffeeImp getCoffeeImp () {return this.coffeeImp;}
Résumé public void pourcoffee ();
}
CoffeeImp est une interface comportementale sans lait ajouté.
La copie de code est la suivante:
classe abstraite de café CoffeeImp {
Abstract public void pourcoffeeImp ();
}
Maintenant, nous avons deux classes abstraites, nous les héritons respectivement et implémentons la classe concrète:
La copie de code est la suivante:
// tasse moyenne
classe publique MediumCoffee prolonge le café {
public mediadcoffee () {setCoffeeImp ();}
public void pourcoffee () {
CoffeeImp Coffeeimp = this.getCoffeeImp ();
// Nous utilisons le nombre de répétitions pour expliquer s'il faut faire une tasse à mi-tasse ou une grande tasse.
CaxeImp.pourCoffeeImp ();
}
}
}
La copie de code est la suivante:
// Big Cup
La classe publique SuperSizEcoffee étend le café {
public supersizecoffee () {setCoffeeImp ();}
public void pourcoffee () {
CoffeeImp Coffeeimp = this.getCoffeeImp ();
// Nous utilisons le nombre de répétitions pour expliquer s'il faut faire une tasse à mi-tasse ou une grande tasse.
CaxeImp.pourCoffeeImp ();
}
}
}
Ce qui précède est les implémentations spécifiques de la tasse moyenne et de la grande tasse respectivement.
La copie de code est la suivante:
// ajouter du lait
classe publique MilkcoffeeImp étend le café impor
MilkCoffeeImp () {}
public void pourcoffeeImp () {
System.out.println ("Ajout d'un délicieux lait");
}
}
// pas de lait ajouté
classe publique FragrantCoffeeImp étend le café {
FragrantCoffeeImp () {}
public void pourcoffeeImp () {
System.out.println ("Rien n'a ajouté, un parfum frais");
}
}
Nous avons déjà mis en place le cadre de base du modèle de pont.
1. Ajouter du lait à la moyenne tasse
2. Pas de lait ajouté dans la coupe moyenne
3. Ajouter du lait à une grande tasse
4. Grande tasse sans lait
Voyons comment il est combiné dynamiquement.
La copie de code est la suivante:
classe publique CoffeeImpingleton {
Coffee Coffee imprimé Coffee imprimé;
Public CoffeeImpingleton (CoffeeImp CoffeeImpin)
{this.coffeeImp = coffeeimpin;}
public static Coffeeimp getTheCoffeeImp () {
Retournez CoffeeImp;
}
}
Voyons comment la tasse de lait moyen et la grande tasse de lait sortent:
// Sortez le lait
CaxeImsingleton CoffeeIMPSingleton = new CoffeeImpsingleton (New MilkCoffeeImp ());
// tasse centrale avec du lait
MediumCoffee MediumCoffee = new MediumCoffee ();
MediumCoffee.pourCoffee ();
// une grande tasse de lait
Supersizecoffee supersizecoffee = new supersizecoffee ();
supersizecoffee.pourcoffee ();
Remarque: Les classes d'exécution du schéma de ponts telles que le café et le café sont des relations individuelles, et la création correcte du café est la clé de ce schéma.
Application du mode de pont dans EJB
Il existe un modèle d'objet d'accès aux données (DAO) dans EJB, qui sépare la logique métier des ressources de données spécifiques car différentes bases de données ont des opérations de base de données différentes. Les comportements qui exploitent différentes bases de données sont indépendamment résumés en une interface comportementale DAO, comme suit:
1. objet d'activité (similaire au café)
Mettez en œuvre certaines opérations commerciales abstraites: comme la recherche d'un utilisateur pour passer toutes les commandes. DaoIMPlementor est utilisé pour les opérations de base de données.
2.Data Access Object (similaire à CoffeeImp)
Quelques opérations abstraites sur les ressources de la base de données.
3. Daoimplementor comme OrderDaocs, OrderDaooracle, OrderDaosyBase (similaire à MilkCoffeeImp FragrantCoffeeImp)
Des opérations de base de données spécifiques, telles que "insérer" et d'autres instructions, OrderDaooracle est Oracle OrderDaosyBase est la base de données Sybase.
4. Base de données (base de données Cloudscape, Oracle ou Sybase via l'API JDBC)