Menu

Programación en Java SE 6 desde cero

Java es un lenguaje de programación orientado a objetos. Como programador Java debes saber que este lenguaje se compila y genera un código byte que corre sobre una maquina virtual instalada en el sistema operativo, esta es una diferencia notable con el resto de lenguajes de programación que normalmente cuando se compilan generan el código máquina específico del sistema operativo en el que se va a correr el programa. 

 

En este módulo aprenderás a declarar Clases, Interfaces y Packages. Hablaremos sobre abstract, extends e implementation, tipos primitivos, como arrays y enums. Sabremos cómo construir los constructores de clases y entenderemos la sobrecarga y sobreescritura de métodos.

Programación en JAVA SE 6 desde cero 

 

  1. Declaración Clases, Interfaces y Packages

  2. Abstract, Extends e Implementation

  3. Inicialización Clases, tipos primitivos, arrays y enums

  4. Constructores

  5. Overriding y Overloading

 

Objetivos:

 

  • Aprender a declarar Clases, Interfaces y Packages.

  • Conocer los términos y su uso: abstract, extends e implementation.

  • Estudiar la inicialización de clases, tipos primitivos, arrays y enums.

  • Construir los constructores de clases.

  • Entender la sobrecarga y sobreescritura de métodos.

 

¿Qué es JAVA?

 

Java es un lenguaje de programación orientado a objetos y desarrollado por Sun Microsystems (actualmente Oracle).

Como programador Java ya sabes que este lenguaje se compila y genera un código byte que corre sobre una maquina virtual instalada en el sistema operativo, esta es una diferencia notable con el resto de lenguajes de programación que normalmente cuando se compilan generan el código máquina específico del sistema operativo en el que se va a correr el programa. 

Esta característica del lenguaje es una de las que más popularidad le ha dado ya que hace que sea multiplataforma, con el mismo código compilado lo podremos ejecutar en cualquier sistema operativo que tenga instalada una máquina virtual.

En este capítulo cubriremos los fundamentos de la programación en este lenguaje, como la construcción de clases, interfaces y la creación de paquetes, así como la ejecución de los programas construidos en Java.

 

Clases de Java

 

Uno de los objetivos de cualquier lenguaje orientado a objeto es ser capaz de escribir correctamente las clases. Cualquier código escrito en Java siempre debe estar contenido dentro de una clase.

 

Una clase describe un objeto, que es cualquier entidad en el programa. Ese objeto puede representar cualquier cosa tangible, como una mesa, una persona o una tarjeta de crédito, o quizá puede representar algo que es menos concreto en el ámbito del programa, como un evento o un flujo de datos que hemos leído de un fichero.

Un objeto es una instancia de una clase. Para ser capaz de visualizar con claridad este concepto debemos pensar en la clase como un molde, o como la definición de una entidad (como la tarjeta de crédito) y el objeto es la tarjeta de crédito que existe físicamente.

La clase es el elemento fundamental en la programación en Java. Y a continuación detallaremos las reglas de cómo se deben escribir las clases.

 

Cualquier clase debe estar escrita en un fichero de texto con la extensión .java. Es importante remarcar que el nombre del fichero debe coincidir exactamente con el nombre de la clase. En consecuencia, un fichero .java únicamente puede incluir una clase pública, aunque existe el concepto de clase anidada que es una pequeña excepción a esta regla que se verá posteriormente.

 

Compilación de un programa en JAVA

 

Una vez compilada la clase escrita se generará el código byte al que hacíamos referencia anteriormente. Siempre que se compile una clase el fichero resultante tendrá nombre del fichero original y la extensión cambiará a .class. 

 

Java permite escribir múltiples clases dentro un mismo fichero .java, aunque sólo una de nivel más alto. Y como resultado de la compilación se generará un fichero .class por cada clase contenida en el fichero .java que contiene el código fuente. Por ejemplo, observa cómo se crea un fichero Tarjeta.java con el código contenido en la imagen de la derecha.

 

