Aspectos Relevantes De Una Clase en Java

Constructores

     Un constructor es un método que se ejecuta automáticamente cuando se crea un objeto de una clase; sirve para inicializar los miembros de la misma.

     El constructor tiene el mismo nombre que clase; cuando se define, no se puede especificar un valor de retorno porque nunca devuelve uno; sin embargo, puede tomar cualquier número de argumentos.

     La clase Rectangulo tiene un constructor con cuatro parámetros.

public class Rectangulo { private int izdo; private int superior; private int dcha; private int inferior; // constructor public Rectangulo(int iz, int sr, int d, int inf) { izdo = iz; superior = sr; dcha = d; inferior = inf; } // definiciones de otros métodos miembro }

     Al crear un objeto se transfieren los valores de los argumentos al constructor, con la misma sintaxis que la llamada a un método; por ejemplo:


                 Rectangulo Rect = new Rectangulo (25, 25, 75, 75);


     Se creó una instancia de Rectángulo, pasando valores concretos al constructor de la clase, de esta forma queda inicializado.

Constructor por defecto

     Un constructor que no tiene parámetros se llama constructor por defecto; el cual normalmente inicializa los miembros dato de la clase con valores predeterminados.

     El constructor por defecto inicializa x e y a cero.

public class Punto { private int x; private int y; public Punto()    // constructor por defecto { x = 0; y = 0; } } Cuando se crea un objeto Punto sus miembros dato se inicializan a cero. Punto P1 = new Punto() ;    // P1.x == 0, P1.y == 0

Constructores sobrecargados

     Al igual que se puede sobrecargar un método de una clase, también se puede sobrecargar su constructor; de hecho, los constructores sobrecargados son bastante frecuentes porque proporcionan diferentes opciones de inicializar objetos.

Métodos de una clase

     Si ha programado en algún otro lenguaje orientado a objetos como c++ o pascal ya se puede estar familiarizado con los métodos dado a que se puede pensar en los métodos como funciones o procedimientos. Un método es una función que pertenece a la clase.

     Los métodos en Java siempre son miembros de clases, no hay métodos o funciones fuera de ellas; su implementación se incluye dentro del cuerpo de la clase.

       La clase Racional define el numerador y denominador característicos de un número;por cada dato, se proporciona una método miembro que devuelve su valor y un método que asigna numerador y denominador; tiene un constructor que inicializa un objeto a 0/1.

class Racional { private int numerador; private int denominador; public Racional() { numerador = 0; denominador = 1; } public int leerN() { return numerador; } public int leerD() { return denominador; } public void fijar (int n, int d) { numerador = n; denominador = d; } }

This

Definida implícitamente en el cuerpo de los métodos, hace alusión al objeto sobre el que se invoca el método, es decir, el this es utilizado para hacer referencia al objeto de la clase actual. Se puede usar el this para referenciar a los miembros de la clase como métodos, constructores y variables.

class Triangulo { private double base; private double altura; public void datosTriangulo(double base, double altura) { this.base = base; this.altura = altura; } // ... }

           Con this se evita la colisión entre argumentos y variables instancia.

Sobrecarga de métodos

        En Java es posible sobrecargar métodos, es decir, definir dos o más dentro de la misma clase, que compartan nombre y que las declaraciones de sus parámetros sean diferentes; la sobrecarga es una forma de polimorfismo.

      Se define la clase llamada sobrecarga con cuatro métodos de nombre prueba sobrecargados, diferenciándose entre ellos por el número/tipo de los parámetros; main() llama a cada uno de ellos.

Sobre-escritura de métodos

En java la sobre-escritura toma un método de la clase padre y se emplea en una subclase con el mismo nombre y parámetros establecidos pero utilizando este método para la subclase en específico , esto para facilitar el traslado de información de una clase a otra.

Interfaces

Las interfaces son clases sin ningún  tipo de implementanción , es decir, en una interfaz solo deben aparecer métodos declarados y son usadas de una manera similar a las clases abstractas con la diferencia que la clase abstracta puede tener metodos implementados las interfaces no. 
Las interfaces se declaran con la palabra reservada interface. Las interfaces no encapsulan datos solo definen cuales son los métodos  que van a implementar los objetos de las clases que utilicen la interfaz 

