[RESOLVIDO] Chamar metodo da classe sem saberm quantas classes tem

[waksman]

Eu estou aqui com umas classes, funcionam perfeitamente, mas eu tenho muito trabalho manual e queira deixar isso automatico, mas não sei se tem como
(Depois alguem me da o nome correto do assunto pra mim trocar, ficou muito vago)

Eu tenho uma classe Pai e varias filhas. Pra não ter que ficar instanciando filha a filha uma por vez, eu criei uma classe que faz isso pra mim, resolveu na aplicação final, mas ainda sim tenho que instanciar uma a uma, depois atualizar o outro metodo tambem um a um, o que eu queria era chamar essas classes/metodos sem precisar escrever o codigo (Se é que é possivel). Vamo fazer um exemplo pratico disso.

Classe Pai

public class Pai{
public Pai(){}

public void comum(){...}
}

filha 1

public class F1 extends Pai{
...
}

filha 2

public class F2 extends Pai{
...
}

filha 3

public class F3 extends Pai{
...
}

Até aqui ta facil, dai pra controlar essas filhas eu criei uma “Mãe”

Mae

public class Mae{
    public F1;
    public F2;
    public F2;

    public void initF1(){
        ...
    }

    public void initF2(){
        ...
    }

    public void initF3(){
        ...
    }

    public void comum(){
        if(f1 != null){
            f1.comum();
        }

        if(f2 != null){
            f2.comum();
        }

        if(f3 != null){
            f3.comum();
        }
    }
}

Veja que o codigo destá classe é totalmente repetitivo, era isso que eu queria automatizar, se for possivel. Claro eu ainda prefiro utilizar esta classe mae a iniciar uma por uma em varias partes do projeto, iniciar so a Mae é muito mais facil, aqui nao esta no exemplo, mas tem parametros nos constructors e tal, dai a necessidade/facilidade de uma classe que controle as demais.

Conforme a necessidade eu vou adicionando novos filhos ai tem ir na mae e atualizar os comandos.

[pvrsouza]

Eu ainda não domino Padrões de Projeto, mas acho que com ele vc consegue resolver seu problema. Acredito que o padrão Factory atende a isso.

De uma olhada aqui!

[Poneis123]

Essas classes filhas que vc colocou (F1, F2, F3) elas são identicas? tem os mesmos atributos e métodos?

Se for isso, vc pode deixar apenas 1 classe filha e conforme a necessidade de criar uma outra filha vc instancia uma nova classe e guarda em uma lista por exemplo.

Ex:public class Filha extends Pai{ ... }
Ai na Classe mãe, ao inves de declarar cada uma das filhas, vc diz q ela vai ter uma lista de Filhas:

[code]public class Mae{
List filhas;

//Metodo construtor
public Mae(){
filhas = new ArrayList();
}

//Metodo que adiciona a filha
public adicionaFilha(Filha f){
   filhas.add(f)
}

.
.
.
}[/code]
Num sei se entendi certinho, mas ve se é isso q vc queria ae.
Qualquer coisa é só falar.

[waksman]

Poneis123: Não, alguns metodos até tem a mesma assinatura, mas tem algumas diferenças de uma para outra, uns metodos a mais ou a menos. Mas na classe mae o que eh chamado initFilha e o comum é sempre o mesmo, os demais metodos eu acesso na aplicacao direto, por isso dexei as variaveis como publica. “mae.filha.metodoEspecifico()”. Na verdade a classe mãe so chama os metodos da Classe pai em cada uma das filhas.
pvrsouza: Hmm… não conheço, mas vou dar uma olhada no Factory ver o que ele oferece.

[waksman]

Vejamos se consigo me expressar melhor.

A classe pai ta la no seu pacote.

As filhas tao em outro pacote, junto com a mae.

