Boa tarde a todos, primeiro gostaria de me desculpar pela ausência.
Ando meio sem tempo, estou mexendo em um servidor ( depois posto o projeto todo, configuração do servidor windows 2003 Server, Site, Forum e OT ) e também a faculdade ( essa sim consome todo o tempo e a disposição ).
Bom, vamos falar sobre o padrão JAVA de codificação, faz algum tempo que percebi a dificuldade de quem está começando a aprender JAVA com as chamadas de metodos em um retorno de outro metodo ( aqueles metodos confusos, todos concatenados e de classes diferente e dai a primeira pegunta que vem a cabeça de quem está aprendendo “mais como? como se chama metodos de classes diferentes em uma linha só? que coisa de doida! ).
Calma gente, ( realmente é coisa de doido rsrs ) vamos entender ( ou tentar?! ) isso melhor.
Para explicar com detalhes como funciona esse procedimento, vou dar um exemplo de um código “fora do padrão” e um “dentro do padrão”.
/* —————————————— Começo Classes ——————————————*/
Classes utilizadas nos 2 ( Fora e Dentro do padrão de codificação ) exemplo:
/* ———————- Classe1 ———————- */
public class Classe1 {
private Classe2 obj2;
public Classe2 metodo1() {
obj2 = new Classe2();
return obj2;
}
}
/* ---------------------- Fim Classe1 ---------------------- */
/* ---------------------- Classe2 ---------------------- */
public class Classe2 {
private Classe3 obj3;
public Classe3 metodo2() {
obj3 = new Classe3();
return obj3;
}
}
/* ---------------------- Fim Classe2 ---------------------- */
/* ---------------------- Classe3 ---------------------- */
public class Classe3 {
private Classe4 obj4;
public Classe4 metodo3() {
obj4 = new Classe4();
return obj4;
}
}
/* ---------------------- Fim Classe3 ---------------------- */
/* ---------------------- Classe4 ---------------------- */
public class Classe4 {
private Classe4 obj4;
public int soma(int i, int x) {
int n = i+x;
return n;
}
}
/* ---------------------- Fim Classe4 ---------------------- */
/* ------------------------------------------ Fim Classes ------------------------------------------*/
Fora dos padrões de codificação:
/* ------------------------------------------ Começo ------------------------------------------*/
/*
Aqui falamos que x ira receber um obj ( referência* ) da classe1, y ira receber um obj ( referência* ) classe2 e assim por diante...lembrando que declarar é alocar um espaço na memória com a estrutura para receber um obj ( referencia* ) do tipo declarado;
*/
Classe1 x;
Classe2 y;
Classe3 u;
Classe4 i;
int n;
x = new classe1;
//retorna um obj ( referência* ) da classe2;
y = x.metodo1();
//retorna um obj ( referência* ) da classe3;
u = y.metodo2();
//retorna um obj ( referência* ) da classe4;
i = u.metodo3();
//retorna a soma de 2 numeros inteiros;
n = i.soma(4,5);
/* ------------------------------------------ FIM ------------------------------------------*/
Dentro dos padrões de codificação:
/* ------------------------------------------ Começo ------------------------------------------*/
//aqui declaramos a variável que receberá um obj ( referência* ) do tipo classe1 e instânciamos o novo obj ( new classe1(); );
classe1 x = new classe1();
int n;
/*
metodo1 retorna um obj ( referência* ) da classe 2, que por sua vez tem um método ( metodo2 ) que retorna um obj ( referência* ) da classe3, que por sua vez tem um método ( metodo 3 ) que retorna um obj ( referência* ) da classe4, esse ultimo é atribuído a i que é uma variável da classe 4;
*/
n = x.metodo1().metodo2().metodo3().soma(4,5);
/*
Pode ocorrer de a chamada ser:
n = classe1.metodo1().....;
Isso ocorrer porque o método é estáticos (static );
*/
/* ------------------------------------------ FIM ------------------------------------------*/
Att,
Rafael Simões Miranda