El resultado de la compilación del programa generará dos ficheros: Tarjeta.class y Propietario.class. Observa que la segunda clase no puede ser pública ya que en el fichero ya existe una clase pública. El lenguaje tampoco permite que la clase de nivel más alto no sea public. En este ejemplo Propietario se ha dejado con el modificador de acceso por defecto aunque también existen en el lenguaje protected y private.

 

Interfaces en JAVA

 

Una interface en Java es una colección de métodos sin implementar, es decir, únicamente su definición.  Una clase puede implementar una interfaz, lo que hará necesario que esa clase contenga el código de cada método que esté descrito en la definición de la interface.

 

Una interface tiene las siguientes propiedades: 

 

  • Esta definida en un fichero .java.   Si la interface es public, el nombre del fichero deberá coincidir con el nombre de la clase, y será accesible desde cualquier paquete del proyecto. Si por el contrario la interface tiene el modificador de acceso por defecto, sólo será accesible por las clases que estén contenidas dentro del paquete donde está escrita.

  • Las interfaces se deben compilar igual que cualquier otra  clase que escribamos en Java y el resultado será un fichero binario con el mismo nombre del fichero original cambiando la extensión .java por .class.

  • Todos los métodos incluidos en una interface son abstractos  por lo tanto no será necesario incluir este modificador en la definición de los mismos. Aunque implica que no se puede escribir el código de ningún método en la interface.

  • Todos los métodos de una interface son públicos  por lo tanto no es necesario añadir el modificador explícitamente.

  • Todos los campos o atributos de una interface son public, static y final. 

  • Una interface no puede declarar métodos de tipo static.

 

Una interface tiene algunas similitudes con una clase, pero no es lo mismo. Por ejemplo una interface no se puede instanciar, es decir no puede crear un objeto a partir de una interface.

 

Veamos el siguiente ejemplo, en el que se muestra la interface Imprimible:

public interface Imprimible { int MAX_PAG = 5000; public void imprimir(int paginas); int getNumeroPaginas(); }

 

 

Hemos definido la interface Imprimible que declara el un atributo, MAX_PAG, y dos métodos. Recuerda que MAX_PAG es public, static y final, aunque estos modificadores se hayan omitido. Igualmente los métodos los abstract y public, aunque imprimir incluya el modificador.

Debido al hecho que los métodos de una interface deben ser abstractos es necesario que tengan la misma sintaxis que se refleja en el ejemplo:

 

  • Primero el modificador de acceso,  aunque ya sabemos que todos los métodos son public independientemente de escribirlo explícitamente o no.

  • Seguidamente incluiremos el tipo de retorno. En el ejemplo el método imprimir indica que no se retornará nada y el método getNumeroPaginas indica que se retornará una variable de tipo entero.

  • A continuación se indica el nombre del método que deseamos que sea programado cuando se implemente esta interface que incluye los paréntesis donde se escriben las variables que recibe como parámetro.

  • Finaliza en punto y coma y no con las habituales llaves donde se escribiría nuestro código Java ya que los métodos definidos por una interface no van programados.

 

Necesariamente cualquier clase que implemente una interface estará obligada a implementar cada uno de los métodos que contiene.

Una interface a nivel práctico proporciona un contrato por el cual cualquier clase que la implemente nos da mucha información sobre su comportamiento.

 

Paquete en JAVA

 

El paquete es una agrupación de clases e interfaces. También puede contener enumeraciones y anotaciones, incluso dentro de un paquete se pueden contener otros tipos de ficheros que no sean propios del leguaje pero que se haga uso de ellos en nuestro programa como fichero .xml o .properties.

El hecho de agrupar los elementos de Java esta basado tradicionalmente en sus relaciones de uso, por ejemplo el paquete del API java.util contiene el conjunto de clases e interfaces que provee el lenguaje de utilidades, o el paquete java.io contiene las que están destinadas a realizar todo tipo de operaciones de entrada salida.

 

