Tipos de datos, clases, visibilidad y programación en Java: ejemplos prácticos

Programación en Java: tipos de datos, clases y ejemplos prácticos

Ejemplos de código en Java

1. Contar la letra 'a' en un texto

Programa que cuenta el número de letras 'a' introducidas hasta encontrar un punto (.).

public class ComptarA {
    public static void main(String[] args) {
        try {
            // declaraciones
            char letra;
            int nombre;

            // inicialización
            nombre = 0;
            // presentación
            System.out.println("Escriu un text acabat en '.' " +
                "i jo compto el nombre de 'a' " +
                "que hi apareguin.");
            // situarse sobre el primer elemento
            letra = (char) System.in.read();
            // mientras no sea el final
            while (letra != '.') {
                // tratar el elemento en curso
                if (letra == 'a') nombre = nombre + 1;
                // situarse sobre el siguiente elemento
                letra = (char) System.in.read();
            }
            // dar resultados
            System.out.println("El nombre de lletres 'a' trobades és " +
                nombre);
        } catch (Exception e) {}
    }
}

2. Cálculo del valor absoluto de un entero

import java.io.*;

public class ValorAbsolut {
    public static void main(String[] args) {
        try {
            String entrada;
            int x;
            BufferedReader in = new BufferedReader(
                new InputStreamReader(System.in));
            System.out.println(
                "Programa de càlcul del valor absolut d'un enter");
            System.out.println();
            System.out.print("Introdueix un valor enter: ");
            entrada = in.readLine();
            x = Integer.parseInt(entrada);
            if (x < 0) x = -x;
            System.out.println("El seu valor absolut és: " + x);
        } catch (Exception e) {}
    }
}

3. Cálculo del promedio de exámenes

import java.io.*;

public class Cap2Ej3 {
    public static void main(String[] args) {
        // Definimos el objeto br para leer líneas de la entrada
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // Definimos variables nombre, error y acumulador dándole valores por defecto
        String nombre = "";
        float acumulador = 0;
        boolean error;
        // Iniciamos el bloque que podrá producir errores, sólo para el nombre
        try {
            System.out.println("Nombre:?");
            nombre = br.readLine();
        } catch (Exception ex) {
            ex.printStackTrace(System.err);
        }
        // iniciamos una iteración del 0 al 9
        for (int i = 0; i < 10; i++) {
            error = false;
            // iniciamos el bloque do{} while(); que se repetirá en caso de error
            do {
                error = false;
                // iniciamos el bloque try que podrá dar error de conversión numérica
                try {
                    // ponemos i+1 entre (), caso contrario se concatenarán como texto
                    System.out.print("Examen " + (i + 1) + "? ");
                    acumulador += Float.parseFloat(br.readLine());
                } catch (NumberFormatException ex) {
                    System.out.println("Error, ingresar de nuevo");
                    error = true;
                } catch (IOException ex) {
                    ex.printStackTrace();
                    System.exit(-1);
                }
            } while (error);
        }
        // Tenemos lista la suma parcial y calculamos su promedio.
        acumulador /= 10;
        // Redondeamos el resultado a dos dígitos.
        acumulador = (float) Math.round(acumulador * 100) / 100;
        System.out.println(nombre + ", tu promedio es de: " + acumulador);
        System.exit(0);
    }
}

4. Clase Complex: números complejos

La clase Complex permite representar y operar con números complejos.

public class Complex {
    // ATRIBUTOS
    private float partReal, partImaginaria;

    // CONSTRUCTORES
    public Complex(float pReal, float pImag) {
        partReal = pReal;
        partImaginaria = pImag;
    }

    // MÉTODOS
    public float real() {
        return partReal;
    }

    public float imaginaria() {
        return partImaginaria;
    }

    public static Complex suma(Complex a, Complex b) {
        return new Complex(a.real() + b.real(),
            a.imaginaria() + b.imaginaria());
    }

    public static Complex resta(Complex a, Complex b) {
        return new Complex(a.real() - b.real(),
            a.imaginaria() - b.imaginaria());
    }

    public static Complex producte(Complex a, Complex b) {
        float pR, pI;
        pR = a.real() * b.real() + a.imaginaria() * b.imaginaria();
        pI = a.real() * b.imaginaria() + a.imaginaria() * b.real();
        return new Complex(pR, pI);
    }

