21 oct 2014

Métodos y atributos estáticos en Java

Se puede aplicar el especificador static, tanto a atributos como a métodos. Los atributos declarados con static pertenecen a la clase, y no a un objeto concreto de ella. Su valor se comparte para todos los objetos de esa clase.

[public] class Nombreclase {
static tipo atributo;
static tipo metodo(parametros) {
// código
}
}

Desde un método con alcance de clase o método static de una clase, sólo es posible acceder a características (atributos y métodos) static, pero no a atributos y métodos no static. Sin embargo desde un no static, se puede acceder a ambas características, las static y las no static.
Un miembro estático se crea cuando se carga la aplicación que contiene la clase y existe durante toda la vida de la aplicación. Se puede acceder al miembro incluso antes de que la clase se haya instanciado, a través del nombre de la clase, de esta forma:
Nombreclase.metodo();
Nombreclase.atributo = valor;

Para poder acceder a un miembro no estático, es necesario crear un objeto y acceder al miembro mediante el descriptor:
Nombreclase objeto = new objeto(param);
objeto.metodo(param);
Un atributo estático suele llevar un modificador de acceso public, protected, o sin modificador para poder ser accesible desde el exterior.


Un método estático no puede utilizar this y super.

20 oct 2014

Métodos de acceso en Java

El concepto de método de acceso está ligada a la idea de encapsulación, concepto fundamental de la programación orientada a objetos.

La encapsulación busca que los atributos de las clases estén protegidos, normalmente mediante acceso privado, de forma que sólo puedan ser accesibles mediante métodos públicos, denominados métodos de acceso. Esto evita la corrupción de datos.

Es habitual seguir el convenio de anteponer la palabra get al nombre del método de consulta que devuelve el valor del atributo, por ejemplo getNombre() y la palabra set al método que permite modificarlo setNombre().


public String getNombre() {
        return nombre;
    }

public void setNombre(String nombre) {
        this.nombre = nombre;
    }

public String getDireccion() {
        return direccion;
    }

public void setDireccion(String direccion) {
        this.direccion = direccion;
    }

public int getTelefono() {
        return telefono;
    }

public void setTelefono(int telefono) {
        this.telefono = telefono;
    }



17 oct 2014

Constructores en Java


Un constructor es un método que se ejecuta automáticamente siempre que se declara un objeto de una clase, bien cuando se crea el objeto directamente (declaración de variables matriciales estáticas y automáticas) o cuando se crea dinámicamente, mediante el operador new

Reglas para la creación de un constructor:

o   El nombre de un constructor es exactamente el nombre de la clase.
o   Los constructores no tienen tipo de devolución, ni siquiera void.
o   Pueden recibir, o no, argumentos.
o   Las clases pueden tener uno o más constructores, normalmente con el especificador de acceso public, basándose en la sobrecarga de métodos.

Se denomina, constructor por defecto de la clase, al que no tiene argumentos.

El lenguaje Java carece de destructores,  por lo que la memoria asociada a un objeto será liberada de forma automática por el recolector de basura (garbage collector).

Ejemplo de tres constructores para una misma clase:

    public Ficha() {
        nombre = "Nombre";
        apellidos = "Apellidos";
        curso = "2011";
        DNI = "01234567X";
        grupoPracticas = "X7";
        numNotas = 5;
        calificaciones = new float[numNotas];
    for (int i = 0; i < numNotas; i++) {
            calificaciones[i] = i;
        }
        comentarios = "Comentarios";
    }

    public Ficha(Ficha orig) {
        nombre = orig.nombre;
        apellidos = orig.apellidos;
        curso = orig.curso;
        DNI = orig.DNI;
        grupoPracticas = orig.grupoPracticas;
        numNotas = orig.numNotas;
        calificaciones = orig.calificaciones.clone();
        comentarios = orig.comentarios;
    }

    public Ficha(String nom, String ape, String cur,
            String ID, String gp, float[] cal, int num, String com) {
        nombre = nom;
        apellidos = ape;
        curso = cur;
        DNI = ID;
        grupoPracticas = gp;
        numNotas = num;
        calificaciones = cal.clone();
        comentarios = com;
    }


16 oct 2014

Clases y objetos en Java

Introducción a las clases

La unidad fundamental de programación en Java es la clase.

