Curso de programación con java

    Autor: Luis Fernando Apáez Álvarez

  -Curso PyM-

    Clase 3: POO parte I

    Fecha: 04 de diciembre del 2022

Contenido

• Clases

• Encapsulamiento

• Palabra this

   

Clases en java

Crearemos una carpeta nueva (denominada clases) en nuestro lugar de trabajo y dentro de ella crearemos el archivo Persona.java. Luego

x
// declaramos el nombre del paquete (es decir, de la carpeta)
package clases;

// definimos una clase publica nueva
public class Persona {
    // Atributos:
    // tipo de dato | nombre del atributo
    String nombre;
    String apellido;
  
    // Metodos:
    // Imprime en consola el nombre y apellido
    public void desplegarInfo(){
        System.out.println("Nombre: " + nombre + "\nApellido: " + apellido);
    }
}
// Fin de la clase persona

Después, dentro de la misma carpeta crearemos un nuevo archivo denominada PruebaPersona.java

xxxxxxxxxx
package clases;

public class PruebaPersona {
    // metodo principal
    public static void main(String[] args) {
        // Creamos un objeto de la clase Persona
        // (estamos mandando a llamar al constructor)
        Persona persona1 = new Persona();

        // Ya podemos acceder a los atributos y metodos de la clase
        persona1.nombre = "Juan";
        persona1.apellido = "Perez";

        // Ahora accedemos al metodo desplegarinfo
        persona1.desplegarInfo();

        /* Ahora instanciaremos otra persona y mandamos a 
         * imprimirla directamente
        */
        Persona persona2 = new Persona();
        System.out.println(persona2);
        // lo que nos muestra la clase y la direccion de memoria,
        // asimismo, se nos mostraran los atributos para ese objeto
        // con valores nulos
        persona2.desplegarInfo();
    }
}

xxxxxxxxxx
Nombre: Juan
Apellido: Perez
clases.Persona@2c7b84de
Nombre: null
Apellido: null

Crearemos otra clase de ejemplo. Para ello, en nuestro espacio de trabajo crearemos otra carpeta con dos archivos. El primero de ellos: Persona.java

x
/* Creamos la clase persona de la siguiente manera:
 * 1) Definimos los atributos de la clase
 * 2) Definimos el constructor de la clase
 * 3) Definimos dos metodos de la clase
 */

package Ejercicio1;
public class Persona {
    // Atributos
    String nombre;
    String apellido;
    int edad;
    // Nos servirán para los metodos de la clase
    boolean hablando = false;
    String mensaje;
    boolean corriendo = false;
    // Constructor:
    // en java: this
    // en python: self
    public Persona(String nombre, String apellido, int edad) {
        this.nombre = nombre;
        this.apellido = apellido;
        this.edad = edad;
    }
    // Metodos:
    // Hablar
    public void hablar(String msj) {
        this.mensaje = msj;
        if (this.hablando) {
            System.out.println(mensaje);
            this.hablando = false;
        } 
    }
    // Correr:
    public void correr(int distancia) {
        if (this.corriendo) {
            System.out.println("Corriendo " + distancia + " metros");
            this.corriendo = false;
        }
    }
        
}

Creamos el segundo archivo pruebaPersona.java

xxxxxxxxxx
package Ejercicio1;

public class pruebaPersona {
    public static void main(String[] args) {
        // Creamos un objeto de la clase Persona
        Persona persona1 = new Persona("Juan", "Perez", 30);

        // Exploramos sus atributos
        System.out.println(persona1.nombre + " " + persona1.apellido + " " + persona1.edad);
        System.out.println(persona1.hablando);

        // Cambiamos el valor del atributo hablar
        persona1.hablando = true;
        System.out.println(persona1.hablando);
        
        // Usamos el metodo hablar
        persona1.hablar("Hola mundo");

        // Vemos el valor del atributo hablando
        System.out.println(persona1.hablando);
    }
}

xxxxxxxxxx
Juan Perez 30
false
true
Hola mundo
false

Otro ejemplo más sobre la definición de una clase. De nuevo crearemos una carpeta en nuestro espacio de trabajo y agregaremos dos archivos.