    public String toString() {
        return "(" + partReal + " + " + partImaginaria + " i)";
    }

    public void canviReal(float nou) {
        partReal = nou;
    }

    public void canviImag(float nou) {
        partImaginaria = nou;
    }
}

Uso de la clase en un programa:

public class UsComplex {
    public static void main(String[] args) {
        Complex a, b, c;
        System.out.println("Programa que muestra la utilización" +
            " de los números Complex");
        // Crear dos números complejos
        a = new Complex(2, 4);
        b = new Complex(1, 2);
        // Sumar dos complejos
        c = Complex.suma(a, b);
        // Escribir el resultado de la operación
        System.out.println("La suma de " + a + " i " + b + " es: " + c);
        // hacer que la parte imaginaria de c sea igual a la real de b
        c.canviImag(b.real());
        // Utilizar la operación producto
        System.out.println(b + " x " + c + " = " + Complex.producte(b, c));
    }
}

5. Contar repeticiones de la primera palabra

public class ComptarRepeticionsPrimeraParaula {
    public static char lletra;

    public static final int MAXIM = 21;
    // Notar las dos constantes blanc y sentinella.
    // Tienen el mismo valor pero el contexto en el que se utilizan es muy diferente.
    // blanc está relacionado con la secuencia de entrada
    // sentinella está relacionado con la marca de final de palabra
    // podría darse el caso de que se decidiera cambiar su valor
    public static final char blanc = ' ';
    public static final char punt = '.';
    public static final char sentinella = ' ';

    public static char[] primeraParaula = new char[MAXIM];

    public static void main(String[] args) {
        int nombre;

        presentacio();
        nombre = 0;

        lletra = blanc;
        llegirPrimeraParaula();

        while (lletra != punt) {
            botarBlancs();
            if (coincideixSequencia())
                nombre++;
            botarParaula();
        }

        System.out.println("El nombre de vegades que s'ha " +
            "repetit la primera paraula és: " + nombre);
    }

    public static void presentacio() {
        System.out.println("Aquest programa comptabilitza el nombre" +
            " de vegades que es repeteix la primera");
        System.out.println("paraula d'un text escrit acabat " +
            " '" + punt + "')");
        // la combinación \n sirve para indicar un cambio de línea
        // adicional en este caso habrá dos cambios de línea.
        System.out.println("\n\nEscriu el text (acabant amb" +
            " '" + punt + "')");
    }

    public static void llegirPrimeraParaula() {
        int idx = 0;
        try {
            botarBlancs();
            while ((idx < MAXIM) &&
                (lletra != blanc) && (lletra != punt)) {
                primeraParaula[idx] = lletra;
                idx++;
                lletra = (char) System.in.read();
            }
        } catch (Exception e) {}
        // escribir el sentinella a continuación de la última letra
        // escrita. Tanto si ha habido problemas como si no
        primeraParaula[idx] = sentinella;
    }

    public static void botarBlancs() {
        try {
            while (lletra == blanc)
                lletra = (char) System.in.read();
        } catch (Exception e) {}
    }

    public static void botarParaula() {
        try {
            while ((lletra != blanc) && (lletra != punt))
                lletra = (char) System.in.read();
        } catch (Exception e) {}
    }

    public static boolean coincideixSequencia() {
        int idx = 0;
        try {
            while ((lletra == primeraParaula[idx]) &&
                (lletra != blanc) && (lletra != punt)) {
                lletra = (char) System.in.read();
                idx = idx + 1;
            }
        } catch (Exception e) {}
        return ((primeraParaula[idx] == sentinella) &&
            ((lletra == blanc) || (lletra == punt)));
    }
}

Conceptos teóricos

Tipos de datos

El tipo de dato describe el conjunto de posibles valores que puede tener una variable y también las operaciones que se pueden realizar con ellas.

Tipos de datos estructurados

Los tipos de datos estructurados se forman a partir de una agrupación de componentes. Cada uno de estos componentes puede estar formado por elementos de cualquier tipo de dato.

• Tablas (arrays o vectores): todos los componentes son del mismo tipo de dato, por eso se llaman tipos de datos homogéneos.
• Tuplas (registros o estructuras): los componentes pueden ser de tipos de datos diferentes entre sí, por eso se llaman tipos de datos heterogéneos.