Los beneficios de paquetizar los programas en Java son:

 

  • Organizar los programas agrupando los elementos del programa asociados por su trabajo dentro del mismo. No debemos olvidar que los programas suelen estar compuestos por multitud de clases y menospreciar su ordenación puede conllevarnos fracasos importantes en los proyectos.

  • La paquetización crea espacios de nombres para nuestras clases e interfaces, lo que hará que a la hora de invocar desde una clase a otra clase habrá que referirse a ella por su nombre completo, que se conformará del nombre del paquete y el nombre de la clase.

 

Consecuencia de los paquetes en JAVA

 

El hecho de haber estructurado nuestra clase dentro de un paquete tiene dos consecuencias inmediatas:

 

El nombre de nuestra clase será es.empresa.Tarjeta. Ya que como hemos mencionado anteriormente el nombre de una clase para hacer referencia a ella en el código es el nombre del paquete donde está contenida y el nombre del fichero sin la extensión.

Para poder ejecutar el programa habrá que seguir una relación directa en la estructura de nuestro sistema de ficheros con nuestro programa, por lo tanto el fichero .class para poder ejecutarlo se debe encontrar en una estructura de directorios es/empresa/Tarjeta.class.

 

Abstract, Extends e Implementation en JAVA

 

Java permite el empleo de la herencia, característica muy potente que permite definir una clase tomando como base a otra clase ya existente. Esta característica es uno de los principios de la programación orientada a objetos.

 

El lenguaje cuenta con tres modelos diferentes para generar herencia. Extendiendo directamente de una clase ya programada con sus métodos y atributos, extendiendo de una clase abstracta o implementando una interfaz. Cada uno de los modelos de herencia es algo diferente y la opción de utilizar unos u otros suelen ser decisiones adoptadas a nivel de diseño del programa.

 

A continuación en el capítulo se detallan las palabras reservadas del lenguaje abstract, extends e implements que se utilizan para los diferentes tipos de herencia antes mencionados.

 

Abstract

 

Es un modificador con el que cuenta el lenguaje que permite definir algo y dejarlo únicamente expresado, en el caso de un método indica que no vamos a introducir el código en él. En el caso de una clase abstract indica que es una clase que no puede ser instanciada, es decir no vamos a poder generar un objeto a partir de esa clase.

 

En el siguiente ejemplo se muestra la definición de una clase abstracta:

 

public abstract class Empleado {

      private int codigo;

      private  String nombre;

 

      public  void imprimeNombre() {

          System.out.println(“El nombre del empleado  es: ” + nombre);

       }

    }

 

 

Con la definición que acabamos de hacer de la clase abstract no se permite generar objetos a partir de esta clase, lo que indica que si dentro de otra clase escribiéramos una sentencia como la siguiente:

Empleado miEmpleado = new Empleado();

Este código genera un error de compilación, y cuando obtenemos un error de compilación no se genera el fichero de código byte .class y por lo tanto no podemos ejecutar nuestro programa.

 

Entonces nos podemos preguntar ¿Cuál es el cometido de estas clases?

La respuesta es que son clases destinadas a la herencia, nos permite generar un código base para luego poder reutilizarlo en otras clases de nivel más bajo que se utilizarán en nuestro programa.

 

El modificador abstract no sólo se puede aplicar a las clases, sino que también se puede utilizar a nivel de método.

Si recordamos las interfaces nos referíamos a ellas diciendo que todos los métodos son abstractos porque no se implementan. Este es el cometido exacto del modificador a nivel de método, indica que el método no se va a implementar y que obligatoriamente se debe implementar en las clases que hereden o deriven de esta clase o interface. Se muestra a continuación un ejemplo de definición de método abstracto:

public abstract String calculaImpuestos();

 

El uso del modificador abstract en los métodos impone una serie de condiciones que deben ser cumplidas:

Cualquier clase que incluya métodos abstractos deben ser declaradas como abstracta, y por lo tanto no podrán ser instanciadas.

Cualquier clase concreta (entendemos por concreta las no abstractas) que herede de una clase abstracta, obligatoriamente debe redefinir e implementar los métodos de la clase padre declarados abstract.

Si una clase hija no redefine los métodos abstract esta debe ser necesariamente definida como abstract.

 