xxxxxxxxxx
/* Crear una clase referente a una caja con sus respectivos atributos
 * y con un metodo para calcular el volumen de la caja ademas:
 * 1) debe tener dos constructores, uno vacio y el otro con argumentos
 * 2) Crear una clase de prueba para crear un objeto que mande a imprimir el
 * volumen
 */

package Ejercicio2;

public class Caja {
    // Declaracion de atributos
    float ancho;
    float largo;
    float alto;

    // Constructor vacio
    public Caja() {
        System.out.println("Ejecutando constructor vacio");
    }
    // Constructor con argumentos
    public Caja(float ancho, float largo, float alto) {
        System.out.println("Ejecutando constructor con argumentos");
        this.ancho = ancho;
        this.largo = largo;
        this.alto = alto;
    }
    // Metodo para calcular el volumen de la caja
    public float calcularVolumen() {
        return ancho * largo * alto;
    }
}

Probamos la clase anterior

package Ejercicio2;

public class pruebaCaja {
    public static void main(String[] args) {
        // Crear una clase referente a una caja con sus respectivos atributos
        // y con un metodo para calcular el volumen de la caja ademas:
        // 1) debe tener dos constructores, uno vacio y el otro con argumentos
        // 2) Crear una clase de prueba para crear un objeto que mande a imprimir el
        // volumen
        Caja caja1 = new Caja();
        Caja caja2 = new Caja(2, 3, 4);
        System.out.println("El volumen de la caja 1 es: " + caja1.calcularVolumen());
        System.out.println("El volumen de la caja 2 es: " + caja2.calcularVolumen());
    }
}

xxxxxxxxxx
Ejecutando constructor vacio
Ejecutando constructor con argumentos
El volumen de la caja 1 es: 0.0
El volumen de la caja 2 es: 24.0

Notemos que se imprime en consola los mensajes que colocamos en el constructor. Lo que ocurre es que cuando creamos un objeto, lo primero que se ejecuta es el constructor de la clase, de modo que, como en los constructores que definimos mandamos a imprimir en consola unos mensajes, entonces por eso es lo primero que se ejecuta y por ello es que vemos esos mensaje primero en la salida.

Para finalizar veremos otro ejemplo en la definición de una clase

xxxxxxxxxx
package operaciones;

public class Aritmetica {
    // Atributo de la clase 
    int a;
    int b;
    // Definicion del constructor(vacio):
    public Aritmetica() {
        System.out.println("Ejecutando el constructor");
    }
    // Definicion del constructor con argumentos:
    public Aritmetica(int a, int b) {
        this.a = a;
        this.b = b;
        System.out.println("Ejecutando el constructor con argumentos");
    }
    // Metodo:
    // Metodo que no regresa informacion (void)
    public void sumar(){
        // Variables locales
        int resultado = a + b;
        System.out.println(resultado);
    }
    // Metodo que regresa un entero
    public int sumarConRetorno(){
        return a + b;
    }
    // Metodo que recibe parametros:
    public int sumarConArgumentos(int arg1, int arg2) {
        a = arg1;
        b = arg2;
        return a + b;
    }
    // Alternativa a lo anterior:
    public int sumarConArgumentos2(int arg1, int arg2) {
        this.a = arg1;
        this.b = arg2;
        return this.a + this.b;
    }
}

realizamos las pruebas

x
package operaciones;

public class PruebaAritmetica {
    public static void main(String[] args) {
        // Variables locales
        var a = 10;
        var b = 20;
        System.out.println("variables locales " + a + " y " + b);

        // Creamos un objeto de la clase Aritmetica
        Aritmetica aritmetica1 = new Aritmetica();
        
        // modificamos los atributos de nuestro objeto
        aritmetica1.a = 10;
        aritmetica1.b = 20;

        // Metodo sumar
        aritmetica1.sumar();

        // Metodo sumarConRetorno
        /* Requerimos declarar una variable int pues
         * este metodo retorna un valor entero
         */
        int resultado = aritmetica1.sumarConRetorno();
        System.out.println("Resultado desde la prueba" + resultado);
        // O podriamos simplemente colocar:
        // System.out.println("Resultado desde la prueba" + aritmetica1.sumarConRetorno());

        // Metodo sumarConArgumentos
        var resultado2 = 0;
        resultado2= aritmetica1.sumarConArgumentos(30, 40);
        System.out.println(resultado2);

        //Instancia objeto con constructor con argumentos:
        Aritmetica aritmetica2 = new Aritmetica(50, 60);
        System.out.println(aritmetica2.a);
    }
    // Todo lo que definimos en el método main no está disponible para otros metodos