Eu queria que a Mae buscasse todas as classes, exceto ela mesma, do seu pacote, e “declarasse” essa variavel, pra poder acessar como eu acesso na aplicacao, ou de forma parecida com isso
" mae.filha.metodoEspecifico() ou mae.filha.metodoDaClassePai() ";

Da mesma maneira, ela deveria disponibilizar o Metodo initFilha, mas isso não seria problema, uma vez que o item de cima fosse atendido, bastaria chamar na aplicacao “mae.filha.init()” que é um metodo da Classe Pai. (Esse qui pode até não ter, não iria mudar muita coisa)

E por fim um que encerra as filhas, esse buscaria todas as suas variaveis, e chamaria o metodo comum que encerra cada uma delas, se ela ja tiver sido inicializada. "if(var != null){var.metodo()}

[dudaskank]

Acho que um array já daria conta da chamada pro método, ou uma collection também funciona. Já para inicializar não teria jeito, a não ser que os parâmetros para os construtores sejam os mesmos.

Buscar as classes do pacote eu nunca tentei não, mas deve ser possível… com os nomes das classes você só precisa de um pouco de reflection para conseguir o que você quer.

Eu fiz um teste aqui, declarei uma lista de Pai e coloquei as filhas dentro. Assim é possível chamar os métodos comuns, mas os específicos seria preciso alguns if’s e instanceof’s.

import java.lang.reflect.Constructor;
import java.util.Collection;
import java.util.Collections;

public class TestePai {
	public class Pai {
		public void comum() {
			System.out.println(getClass().getSimpleName());
		}
	}

	public class F1 extends Pai {
		public F1(String parametro) {
			System.out.println(parametro);
		}
	}

	public class F2 extends Pai {
		public F2(Integer parametro) {
			System.out.println(parametro.intValue());
		}
	}

	public class F3 extends Pai {
		public F3(Collection<Object> parametro) {
			System.out.println(parametro.size());
			System.out.println(parametro.toArray()[0]);
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Pai vetor[] = new Pai[3];
		for (int i = 0; i < vetor.length; i++) {
			System.out.println("Posição " + i);
			vetor[i] = initF(i);
			if (vetor[i] != null) {
				vetor[i].comum();
			}
		}
	}

	private static Pai initF(int i) {
		Class<?> classes[] = { F1.class, F2.class, F3.class };
		Object parametros[] = { "String", new Integer(10),
				Collections.singletonList("Lista com uma string") };
		Class<?> classesParametros[] = { String.class, Integer.class, Collection.class };
		if (i < 0 || i >= classes.length) {
			return null;
		} else {
			try {
				// quando a classe em questão é uma classe dentro de outra, o construtor recebe
				// a classe onde ela é declarada e depois os atributos definidos no construtor
				Constructor<?> construtor = classes[i]
						.getConstructor(TestePai.class, classesParametros[i]);
				return (Pai) construtor.newInstance(null, parametros[i]);
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			}
		}
	}
}

[waksman]

Vix, isso ta caminhando pra um lado que eu desconheço totalmente… mas vamo la…

Respondendo a primeira pergunta, sim o constructor e o metodo [color=blue]init[/color] são todos iguais, a unica coisa diferente são os metodos especificos, que nada mais fazem que passar parametros para os metodos comuns do pai, com algumas poucas exceções que fazem trabalhos diferentes. O metodo que finaliza tambem é comoum ja que vem do pai, tanto init quanto finalizar. O constructor na verdade está em branco, o init faz o trabalho. Tive um pouco de problemas dexando os dados no constructor, entao fiz o init, ai fico 100%

[color=blue]Tentando entender seu codigo, eu deveria de algum modo, buscar as classes no pacote, entao inicializar um vetor da classe pai com o total de classes encontrados no pacote? [/color]Se for isso eu vou pesquisar como fazer, dai a gente segue pra chamada dos metodos…

Não sei se muda algo, mas as classes Filhas implementao um modelo que eu fiz dos metodos que devem retornar algo em comum como nome ou algo assim, so que em locais diferentes, o que acaba mudando o codigo do metod, mas ainda tendo o mesmo retorno.

Pai

public class Pai{
    public Pai(){}

