Estou começando a estudar Java e estou me sentindo meio perdido. Depois de 10 anos programando em Delphi fica complicado querer fazer tudo de uma vez em uma nova linguagem. Acontece que tenho um pequeno aplicativo em Delphi utilizando alguns dos vários recursos de OO que não estou conseguindo reescrever em Java. Espero que possam me ajudar.
Vou escrever aqui os meus métodos em Delphi e gostaria se possível que alguem conseguisse converter esse código em Java pra mim. Para entender é fácil mas pra converter é que é o complicado. Desde já agradeço.
TPersistente = class
public
function Persistir: Boolean; virtual; abstract;
class function Obter(pID: Integer): TPersistente; virtual; abstract;
class function ObterTodos: TList; virtual; abstract;
funciton Destruir(pID: Integer): Boolean; virtual; abstract;
end;
Bom, essa primeira classe é a minha classe base, várias outras classes irão descender dela e reescrever os métodos. Já vi que no java não existe virtual, apenas abstract.
TDepartamento = class
end;
Não preciso entrar em detalhe dessa segunda classe pois não me está atrabalhando… O problema vai vir agora que vou herdar minha terceira classe da primeira.
TDepartamentoDAO = class(TPersistente)
public
function Persistir(pDepartamento: TDepartamento); Boolean; reintroduce; overload;
class function Obter(pID: Integer); TDepartamento; reintroduce; overload;
class function ObterTodos: TList; override;
function Destruir(pID: Integer); Boolean; override;
end;
O primeiro método altera a assinatura do seu referente na primeira classe;
O segundo método altera o retorno do seu referente na primeira classe;
E é nisso aí que mora o meu problema. Eu já tentei de umas 10 maneira diferentes reescrever isso em Java mas não obtive sucesso.
Eu sei que ninguém aqui está para converter código pro outro. Mas isso já vai ser de grande ajuda para mim.
Minha classe persistente como disse vai ser minha classe base.
Além da minha classe TDepartamentoDAO, ainda vou ter outras como por exemplo TFuncionarioDAO.
No caso de TDeparmentoDAO:
TDepartamentoDAO = class(TPersistente)
public
function Persistir(pDepartamento: TDepartamento); Boolean; reintroduce; overload;
class function Obter(pID: Integer); TDepartamento; reintroduce; overload;
class function ObterTodos: TList; override;
function Destruir(pID: Integer); Boolean; override;
end;
No caso de TFuncionarioDAO:
TFuncionarioDAO = class(TPersistente)
public
function Persistir(pFuncionario: TFuncionario); Boolean; reintroduce; overload;
class function Obter(pID: Integer); TFuncionario; reintroduce; overload;
class function ObterTodos: TList; override;
function Destruir(pID: Integer); Boolean; override;
end;
No Delphi o modificador class function é a mesma coisa que o static do Java. Ou seja, não preciso instanciar um objeto TDepartamentoDAO ou TFuncionarioDAO para acessar os métodos Obter e ObterTodos.
Ambas as classes precisam implementar os quatro métodos da classe base TPersistente. Isso é minha garantia de que todos as classes vão escrever os métodos que eu preciso.
Método Persistir
Recebe uma classe distinta, TDepartamento ou TFuncionario e faz um insert ou update no banco com as informações que cada uma dela possui, ex. código e descrição/nome funcionário.
Método Obter
Efetua um select no banco de dados para retornar um objeto com as características que foi passado no parametro pID.
Método ObterTodos
Efetua um select no banco de dados e retorna um TList com tantos quantos objetos referentes ao registros que foram encontrados no bando de dados, ou de departamento ou de funcionário.
Método Destruir
Retira um registro do banco de dados baseado o ID informado.
Sugiro que repense seu problema utilizando Java, ao invés de tentar traduzir códigos do Delphi pro Java.
Senão vc vai continuar programando em Delphi, mas usando uma linguagem diferente.
Sempre procuro fazer isso, qdo aprendo uma linguagem/framework nova. Tento pensar em outra forma de solucionar meu problema, e como a nova tecnologia pode me ajudar nisso.
Entendo. Você declarou dessa forma porque você sempre sobrescreverá os métodos, uma vez que os parâmetros serão redefinidos para a entidade que seu DAO persistirá.
Me diga uma coisa: você tem algum código IMPLEMENTADO de fato na sua classe TPersistence? Ou todos os métodos são abstratos?
Se não tiver, qual o motivo de você declarar métodos de busca como estáticos e métodos de persistência como de instância? Ou deixa tudo estático ou não.
Se você optar por eliminar os métodos estáticos, uma interface pode ser declarada ( pegando o gancho do nosso colega Guitar_Men ):
public interface Persistence<T> {
boolean persist(T t);
T get(int id);
List<T> getAll();
boolean delete(T t);
}
Como eu disse antes, essa interface pode ser declarada no Delphi também ( exceto pelo uso de Generics ).
No mais, como os colegas falaram, não é tão simples “traduzir” um programa de uma linguagem para outra. Em Java, por exemplo, a utilização de Generics facilita muita coisa.
tnaires até dá pra seguir a sugestão de deixar tudo estático ou não. Mas mesmo assim, eu continuo com o problema de troca de assinatura dos métodos. O Java não me deixa trocar a assinatura e muito menos o retorno de uma função pelo meios que eu estudei até agora. E eu sei, como o rafagil escreveu, que preciso pensar em Java em vez de traduzir o código Delphi. Porém como eu sou novo em Java, não sei quais os recursos que a linguagem me oferece para que eu possa fazer o que eu faço com o Delphi de uma forma menos traumática :lol:
Eu tentei de todas as formas fazer com que:
TPersistente = class
public
function Persistir: Boolean; virtual; abstract;
end;
Na herança se tornasse:
TDepartamentoDAO = class(TPersistente)
public
function Persistir(pDepartamento: TDepartamento): Boolean; reintroduce; overload;
end;
Tá vendo? O método mudou a assinatura, mas continua o mesmo método. E eu não consegui fazer essa simples coisa.
O que você quer é um reintroduce, mas em Java não tem isso.
Você precisa sobrescrever o método abstrato “persistir” que você declarou na classe mãe, e depois escrever uma sobrecarga para ele.
Exemplo:[code]public abstract class Persistence {
abstract boolean persistir();
}
public class DepartamentoDAO extends Persistence {
public boolean persistir() {
// O método declarado na classe mãe
}
public boolean persistir(Departamento d) {
// A sobrecarga do método
}
}[/code]Em Java, você não precisa declarar as funções duas vezes. Veja que também não faz parte das convenções de código iniciar uma classe em Java com “T” ( que vem de type, do Pascal ).
tnaires obrigado… eu até tinha pensado em fazer isso mesmo… mas pensei que dava pra fazer de outra forma… Mais uma vez obrigado.
E não tem como eu deixar a definição da classe herdada “escondida”?
Ou seja, quando eu tiver escrevendo minha aplicação e necessitar utilizar a classe DepartamentoDAO só apareça para mim o método persistir que aceita o parâmetro Departamento p. Que não mostre que a sobrecarga do método.
[quote=romulojn]tnaires obrigado… eu até tinha pensado em fazer isso mesmo… mas pensei que dava pra fazer de outra forma… Mais uma vez obrigado.
E não tem como eu deixar a definição da classe herdada “escondida”?
Ou seja, quando eu tiver escrevendo minha aplicação e necessitar utilizar a classe DepartamentoDAO só apareça para mim o método persistir que aceita o parâmetro Departamento p. Que não mostre que a sobrecarga do método.[/quote]
Mas aí é que tá… Você vai usar essa implementação da classe mãe em alguma especialização? Senão, por que esse método tá aí? Só pra servir de sobrecarga?
É melhor você escrever uma forma genérica do método “persistir” na classe abstrata, que recebe um Object ou um tipo genérico ( é melhor você começar a estudar generics ).
E volto a insistir: use uma interface, porque pelo jeito sua classe mãe não tem nenhuma implementação que poderá ser útil para suas filhas.