Con la aparición de la programación orientada a objetos han surgido otros conceptos muy relacionados con las tuplas: las clases y los objetos.

Tipo Abstracto de Datos (TAD)

Para llegar al concepto de clase, primero hay que hablar del Tipo Abstracto de Datos (TAD). Un TAD se caracteriza por:

• Exporta un tipo, elemental o no.
• Exporta un conjunto de operaciones, lo que se conoce como interfaz.
• Las operaciones de la interfaz son las únicas permitidas para el tipo exportado. No existe ningún otro mecanismo de acceso a la estructura de datos definida.
• Existen axiomas y precondiciones que definen el ámbito de aplicación del Tipo Abstracto de Datos.

Subprogramas

Cada subprograma se caracteriza por cuatro aspectos:

• Nombre del subprograma: es la manera de identificar cada uno de los subprogramas.
• Argumentos o parámetros: información adicional que se puede suministrar a los subprogramas para que funcionen adecuadamente. Usualmente se indica como una lista cerrada entre paréntesis.
• Tipo de valor resultado: tipo de información que el subprograma puede suministrar como resultado de su ejecución. Si no se espera ningún valor resultado, se indica con el tipo especial void. Cuando un subprograma tiene valor resultado se llama función; cuando no, procedimiento. El valor que devuelve el subprograma se genera con la instrucción return.
• Ámbito del subprograma: contexto desde el que se puede invocar al subprograma. Los valores posibles son, en principio, dos: público y privado. Además, existe el concepto de propiedad del subprograma, que de momento se puede considerar siempre como estático.

Tablas

Las características que definen una tabla son:

• El nombre
• El número de elementos
• El tipo de cada uno de los elementos

Registros

Un registro es una agrupación de datos, los cuales no necesariamente son del mismo tipo. Se definen con la palabra struct.

Para acceder a cada uno de los datos que forman el registro, tanto para leer su valor como para cambiarlo, se debe indicar el nombre de la variable y el del dato (o campo) separados por un punto.

Arrays

Una tabla, vector, matriz o array (algunos autores lo traducen como «arreglo») es un conjunto de elementos, todos del mismo tipo. Estos elementos tendrán todos el mismo nombre y ocuparán un espacio contiguo en la memoria.

Visibilidad en la programación orientada a objetos

Un objeto siempre puede acceder a cualquier atributo o método de la clase a la que pertenece y usarlo sin restricción. Para establecer la visibilidad de los atributos y métodos, los lenguajes de programación definen tres niveles de acceso:

• Público: cualquier clase puede acceder a cualquier atributo o método declarado como público y usarlo.
• Protegido: cualquier clase hija puede acceder a cualquier atributo o método declarado como protegido en su clase madre y usarlo.
• Privado: ninguna clase puede acceder a un atributo o método declarado como privado y usarlo.

La visibilidad de atributos y métodos en la POO ayuda a incrementar factores de calidad como la reutilización, la portabilidad y la facilidad de uso de las clases. Nos ayuda a reutilizar código sin miedo a que esa reutilización nos «desmonte el chiringuito».

Hay tres tipos de visibilidad:

• Privada: un atributo, propiedad o método privado es invisible fuera de la unidad donde se declara. Se establece anteponiendo la sección private en la clase.
• Pública: un atributo, propiedad o método público es visible fuera de la clase en cualquier parte. Se ocultan otros detalles técnicos. Como clientes, hacemos uso indirecto de ciertos elementos privados mediante el acceso público. De forma análoga a private, para dar visibilidad pública debemos anteponer public.
• Protegida: un elemento protegido es visible solamente en la unidad donde se declara la clase y en cualquier clase que descienda de ésta. Es un término intermedio entre privado y protegido. Como desarrolladores herederos necesitamos conocer algunos detalles técnicos e internos del funcionamiento de la clase base para implementar nuestros propios mecanismos y extenderlos en caso de ser necesario, pero como clientes no tenemos acceso. Se antepone protected. Preste atención: dije algunos, no todos.

Variables y constantes

En programación, una variable es un espacio de memoria reservado para almacenar un valor que corresponde a un tipo de dato soportado por el lenguaje de programación. Una variable es representada y usada a través de una etiqueta (un nombre) que le asigna un programador o que ya viene predefinida.

Una constante es un valor que no puede ser alterado durante la ejecución de un programa. Corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos.