JAVA. RESUMEN DEL LIBRO CORE JAVA 2 VOLUMEN I

NOTA PREELIMINAR: EL CONTENIDO DE ESTE MANUAL ES UN RESUMEN Y REESTRUCTURACIÓN DE LA OBRA ORIGINAL. LOS CONCEPTOS ESTÁN AGRUPADOS SEGÚN SU USO MÁS HABITUAL, DE TAL FORMA QUE SE PUEDAN RECORDAR CON FACILIDAD. ESTO NO QUIERE DECIR QUE NO EXISTA OTRA ESTRUCTURA DE DOCUMENTO QUE SE ADAPTE MEJOR A OTRAS NECESIDADES. EN NINGUN MOMENTO SE PRETENDE QUE EL DOCUMENTO SUSTITUYA AL LIBRO YA QUE NO EXPLICA NI EJEMPLIFICA NINGÚN CONCEPTO.

Introducción

Java es uno de los mejores lenguajes que pueden usar los buenos programadores. Es SEGURO, PORTABLE y tiene AUTOMÁTICA DE BASURA.

Con respecto a C++: No tiene ficheros de encabezado, no hay aritmética de punteros, no hay estructuras ni uniones, no hay sobrecarga de operadores, etc…

Actualmente las capacidades de Java son, en esencia, las de C++.

Java es un lenguaje interpretado, no compilado. Tiene una tecnología JIT que compila justo antes de la ejecución fragmentos del programa.

Los tamaños de los datos primitivos ESTÁN ESPECIFICADOS.

Applet: programa Java que se ejecuta en páginas web.

Wn 1998 se denomina “Java 2 Standard Eition Software Development Kit v1.2”

Java no es un lenguaje de programación fácil de aprender. Aunque java es interpretado, resulta tan rápido como C++ gracias a JIT.

Sintaxis básica

Comentarios

Variables

Declaración

tipo identificador; int a;

Inicialización

tipo identificador = valor; int a = 0;

• Hay que inicializar siempre las variables

Modificador 'final'

final tipo identificador = valor; final int a = 0;

• Se suele utilizar siempre MAYÚSCULAS para variables

Modificador 'static'

static tipo identificador = valor; static int a = 0;

• Suele ir fuera del bloque main

Ámbito de variable

public|private tipo identificador; public int a;

Esquema general

[public|private|protected] [static] [final] tipo identificador [= valor];

Matrices

Declaración e inicialización

int[] a = new int[100]; int a[] = new int[100]; a.lenght(); int[] primos = {2,3,5,7,11,13}; primos = new int[]{2,3,5,7,11,13};

Copia de matrices

a = b; //esto hace que a apunte a la misma dirección que b

Para copiar dos matrices realmente hay que utilizar:

System.arraycopy

Para ordenar una matriz:

Arrays.sort (a);

Matrices multidimensionales

// Inicialización:
{
    {a,b,c,d,e,f},
    {a,b,c,d,e,f},
    {a,b,c,d,e,f},
    {a,b,c,d,e,f}
}

Control de flujo

Bloques

