Clases y objetos.
Tenemos una mesa en la cocina, una en el salón, una mesilla de noche y una en un taller. Estas mesas son diferentes entre sí, pero, sin embargo, hay algo en ellas que hace que todas SEAN mesas. Una es cuadrada, otra redonda, unas con tres patas y otras con cuatro. ¿Por qué, si son tan diferentes, son todas mesas? Porque tienen una “esencia común”.
A esa esencia en común la denominamos clase Mesa, y a las distintas mesas individualizadas, objetos del tipo Mesa.
En POO definimos un concepto más que fundamental: el concepto de Clase.
La Clase es un conjunto de:
a) Datos
int numPatas;
String color;
String forma;
b) Métodos
constructor:
public Mesa (int numP, String color, String forma){
this.numPatas = numP;
this.color = color;
this.forma = forma;
}
Otros...
Los datos o atributos o variables de objeto determinan el "ser" de las cosas, y los métodos el "operar" de las mismas, a modo de herramientas.
Un objeto de una Clase se crea con un constructor de la misma, mediante el operador new y asignándole a una variable objeto los atributos definidos previamente.
Mesa mSalon = new Mesa(4, roja, circular);
Es decir, hemos creado una mesa salón, de tipo Mesa, pasándole los parámetros al constructor de 4 patas, color roja y forma circular.
ANALICEMOS LAS DISTINTAS MANERAS DE UTILIZAR LOS ATRIBUTOS DE OBJETO:
1.- CLASE CON ATRIBUTOS INICIALIZADOS EN CABECERA Y USANDO EL CONSTRUCOR POR DEFECTO:
public class Mesa {
String color = "verde";
String forma = "circular";
int numPatas = 5;
public void setColor(String newColor){this.color = newColor;}
public void setForma(String newForma){this.forma = newForma;}
public void setNumPatas(int newNumPatas){this.numPatas = newNumPatas;}
public String getColor(){return this.color;}
public String getForma(){return this.forma;}
public int getNumPatas(){return this.numPatas;}
public String toString(){
return this.color+"\t"+this.forma+"\t"+this.numPatas;
}
public static void main(String[] arg){
Mesa comedor = new Mesa();
System.out.println(comedor.toString());
}
}
El resultado del main es:
verde circular 5;
SI EN EL MAIN UTILIZAMOS METODOS SETER:
public static void main(String[] arg){
Mesa comedor = new Mesa();
comedor.setColor("blanco");
comedor.setForma("cuadrada");
comedor.setNumPatas(7);
System.out.println(comedor.toString());
}
El resultado es:
blanco cuadrada 7
Es decir, hemos cambiado los atributos de la mesa del comedor.
Se observa como los métodos son invocados por el objeto -comedor- mediante el punto.
2.- CLASE CON ATRIBUTOS NO INICIALIZADOS EN CABECERA Y USANDO EL CONSTRUCOR POR DEFECTO:
public class Mesa {
String color ;
String forma;
int numPatas;
public void setColor(String newColor){this.color = newColor;}
public void setForma(String newForma){this.forma = newForma;}
public void setNumPatas(int newNumPatas){this.numPatas = newNumPatas;}
public String getColor(){return this.color;}
public String getForma(){return this.forma;}
public int getNumPatas(){return this.numPatas;}
public String toString(){
return this.color+"\t"+this.forma+"\t"+this.numPatas;
}
public static void main(String[] arg){
Mesa comedor = new Mesa();
System.out.println(comedor.toString());
}
}
SI EN EL MAIN NO UTILIZAMOS METODOS SETER:
public static void main(String[] arg){
Mesa comedor = new Mesa();
System.out.println(comedor.toString());
}
El resultado es:
null null 0; es decir, los valores estan inicializados por defecto: los Strings a null y el int a 0;
SI EN EL MAIN SI UTILIZAMOS METODOS SETER:
public static void main(String[] arg){
Mesa comedor = new Mesa();
comedor.setColor("blanco");
comedor.setForma("cuadrada");
comedor.setNumPatas(7);
System.out.println(comedor.toString());
}
El resultado es:
blanco cuadrada 7; es decir hemos modificado los valores por defecto null, null, 0;
3.- CLASE CON ATRIBUTOS NO INICIALIZADOS EN CABECERA Y USANDO EL CONSTRUCOR CON PARAMETROS:
public class Mesa {
String color ;
String forma;
int numPatas;
public Mesa(String newColor, String newForma, int newNumPatas){
this.color = newColor;
this.forma = newForma;
this.numPatas = newNumPatas;
}
public void setColor(String newColor){this.color = newColor;}
public void setForma(String newForma){this.forma = newForma;}
public void setNumPatas(int newNumPatas){this.numPatas = newNumPatas;}
public String getColor(){return this.color;}
public String getForma(){return this.forma;}
public int getNumPatas(){return this.numPatas;}
public String toString(){
return this.color+"\t"+this.forma+"\t"+this.numPatas;
}
public static void main(String[] arg){
//Hemos de inicializar los parametros del constructor, de lo contrario no compilaria
String color = "verde"; String forma = "octogonal"; int numPatas = 8;
Mesa comedor = new Mesa(color, forma, numPatas);
System.out.println(comedor.toString());
}
}
El resultado es:
verde octogonal 8; es decir, los valores estan inicializados como parametros del constructor
SI EN EL MAIN SI UTILIZAMOS METODOS SETER:
public static void main(String[] arg){
Mesa comedor = new Mesa();
comedor.setColor("blanco");
comedor.setForma("cuadrada");
comedor.setNumPatas(7);
System.out.println(comedor.toString());
}
El resultado es:
blanco cuadrada 7; es decir hemos modificado los valores dados al constructor por los posteriores seters;
Aqui hemos visto variables de objeto, que están en la cabecera de la clase, variables locales, introducidas a traves de los parámetros de los métodos constructores o seters,... que incluso modifican los valorea de los atributos del objeto.
3.- CLASE CON ATRIBUTOS NO INICIALIZADOS EN CABECERA Y USANDO EL CONSTRUCOR CON PARAMETROS:
public class Mesa {
String color ;
String forma;
int numPatas;
public Mesa(){//Constructor sin parametros. Inicializamos los atributos de los objetos en el //constructor, es como hacerlo en la cabecera
this.color = "amarillo";
this.forma = "rectangular";
this.numPatas = 6;
}
public void setColor(String newColor){this.color = newColor;}
public void setForma(String newForma){this.forma = newForma;}
public void setNumPatas(int newNumPatas){this.numPatas = newNumPatas;}
public String getColor(){return this.color;}
public String getForma(){return this.forma;}
public int getNumPatas(){return this.numPatas;}
public String toString(){
return this.color+"\t"+this.forma+"\t"+this.numPatas;
}
public static void main(String[] arg){
Mesa comedor = new Mesa();
System.out.println(comedor.toString());
}
}
El resultado es:
amarillo rectangular 6; es decir, los valores estan inicializados como parametros del constructor
SI EN EL MAIN SI UTILIZAMOS METODOS SETER:
public static void main(String[] arg){
Mesa comedor = new Mesa();
comedor.setColor("blanco");
comedor.setForma("cuadrada");
comedor.setNumPatas(7);
System.out.println(comedor.toString());
}
El resultado es:
blanco cuadrada 7; es decir hemos modificado los valores dados en el constructor por los posteriores seters;
Todas las variables que hemos usado son de objeto, así como los métodos, también de objeto o dinámicos.
A continuación veremos una clase repositorio de métodos estáticos Math...
Comentarios
Publicar un comentario