Java.Introducción II.
Clases.
Vamos a profundizar un poco más en las Clases. Existen dos tipos de clases:
- Las prediseñadas. Son las que ya vienen incorporadas en el propio lenguaje. Un ejemplo puede ser la clase Math, String…, hay muchísimas y cada día aumentando.
- Las personalizadas. Son las que creamos nosotros mismos para programar.
Ahora crear objetos se hacen con constructores. Un constructor es como un “procedimiento” en el que le damos parámetros, que en realidad son las variables de clase y así almacenar esos datos en los objetos.
Cada clase tiene un constructor. Si no escribimos explícitamente un constructor para una clase, Java crea un constructor predeterminado ya que es obligatorio tener mínimo uno.
Los constructores deben tener el mismo nombre que la clase. Una clase puede tener mínimo uno, pero pueden tener muchos más. Veamos un ejemplo como funcionan:
public class Perro{
String nombre;
String raza; public Perro() {
/*contructor por defecto, no tiene parámetros, inicia los valores por defectos a las variables de clase.*/
}
public Perro (String nombrep) {
// Contructor con un solo parámetro.
} public Perro (String nombrep, String razap) {
// Constructor con varios parámetros.
}
}
Estupendo pero….¿Como llamo al constructor para crear los objetos?.
NombreClase nombreObjeto=new NombreClase(parámetro/s)Esto se ve siempre mejor con un ejemplo:
public class Perro{
String nombre;
String raza;
public Perro() {
//contructor por defecto, no tiene parámetros.
}
public Perro (String nombrep) {
// Contructor con un solo parámetro.
nombre=nombrep;
} public Perro (String nombrep, String razap) {
// Constructor con varios parámetros.
nombre=nombrep;
raza=razap;
}
public static void main(String []args) {
// Creamos el objeto invocando al constructor.
Perro objetoByron= new Perro( "Byron" );
Perro objetoYaco= new Perro( "Yaco", "Border Collie");
}
}
¿Y como se yo cual es el constructor que estoy invocando? Pues muy simple, si invocamos a un constructor con un parámetro el buscará el que sólo tiene un parámetro. Si usas el de dos parámetros invocará el que corresponda. Eso si, si resulta que invocas a uno que no has creado te va a dar un error. Se usarán según necesidad del propio programa, es posible que tengamos que crear muchos constructores.
Los parámetros de los constructores se pueden llamar como queramos y dentro de éstos asignamos el valor del parámetro a las variables de clase.
Yo tengo la manía de poner siempre una ‘p’ al fina las variables que use en los constructores o métodos. Así diferencio lo que es una variable de clase y un parámetro. Pero son cosas que yo me he acostumbrado a hacer. Sois libres de hacerlo como queráis.
Variables.
Java tiene 3 tipos de variables:
- Variables a nivel de clase: Son variables dentro de una clase pero fuera de cualquier método y fuera del main. Estas variables se inicializan cuando se crea un objeto. Se puede acceder desde dentro de cualquier método, constructor o bloques de esa clase en particular.
- Variables a nivel método: Se definen dentro de los métodos o procedimientos. La variable se declarará e inicializará dentro del método y se borrará cuando el método haya terminado de ejecutarse.
- Variables de bloque: Son variables que se definen dentro de un bloque, por ejemplo un if, for…etc y se borrará cuando ese bloque se haya ejecutado.
Tipo de Datos Primitivos.
Enteros.
- Int. 4 bytes de almacenamiento. Comprende desde -2.147.483.648 hasta 2.147.483.647.
- Short. 2 byte de almacenamiento. Comprende desde -32.268 hasta el 32.267.
- Long. 8 byte de almacenamiento. Números enormes más grandes que el Int. Se poner siempre el subfijo L para saber que es de este tipo, por ejemplo 5.000.000.000L.
- Byte. 1 byte de almacenamiento. Comprende desde el -128 hasta el 127.
Coma Flotante.
- Float. 4 byte de almacenamiento. Aproximadamente 6 a 7 cifras decimales. Subfijo F.
- Double. 8 byte de almacenamiento. Aproximadamente 15 cifras decimales. No necesita ningún subfijo.
Texto.
- Char. Representa un solo caracteres. Se usan comillas simples (‘a’).
Lógicos.
- Boolean. Son las que representan a true o false.
Modificadores de Acceso.
Antes de empezar con las variables me gustaría hablar un poco de los modificadores de acceso, ya que son muy importantes a la hora declararlas. Existen 4 tipo de modificadores de acceso:
- Default. Si no se le indica nada a la variable o método será el que se asigne por defecto. Sólo las clases de un mismo paquete pueden acceder a esta propiedad o método.
- Private. Únicamente la clase puede acceder a las propiedades o métodos. Normalmente las atributos deben estar en modo private.
- Protected. las clases del mismo paquete y que heredan de la clase pueden acceder a la propiedad o método.
- Public. Es la menos restrictiva, es decir, cualquier clase o método puede acceder, es decir todo el mundo puede tener acceso.
Esto es lo que se le llama como Encapsulación en Java.
Declaración de Variables.
Java es muy estricto a la hora de declaración de variables;
- No podrás usarlas si no las declaras.
- No podrás usarlas si no tiene un valor y está declarada.
¿Cómo se declaran variables?. Simplemente ponemos el modificador de acceso, el tipo de variable [espacio] y el nombre que vayamos a ponerle.
public class Variables {
public static void main(String[] args) { int a; // Declarar solo una variable.
int b, c, d; // Declarar variables del mismo tipo.
int e= 10, f= 10; // Declarar variables y asignar valor.
byte g= 22; // Declarar y asignar valor o inicializar.
double h= 3.25; // Declarar variables tipo double.
float f=2.4578965F; // Declarar variables tipo float.
char i= 'a'; // Declarar varibles tipo carácter.
String j="Byron"; //Declarar variables tipo cadena de texto.
final double pi=3.1416; /* variable constante. En este tipo de variables no se puede variar el valor, siempre será el mismo. */
}
}
Operadores.
Aritméticos.
- Suma. +
- Resta. -
- Multiplicación. *
- División. /
Lógicos, relacionales y booleanos.
- Mayor que. >
- Menor que. <
- Mayor o menos que. <>.
- !Distinto de. !=.
- Igual que. ==.
- &&. Y lógico.
- ||. O lógico.
Incremento y decremento.
- Incremento. ++. Incrementa en 1
- Decremento. — . Decrementa en 1.
- Incremento. +=número. a+=2; Incrementa en 2 el valor de a.
- Decremento. -=número. a-=2; Decrementa en 2 el valor de a.
- Concatenación. +. Concatena textos, variables…etc. Se pueden concatenar en una misma línea varios textos y variables.
System.out.println("El valor de decimal es: "+decimal+" y aquí meto más texto "+Variable+" podemos poner todas las variables y texto que queramos");Vale, ya se declarar variables, darles valores, hacer cuentas, pero…¿Como hago para dar valores a los atributos de los objetos de una clase?
Getter y Setter.
Vamos a hablar un poquito de los métodos. Éstos son procedimientos o funciones que realizan una serie de instrucciones. Se deben crear fuera del main. ¿Cómo se crea un método?
[Modificador de acceso] [Otros modificadores] Valor_retorno
nombre_método (parámetros){ instrucciones..
}
Veamos un ejemplo:
public static int sumaNumeros (int num1, int num2){
int resultado=num1+num2;
return resultado;
}- Este ejercicio lo único que nos devuelve la suma de dos números. Muy sencillito.
Analicemos un poco el código:
- public static: Modificador de acceso.
- int sumaNumeros; Aquí le indicamos el tipo de valor que nos devolverá el método y el nombre que le vamos a poner.
- return. Esto es muy importante ponerlo cuando lo que queremos es que nos devuelva un valor.
Pero hay que decir que no todos los métodos nos tienen que devolver algún valor, lo mismo solo queremos que muestra algo en pantalla. Si es así se haría de otra forma:
public static void sumaNumeros (int num1, int num2){
int resultado=num1+num2;
System.out.println("El resultado de la suma es "+resultado);
}- En este ejemplo hace exactamente lo mismo pero no devuelve ningún valor, es decir, no es necesario poner el return. Para esto precisamente sirve el void en el método, le indica a java que no va a devolver nada todo lo hace dentro del procedimiento.
bueno, entonces que eso de getter y setter. Son métodos espaciales que sirven para ver el valor de una variable de clase o modificarla. Veamos un ejemplo usando la clase perro:
// Generamos los getters y setters.public String getNombre() {
return nombre;
}public void setNombre(String nombrep) {
this.nombre = nombrep;
}public String getRaza() {
return raza;
}public void setRaza(String razap) {
this.raza = razap;
}
Hay una forma automática de generarlos en en Eclipse. Menú Source/Generate getters y setters.
¿Que es eso de this en el código?. Cuando se llama a un método, se pasa automáticamente un argumento implícito que hace referencia un objeto. Esta referencia se llama this, lo que hace es decirle a java que utilice el objeto con el que se está trabajando en ese momento. Es algo así como la ruta absoluta y por omisión en los sistemas operativos.
this.raza=raza; // El this reemplaza a nombreObjeto.raza=razap ¿Y como llamo o invoco esos getters y setters?
Pues simplemente poniendo el nombre del objeto, un punto y método que queramos usar.
objetoYaco.setRaza("Border Collie");System.out.println("El nombre del la raza del objetoYaco es: "+objetoYaco.getNombre());
En este ejemplo usamos un set para cambiar la raza al objetoYaco y luego mostramos la raza del objetoYaco para comprobar que lo ha cambiado correctamente.
Entonces que diferencia hay entre métodos, funciones y los getter y setter? Los getter y setter sólo sirven para ver/modificar los atributos de una clase, para lo demás se usan métodos, procedimientos y funciones.
Vale, ya se como modificar/ver el valor de las variables de clase ahora quiero empezar a usar métodos, ¿Cómo lo hago?. Pues se hace exactamente igual que invocar los getters y setter.
Vamos a hacer un pequeño ejemplo que haga varias operaciones matemáticas con dos valores:
public class Calcular { private int num1;
private int num2;// Los setters y getters. public int getNum1() {
return num1;
} public void setNum1(int nump) {
this.num1 = nump;
} public int getNum2() {
return num2;
} public void setNum2(int num2p) {
this.num2 = num2;
}// creamos constructores. public Calcular() {
} public Calcular(int num1p, int num2p) {
num1=num1p;
num2=num2p;
}// método para sumar. public void sumar(int num1p, int num2p) {
int result=num1p+num2p;
System.out.println("El resultado de la suma es: "+result);
}// método para restar. public void restar(int num1p, int num2p) {
int result=num1p-num2p;
System.out.println("El resultado de la resta es: "+result);
}//método para multiplicar public void multi(int num1p, int num2p) {
int result=num1p*num2p;
System.out.println("El resultado de multi es: "+result);
}// El main. public static void main(String[] args) {
int numero1=7;
int numero2=10;
Calcular misCuentas=new Calcular(numero1, numero2);//invocamos los métodos para hacer las cuentas.
misCuentas.sumar(numero1, numero2); //invocamos sujmar.
misCuentas.restar(numero1, numero2); //invocamos restar.
misCuentas.multi(numero1, numero2); //invocamos multiplicar.
}
}
Como vemos en el código para invocar los métodos solo basta con poner “Objeto.método(parámetro1, parámetro2…);”. Como es lógico esto no funciona si no construimos el objeto antes.
Continúa por Clases Predefinidas.