{ { int n=0 { int n=0; //ERROR, ESTO ESTÁ PROHIBIDO, NO SE PUEDE DECLARAR N PORQUE //YA ESTÁ DECLARADA EN EL BLOQUE SUPERIOR { //Esto es un bloque } } } }

No se pueden declarar variables con el mismo nombre en bloques anidados, está prohibido.

Condicionales

if

if (condición) sentencia else sentencia;

if (condición)
{}
else if (condición)
{}
...
else 
{}

condición ? valor_true : valor_false;

• condición es cualquier expresión que devuelva un valor booleano
• sentencia es una expresión comprendida entre ; ; o un bloque de instrucciones

switch

switch (option) { Case 1: {} break; Case 2: {} break; Case 3: {} break; ... default: {} }

• option es cualquier variable discreta (enteros o enumeraciones)

Bucles

for

for (variable; condición; incremento){sentencia}

• variable es la inicialización de la variable ke se va a autilizar
• condición es una expresión booleana. El bucle terminará cuando sea false
• incremento es el incremento de la variable inicializada, suele ser i++, i--

while

while (condición) {sentencia}

• condición es una expresión booleana. El bucle terminará cuando sea false

do

do {sentencia} while (condición);

• nota: termina con ; a diferencia del resto de bucles, ya que no termina con una llave de fin de bloque.

for each

for (variable : colección) sentencia;

• variable inicialización de la variable a utilizar
• colección array o estructura de elementos

Objetos

Vocabulario

Clase: Plantilla o plano a partir del cual se crean realmente los objetos.

Ejemplar: (o instancia) es una copia de una “plantilla” en memoria para ser utilizada.

Encapsulación: Combinar los datos y el comportamiento en una misma entidad y ocultar la implementación de los datos al usuario.

Campos de ejemplar: Son los datos del objeto propiamente.

Método: Procedimiento que opera sobre los datos.

Estado: Conjunto específico de valores que tienen los campos de ejemplar de un determinado objeto que ha sido construido en memoria.

Herencia: Tecnología que consiste en que un objeto extiende a otros sus propiedades y métodos.

UML: (Lenguaje Modelado Unificado) sirve para diseñar relaciones entre objetos. Constructor: Método especial cuyo fin es construir objetos, es decir, darles valores iniciales a sus variables.

Método desaprobado: (deprecated) es un método que no debería existir y se recomienda no utilizarlo.

Palabra 'final': Signifia lo mismo que “constante”.

'Paso por...': Jerga, hace referencia al modo de transmitir datos entre métodos.

Sobrecarga: Situación en la que convergen en una clase métodos con igual nombre pero distinta lista de argumentos. La resolución de sobrecarga es un mecanismo que decide qué método invocar en cada momento.

Constructor predeterminado: Es un constructor que no tiene argumentos.

Paquete: Forma de agrupar clases en una colección.

Importar: Hacer “visible” un paquete a una clase.

Ventajas del diseño orientado a objetos

• Es un mecanismo cómodo para la agrupación de métodos.
• Tiene mayor facilidad de depuración
• Es posible crear múltiples instancias de un objeto.
• Es más fácil de mantener y mejorar.
• Los métodos de modificación pueden realizar comprobación de error.

Estructura de una clase

    //Constructores
    {
        //Bloque de inicialización
        //Puede ir en cualquier lugar del código
        //Se ejecuta al crear una instancia del objeto, antes que los constructores.
    }

    static {
        //Bloque de inicialización static
        //Puede ir en cualquier lugar del código
        //Se ejecuta al iniciar el programa, aunque no se haya creado ninguna instancia
        //del objeto en memoria.
    }

    public NombreClase() {
        //Constructor por defecto (obviamente es obligatorio k tenga ámbito público).
    }

    public NombreClase(int a,int b) {
        //Constructor con argumentos
    }

    //Métodos

    //Métodos públicos

    //Métodos públicos inspectores

    public int getAncho() {
        return 1;
    }

    public objetoMosca getMosca() {
        return this->mosca.clone();
    }

    //Métodos públicos mutadores

    public void setAncho(int ancho) {
        if (ancho>=0) {
            this->ancho = ancho;
        }else{
            this->ancho = 0;
        }
    }

    //Métodos privados

    //Métodos privados inspectores

    private int getCalculoComplejo1() {
        return 2*6;
    }

    //Métodos privados mutadores

    private void setModo(String modo) {
        if (clave.equals(modo1)) {
            modo1=true;
            modo2=false;
            modo4=false;
            factorX *= factorX;
        }
    }

    //Campos
    private int cantidad1=0;
    private int cantidad2=0;
    private double factorX=0.012;
    private double factorY=0.0089;

    //Constantes
    public static final int A=0;
    public static final int B=1024;
    private static final int Z=11111;

}

NOTA: El nombre de fichero tiene que ser igual al nombre de la clase public. En un fichero fuente puede haber 1 clase public y infinitas privadas.

Ámbitos: Privado: pueden acceder sólo las entidades del propio objeto. Público: pueden acceder entidades de cualquier clase.

Constructores

Cuando se crea un objeto es necesario dar valores a sus campos antes de utilizarlo. Esta tarea se puede realizar mediante tres procedimientos.

Dando un valor en la declaración

int a = 50;
obj b = new obj();

Mediante bloques de iniciación

Se suelen utilizar como alternativa a la inicialización en la declaración, cuando se requiere un cálculo complejo del valor inicial. Se ejecutan siempre antes que las constructoras.

    {
        //Esto es un bloque de iniciación
        //Puede ir en cualquier lugar del bloque de la clase
    }

    static{
        //Esto es un bloque de iniciación static
        //Se ejecuta aunque no haya ninguna instancia del objeto en memoria
        //También puede ir en cualquier lugar del bloque de la clase
    }
}

Mediante constructores

• Los constructores tienen el mismo nombre que la clase.
• Sólo se pueden llamar a través del operador new.
• Una clase puede tener más de un constructor.
• Un constructor puede tener 0, 1 o más parámetros. Si tiene 0 parámetros se llama constructor por defecto.
• Creación del constructor por defecto: si se crea una clase sin constructores, se crea un constructor por defecto de forma automática. Si la clase ya tiene un constructor el compilador no creará ningún constructor por defecto, es decir, declarar una variable con el constructor por defecto dará error.
• Si los campos de objeto no han sido inicializados pese a tener constructor o por cualquier otro motivo, se inicializan automáticamente a 0, false o null dependiendo del tipo de objeto. (Se considera una mala práctica de programación recurrir a esto).

    public nombreClase() {
        a=0;
    }

    public nombreClase(int valor) {
        a=valor;
    }

}

