O que é uma classe de wrapper?

O que é uma classe de wrapper?
Como essas classes são úteis?

Em geral, uma classe de wrapper é qualquer classe que "encapsula" ou "encapsula" a funcionalidade de outra classe ou componente. Isso é útil ao fornecer um nível de abstração da implementação da classe ou componente subjacente; por exemplo, as classes de wrapper que envolvem os componentes COM podem gerenciar o processo de chamada do componente COM sem incomodar o código de chamada. Eles também podem simplificar o uso do objeto subjacente, reduzindo o número de pontos de interface envolvidos; freqüentemente, isso torna o uso mais seguro dos componentes subjacentes.

Exatamente o que parece: uma classe que "agrupa" a funcionalidade de outra classe ou API em uma API mais simples ou meramente diferente.

Veja: Padrão do adaptador , Padrão da fachada

As classes de wrapper fornecem uma maneira de usar tipos primitivos como objetos. Para cada primitiva, temos uma classe de wrapper como,

int Integer
byte Byte 

Integer e Byte são as classes de wrapper do primitivo int e byte. Há momentos / restrições em que você precisa usar as primitivas como objetos para que as classes de wrapper forneçam um mecanismo chamado de boxe / unboxing.

O conceito pode ser bem entendido pelo exemplo a seguir como

double d = 135.0 d;
Double doubleWrapper = new Double(d);

int integerValue = doubleWrapper.intValue();
byte byteValue = doubleWrapper.byteValue();
string stringValue = doubleWrapper.stringValue();

portanto, é assim que podemos usar o tipo de classe wrapper para converter também em outros tipos primitivos. Esse tipo de conversão é usado quando você precisa converter um tipo primitivo em objeto e usá-los para obter outras primitivas também. Apesar dessa abordagem, você precisa escrever um grande código. No entanto, o mesmo pode ser alcançado com a técnica de conversão simples, pois o snippet de código pode ser obtido conforme abaixo

double d = 135.0;
int integerValue = (int) d ;

Embora o valor duplo seja explicitamente convertido em valor inteiro, também chamado de downcasting.

Uma classe de wrapper não precisa necessariamente envolver outra classe. Pode ser uma funcionalidade de quebra de classe da API em, por exemplo, um arquivo DLL.

Por exemplo, pode ser muito útil criar uma classe de empacotador de DLL, que cuida de toda a inicialização e limpeza de DLL e criar métodos de classe que envolvem ponteiros de função criados a partir de, por exemplo GetProcAddress().

Felicidades !

Uma classe de wrapper é uma classe que "envolve" outra coisa, assim como seu nome.

A definição mais formal seria uma classe que implementa o Padrão do Adaptador . Isso permite modificar um conjunto de APIs para um formato mais utilizável e legível. Por exemplo, em C #, se você quiser usar a API nativa do Windows, ajudará a agrupá-la em uma classe que esteja em conformidade com as diretrizes de design do .NET.

Existem vários padrões de design que podem ser chamados de classes de wrapper.

Veja minha resposta para " Como os padrões de proxy, decorador, adaptador e ponte diferem? "

Também pode ser valioso observar que, em alguns ambientes, muito do que as classes de wrapper podem fazer está sendo substituído por aspectos.

EDITAR:

Em geral, um invólucro vai expandir o que o invólucro faz, sem se preocupar com a implementação do invólucro, caso contrário, não há sentido em invólucro versus estender a classe empacotada. Um exemplo típico é adicionar informações de tempo ou funcionalidade de registro em torno de alguma outra interface de serviço, em vez de adicioná-lo a todas as implementações dessa interface.

Isso acaba sendo um exemplo típico para a programação da Aspect. Em vez de passar por uma função de interface por função e adicionar log de clichê, na programação de aspectos, você define um corte de ponto, que é um tipo de expressão regular para métodos, e declara métodos que deseja executar antes, depois ou ao redor de todos os métodos correspondentes o pointcut. Provavelmente, é justo dizer que a programação de aspectos é um tipo de uso do padrão Decorator, para o qual as classes de wrapper também podem ser usadas, mas que ambas as tecnologias têm outros usos.

A classe Wrapper é uma classe que quebra a outra classe e fornece a abstração entre o cliente e a classe original que está sendo quebrada.