    // Creamos otro metodo
    public static void metodo2() {
        // Lo siguiente marca error
        // System.out.println("Ejecutando metodo2" + a);
        System.out.println("Ejecutando metodo2");
    }
}

x
variables locales 10 y 20
Ejecutando el constructor
30
Resultado desde la prueba30
Resultado desde la prueba30
70
Ejecutando el constructor con argumentos
50

Encapsulamiento

Recordemos que a veces es necesario encapsular atributos o métodos, pues no queremos que éstos sean de fácil acceso o que se lleguen a modificar. Recordemos también que en Python no había como tal atributos o métodos privados, en cambio, en java sí que los tendremos.

xxxxxxxxxx
// Nombre de la carpeta
package Encapsulamiento;

public class Persona {
    // Atributos privados
    private String nombre;
    private double sueldo;
    private boolean eliminador;    

    // Constructor
    public Persona(String nombre, double sueldo, boolean eliminador) {
        this.nombre = nombre;
        this.sueldo = sueldo;
        this.eliminador = eliminador;
    }
    // Metodo toString:
    /* Nos permite imprimir el estado o informacion del objeto.
     * Convierte a cadena cada uno de los atributos del objeto. 
     */
    public String toString(){
        return "Persona [ nombre: " + nombre + ", sueldo: " + sueldo +
               ", eliminador: " + eliminador + " ]";
    }

    // Getters y setters:
    // Atributo nombre
    // Get: recuperar información
    public String getNombre() {
        return this.nombre;
    }
    // Set: modificar
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    // Atributo sueldo
    public double getSueldo() {
        return this.sueldo;
    }
    public void setSueldo(double sueldo) {
        this.sueldo = sueldo;
    }
    // Atributo eliminador
    public boolean isEliminador() {
        return this.eliminador;
    }
    public void setEliminador(boolean eliminador) {
        this.eliminador = eliminador;
    }
}

donde para cada atributo privado le hemos definido los correspondientes getters y setters. Luego

xxxxxxxxxx
// Nombre de la carpeta
package Encapsulamiento;

public class Persona_prueba {
    public static void main(String[] args) {
        // Creamos un objeto de la clase Persona
        Persona persona = new Persona("Juan", 1000.0, true);
        // Ya no podemos acceder directamente a los atributos
        // system.out.println(persona.nombre); ya no se puede, en su lugar:
        System.out.println("Nombre: " + persona.getNombre());

        // Como alternativa a lo anterior podemos utlizar el metodo toString()
        // El cual solo debemos imprimir el objeto que creamos
        System.out.println(persona);
    }
}

xxxxxxxxxx
Nombre: Juan
Persona [ nombre: Juan, sueldo: 1000.0, eliminador: true ]

Veamos ahora un ejemplo de una clase que simule funciones básicas de una calculadora:

xxxxxxxxxx
/* Crearemos una clase, denominada calculadora, que efectue algunas
 * operaciones basicas de suma, resta, multiplicacion y division.
 * Para ello deberemos de definir los atributos y metodos necesarios.
 * Utilizar encapsulamiento para que los atributos.
 */

package Ejercicio3;

public class Calculadora {
    // Atributos
    private double x;
    private double y;
    // Constructor
    public Calculadora(double x, double y) {
        this.x = x;
        this.y = y;
    }
    // Getters y Setters
    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
    }
    // Metodos:
    // Mensaje inicial:
    public void mensajeInicial() {
        System.out.println("Bienvenido a la calculadora");
    }
    // Suma de dos numeros
    public double suma() {
        return this.x + this.y;
    }
    // Resta de dos numeros
    public double resta() {
        return this.x - this.y;
    }
    // Multiplicacion de dos numeros
    public double multiplicacion() {
        return this.x * this.y;
    }
    // Division de dos numeros
    public double division() {
        return this.x / this.y;
    }
}

realizamos la prueba:

xxxxxxxxxx
package Ejercicio3;