    public void init(parametros){...}

    public void finalizar(){
        if(variavel != null){
            //encerrar
        }
    }

    public metodoComum1(String valor){...}
}

F1 (A assinatura das filhas é sempre essa “public class [color=blue]NOME[/color] extends Pai implements Modelo”)

public class F1 extends Pai implements Modelo {
    public F1(){}

    public metodoX(parametro){
        //Verificações e outras ações
        super.metodoComum1(valorEncontrado);
    }

    public String getNome(String id){...}//Este método veio do MODELO, todas as filhas tem.
}

Codigo no projeto

Mae mae = new Mae(valores)//Esses "valores" são os mesmo passados para o metodo init. Só que deixei a inicialização manual por que existe muitas classes então nao queria inicializar todas de uma vez. Existe conexões com o banco e tal
mae.F1.init(valores);
mae.F1.metodoX(outrosValores);
System.out.println(mae.F1.getNome("80"));
mae.F1.finalizar();

O codigo no projeto está exatamente assim, o que muda memso é so a tal da classe “MAE”, pra ficar mais claro eu tenho isso em duas situações, nas classes que interagem com o banco, as filhas contem todos os selects de sua tabela, e nas classes de verificações, do mesmo modo existe uma classe de verificação para cada classe de tabela, existe tambem a “mae” das verificações. Cada verificação extende da VerificaçãoComum, do mesmo modo que cada filha extende do pai no exemplo anterior. O que faço é passar para a classe mae das Tabelas do banco a Classe Mae das Verificações.

É como eu tava dizendo, tudo ta pronto e funciona perfeitamente, a questão é só o trabalho de cada vez atualizar a classe MAE 2 vezes para cada classe que eu precise criar.

[waksman]

Ok, bom não conheço essa area do java, como ja tinha dito antes, pois bem, Criei um teste aqui que simula o que vou usar, mas não conseguir ir muito longe, eu to lendo aqui o mesmo sobre tutorial do GUJ (http://www.guj.com.br/article.show.logic?id=10) Reflection, como foi sugerido, mas desculpa a ignorancia mas não consegui nem nem esboçar o codigo pra chamar o metodo. Eu consegui listar os metodos e reparei que não aparecem os metodos do EXTENDS que deveriam vir do Pai. Bom aqui o exemplo que estou usando como referencia

Mudei minha analogia pra uma classe de “matematica” so pra ficar facil de trabalhar
Então temos o PAI ([color=darkblue]Basico[/color])
Filha 1 ([color=green]Multiplica[/color])
Filha 2 ([color=green]Divide[/color])
Mae ([color=red]Contas[/color])

Codigo:

package teste;

public class Basico {

    public int a;
    public int b;

    public Basico(){}

    public void init(Object a, Object b) throws Exception {
        if (a != null && b != null) {
            this.a = Integer.parseInt(a.toString());
            this.b = Integer.parseInt(b.toString());
        } else {
            throw new Exception("Valores invalidos!");
        }
    }

    public int soma(){
        return  a+b;
    }

    public int subtraiAB(){
        return  a-b;
    }

    public int subtraiBA(){
        return  b-a;
    }
}
/*****************************************/

package teste;

public class Divide extends Basico {

    public float divideAB() {
        return super.a / super.b;
    }

    public float divideBA() {
        return super.b / super.a;
    }
}
/*****************************************/

package teste;

public class Multiplica extends Basico {

    public float multiplica() {
        return super.a * super.b;
    }
}
/*****************************************/

package teste;

import java.lang.reflect.*;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Contas {
    static Class[] contas;

    public static void main(String[] args){
        try {
            contas = new Class[2];
            contas[0] = Class.forName("teste.Multiplica");
            contas[1] = Class.forName("teste.Divide");
            for(int cont=0;cont<contas.length; cont++){
                System.out.println("\n----- " + contas[cont].getName() + " --------\n");
                Method[] metodo = contas[cont].getDeclaredMethods();
                for(int cont2=0;cont2<metodo.length;cont2++){
                    System.out.println("Metodo 1: " + metodo[cont2].getName());
                }
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Contas.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

Em fim, o codigo exemplifica a situação, da pra ver que eu iniciei as Classes filhas na mão, seria preciso fazer isso automaticamente, eu axei ate algoritmo aqui no forum que lista as classes do jar, mas do classpath da classe que o cara usou, falar a verdade eu nao entendi nada
Depois so precisaria entender como que chama o metodo, eu li no tutorial, copiei e coloei, ele roda, mas eu nao consigo escrever ele, ou seja não entendi a partde de invocação de metodos

OBS: A ideia não é ter uma classe q tenha todos os comandos das classes filhas, o exemplo da a entender que estou tentando fazer uma classe montando ela atraves de outras, a ideia eh o exemplo da chamada de metodos e de como carregar as classes do pacote.>

[waksman]

Estava tentando pegar os arquivos do pacote via java.io.file, mas nao consigo iniciar o file no pacote atual

//Eu estava testando os metodos na verdade eu nao sei como fazer, dai tentei esse e outros
java.io.File classe = new java.io.File(Contas.class.getPackage().getImplementationTitle());
String[] nomes = classe.list();
            for( int cont = 0; cont< nomes.length; cont++){
                System.out.println(nomes[cont]);
            }

Dai esse codigo assima nao funciona, mas alguem sabe como iniciar o file no package atual?

[waksman]

Ok. analisando o que eu queria, verifiquei que seria mais trabalhoso fazer desta maneira então eu queria apenas chamar UM UNICO metodo da variavel mas estou recebendo o erro que o objeto não é uma instancia da classe declarada.

comentado abaixo as maneira que eu tentei invocar o metodos "FECHAR";
linha 29 teste 1
linha 31 teste 2
linha 33 teste 3
linha 36,37 e 38 teste 4

public class AcessoTabelas {

    tabelas.ClCusto clCusto;
    tabelas.ClFatura clFatura;
    tabelas.SysUsuario sysUsuario;

    public AcessoTabelas() {
    }

    public void fecharTodas() {
        //Obter todas as variaves da classe
        java.lang.reflect.Field[] atributos = this.getClass().getDeclaredFields();
        try {
            //Percorrer vetor
            for (int cont = 0; cont < atributos.length; cont++) {
                //Mostrar TIPO e VARIAVEL
                System.out.print(atributos[cont].getType().getName());
                System.out.println(" " + atributos[cont].getName() + ";");

                //Obter todos os metodos da variavel
                java.lang.reflect.Method[] metodos = atributos[cont].getType().getMethods();

                //Mostrar todos os metodos da variavel
                for (int cont2 = 0; cont2 < metodos.length; cont2++) {
                    System.out.println("  " + metodos[cont2].getName());
                }

                //Executar o metodo FECHAR da variavel
                atributos[cont].getType().getMethod("fechar", null).invoke(Class.forName(atributos[cont].getType().getName()), null);

                //atributos[cont].getType().getMethod("fechar", null).invoke(atributos[cont].getType(), null);

                //atributos[cont].getType().getMethod("fechar", null).invoke(atributos[cont], null);


                //Class classe = atributos[cont].getType();
                //java.lang.reflect.Method m = classe.getMethod("fechar", null);
                //m.invoke(classe, null);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalArgumentException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InvocationTargetException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NoSuchMethodException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        } catch (SecurityException ex) {
            Logger.getLogger(AcessoTabelas.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static void main(String[] args) {
        AcessoTabelas a = new AcessoTabelas();
        a.fecharTodas();
    }
}

/******ERRO******/
20/05/2010 16:18:52 teste.AcessoTabelas fecharTodas
SEVERE: null
java.lang.IllegalArgumentException: object is not an instance of declaring class
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at teste.AcessoTabelas.fecharTodas(AcessoTabelas.java:43)
        at teste.AcessoTabelas.main(AcessoTabelas.java:71)
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)

So explicando, o nome da classe, o tipo da classe e o nome dos metodos, TODOS aparecem corretamente (linha 17, 18 e 25) o problema é na chamada mesmo que eu não entendio como ocorre.
a estrutura da calsse é essa. Em todos os teste o erro retornado é sempre o mesmo [color=red]"object is not an instance of declaring class"[/color]

package tabelas;

import java.sql.SQLException;
import verificacao.AcessoTabela;

public class ClCusto extends bd.Comando implements bd.Modelo {
    /*SEUS METODOS PARTICULARES*/
}

package bd;

import java.sql.ResultSetMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Comando {
    /*Atributos*/
    /*Metodos*/

    /**
     * Fecha conexão atual
     */
    public void fechar() {
        try {
            cnx.fechar();
        } catch (Exception e) {
            cnx = null;
        } catch (Throwable e) {
            cnx = null;
        } finally {
            cnx = null;
        }
    }
}

Resumidamente, eu quero chamar o metodo FECHAR da classe ClCusto que [color=blue]extend[/color] da classe COMANDO
So que ali eu faço um loop pra rodar todas as variaves que eu tenho e chamar o metodo fechar de todas elas, uma vez que todas extendem da calsse COMANDO

---

Eu to tentando usar está classe que funciona como referencia junto com outros materias na net e aqui memso no GUJ…

package teste;

import java.lang.reflect.Method;

public class RunMthdRef {
  public int add(int a, int b) {
    return a+b;
  }

  public int sub(int a, int b) {
    return a-b;
  }

  public int mul(int a, int b) {
    return a*b;
  }

  public int div(int a, int b) {
    return a/b;
  }

  public static void main(String[] args) {
    try {
      Integer[] input={new Integer(2),new Integer(6)};
      Class cl=Class.forName("teste.RunMthdRef");
      Class[] par=new Class[2];
      par[0]=Integer.TYPE;
      par[1]=Integer.TYPE;
      Method mthd=cl.getMethod("add",par);
      Integer output=(Integer)mthd.invoke(new RunMthdRef(),input);
      System.out.println(output.intValue());
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

[waksman]

Seguinte, Desconciderando tudo o que foi dito, partindo do zero.
OK, acredito que cheguei no ponto final pra descobri o problema, espero que esteja certo. Apos algumas pesquisas, descobri o MIRROR (http://projetos.vidageek.net/mirror-pt/method/invocando-metodos/), fiz uns teste e relmente é mais facil utiliza-lo

Criei uma classe de teste e chamei de ClasseX, é esta tal ClasseX que contem o metodo que eu quero chamar, o metodo chamandoMetodo

package teste;

public class ClasseX {

    public void chamandoMetodo() {
        System.out.println("OK. Chamow o metodo");
    }
}

Ok, entao criei a classe pra chamar este metodo via reflection pra ver como funciona.

package teste;

import java.util.logging.Level;
import java.util.logging.Logger;
import net.vidageek.mirror.dsl.Mirror;

public class Teste {

    ClasseX x1;

    public Teste(){
        x1 = new ClasseX();
    }

    public void testeClasseX(){
        new Mirror().on(x1).invoke().method("chamandoMetodo").withoutArgs();
    }

    public void testeReflectionClasseX() throws NoSuchFieldException{
        Class<?> classe = getClass().getDeclaredField("x1").getType();
        new Mirror().on(classe).invoke().method("chamandoMetodo").withoutArgs();
    }

    public static void main(String args[]){
        try {
            Teste t = new Teste();
            t.testeClasseX();
            t.testeReflectionClasseX();
        } catch (NoSuchFieldException ex) {
            Logger.getLogger(Teste.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
/******************************/
run-main:
OK. Chamow o metodo
Exception in thread "main" java.lang.IllegalStateException: attempt to call instance method chamandoMetodo on class teste.ClasseX
        at net.vidageek.mirror.invoke.MethodHandlerByMethod.withArgs(MethodHandlerByMethod.java:48)
        at net.vidageek.mirror.invoke.MethodHandlerByName.withArgs(MethodHandlerByName.java:46)
        at net.vidageek.mirror.invoke.MethodHandlerByName.withoutArgs(MethodHandlerByName.java:42)
        at teste.Teste.testeReflectionClasseX(Teste.java:21)
        at teste.Teste.main(Teste.java:28)
Java Result: 1
CONSTRUÍDO COM SUCESSO (tempo total: 1 segundo)

Como observa-se, o primeiro metodo funciona, mas a minha intencao é obter todas as variaveis da classe e chamar o metodo. No exemplo, ali eu chamei direto a variavel pelo seu nome, teria ali um [color=blue]for[/color] para obter todas as variavies mas pra testar eu dexei so uma, o que eu observei é que quando passo a variavel como Class<?> ele perde a instancia, ou algo assim, é ai que acredito que esta o problema.

Se eu passo a variavel direto para o Mirror, ela funciona
Mas quando eu pego as variaveis da classe pelo reflection e passo pro metodo ele nao consegue executar.

//FUNCIONA
new Mirror().on(x1).invoke().method("chamandoMetodo").withoutArgs();
//Nao funciona
new Mirror().on(classe).invoke().method("chamandoMetodo").withoutArgs();

A qustão é que não adiantaria nada eu fazer isto:

public void chamaX(){
    new Mirror().on(x1).invoke().method("chamandoMetodo").withoutArgs();
    new Mirror().on(x2).invoke().method("chamandoMetodo").withoutArgs();
    new Mirror().on(x3).invoke().method("chamandoMetodo").withoutArgs();
    new Mirror().on(x4).invoke().method("chamandoMetodo").withoutArgs();
}

Que seria exatamente o mesmo que fazer:

public void chamaX(){
    x1.chamandoMetodo();
    x2.chamandoMetodo();
    x3.chamandoMetodo();
    x4.chamandoMetodo();
}

Que é exatamente o que eu nao quero fazer.

Ter de digitar todas as variaveis que tenho e chamar uma por uma. Fora que adiciono novas variaveis toda hora, o que torna esse processo muito facil de se ter erros, hora ou otra eu tenho o famoso "null pointer exceptioin", por que eu esqueci de instancia alguma variavel. Queria fazer este processo automaticamente. Alguem tem alguma ideia?

[waksman]

O reflection estava me dando mais trabalho que solucao, claro, uma area que desconheco vai dar trabalho de inicio mesmo, mas como estou um pouco sem tempo eu consegui resolver com um HashMap simples. Quando estiver com tempo pretendor procurar a solucao em reflection e implementar outras coisas, tinha até um projeto pra incluir as classes automaticamente ao colocar em uma determinada pasta, mas por falta de conhecimento nas areas requiridas deixei de lado. Mas é isso ai, Novamente, agradeço os post.

package tabelas;

public class AcessoTabela {

    private String usr;
    private String pss;
    private String host;
    public Asterisk asterisk;
    private String usrAsterisk;
    private String passAsterisk;
    private String hostAsterisk;
    private java.util.HashMap vars;
    private int contVars;
    public SysUsuario sysUsuario;
    public RgTipo rgTipo;
    public RgSetor rgSetor;
    public RgEndereco rgEndereco;
    public EpEmpresa epEmpresa;
    public ClFatura clFatura;
    public SysPermissao sysPermissao;
    public SysMenu sysMenu;
    public RgTelefone rgTelefone;
    public ClCusto clCusto;
    public ClDetalhamento clDetalhamento;
    public ClResponsavel clResponsavel;
    public SysCor sysCor;
    public SysControle sysControle;
    public ClGru clGru;
    public ClGruHistorico clGruHistorico;
    public ClContadorGru clContadorGru;

    public AcessoTabela() {
        host = "HOST;
        usr = "USER";
        pss = "PASS";
        hostAsterisk = "HOST 2";
        usrAsterisk = "USER";
        passAsterisk = "PASS";
        vars = new java.util.HashMap(0, 1);
        contVars = 0;
    }

    public void initAsterisk() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        asterisk = new Asterisk();
        asterisk.setConexao(hostAsterisk, usrAsterisk, passAsterisk);
        vars.put(contVars++, asterisk);
    }

    public void initSysUsuario() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        sysUsuario = new SysUsuario();
        sysUsuario.setConexao(host, usr, pss);
        vars.put(contVars++, sysUsuario);
    }

    public void initRgTipo() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        rgTipo = new RgTipo();
        rgTipo.setConexao(host, usr, pss);
        vars.put(contVars++, rgTipo);
    }

    public void initRgSetor() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        rgSetor = new RgSetor();
        rgSetor.setConexao(host, usr, pss);
        vars.put(contVars++, rgSetor);
    }

    public void initRgEndereco() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        rgEndereco = new RgEndereco();
        rgEndereco.setConexao(host, usr, pss);
        vars.put(contVars++, rgEndereco);
    }

    public void initEpEmpresa() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        epEmpresa = new EpEmpresa();
        epEmpresa.setConexao(host, usr, pss);
        vars.put(contVars++, epEmpresa);
    }

    public void initClFatura() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clFatura = new ClFatura();
        clFatura.setConexao(host, usr, pss);
        vars.put(contVars++, clFatura);
    }

    public void initSysPermissao() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        sysPermissao = new SysPermissao();
        sysPermissao.setConexao(host, usr, pss);
        vars.put(contVars++, sysPermissao);
    }

    public void initSysMenu() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        sysMenu = new SysMenu();
        sysMenu.setConexao(host, usr, pss);
        vars.put(contVars++, sysMenu);
    }

    public void initRgTelefone() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        rgTelefone = new RgTelefone();
        rgTelefone.setConexao(host, usr, pss);
        vars.put(contVars++, rgTelefone);
    }

    public void initClCusto() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clCusto = new ClCusto();
        clCusto.setConexao(host, usr, pss);
        vars.put(contVars++, clCusto);
    }

    public void initClDetalhamento() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clDetalhamento = new ClDetalhamento();
        clDetalhamento.setConexao(host, usr, pss);
        vars.put(contVars++, clDetalhamento);
    }

    public void initClResponsavel() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clResponsavel = new ClResponsavel();
        clResponsavel.setConexao(host, usr, pss);
        vars.put(contVars++, clResponsavel);
    }

    public void initSysCor() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        sysCor = new SysCor();
        sysCor.setConexao(host, usr, pss);
        vars.put(contVars++, sysCor);
    }

    public void initSysControle() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        sysControle = new SysControle();
        sysControle.setConexao(host, usr, pss);
        vars.put(contVars++, sysControle);
    }

    public void initClGru() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clGru = new ClGru();
        clGru.setConexao(host, usr, pss);
        vars.put(contVars++, clGru);
    }

    public void initClGruHistorico() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clGruHistorico = new ClGruHistorico();
        clGruHistorico.setConexao(host, usr, pss);
        vars.put(contVars++, clGruHistorico);
    }

    public void initClContadorGru() throws ClassNotFoundException, java.sql.SQLException, Throwable {
        clContadorGru = new ClContadorGru();
        clContadorGru.setConexao(host, usr, pss);
        vars.put(contVars++, clContadorGru);
    }

    public void fecharTodas() {
        for (int cont = 0; cont < vars.size(); cont++) {
            if (vars.get(cont) != null) {
                ((bd.Comando) vars.get(cont)).fechar();
            }
        }
    }
}