Destructores

El método especial finalize se puede añadir a todos los objetos con motivo de liberar recursos. Se invoca antes que el recolector de basura. No es fiable el uso de finalize. IMPORTANTE: Si una clase tiene el método finalize, es necesario invocarlo cuando terminemos de utilizar el objeto.

Campos y campos de ejemplar

Son variables que se declaran a nivel de objeto para almacenar su estado una ves se creen en memoria. Por norma general LOS CAMPOS DE EJEMPLAR HAN DE SER SIEMPRE PRIVADOS.

Los campos de ejemplar se pueden definir como final. En este caso no es necesario que sean privados. NOTA: la constante debe tener un valor antes de que finalice el último constructor. A partir de entonces no se podrá modificar el valor.

Este modificador es útil para campos de tipo primitivo o de una clase inmutable (como la clase String)

Son más frecuentes los campos static final:

Public static final double PI=3.14159;

Las constantes públicas son correctas.

La cláusula static

--CAMPOS--

Si un campo se declara con static, todos los objetos de esa clase tendrán una zona de memoria común (ese campo). Estos campos se denominan CAMPOS DE CLASE Esta copia en memoria se crea aún sin haber ningún ejemplar creado.

--MÉTODOS-- Un método static no opera sobre un objeto, es decir, no tiene parámetro estático. Un método static no puede acceder a los campos de ejemplar, pero sí los campos de clase.

--BLOQUES— Los bloques static son bloques que se encuentran dentro del bloque de clase y se ejecutan una vez aún sin haber creado ninguna instancia del objeto.

--UTILIZACIÓN— Normalmente se utilizan métodos static cuando: Un método necesita acceder a campos de clase Sólo se utiliza una funcionalidad, sin ningún campo ni un objeto creado. Cuando se llama algún método static se recomienda utilizar el nombre de la clase y no del objeto.

Métodos

Tipos

Métodos de acceso – para consultar el estado del objeto. Es recomendable crear siempre una copia mediante .clone(), así se evita pasar una referencia.

Convención getValor();

Métodos de modificación – para modificar el estado del objeto.

Convención setValor();

Privilegios de acceso (ámbito)

Un método puede acceder a:

• Datos privados del objeto al cual se aplique.
• Datos privados de TODOS los objetos de su clase.

NOTA: si un método es público no podemos limitarnos a eliminarlo.

Parámetros de los métodos

Los métodos pueden pasar variables por VALOR y por REFERENCIA.

¡¡¡JAVA SOLO EMPLEA LLAMADAS POR VALOR!!!

La movida de esto es que java puede pasar referencias por valor :-O ¡!

Esto significa que no se pueden modificar parámetros de un tipo primitivo ¿???? Qué raroo

Es decir, si paso una variable de un tipo primitivo, no puede ser modificada.

Sobrecarga

Java admite, al igual que C++, sobrecarga en operadores y métodos.

“Resolución de sobrecarga” Proceso por el que se decide qué método invocar mediante los argumentos de la sentencia de invocación. Si no se encuentra el método adecuado se produce un error en tiempo de compilación.

NOTA: no se puede tener dos métodos iguales y que produzcan resultados de tipos distintos. Esto es, no puede haber dos métodos con la misma signatura. “Signatura de un método”:

modificadores tipoDevuelto NombreMetodo(Argumentos) <-- signatura

Consejos para el diseño de clases

• Datos siempre privados (campos private)
• Dar siempre valores iniciales!!!
• No utilizar muchos tipos básicos en una clase (repartirlos en varias clases)
• No todos los campos necesitan métodos individuales de acceso y modificación
• Utilizar un formato estándar en las definiciones de clases
• Fragmentar las clases que tienen “demasiadas responsabilidades”
• Conseguir que los identificadores de métodos y campos reflejen sus responsabilidades.