public class Prueba_calculadora {
    public static void main(String[] args) {
        // Creamos un objeto de la clase Calculadora
        Calculadora calc = new Calculadora(10.0, 5.0);
        // Mensaje inicial
        calc.mensajeInicial();
        // Calculamos la suma
        System.out.println("La suma es: " + calc.suma());
        // Calculamos la resta
        System.out.println("La resta es: " + calc.resta());
        // Calculamos la multiplicacion
        System.out.println("La multiplicacion es: " + calc.multiplicacion());
        // Calculamos la division
        System.out.println("La division es: " + calc.division());

        // Accedemos a los atributos del objeto:
        System.out.println("El valor de x es: " + calc.getX());
        System.out.println("El valor de y es: " + calc.getY());

        System.out.println("----------------------------------------------------");

        // Modificamos los atributos del objeto:
        calc.setX(20.0);
        calc.setY(10.0);

        // Vemos los cambios
        System.out.println("El valor de x es: " + calc.getX());
        System.out.println("El valor de y es: " + calc.getY());
    }
}

xxxxxxxxxx
Bienvenido a la calculadora
La suma es: 15.0
La resta es: 5.0
La multiplicacion es: 50.0
La division es: 2.0
El valor de x es: 10.0
El valor de y es: 5.0
----------------------------------------------------
El valor de x es: 20.0
El valor de y es: 10.0

Palabra this

x
package palabraThis;

public class palabraThis {
    public static void main(String[] args) {
        // Creamos un objeto de la clase persona. Dicha clase
        // la definimos lineas abajo
        Persona persona = new Persona("Luis", "Apaez");
        System.out.println(persona.nombre);
        System.out.println(persona + " otra impresión");
    }
}

/* Dentro de un documento solo podemos poner una clase publica,
 * las demas solo se podran acceder desde el mismo documento.
 * Asi, si creamos otra clase omitimos la palabra public, al igual, en los
 * metodos ya no escribiremos esta palabra
 */

 // Creamos otras clases
class Persona{
    // Atributos
    String nombre;
    String apellido;
    // Constructor
    Persona(String nombre, String apellido){
        this.nombre = nombre;
        this.apellido = apellido;
        System.out.println("Desde el constructor: " + this.nombre);
        System.out.println("Impresion desde el objeto actual: " + this);
        // Mandamos a llamar el metodo imprimirr() de la clase imprimir
        // el cual se definira lineas abajo
        new imprimir().imprimirr(this);
        // o alternativamente
        // imprimir imp = new imprimir();
        // imp.imprimirr(this);
    }
}

class imprimir{
    public void imprimirr(Persona persona){
        System.out.println("Persona desde imprimir: " + persona);
        System.out.println("Impresion desde el objeto actual " + this);
    }
}

x
Desde el constructor: Luis
Impresion desde el objeto actual: palabraThis.Persona@3fee733d
Persona desde imprimir: palabraThis.Persona@3fee733d
Impresion desde el objeto actual palabraThis.imprimir@4617c264
Luis
palabraThis.Persona@3fee733d otra impresión

donde:

• Desde el constructor: Luis corresponde a la salida desde el constructor cuando estamos instanciando la clase Persona.
• Impresion desde el objeto actual: palabraThis.Persona@3fee733d: De la misma manera desde el constructor se manda a imprimir dicha línea y es llamada cuando instanciamos la clase Persona persona = new Persona("Luis", "Apaez");. En ese momento hemos creado el objeto persona y así el constructor es llamado. En ese momento el objeto a apuntar es persona, de modo que al considerar System.out.println("Impresion desde el objeto actual: " + this); del constructor, this está apuntando al objeto persona, es por ello que vemos palabraThis.Persona@3fee733d con el nombre de la clase principal, seguido de la clase que instancia el objeto y finalmente la dirección de memoria de dicho objeto.
• Persona desde imprimir: palabraThis.Persona@3fee733d: desde el constructor se manda a llamar al método imprimirr() de la clase imprimir de manera análoga a lo que se explicó en el punto anterior.
• Impresion desde el objeto actual palabraThis.imprimir@4617c264: En este caso, como creamos un objeto nuevo de la clase imprimir, entonces this estará apuntando ahora a ese objeto.

Y finalmente se muestran los mensaje que mandamos a imprimir en el método principal.