Definição da ponte: separa a abstração e o comportamento e combina cada um de forma independente, mas dinamicamente.
Por que usar o modo Bridge
Geralmente, quando uma classe ou interface abstrata possui várias implementações concretas (subclasse concreta), a relação entre esses concretos pode ser a seguinte:
1. Essas implementações específicas são paralelas.
2. Em aplicação prática, geralmente é possível se sobrepor conceitualmente entre essas múltiplas classes de concreto. Em seguida, precisamos separar o abstrato comum e o comportamento comum.
Por exemplo, como exemplo, existem dois tipos de café: xícaras médias e grandes, e também existem diferentes tipos de leite e leite. Se a herança simples é usada, existe uma sobreposição de conceito entre essas quatro implementações específicas (milhão de copos com leite sem leite), porque existem copos médios com leite e existem copos médios sem leite. É também na Copa do Médio. Em seguida, usamos o modo Bridge para implementá -lo.
Como implementar o modo de ponte
O café mencionado acima é um exemplo. Planejamos originalmente projetar apenas uma interface (classe abstrata).
Vamos dar uma olhada no código da interface da parte abstrata:
A cópia do código é a seguinte:
Caixa de classe abstrata pública {
Coffeeimp Coffeeimp;
public void setCoffeeimp () {
this.coffeeimp = CoffeeImtsingleton.getTheCoffeimp ();
}
public Coffeeimp getCoffeeimp () {return this.coffeeimp;}
Resumo público Void Pourcoffee ();
}
O Coffeeimp é uma interface comportamental sem leite adicionado.
A cópia do código é a seguinte:
classe abstrata pública Coffeeimp {
Resumo public void Pourcoffeeimp ();
}
Agora temos duas classes abstratas, herdamos respectivamente e implementamos a classe concreta:
A cópia do código é a seguinte:
// Copo do meio
classe pública Mediumcoffee estende o café {
public MediumCoffee () {setCoffeeimp ();}
public void Pourcoffee () {
Coffeeimp Coffeeimp = this.getcoffeeimp ();
// Usamos o número de repetições para explicar se deve fazer uma xícara intermediária ou um copo grande.
Coffeeimp.pourcoffeeimp ();
}
}
}
A cópia do código é a seguinte:
// Big Cup
classe pública SupersizeCoffee estende o café {
public supersizeCoffee () {setCoffeeimp ();}
public void Pourcoffee () {
Coffeeimp Coffeeimp = this.getcoffeeimp ();
// Usamos o número de repetições para explicar se deve fazer uma xícara intermediária ou um copo grande.
Coffeeimp.pourcoffeeimp ();
}
}
}
O exposto acima são as implementações específicas do copo médio e do copo grande, respectivamente.
A cópia do código é a seguinte:
// Adicione o leite
classe pública Milkcoffeeimp estende o café {
Milkcoffeeimp () {}
public void Pourcoffeeimp () {
System.out.println ("Adicionado delicioso leite");
}
}
// sem leite adicionado
classe pública FragrantCoffeeimp estende o Coffeeimp {
Fragrantcoffeeimp () {}
public void Pourcoffeeimp () {
System.out.println ("Nada adicionado, fragrância fresca");
}
}
Já configuramos a estrutura básica do modelo da ponte.
1. Adicione o leite ao copo médio
2. Nenhum leite adicionado no copo médio
3. Adicione o leite a um copo grande
4. Copo grande sem leite
Vamos ver como é combinado dinamicamente.
A cópia do código é a seguinte:
classe pública CoffeeImtsingleton {
Coffeeimp de café estático privado;
Public CoffeeImtsingleton (Coffeeimp Coffeeimpin)
{this.coffeeimp = Coffeeimpin;}
public static Coffeeimp getTheCoffeeimp () {
Retornar Coffeeimp;
}
}
Vamos ver como sai o copo médio de leite e a grande xícara de leite:
// Retire o leite
CoffeeImtsingleton CoffeeImtsingleton = New CoffeeImtsingleton (New Milkcoffeeimp ());
// Copo do meio com leite
MediumCoffee MediumCoffee = new MediumCoffee ();
MediumCoffee.pourcoffee ();
// Uma xícara grande de leite
SuperSizeCoffee SuperSizeCoffee = new SuperSizeCoffee ();
SuperSizeCoffee.pourcoffee ();
NOTA: Classes de execução de esquema de ponte, como Coffeeimp e Coffee, são relacionamentos individuais, e criar corretamente o Coffeeimp é a chave para esse esquema.
Aplicação do modo Bridge em EJB
Existe um padrão de objeto de acesso a dados (DAO) no EJB, que separa a lógica de negócios de recursos de dados específicos porque diferentes bancos de dados têm diferentes operações de banco de dados. Os comportamentos que operam diferentes bancos de dados são abstraídos independentemente em uma interface comportamental dao, como segue:
1. Objeto de Business (semelhante ao café)
Implementar algumas operações de negócios abstratas: como encontrar um usuário para fazer todos os pedidos. O DAOIMPLEMENTOR é usado para operações de banco de dados.
2.Data Objeto de acesso (semelhante ao Coffeeimp)
Algumas operações abstratas sobre os recursos do banco de dados.
3. Daoimplementor como OrderDaocs, OrderDaoorracle, Orderdaosybase (semelhante ao Milkcoffeeimp FragrantCoffeeimp)
Operações específicas de banco de dados, como "inserção em" e outras instruções, o OrderDaoorracle é o Oracle OrderDaosyBase é um banco de dados Sybase.
4. Banco de dados (Cloudscape, Oracle ou Sybase Database via JDBC API)