Gostaria de ter uma interface (de nome Modificavel) na qual uma seria de classes a implementasse (Cliente, Vendedor, etc.),inclusive os Dao’s das respectivas classes implemetassem Modificavel. Porem estou a ter problemas na implementacao, tal como podem ver nos codigos abaixo:
[code] public interface Modificavel {
public void registar(Modificavel m);
public void remover(int id);
public void removerTodos(Modificavel m);
public void editar(Modificavel m);
}
[/code]
Depois ter a classe Cliente
[code]public class Cliente implements Modificavel{
private String nome, contacto, profissao;
private int id;
private String encomenda;
// getters & setters
// implementacao dos metodos de Modificavel
}[/code]
E um ClienteDAO…
[code]// imports
public class ClienteDAO implements Modificavel{
private Connection connection;
public ClienteDAO() {
this.connection = new ConnectionFactory().getConnection();
}
@Override
public void registar(Modificavel m) { /* aqui e onde reside o problema. Gostaria de poder implementar todos metodos passando objectos
de classes que implementam Modificavel nas imlementacoes dos metodos de Modificavel. */
String sql = "INSERT INTO cliente (nome, contacto, profissao, encomenda) VALUES (?,?,?,?)";
try {
PreparedStatement statement = connection.prepareStatement(sql);
statement.setString(1, cliente.getNome()); // erro aqui
statement.setString(2, cliente.getEmail()); // erro aqui
statement.setString(3, cliente.getEncomenda().getTitulo()); // erro aqui
statement.execute();
statement.close();
} catch (SQLException e) {
throw new RuntimeException("Bug ao inserir");
}
}[/code]
não entendi sua dúvida.
Você indica linhas de erros em três pontos, onde você seta valores.
E não use Statement e execute, use PreparedStatement e executeUpdate().
recebe um objeto Modificavel … e a interface modificavel contêm os seguintes métodos:
public interface Modificavel {
public void registar(Modificavel m);
public void remover(int id);
public void removerTodos(Modificavel m);
public void editar(Modificavel m);
}
ou seja … apesar de Cliente ser Modificavel … nem todo Modificavel é Cliente …
Então Modificavel só conhece os métodos dele … e não da classe Cliente.
Mas se ClienteDAO.registrar(Modificavel) só vai registrar Cliente, porque você passaria um Vendedor para a classe ClienteDAO ? Isso não faz sentido.
Você realmente está amarrado a esse modelo? Se não, poderia implementar utilizando generics:
public interface GenericDAO <T, PK> {
public void registar(T t);
public void remover(PK id);
public void removerTodos(T t);
public void editar(T t);
}
public class Cliente {
}
public class ClienteDAO implements GenericDAO <Cliente, Long> {
public void editar(Cliente t) {}
public void registar(Cliente t) {}
public void remover(Long id) {}
public void removerTodos(Cliente t) {}
}
Segue um tutorial: http://www.ibm.com/developerworks/java/library/j-genericdao/index.html
É o seguinte:
Tenho 4 classes (Cliente, Livro, Encomenda, Venda) e eu gostaria que todas elas tivessem alguns métodos comuns, que são: registar(Entidade e); onde Entidade pode ser a classe onde o método está sendo implementado. Mas como eu pretendo fazer o uso de interfaces pelo facto de essas classes terem métodos com mesmo fim (registar), pensei em criar uma interface (Modificavel) que contém algumas assinaturas que serão implementadas em todas essas classes.
[code]
public interface Modificavel {
public void registar(Modificavel m);
public void remover(int id);
public void removerTodos(Modificavel m);
public void editar(Modificavel m);
/modificavel e um entidade que pode ser inserida, removida, editada e
exibida (devolvida) no sistema/
}[/code]
Só que, não sei como proceder, uma vez tenho de fazer DAO para todas essas classes, pois pretendo persistir com MySQL. Deverei por exeplo, fazer com que ClienteDAO implemente Modificavel? E se assim for, como me arranjo nos statements:
[code]
public class ClienteDAO // devera implementar Modificavel
// outro codigo conexao com base de dados
public void registar(Modificavel m) { // caso implemente modificavel.
Modificavel cliente = new Cliente(); // devo fazer isto para usar nos prepared statemant?
String sql = "INSERT INTO cliente (nome, contacto, profissao, encomenda) VALUES (?,?,?,?)";
try {
PreparedStatement statement = connection.prepareStatement(sql);
statement.setString(1, cliente.getNome());
statement.setString(2, cliente.getContacto());
statement.setString(2, cliente.getProfissao());
statement.setString(3, cliente.getEncomenda();
statement.execute(); // Nel, nao percebi porque nao usar Statement e execute mas sim executeUpdate()
statement.close();
} catch (SQLException e) {
throw new RuntimeException("Bug ao inserir");
}
} [/code]
Gostei da tua abordagem, mas parece que ela e usada em combinacao de frameworks de persistencia Hibernate ou Spring, nao estou usando nenhum deles, estou fazendo um trabalho de escola e ainda nao usei frameworks
//classe de conexao
public class Conexao{
public static Connection getConnection() throws SQLException{
try {
Class.forName("com.mysql.jdbc.Driver");
return DriverManager.getConnection("jdbc:mysql://xxx.xxx.xxx.xxx/bd?user=root&password=root");
} catch (ClassNotFoundException e) {
JOptionPane.showMessageDialog(null, e.getMessage());
throw new SQLException();
}
}
}
//bean de clientes
public class Clientes{
private Long id;
private String nome;
private String sobreNome;
//get e set
}
// DAO de Clientes
public class ClientesDAO{
private Connection con;
public ClientesDAO() throws SQLException{
this.con = Conexao.getConnection();
}
public void insere(Clientes cli) throws SQLException{
PreparedStatement stm = this.con.prepareStatement("INSERT INTO Clientes (nome, sobreNome) VALUES (?, ?)");
stm.setString(1, cli.getNome());
stm.setString(2, cli.getSobreNome());
stm.executeUpdate();
stm.close();
}
}
//testa insere
public class TestaInsere{
public static void main(String[] args){
Clientes c = new Clientes();
ClientesDAO cDAO = new ClientesDAO();
c.setNome("Fernando");
c.setSobreNome("Paiva");
cDAO.insere(c);
}
}