Las clases:
o   Contienen los métodos (código ejecutable).
o   Proporcionan la estructura de los objetos.
o   Proporcionan el mecanismo para fabricar objetos a partir de las definiciones de la clase.

Cada objeto es una instancia de la clase.

Los elementos fundamentales de una clase son los atributos y los métodos.

Plantilla básica de una clase:

class nombre_de_clase {
    [modificador_acceso]tipo variable_de_instancia1;
    [modificador_acceso]tipo variable_de_instancia2;
    ...
    [modificador_acceso]tipo variable_de_instanciaN;
    [mod_acceso]tipo nombre_método1 (lista_de_parámetros){
         cuerpo_del_método;
    }
    [mod_acceso]tipo nombre_método2 (lista_de_parámetros){
         cuerpo_del_método;
    }
    ...
    [mod_acceso]tipo nombre_métodoN (lista_de_parámetros){
         cuerpo_del_método;
    }
}

El archivo fuente es la unidad de compilación Java:
o   Archivo de texto con una o más definiciones de clase (no hay ni funciones ni variables globales).
o   Estos ficheros tienen extensión .java

Cuando se compila el código fuente, cada clase individual se coloca en un fichero de salida propio con el nombre de la clase con extensión .class

Una aplicación Java debe tener una clase que contenga un método main con el que poder iniciar el programa:
o   El compilador de Java compilará todas las clases que no tengan un método main.
o   El intérprete de Java, sin embargo, no tiene modo alguno de ejecutar esas clases.
o   El fichero fuente y la clase con el método main deben tener el mismo nombre (incluyendo mayúsculas y minúsculas).

Ejemplo:

package personabasicojava;
class Persona {
    public Persona() {
        nombre = "Juan";
        tel = 5551234;
    }
    String nombre;
    int tel;
}
public class PersonaBasicoJava {
    public static void main(String[] args) {
        Persona p = new Persona();
        System.out.println("Nombre: " + p.nombre);
        System.out.println("Telefono: " + p.tel);
        return;
    }
}


Creación de objetos


Cada clase que se crea añade otro tipo que puede utilizarse igual que los tipos simples.

Cuando se declara una nueva variable se puede utilizar un nombre de clase como tipo
o   A estas variables se las denomina referencias a objeto

Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo declarado.

Cuando se declara que el tipo de una variable es una clase, tiene como valor por defecto null.
                       
            Empleado emp;

El operador new crea una única instancia de una clase y devuelve una referencia a ese objeto.
           
Empleado emp = new Empleado( );

Aquí emp es una referencia a una instancia de Empleado.


 Modificadores de control de acceso

Las clases tienen dos tipos de especificación de acceso: privadas de un paquete, que es la situación por omisión, sin indicar nada, o bien públicas, lo cual se indica anteponiendo public al nombre de la clase.

Todos los atributos y métodos de una clase son accesibles para el código de la propia clase.

Para controlar el acceso de otras clases (así como la herencia por las subclases), los miembros de una clase tienen unos modificadores de control de acceso:
o   public: Los miembros declarados como públicos son accesibles en cualquier lugar donde sea accesible la clase (y son heredados por las subclases).

o   private: Los miembros declarados como privados son accesible sólo en la propia clase.

o   protected: Los miembros declarados como protegidos son accesibles para las subclases y heredados de ellas, así como por el código del mismo paquete.

Los miembros que se declaren sin modificador (conocidos como default o package-private) son accesibles sólo desde las clases del mismo paquete.


Declaración de atributos


Normalmente, los atributos tienen visibilidad private, salvo que sea conveniente acceder a ellos directamente desde clases derivadas.


public class Ficha {
    // Declaración de atributos en Java
    private String nombre;
    private String apellidos;
    private String curso;
    private String DNI;
    private String grupoPracticas;
    private int numNotas;
    private float[] calificaciones;
    private String comentarios;

 

Declaración de métodos


public class Ficha {
    …
   
    public Ficha() {     
    nombre = "Nombre";
    apellidos = "Apellidos";
    curso = "2012";
    DNI = "01234567X";
    grupoPracticas = "X7";
    numNotas = 5;
    calificaciones = new float[numNotas];
    for (int i = 0; i < numNotas; i++) {
        calificaciones[i] = i;
         }
           comentarios = "Comentarios";
    }