          Implementación de una interfaz

La interfaz especifica el comportamiento común que tiene un conjunto de clases, el cual se realiza en cada una de ellas y se conoce como implementación de interfaz; utiliza una sintaxis similar a la derivación o extensión de una clase, con la palabra reservada implements en lugar de extends.

Jerarquía de interfaces

Es importante recordar que las interfaces se pueden organizar de forma jerárquica, de forma que los métodos sean heredados; a diferencia de las clases que sólo pueden heredar de una clase base (herencia simple), las interfaces pueden heredarse tanto como se precise; y como en las clases, también se utiliza la palabra reservada extends para especificar su herencia.

Clases abstractas

Las clases abstractas son aquellas que se basan en que una superclase permita unificar campos y métodos de las subclases, evitando la repetición de código y unificando procesos.

abstract class NombreClase { // ... } Por ejemplo: public abstract class Persona { private String apellido; // public void identificacion(String a, String c){...} }

Las clases abstractas tienen, como lo indica su nombre métodos abstractos; si una clase tiene un método abstracto debe declararse con la palabra reservada abstract; una característica importante de estas clases es que debe tenr al menos un metodo sin instanciar .

Ejemplo:

En el ejemplo podemos observar que figura es una clase abstracta ya que el metodo área no esta inicializado esto debido a que el área varia dependiendo de la figura por lo tanto nos conviene usar una clase abstracta para que en el momento en el ésta se herede a una subclase no tenga ningún tipo de dato que pueda complicar el proceso 

El código seria de la siguiente manera :

public abstract class Figura { protected double x; protected double y; public Figura (double x. double y) { this.x =x this.y = y; } Publib abstract double area() ; } publib class Circulo extends Figura { private double radio; public Circulo (double x, double y, double radio) { super (x, y); this.radio =radio; } public double area () { return Math. P* radio *radio; } } public class Cuadrado extends Figura  {  private double lado;  public Cuadrado (double x, double y, double lado) {  super (x, y);  this.lado = lado;  } public double area ()  {  return lado*lado; } }

 Clases derivadas

  La herencia o relación es-un, es la relación existente entre dos clases: una es la derivada que se crea a partir de otra ya existente, denominada base; la nueva hereda de la ya existente; por ejemplo: si existe una clase Figura y se desea crear una clase Triangulo, esta última puede derivarse de la primera pues tendrá en común con ella un estado y un comportamiento, aunque tendrá sus características propias; Triangulo es-un tipo de Figura; otro ejemplo es Programador que es-un tipo de Empleado.


Declaración de las clases Programador y Triangulo; la primera se deriva o extiende la clase Empleado; la segunda, de Figura.

1. class Programador extends Empleado { public miembro público // miembros públicos private miembro privado // miembros privados } 2. class Triangulo extends Figura { public // miembros públicos protected // miembros protegidos ... }

Una vez creada la clase derivada, el siguiente paso es añadir los nuevos miembros que se requieren para cumplir las necesidades específicas de la nueva clase.

Condiciones de error en programas

La escritura de código fuente y el diseño correcto de clases y métodos es una tarea difícil y delicada, por ello es necesario manejar con eficiencia las erratas que se produzcan. El manejo de errores es una etapa importante en el diseño de programas ya que no siempre se puede asegurar que las aplicaciones utilizarán objetos o llamadas a métodos correctamente; en lugar de añadir conceptos aislados de manejo de errores al código del programa, se prefiere construir un mecanismo de dicho manejo como una parte integral del proceso de diseño.

¿Por qué considerar las condiciones de error?

La captura (catch) o localización de errores es siempre un problema en programación; en la fase de desarrollo se debe pensar cómo localizar los errores; también hay otras cuestiones a tener en cuenta como: ¿dónde deben capturarse los errores?, o ¿cómo pueden manejarse?.

La solución a tales problemas en Java es llamar mecanismos del lenguaje que soportan manejo de errores para evitar hacer códigos de manejo de errores complejos y artificiales en cada programa; cuando se genera una excepción en Java, el error no se puede ignorar porque el programa terminará; si el código de tratamiento del error encuentra el tipo de error específico, el programa tiene la opción de recuperación del error y continuar la ejecución. Java busca automáticamente en un bloque de código llamado manejador de excepciones para responder de un modo apropiado; esta respuesta se llama capturar o atrapar una excepción (catching an exception).

Mecanismo del manejo de excepciones en Java

     El modelo de un mecanismo de excepciones consta fundamentalmente de cinco nuevas palabras reservadas: try, throw, throws, catch y finally.

·        try es un bloque para detectar excepciones,

·        catch es un manejador para capturar excepciones de los bloques try,

·         throw es una expresión para levantar (raise) excepciones,

·        throws indica las excepciones que puede elevar un método,

·        finally es un bloque opcional situado después de los catch de un try.

        Los pasos del modelo son:

1.     Establecer un conjunto de operaciones para anticipar errores; esto se realiza en un bloque try.

2.  Cuando una rutina encuentra un error, lanzar una excepción; el lanzamiento (throwing) es el acto de levantar una excepción.

3.     Para propósitos de limpieza o recuperación, anticipar el error y capturar (catch) la excepción lanzada.

  El mecanismo de excepciones se completa con:

  Un bloque finally que, si se especifica, siempre se ejecuta al final de un try;

 Especificaciones de excepciones que dictamina cuáles, si existen, puede lanzar un método.

  Normas

try { sentencias } catch (parámetro) { sentencias } catch (parámetro) { sentencias } etc.