uma classe de wrapper geralmente é uma classe que possui um objeto como uma propriedade privada. o wrapper implementa a API desse objeto privado e, portanto, pode ser passado como um argumento onde o objeto particular o faria.

digamos que você tenha uma coleção e deseje usar algum tipo de tradução quando objetos forem adicionados a ela - você escreve uma classe de wrapper que possui todos os métodos da coleção. quando add () é chamado, o wrapper converte os argumentos em vez de apenas passá-los para a coleção particular.

o wrapper pode ser usado em qualquer lugar em que uma coleção possa ser usada e o objeto privado ainda pode ter outros objetos fazendo referência a ele e lendo-o.

Uma classe de wrapper é uma classe usada para quebrar outra classe para adicionar uma camada de indireção e abstração entre o cliente e a classe original que está sendo quebrada.

A classe wrapper é um wrapper em torno de um tipo de dados primitivo. Ele representa tipos de dados primitivos em suas instâncias de classe correspondentes, por exemplo, um tipo de dados booleano pode ser representado como uma instância de classe booleana. Todas as classes primitivas de wrapper em Java são imutáveis, ou seja, uma vez que um valor atribuído a uma instância de classe de wrapper não pode mais ser alterado.

A programação Java fornece classe de wrapper para cada tipo de dados primitivo, para converter um tipo de dado primitivo no objeto correspondente da classe de wrapper.

Criar uma classe de invólucro bem-estar não é uma tarefa fácil. Compreender uma classe de wrapper como ela é projetada por outras pessoas também não é uma tarefa fácil. Porque é idéia, não código. Somente quando você entende a ideia, é possível entender o wrapper.

As classes de wrapper surgiram para atender a uma necessidade básica dos programadores - ou seja, usar valores primitivos sempre que apenas objetos são permitidos. Como o nome sugere, as classes de wrapper envolvem um valor primitivo e mantêm o valor em um Object. Portanto, todos os locais em que as primitivas não eram permitidas - como genéricos, hashmap-keys, Arraylists etc. - os programadores agora têm a opção de fornecer esses valores primitivos como seus tipos de wrapper correspondentes.

Além disso, esses tipos de wrapper possuem vários métodos de utilidade para converter do tipo primitivo para os tipos de wrapper correspondentes e vice-versa, e também de Strings para os tipos de wrapper e vice-versa.

Escrevi um artigo detalhado sobre classes de invólucros em um blog que explica detalhadamente o conceito de tipos de invólucros - http://www.javabrahman.com/corejava/java-wrapper-classes-tutorial-with-examples/ (Divulgação - Este blog é de minha propriedade)

Atualmente, usei uma classe de wrapper para o meu projeto e os principais benefícios que recebo (apenas um benefício para ampliar a explicação do tópico):

Manipulação de exceções: minha classe principal, que outra classe envolve, possui métodos que estão lançando exceções, se houver alguma, então criei uma classe de wrapper que lida com as exceções e as registra imediatamente. Portanto, no meu escopo principal, não há manipulação de exceção. Eu apenas chamo um método e faço alguma coisa.

Uso Fácil: Eu posso facilmente iniciar o objeto. Normalmente, a fase de iniciação é construída com várias etapas.

Legibilidade do código: Quando outro programador abre meu código, o código parecerá muito claro e fácil de manipular.

Ocultando os detalhes: Se você estiver gerando uma classe que outro programador usará, poderá agrupar os detalhes como "tratamento de erros, tratamento de exceções, registro de mensagens e etc ..." para que o programador não precise lidar com o caos, simplesmente usa os métodos.

Uma classe de wrapper é uma classe que tem o único objetivo de conter algo e adicionar alguma funcionalidade a ele. Em Java, uma vez que as primitivas (como ints, floats, chars ...) não são objetos; portanto, se você quiser tratá-las como uma, precisará usar uma classe de wrapper. Suponha que você queira criar um vetor de ints, o problema é que um vetor contém apenas objetos não primitivos. Então, o que você fará é colocar todas as entradas em um invólucro inteiro e usá-lo. Exemplo:

int number = 5;
Integer numberWrapped = new Integer(number);
//now you have the int in an object.
//and this is how to access the int value that is being wrapped.
int again = numberWrapped.intValue();

um wrapper é uma classe usada para se comunicar entre dois aplicativos diferentes entre plataformas diferentes