Extends

 

Si una clase deriva de otra (extends) hereda todas sus variables y métodos. La clase hija puede añadir nuevas variables (atributos) y métodos y/o redefinir las variables y métodos heredados.

En Java a diferencia de otros lenguajes de programación orientados a objeto no se permite la herencia múltiple, es decir únicamente se permite derivar de una única clase. Aunque cabe remarcar que es posible conseguir un resultado parecido en base a interfaces.

A continuación se muestra un ejemplo, donde tenemos dos clases, la clase Fruta, que denominamos clase padre, y la clase Fresa que es una clase que deriva de Fruta y por lo tanto hereda todos sus métodos y atributos que no son privados. La herencia a nivel de modificador de acceso sólo permite heredar aquellos métodos y atributos que no son private, es decir los public, protected y sin modificador de acceso, pero los modificadores de acceso los estudiaremos más adelante:

public class Fruta {    

  private String nombre;    

public  void madurarFruta() {      

  System.out.println(“La fruta: ” +  this.nombre +  “ ha madurado.”);    

  }

}

public class Fresa extends Fruta {}

Una vez realizada la herencia podemos especializar la clase hija añadiendo el nuevo código que sólo aplica a la clase hija:

public class Fresa extends Fruta {  
  public  void morder() {      
    // programación de las acciones      
    // que se realizarían al morder la fresa

  }

}


En este momento ya contamos en la clase Fresa con el método morder() que es único de la clase Fresa y el método madurarFruta() que lo podremos utilizar tanto en la clase Fruta como en la clase Fresa.

La herencia permite la reutilización del código programado, aunque también permite redefinir o sobrescribir cualquier método que exista en la clase padre para que se comporte de diferente forma que la anterior. Imaginemos que por lo que sea el la clase Fruta el método madurarFruta() únicamente imprime que la fruta ha madurado, en cambio para la clase Fresa a parte del mensaje queremos que se imprima la fecha del día de maduración, entonces tendríamos el siguiente código:

public class Fresa extends Fruta {

  public void morder() {

    // programación de las acciones

    // que se realizarían al morder la fresa

  }

  public void madurarFruta() {

    java.util.Date fecha = new java.util.Date();

    System.out.println(“La fruta: ” + this.nombre +  “ ha madurado en ” + fecha); 

  }

}

En este último ejemplo podemos ver como en la clase Fresa hemos sobrescrito el método madurarFruta() para que las líneas de código contenidas sean diferentes a las de la clase Fruta.

El caso de la herencia cuando se trata de derivar de clases abstractas es un poco diferente ya que nos obliga a sobreescribir todos aquellos métodos que en la clase Padre estaban marcados como abstract. Si recordamos cualquier método que poseía dicho modificador nos permitía dejar el método definido pero no lo programábamos, por lo que el compromiso de programación de ese método lo adquieren las clases que hereden de las clases abstractas.

 

Implementation

 

El último modelo de herencia es más restrictivo incluso que el de herencia de clase abstracta, es el caso de la herencia de interface. Esta herencia se consigue a través de la palabra reservada implements, y se materializa como se muestra en el siguiente ejemplo:

Tenemos la interface, en el fichero Comestible.java:

public interface Comestible {

   public void comer();

}

 

Decidimos que nuestra clase Fresa, contenida en el fichero Fresa.java, implemente la interfaz Comestible, quedaría como se muestra a continuación:

 public class Fresa extends Fruta implements Comestible {

   public void morder() {

     // programación de las acciones

     // que se realizarían al morder la fresa

   }

 

   public void madurarFruta() {

     java.util.Date fecha = new java.util.Date();

     System.out.println(“La fruta: ” + this.nombre +  “ ha madurado en ” + fecha);

   }

 

   public void comer() {

     while ( //fruta no terminada ) {

       this.morder();

     }

   }

 }

 

El hecho de haber implementado la interface Comestible nos ha obligado a programar el método contenía la definición, comer(). Dentro de este método comer() se ha incluido un bucle, y la expresión contenida dentro del ámbito del bucle esta en pseudo código, no es lenguaje Java.

 

