Fábrica de Objetos

"SadNess":

galera

Preciso fazer uma pesquisa sobre fábrica de objetos e aplicar isso em um exemplo que o professor passou
Dei uma procurada no Google mas achei o material muito pobre
Alguém tem algum exemplo de o que é e como funciona uma fábrica de objetos?

Autor : Daniel Destro

Factory Method - provê uma classe de decisão, na qual retorna uma das muitas possíveis subclasses de uma classe base abstrata, dependendo do dado fornecido.

Abstract Factory Method - provê uma interface para se criar e retornar uma de muitas famílias de objetos relacionados.

Singleton - provê uma classe que não pode haver mais do que uma única instância, e proporciona um ponto comum e global para se acessar aquela instância.

Builder - separa a construção de um objeto complexo de sua representação, para que de diferentes representações possam ser criadas dependendo das necessidades do programa.

Prototype - começa com uma classe iniciada e instanciada que copia ou gera um clone dela para se fazer novas instâncias, ao invés de se criar novas instâncias.

FACTORY METHOD

Este é um tipo bem comum de padrão utilizado nos programas orientados ao objeto. O padrão Factory Method é caracterizado por retornar uma instância dentre muitas possíveis classes, dependendo dos dados providos a ele. Geralmente, todas as classes que ele retorna têm uma classe pai e métodos em comum, mas cada um executa tarefas diferentes e é otimizado para diferentes tipos de dados.

Vamos considerar um caso simples onde nós podemos usar uma classe Factory. Suponha que nós temos um sistema de consulta de preços de veículos. Informamos qual carro queremos consultar o preço, então a classe factory nos retorna uma instância dele e então consultamos o preço.

Vamos, então, dar uma olhada na implementação:

public abstract class Carro {
    protected float valor;

    public float getPreco() {
        return valor;
    }
}

public class Vectra extends Carro {
    public Vectra() {
        valor = 30000.0f;
    }
}

public class Omega extends Carro {
    public Omega() {
        valor = 50000.0f;
    }
}

public class Golf extends Carro {
    public Golf() {
        valor = 35000.0f;
    }
}

public class Gol extends Carro {
    public Gol() {
        valor = 20000.0f;
    }
}

Agora nossa classe Factory, que é bem simples, e decide qual classe será instanciada, dependendo do parâmetro do tipo passado para o método getClass( ).

public class CarroFactory {
    public static Carro getCarro( String tipoCarro ) {
        if( tipoCarro == null ) return null;
        else if( tipoCarro.equals("Vectra") ) return new Vectra();
        else if( tipoCarro.equals("Omega") ) return new Omega();
        else if( tipoCarro.equals("Golf") ) return new Golf();
        else if( tipoCarro.equals("Gol") ) return new Gol();
        else return null;
    }
}

Vamos agora implementar a classe que se utiliza de todo este aparato do padrão Factory.

public class FactoryExample {
    public static void main( String args[] ) {
        //parâmetro passado como argumento no console
        //pega a instância do tipo do carro
        Carro carro = CarroFactory.getCarro( args[0] );
        //mostra o valor
        if( carro != null ) {
            System.out.println( "Preço: " + carro.getPreco() );
        }
    }
}

Esse é o principio fundamental do padrão Factory Method. Você cria uma abstração, na qual se decide qual das opções de classe retornar. Então você apenas chama o método comum desta classe, sem sequer saber ou se preocupar qual classe você está realmente lhe dando.

Padrões relacionados:

Abstract Factory - O padrão Factory é útil para se construir objetos individuais, para um propósito específico, sem que a construção requeira conhecimento das classes específicas sendo instanciadas. Se você precisar criar um grupo combinado de tais objetos, então o padrão Abstract Factory é o mais apropriado.

Template - O padrão Factory é freqüentemente usando com o padrão Template.

Prototype - O padrão Prototype provê uma alternativa para um objeto trabalhar com outros objetos sem que conheça os detalhes de construção.

ABSTRACT FACTORY METHOD

O padrão Abstract Factory está a um nível de abstração maior do que o padrão Factory Method. Você pode usar este padrão quando deseja retornar uma das muitas classes de objetos relacionadas, cada qual pode retornar diferentes objetos se requisitado. Em outras palavras, o padrão Abstract Factory é uma fábrica de objetos que retorna uma das várias fábricas.

Uma aplicação clássica do Abstract Factory é o caso onde o seu sistema precisa de suporte a múltiplos tipos de interfaces gráficas, como Windows, Motif ou MacIntosh. Você diz ao factory que quer que seu programa se pareça com o Windows e ele retorna a fábrica GUI que retorna os objetos relativos ao Windows. Então, quando você requisita um objeto específico como um botão, check-boxes e janelas, a fábrica de GUI retorna as instâncias desses componentes para o Windows.

Implementando o modelo proposto, temos os seguintes códigos-fonte adicionais:

public abstract class Fabricante {
    protected String name;

    public abstract Carro getCarro( String marca );

    public static Fabricante getInstance( String fabricante ) {
        if( fabricante == null ) {
            return null;
        }
        else if(fabricante.equals("Chevrolet")) {
            return new Chevrolet();
        }
        else if(fabricante.equals("Volkswagen")) {
            return new Volkswagen();
        }
        else {
            return null;
        }
    }
}

public class Chevrolet extends Fabricante {
    public Chevrolet() {
        name = "Chevrolet";
    }

    public Carro getCarro( String marca ) {
        if( marca == null ) {
            return null;
        }
        else if( marca.equals("Vectra") ) {
            return new Vectra();
        }
        else if( marca.equals("Omega") ) {
            return new Omega();
        }
        else {
            return null;
        }
    }
}

public class Volkswagen extends Fabricante {
    public Volkswagen() {
        name = "Volkswagen";
    }

    public Carro getCarro( String marca ) {
        if( marca == null ) {
            return null;
        }
        else if( marca.equals("Gol") ) {
            return new Gol();
        }
        else if( marca.equals("Golf") ) {
            return new Golf();
        }
        else {
            return null;
        }
    }
}

public class AbstractFactoryExample {
    public static void main( String args[] ) {
        //parâmetro passado como argumento no console
        //pega a instância do fabricante
        Fabricante fab = Fabricante.getInstance( args[0] );
        //pega a instância do carro, de acordo com o fabricante
        Carro carro = fab.getCarro( args[1] );
        //mostra o valor
        if( carro != null ) {
            System.out.println( "Preço: " + carro.getPreco() );
        }
    }
}

Padrões relacionados:

Factory Method - O Abstract Factory pode usar o padrão Factory Method.

Te ajuda este artigo ae ?
Um dia eu chego lá :grin:
Um Abraço !

ajudou bastante
vlw cara