miércoles, 15 de enero de 2014

Tutorial Java en Linux Basico 6

En este tutorial veremos Objetos.

Un Objeto es una instancia de una clase,un Objeto se puede tratar separado de los demás teniendo sus propios métodos y variables,para crear un método de una clase se usa la sintaxis:

Clase objeto = new Clase();

Lo que se pasa entre paréntesis es lo que recibe como argumentos el constructor.

Vayamos por partes:

La clase mas simple y que siempre se usa es donde esta el main,por ejemplo nuestro programa HolaMundo.java tiene esto adentro:


1
2
3
4
5
class HolaMundo {
    public static void main(String [] args) {
        System.out.println("Hola Mundo");
    }
}

Como ven pueden pensar que el main es el constructor,pero primero hay que saber que es un constructor,en mis palabras un constructor es:

Una función que se ejecuta antes que ninguna para inicializar o ejecutar acciones especificas.

En java todas las clases publicas deben tener el nombre del archivo que las contiene,en este caso HolaMundo,porque el archivo es HolaMundo.java.

Como crear un constructor?

El constructor es una función sin retorno y sin modificadores,esta debe tener el mismo nombre de la clase,vamos a crear un constructor para ese código:


1
2
3
HolaMundo(int x) {
    System.out.println("Hola se a creado el objeto numero "+x);
}


Este constructor lo único que hace es mostrar el numero de veces que se ha creado el archivo,basado en el paso por argumentos,veamos el código completo:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
class HolaMundo {
    HolaMundo(int x) { // Constructor
        System.out.println("Hola se a creado el objeto numero "+x);
    }
    public static void main(String [] args) {
        System.out.println("Hola Mundo");
        for (int i = 1;i < 11;i++) {
            HolaMundo objeto = new HolaMundo(i); // Creamos objetos basados en el bucle
        }
    }
}


Eso demuestra como se crean los constructores y como es que se ejecutan,no es el mejor ejemplo y de hecho veo mala practica al usar una variable renovada en cada iteracion del bucle,pero eso no es lo que importa,lo que importa es ver como se ejecuta lo que esta adentro del constructor.

Algunas cosas que debemos saber de un constructor es que:

1. Siempre hay un constructor aunque no creemos uno javac lo hace por nosotros.

2. Puede haber mas de un constructor (overloaded;lo veremos mas adelante).

3. Repito, un constructor no lleva ni modificador y modificador de acceso.

Ahora si podemos ver algo un poco mas bueno que la mala practica de arriba,por ejemplo si queremos ver cuantas veces se ha creado un objeto usamos una variable static,como dije en el primer tutorial una variable de modificador static solo se crea una vez,solo una vez.

Algunas cosas que hay que saber o recordar de static:

1. No se considera OOP.

2. Solo se crea una vez.

3. Solo se pueden usar metodos static en métodos del mismo tipo de modificador(static),pero no así a la inversa.

4. Los métodos static en una clase se consideran métodos de clase y no métodos de objeto.

Veamos un ejemplo:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Ejemplo {
 private static int veces = 0;

 Ejemplo() {
  System.out.println("Hola se a creado el objeto numero " + veces);
  veces++;
 }

 public static void main(String[] args) {
  System.out.println("Hola Mundo");
  Ejemplo objeto = new Ejemplo();
  Ejemplo objeto1 = new Ejemplo();
  Ejemplo objeto2 = new Ejemplo();
 }
}


De ese modo podemos usar esa variable static para ver como cuantas veces se ejecuta,como dije los métodos static en una clase se llaman métodos de clase,para llamarlos no necesitamos crear un objeto,por ejemplo:


1
2
3
public static void getVeces() {
 System.out.println("Numero de objetos creados: "+veces);
}

Para usar este metodo no tenemos que instanciar un objeto y luego llamar el metodo:

Ejemplo objeto = new Ejemplo();

objeto.getVeces();

Aunque si funciona,lo que podemos hacer es:

Ejemplo.getVeces(); // Directamente

O mejor aun,las variables static se llaman variables de clase y podemos llamarlas asi:

Ejemplo.veces;

Código completo:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
class Ejemplo {
 private static int veces = 0;

 Ejemplo() {
  System.out.println("Hola se a creado el objeto numero " + veces);
  veces++;
 }

 public static void main(String[] args) {
  System.out.println("Hola Mundo");
  Ejemplo objeto = new Ejemplo();
  Ejemplo objeto1 = new Ejemplo();
  Ejemplo objeto2 = new Ejemplo();
  Ejemplo.getVeces();
 }

 public static void getVeces() {
  System.out.println("Numero de objetos creados: "+veces);
 }
}


Como vemos estamos trabajando solo con la clase del main,pero como creamos nuevas,para crear otras clases podemos hacerlo de distintas maneras para distintas ocasiones,ya que podemos crear clases locales,anónimas,etc pero en este caso veremos clases normales,al gual que la que guarda el main.

Para crear una clase creamos un archivo en el mismo PATH(directorio) donde esta el main,en su momento también hablaremos de paquetes,pero de momento creen una clase,llamada Animales.java:

Esta clase va ademas de la que contiene el main que se llama Ejemplo.java:

vim Animales.java
La clase debe ser publica y el nombre debe ser el mismo del archivo:

public class Animales {

 }

Vamos a crear unas funciones y variables para definir un animal,las cuales deben ser private:

Las variables private solo son visibles para la misma clase,objeto instanciado no lo podra llamar,lo cual hace que sean ocultadas para todo lo que no sea la misma clase,a esto se le conoce en el OOP como encapsulamiento.

Vamos a crear las variables:

private String especie;
private String sexo;
private boolean hambre = true;

Luego vamos a crear un constructor que reciba como parámetros las mismas variables,pero estas seran para definir las variables miembro(las de arriba):

Animales (String e,String s) {
       especie = e;
       sexo = s;
}

Ahora debemos crear una funcion que nos muestre el nombre,el sexo y si tiene hambre,ademas de una funcion para dar de comer:

Primero las funciones para ver el sexo y la especie,como son variables privadas no las podemos ver,asi que vamos a retornarlas como String,para ello tenemos que usar el token this,ya que this hace referencia a la variable del objeto actual,asi:

public String getEspecie() {
return this.especie;
}

Código completo:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Animales {
 private String especie;
 private String sexo;
 private boolean hambre = true;
 public Animales(String e,String s) {
  especie = e;
  sexo = s;
 }
 public String getSexo() {
  return this.sexo;
 }
 public String getEspecie() {
  return this.especie;
 }
 public void tienesHambre() {
  if (hambre)
   System.out.println("Tengo hambre :(");
  else 
   System.out.println("No tengo hambre :D");
 }
 public void darDeComer() {
  this.hambre = false;
 }
}

Como ven uso this para retornar,pero tambien se puede usar para definir,por ejemplo que los parámetros tuvieran el mismo nombre,usariamos this para hacer referencia a la variable miembro:


1
2
3
4
public Animales(String especie,String sexo) {
 this.especie = especie;
 this.sexo = sexo;
}

Ahora en la clase Ejemplo podemos crear un animal:


1
2
3
4
5
6
class Ejemplo {
 public static void main(String[] args) {
  Animales Mono = new Animales("Primate", "Macho");
  System.out.println(Mono.getEspecie());
 }
}

De esa manera hemos usado una clase mas ademas de la que contiene el main,podemos crear tantos animales como queramos y nuevos métodos,pero eso no es lo importante ahora ya que por ejemplo,en este ejemplo a la hora de comer se define en true,pero como vuelve a false(darle hambre de nuevo),pues esto lo veremos cuando veamos Threads,y como poder definir un animal mas especifico,esto lo veremos en herencia,pero de momento solo vimos como crear un objeto de una clase ajena al main.

Al ejecutar veremos esto:


Bien,algo que falta explicar en este tutorial basico de creación de objetos es la sobrecarga de métodos en la cual también veremos la sobrecarga de constructores:

En una clase puede haber distintos metodos con el mismo nombre,pero como se diferencian?

Con el simple hecho del paso por parametros:

Podemos tener estas dos funciones en la misma clase:


1
2
3
4
5
6
7
public void verNumero() {
 System.out.println(veces);
}
public void verNumero(String x) {
 System.out.println(x+veces);
 
}

Esto hará que podamos usar en el objeto:

Objeto.verNumero();

o

Objeto.verNumero("Veces creado : ");

Como dije lo único que lo distingue son los parametros,podriamos decir que lo distinguen los retornos,pero no,ya que el compilador no puede reconocer esto:


1
2
3
4
5
6
7
public void verNumero() {
 System.out.println(veces);
}
public int verNumero() {
 return veces;
 
}

Bien,de igual manera pasa con los constructores,podemos definir dos constructores para los Animales,supongamos esto,podemos darle de comer antes de crearlo,asi que así seria el constructor:


1
2
3
4
5
public Animales(String e,String s,boolean x) {
 especie = e;
 sexo = s;
 hambre = x;
}

Esto aun teniendo el constructor pasado, de esta manera podemos usar dos constructores:

new Animales("Primate", "Hembra");

 o
new Animales("Primate", "Hembra",false);

Aunque no se obstruye uno con otro es recomendable iniciar todos los constructores,para ello usamos this,pero ahora con parámetros:

Por ejemplo llamamos:

Animales mono = new Animales("Primate", "Hembra");
En el constructor usamos this antes que nada:


1
2
3
4
5
public Animales(String e,String s) {
 this(e,s,false);
 especie = e;
 sexo = s;
}

El this inicia el otro constructor.

Como dije al principio podemos si no usamos constructores el compilador creara uno,si existen variables miembro sin iniciar,las cuales iniciaremos en un método,las variables se inician al valor por defecto:

Por ejemplo int 0,String u Objeto null,etc:


1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public class Ejemplo2 {
 private int vint;
 private boolean vbool;
 private char vchar;
 private short vshort;
 private long vlong;
 private double vdouble;
 private String vString;
 
 public void ver() {
  System.out.println(vint);
  System.out.println(vbool);
  System.out.println(vchar);
  System.out.println(vshort);
  System.out.println(vlong);
  System.out.println(vdouble);
  System.out.println(vString);
 }
}

En el main:


1
2
3
4
5
6
7
class Ejemplo {
   public static void main(String[] args) {
   Ejemplo2 ejemplo = new Ejemplo2();
   ejemplo.ver();
   }

}

Aqui terminal la sexta parte de los tutoriales de Java.


Publicadas por Unknown a la/s 5:28 p.m.
Relacionado: , , ,

No hay comentarios.:

Publicar un comentario

Los comentarios serán revisados antes de ser publicados.

Suscribirse a: Comentarios de la entrada (Atom)