Inicialización Clases, tipos primitivos, arrays y enums.

 

La inicialización en Java tiene que ver con el proceso de reserva de memoria y recursos de la máquina donde se ejecuta el programa.

 

Inicialización de Clases en JAVA

 

Aunque la inicialización tiene que ver con el proceso más físico que ocurre entre la maquina virtual Java (JVM como podremos ver en otra documentación) y la máquina donde corre el programa, en el lenguaje existen palabras reservadas que dan estas instrucciones.

En Java esta inicialización a la que hacemos referencia es la encargada de generar objetos a partir de clases. En este punto es cuando debemos ser más conscientes de lo que es una clase, que es lo más físico, el fichero de texto que hemos programado, y el objeto, que es la materialización en memoria de esa clase.

 

Para generar objetos en Java disponemos de un operador, new, que se utiliza como se muestra a continuación:

 

 public class Principal {

   public static void main(String args[]) {

     String miCadena;

     miCadena = new String

     ("Hola mundo desde Java!");

   }

 }

 

La clase Principal.java

 

Para el ejemplo que acabamos de ver hemos utilizado la clase Principal.java, que dispone de un método main con una estructura de definición y parametrización concreta, esta estructura no se puede variar y nos permite que este tipo de clases se ejecuten desde el sistema operativo, cualquier otra clase que no disponga de este método main definido como hemos podido observar en el ejemplo, no se podrá ejecutar.

 

En cuanto al operador new esta creando una instancia de la clase String, que en Java es la encarga de representar cadenas y nos permite trabajar con ellas.

 

Analicemos en más detalle las sentencias del programa:

 

La primera sentencia comienza con la definición de una variable. Para definir una variable debemos indicar el tipo que va a contener. En este caso indicamos al compilador que vamos a trabajar con una variable de tipo cadena y se llama miCadena. El nombre es necesario para poder hacer referencia a partir de ahora en nuestro código a la variable que acabamos de crear.

En la siguiente línea incializamos la variable miCadena que habíamos definido como tipo String, esto se hace con el operador de asignación = y con el operador new trás el cual siempre se debe invocar a un constructor, que realiza la generación del Objeto en memoria y lo inicializa. Pero el constructor lo veremos a fondo en el siguiente apartado.

 String miCadena;

 miCadena = new String ("Hola mundo desde Java!");

 

Tipos primitivos.

 

En Java existen dos tipos de datos, uno ya lo conocemos, el tipo referenciado u objeto, que es una estructura compleja de dato que se compone de atributos y métodos como hemos visto en los capítulos anteriores. Y el segundo tipo de dato que podemos encontrar en el lenguaje es el tipo primitivo, que nos permite trabajar con datos “simples” como números, caracteres o de tipo verdadero o falso.

 

En Java existen ocho tipos diferentes de tipo primitivo, que están ya predefinidos y nos permiten definir variables con un espacio determinado ya por este tipo.

 

  • Byte

  • Short

  • Int

  • Long

  • float

  • double

  • char

  • boolean

 

Nomenclatura en JAVA:

 

En Java se siguen unas normas básicas de nomenclatura a la hora de programar, que nos hace más sencillo ser capaces de reconocer el código cuando lo estamos leyendo. Aplicable a los tipos primitivos es que siempre se escriben los tipos en minúscula lo que nos permitirá reconocerlos rápidamente, mientras que las clases por normal se comienzan en mayúscula.

 

También podemos clasificar estos tipos primitivos por su uso:

 

  • byte, short, int y long para datos de tipo entero.

  • float y double para datos de coma flotante.

  • char para caracteres.

  • boolean para datos verdadero o falso.

 

En el siguiente ejemplo podemos observar como se utilizan algunos de estos tipos primitivos:

 

 public class Principal {

   public static void main(String args[]){

     int x;

     double d;

     char car;

     boolean condicion;

 

     x = 12345;

     d = 2.75;

     car = 'd';

     condicion = true;

       }

 }

 

Arrays en JAVA

 

Una matriz en Java se conoce como array. Y es un bloque contiguo de memoria que representa una colección de tamaño fija de valores que siempre tienen que tener el mismo tipo.

 

Un array en Java es un objeto, por lo tanto se puede instanciar utilizando el operador new y asignarlo a una referencia, igual que cualquier otro objeto. Los arrays tienen un tamaño fijo y no pueden crecer o encogerse dinámicamente (si tienes la necesidad de utilizar una estructura de memoria que pueda calcular su tamaño dinámicamente puede encontrar objetos al uso en el paquete java.util del API).

 

Las variables que hacen referencia a un array deben ir siempre acompañados de los corchetes, que denotan que ese tipo de variable hace referencia a un arrray. En el siguiente ejemplo se muestran tres definiciones de variable a array permitidas en Java:

 int[] tiemposFinalizacion;

 String apellidos[];

 double[]precios;

 

Instanciar en JAVA

 

Una vez se ha definido la variable es necesario, como en cualquier otro objeto, instanciarlo utilizando el operador new. Que a diferencia de los objetos normales será necesario indicar el tamaño del array que estamos definiendo.

 int[ ] tiemposFinalizacion = new int[25];

 String apellidos[ ] = new String[100];

 double [ ]precios = new precios[10];

 

En este momento tiempos de finalización es una instancia a un objeto de tipo array que puede contener 25 referencias a tipo primitivo int. Asimismo apellidos puede contener 100 instancias y precios 10, aunque cada una de las instancias contenidas dentro de la variable se deben inicializar.

 

Mediante los corchetes e indicando con un numero que representa un índice, podemos acceder a cualquiera de los elementos contenidos en el array.

 tiemposFinalizacion[0] = 1002892;

 tiemposFinalizacion[1] = 1004830;

 apellidos[99] = new String ("Sanchez");

 precios[0] = 12.56;

 

Tipología en JAVA

 

Una vez que hemos accedido al elemento deseado mediante los corchetes y su índice trabajaremos normalmente con las reglas correspondientes a su tipología. En el ejemplo podemos observar que cuando trabajamos con tipos primitivos se inicializan directamente en línea, en cambio cuando trabajamos con objetos, como el caso del String, debemos invocar a su constructor para crear el objeto en la variable que queremos referenciarlo.

 

Sobre los índices que utilizamos para acceder a cualquiera de los elementos que están contenidos en un array debemos conocer que van desde el elemento 0 hasta el número de elementos que tiene el array – 1.

Es posible crear e inicializar los arrays en la misma línea con una sintaxis un poco especial que tiene dispuesto el lenguaje:

int[ ] paresMenoresDiez = {2, 4, 6, 8};

 

Con esta sentencia hemos construido un array de cuatro elementos y se han inicializado con los valores 2 en la primera posición (pareMenoresDiez[0]), 4 en la segunda, 6 en la tercera y en la cuarta 8.

Como los arrays son objetos, también tienen métodos y atributos propios de ese tipo de objeto. Vamos a ver el atributo length que indica el tamaño del array. Es un atributo muy útil que veremos en numerosas ocasiones en programas. Por ejemplo pensemos en un algoritmo que inicialice un array de precios con el valor 0 para todos ellos:

 

En el programa que acabamos de leer podemos observar como recorremos con un bucle todo el array desde la posición 0 a la posición tamaño -1 que determina la posición del último elemento del array, y en cada iteración del bucle accedemos a la variable que contiene el array en esa posición y guardamos un 0 en ella.

 

 double precios[] = new precios[10];

 int i = 0;

 for (i=0; i < precios.length; i++) {

  precios[i] = 0;

 } 

 

Arrays Multidimensionales en JAVA

 

En Java se permiten los arrays multidimensionales, y pueden tener tantas dimensiones como nosotros queramos. Por cada dimensión que queramos generar debemos incluir unos corchetes adicionales a los primeros. En el siguiente ejemplo:

 double [][]precios;

 String [][]nombres;

 

Para instanciar los arrays multidimensionales es necesario indicar el tamaño del array por cada dimensión que tenemos;

 precios = new double [3][4];

 nombres 0 String [10][10][10];

 

Para acceder a cualquier elemento de un array multidimensional debemos especificar el índice por cada dimensión del array.

precios[0][0] = 0;

 

Enums en JAVA

 

A partir de la versión 5.0 de Java se introdujo el concepto de enumeración en el lenguaje. Al que se hace referencia con la palabra reservada enum. Una enumeración es un set fijo de constantes, y puedes utilizar una enumeración cuando necesites disponer de una lista de elementos de los que conoces los valores en tiempo de compilación.

 

Los ejemplos más típicos de elementos en los que se pueden utilizar las enumeraciones son: los días de la semana, los meses del año, los planetas del sistema solar. Las posibilidades son ilimitadas.

 public enum Estacion {

  INVIERNO, PRIMAVERA, VERANO, OTOÑO

 }

 

Ejemplo prático:

 

En el ejemplo como se puede observar hemos sustituido la palabra class a la hora de generar la clase por la palabra reservada enum, y al igual que cuando construimos una clase, debemos guardarlo en un fichero de texto con el mismo nombre que la enumeración, en nuestro caso, Estaciones.java. Fichero que también compilaremos y se generara su código byte correspondiente en el fichero Estaciones.class.

 

En el siguiente ejemplo se muestra un ejemplo práctico en el código el uso de una enumeración, ya que se utiliza para que el código de nuestro programa tenga un diseño más elegante y sea más fácil de comprender y mantener, aunque se podría conseguir el mismo efecto 

 

Estacion ahora = Estacion.PRIMAVERA;

switch(ahora) {

  case INVIERNO:

    System.out.println("Ahora hace mucho frío");

    break;

 

  case VERANO:

    System.out.println("Ahora hace mucho calor");

    break;

  default:

    System.out.println("Ahora hace muy buen tiempo");

}

 

Constructores en JAVA

 

Los constructores son unos métodos o funciones miembro muy importantes, y en su definición cuentan con unas particularidades como que no tienen valor de retorno (tampoco se utiliza void para indicar que no lo tienen) y su nombre coincide con el de la clase.

 

public class Rectangulo {  

  private int alto;  

  private int ancho:

 

public Rectangulo(int nuevoAlto, int nuevoAncho) {          

  this.alto = nuevoAlto;          

  this.ancho = nuevoAncho;  

  }

}

 

En este ejemplo se puede observar la clase Rectangulo con dos atributos: alto y ancho, y un constructor. El constructor es el método que es invocado cuando creamos un objeto, es decir en el momento que utilizamos el operador new. Por este hecho es por el que tiene esas necesidades de sintaxis especiales, ya que la máquina virtual Java cuando invocas al constructor con el operador new lo tiene que diferenciar del resto de métodos disponibles en la clase.

 

Rectangulo miRectangulo = new Rectangulo(10, 15);

 

Siempre que se utiliza el operador new se esta indicando a la clase que queremos instanciar que estamos invocando a su constructor. Este método es siempre el primero que se utiliza cuando instanciamos un objeto. Este hecho hace que utilicemos el constructor para realizar tareas relacionadas con la inicialización de los objetos. En concreto en el ejemplo anterior, se muestra como si quieres crear a partir de una clase Rectangulo un objeto de ese tipo, al constructor debes indicarle cual es el tamaño que define ese rectangulo.

 

A los constructores que no tienen parámetros se los conoce como constructores por defecto.

 

El constructor es un método obligatorio en una clase, y si no existiera no se podrían crear objetos a partir de esa clase, por ese motivo cuando se compila una clase, por comodidad y agilidad de programación, si no tiene un constructor programado, se crea automáticamente un constructor por defecto.

 

Overriding en JAVA

 

La reescritura de métodos en Java permite que cuando heredamos de una clase podamos redefinir el código contenido en un método, permitiendo que se comporte de forma diferente que en la clase original, pero sin variar su definición.

 

En este ejemplo podemos ver como la clase Animal cuenta con un método comer que tiene una salida por la consola que imprime “Animal comiendo”, mientras que la clase Caballo que hereda de la clase Animal ha heredado ese mismo método con su comportamiento, pero hemos decidido cambiar el comportamiento asociado al método para la clase Caballo y para ello es necesario sobreescribirlo con el nuevo código, para que cuando se invoque al método comer de la clase Caballo se imprima “Caballo comiendo”.

 

 

public class Animal {

  public void comer() {

    System.out.println("Animal comiendo...");

  }

}

 

class Caballo extends Animal {

  public void comer() {

    System.out.println("Caballo comiendo...");

  }

}

 

Overloading en JAVA

 

La sobrecarga de métodos permite que escribamos un método todas las veces que haga falta variando únicamente su parametrización. En el siguiente ejemplo vemos la clase Rectangulo con el constructor sobrecargado.

 

public class Rectangulo {

  private int alto;

  private int ancho;

 

  public Rectangulo(int nuevoAlto, int nuevoAncho) {

    this.alto = nuevoAlto;

    this.ancho = nuevoAncho;

   }

public Rectangulo() {

  }

}

Ahora cuenta con un constructor que inicializa el tamaño del rectángulo y otro que no lo hace. Por lo tanto con la nueva clase podría generar objetos de tipo Rectangulo de dos formas diferentes.

Rectangulo miRectangulo = new Rectangulo(10,15);

Rectangulo miSegundoRectangulo = new Rectangulo();

 

Seguimos con el curso de Java en el siguiente enlace:

Programación en Java SE 6 desde cero: Parte 2 

Las dudas que os puedan comentarlas justo aquí debajo e iremos respondiendo. 

¡Deja un comentario!

 

Modificado por última vez enDomingo, 17 Abril 2016 10:10
Valora este artículo
(3 votos)

Deja tus comentarios

Enviar un comentario como invitado

0 / 600 Restricción de Carateres
El texto debe estar entre 10-600 caracteres
Your comments are subjected to administrator's moderation.
terminos y condiciones.

Gente en la conversación

  • Gipuzkoa, Spain

    Gracias por los comentarios, como ya dije, si tenéis alguna duda sobre el curso de Java comentar y trataré de ayudar.

    Me gusta 0 URL corta:
  • Invitado - GONZALO

    Michigan, USA

    Gracias por toda la información que nos brindas de forma gratuita, es un trabajo grande el que has hecho para reunir toda esta información que has puesto a disposición de nosotros. Espero terminar el curso de Java y así tener una base de programación más fuerte.

    Me gusta 0 URL corta:
  • Invitado - Luisi

    Calle Gran Vía, 29, 28013 Madrid, Madrid, Spain

    Veo que no soy el primero en comenzar con este maravilloso curso de Java SE 6 gratuito, por lo menos espero terminarlo y cualquier duda que tenga seguro que podéis ayudarme. Gracias, se ve bien el curso, espero poder aprender mucho.

    Me gusta 0 URL corta:
  • Invitado - Andres Felipe

    He llegado a pagar incluso por cursos de Java SE 6 y tenemos aquí uno gratis y más completo incluso. La verdad es que a veces por no buscar un poco compramos cursos que no valen ni un euro. Gracias por el curso de Java, he comenzado hoy ya he visto que hay 7 partes, a ver que tal se me da.

    Me gusta 0 URL corta:
  • Invitado - Oscar Luna

    Justo lo que necesitaba para aclarar algunas dudas, hasta ahora siempre había ido aprendiendo poco a poco, de forma autodidacta y obligado, por necesidad en el trabajo. Con esta series de cursos de Java SE 6 aprenderé y obtendré una base fuerte para poder desarrollar proyectos en el futuro. Gracias

    Me gusta 0 URL corta:
  • Invitado - Abraham Morales

    Llevaba tiempo queriendo comenzar un curso desde cero para programar en Java y no veía la ocasión o la oportunidad y la verdad que con esta serie de cursos seguro que aprenderé una base fuerte para poder dedicarme como programador profesional.

    Me gusta 0 URL corta:
volver arriba