Listado completo de tutoriales

14 - Declaración de una clase y definición de objetos.


La programación orientada a objetos se basa en la programación de clases; a diferencia de la programación estructurada, que está centrada en las funciones.

Una clase es un molde del que luego se pueden crear múltiples objetos, con similares características.

Una clase es una plantilla (molde), que define atributos (variables) y métodos (funciones)

La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones.

Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear un objeto de una clase, se dice que se crea una instancia de la clase o un objeto propiamente dicho.

La estructura de una clase es:

class [nombre de la clase] {
  [atributos o variables de la clase]
  [métodos o funciones de la clase]
  [main]
}

Problema 1:

Confeccionar una clase que permita carga el nombre y la edad de una persona. Mostrar los datos cargados. Imprimir un mensaje si es mayor de edad (edad>=18)

Programa:

import java.util.Scanner;
public class Persona {
    private Scanner teclado;
    private String nombre;
    private int edad;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese nombre:");
        nombre=teclado.next();
        System.out.print("Ingrese edad:");
        edad=teclado.nextInt();
    }
    
    public void imprimir() {
        System.out.println("Nombre:"+nombre);
        System.out.println("Edad:"+edad);
    }
    
    public void esMayorEdad() {
        if (edad>=18) {
            System.out.print(nombre+" es mayor de edad.");
        } else {
            System.out.print(nombre+" no es mayor de edad.");
        }
    }
    
    public static void main(String[] ar) {
        Persona persona1;
        persona1=new Persona();
        persona1.inicializar();
        persona1.imprimir();
        persona1.esMayorEdad();
    }
}

El nombre de la clase debe hacer referencia al concepto (en este caso la hemos llamado Persona):

public class Persona {

Los atributos los definimos dentro de la clase pero fuera de la main:

    private Scanner teclado;
    private String nombre;
    private int edad;

Veremos más adelante que un atributo es normalmente definido con la cláusula private (con esto no permitimos el acceso al atributo desde otras clases)

A los atributos se tiene acceso desde cualquier función o método de la clase (salvo la main)

Luego de definir los atributos de la clase debemos declarar los métodos o funciones de la clase. La sintaxis es parecida a la main (sin la cláusula static):

    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese nombre:");
        nombre=teclado.next();
        System.out.print("Ingrese edad:");
        edad=teclado.nextInt();
    }

En el método inicializar (que será el primero que deberemos llamar desde la main) creamos el objeto de la clase Scanner y cargamos por teclado los atributos nombre y edad. Como podemos ver el método inicializar puede hacer acceso a los tres atributos de la clase Persona.
El segundo método tiene por objetivo imprimir el contenido de los atributos nombre y edad (los datos de los atributos se cargaron al ejecutarse previamente el método inicializar:

    public void imprimir() {
        System.out.println("Nombre:"+nombre);
        System.out.println("Edad:"+edad);
    }

El tercer método tiene por objetivo mostrar un mensaje si la persona es mayor o no de edad:

    public void esMayorEdad() {
        if (edad>=18) {
            System.out.print(nombre+" es mayor de edad.");
        } else {
            System.out.print(nombre+" no es mayor de edad.");
        }
    }

Por último en la main declaramos un objeto de la clase Persona y llamamos a los métodos en un orden adecuado:

    public static void main(String[] ar) {
        Persona persona1;
        persona1=new Persona();
        persona1.inicializar();
        persona1.imprimir();
        persona1.esMayorEdad();
    }

Persona persona1; //Declaración del objeto
persona1=new Persona(); //Creación del objeto
persona1.inicializar(); //Llamada de un método

Problema 2:

Desarrollar un programa que cargue los lados de un triángulo e implemente los siguientes métodos: inicializar los atributos, imprimir el valor del lado mayor y otro método que muestre si es equilátero o no.

Programa:

import java.util.Scanner;
public class Triangulo {
    private Scanner teclado;
    private int lado1,lado2,lado3;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Medida lado 1:");
        lado1=teclado.nextInt();
        System.out.print("Medida lado 2:");
        lado2=teclado.nextInt();
        System.out.print("Medida lado 3:");
        lado3=teclado.nextInt();       
    }
    
    public void ladoMayor() {
    	System.out.print("Lado mayor:");
        if (lado1>lado2 && lado1>lado3) {
            System.out.println(lado1);
        } else {
            if (lado2>lado3) {
                System.out.println(lado2);
            } else {
                System.out.println(lado3);
            }
        }
    }
    
    public void esEquilatero() {
        if (lado1==lado2 && lado1==lado3) {
            System.out.print("Es un triángulo equilátero");
        } else {
            System.out.print("No es un triángulo equilátero");            
        }
    }

    public static void main(String []ar) {
        Triangulo triangulo1=new Triangulo();
        triangulo1.inicializar();
        triangulo1.ladoMayor();
        triangulo1.esEquilatero();
    }
}

Todos los problemas que requieran la entrada de datos por teclado debemos definir un atributo de la clase Scanner:

    private Scanner teclado;

Este problema requiere definir tres atributos de tipo entero donde almacenamos los valores de los lados del triángulo:

    private int lado1,lado2,lado3;

El primer método que deberá llamarse desde la main es el inicializar donde creamos el objeto de la clase Scanner y cargamos los tres atributos por teclado:

    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Medida lado 1:");
        lado1=teclado.nextInt();
        System.out.print("Medida lado 2:");
        lado2=teclado.nextInt();
        System.out.print("Medida lado 3:");
        lado3=teclado.nextInt();       
    }

El método ladoMayor muestra el valor mayor de los tres enteros ingresados:

    public void ladoMayor() {
    	System.out.print("Lado mayor:");
        if (lado1>lado2 && lado1>lado3) {
            System.out.println(lado1);
        } else {
            if (lado2>lado3) {
                System.out.println(lado2);
            } else {
                System.out.println(lado3);
            }
        }
    }

Como podemos observar cuando un problema se vuelve más complejo es más fácil y ordenado separar los distintos algoritmos en varios métodos y no codificar todo en la main.

El último método de esta clase verifica si los tres enteros ingresados son iguales:

    public void esEquilatero() {
        if (lado1==lado2 && lado1==lado3) {
            System.out.print("Es un triángulo equilátero");
        } else {
            System.out.print("No es un triángulo equilátero");            
        }
    }

En la main creamos un objeto de la clase Triangulo y llamamos los métodos respectivos:

    public static void main(String []ar) {
        Triangulo triangulo1=new Triangulo();
        triangulo1.inicializar();
        triangulo1.ladoMayor();
        triangulo1.esEquilatero();
    }

Problema 3:

Desarrollar una clase que represente un punto en el plano y tenga los siguientes métodos: cargar los valores de x e y, imprimir en que cuadrante se encuentra dicho punto (concepto matemático, primer cuadrante si x e y son positivas, si x<0 e y>0 segundo cuadrante, etc.)

Programa:

import java.util.Scanner;
public class Punto {
    private Scanner teclado;
    int x,y;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese coordenada x :");
        x=teclado.nextInt();
        System.out.print("Ingrese coordenada y :");
        y=teclado.nextInt();
    }
    
    void imprimirCuadrante() {
        if (x>0 && y>0) {
            System.out.print("Se encuentra en el primer cuadrante.");
        } else {
            if (x<0 && y>0) {
                System.out.print("Se encuentra en el segundo cuadrante.");
            } else {
                if (x<0 && y<0) {
                    System.out.print("Se encuentra en el tercer cuadrante.");
                } else {
                    if (x>0 && y<0) {
                        System.out.print("Se encuentra en el cuarto cuadrante.");
                    } else {
                        System.out.print("El punto no está en un cuadrante.");
                    }
                }
            }
        }
    }
    
    public static void main(String[] ar) {
        Punto punto1;
        punto1=new Punto();
        punto1.inicializar();
        punto1.imprimirCuadrante();
    }
}

Definimos tres atributos (el objeto de la clase Scanner y los dos enteros donde almacenamos la coordenada x e y del punto:

    private Scanner teclado;
    int x,y;

El método inicializar crea el objeto de la clase Scanner y pide cargar las coordenadas x e y:

    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese coordenada x :");
        x=teclado.nextInt();
        System.out.print("Ingrese coordenada y :");
        y=teclado.nextInt();
    }

El segundo método mediante un conjunto de if verificamos en que cuadrante se encuentra el punto ingresado:

    void imprimirCuadrante() {
        if (x>0 && y>0) {
            System.out.print("Se encuentra en el primer cuadrante.");
        } else {
            if (x<0 && y>0) {
                System.out.print("Se encuentra en el segundo cuadrante.");
            } else {
                if (x<0 && y<0) {
                    System.out.print("Se encuentra en el tercer cuadrante.");
                } else {
                    if (x>0 && y<0) {
                        System.out.print("Se encuentra en el cuarto cuadrante.");
                    } else {
                        System.out.print("El punto no está en un cuadrante.");
                    }
                }
            }
        }
    }

La main no tiene grandes diferencias con los problemas realizados anteriormente, declaramos un objeto de la clase Punto, creamos el objeto mediante el operador new y seguidamente llamamos a los métodos inicializar e imprimirCuadrante en ese orden:

    public static void main(String[] ar) {
        Punto punto1;
        punto1=new Punto();
        punto1.inicializar();
        punto1.imprimirCuadrante();
    }

Problema 4:

Desarrollar una clase que represente un Cuadrado y tenga los siguientes métodos: cargar el valor de su lado, imprimir su perímetro y su superficie.

Programa:

import java.util.Scanner;
public class Cuadrado {
    private Scanner teclado;
    int lado;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese valor del lado :");
        lado=teclado.nextInt();
    }
    
    public void imprimirPerimetro() {
        int perimetro;
        perimetro=lado*4;
        System.out.println("El perímetro es:"+perimetro);
    }
    
    public void imprimirSuperficie() {
        int superficie;
        superficie=lado*lado;
        System.out.println("La superficie es:"+superficie);
    }
    
    public static void main(String[] ar) {
        Cuadrado cuadrado1;
        cuadrado1=new Cuadrado();
        cuadrado1.inicializar();
        cuadrado1.imprimirPerimetro();
        cuadrado1.imprimirSuperficie();
    }
}

En este problema es interesante ver como no definimos dos atributos donde se almacenan la superficie y el perímetro del cuadrado, esto debido a que solo estos datos se los requiere en el método donde se imprimen:

    public void imprimirPerimetro() {
        int perimetro;
        perimetro=lado*4;
        System.out.println("El perímetro es:"+perimetro);
    }

Esto significa que la variable perimetro es una variable local al método imprimirPerimetro. Esta variable es local a dicho método y solo se la puede acceder dentro del método. La diferencia fundamental entre una variable local y un atributo de la clase es que al atributo se lo puede acceder desde cualquier método de la clase y la variable local solo existe mientras se está ejecutando el método.

Problemas propuestos

  1. Confeccionar una clase que represente un empleado. Definir como atributos su nombre y su sueldo. Confeccionar los métodos para la carga, otro para imprimir sus datos y por último uno que imprima un mensaje si debe pagar impuestos (si el sueldo supera a 3000)
  2. Implementar la clase operaciones. Se deben cargar dos valores enteros, calcular su suma, resta, multiplicación y división, cada una en un método, imprimir dichos resultados.
Solución
import java.util.Scanner;
public class Empleado {
    private Scanner teclado;
    String nombre;
    float sueldo;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese el nombre del empleado:");
        nombre=teclado.next();
        System.out.print("Ingrese su sueldo:");
        sueldo=teclado.nextFloat();
    }
    
    public void pagaImpuestos() {
        if (sueldo>3000) {
            System.out.print("Debe abonar impuestos");
        } else {
            System.out.print("No paga impuestos");
        }
    }
    
    public static void main(String[] ar) {
        Empleado empleado1;
        empleado1=new Empleado();
        empleado1.inicializar();
        empleado1.pagaImpuestos();
    }
}




import java.util.Scanner;
public class Operaciones {
    private Scanner teclado;
    int valor1,valor2;
    
    public void inicializar() {
        teclado=new Scanner(System.in);
        System.out.print("Ingrese primer valor:");
        valor1=teclado.nextInt();
        System.out.print("Ingrese segundo valor:");
        valor2=teclado.nextInt();
    }
    
    public void sumar() {
        int suma;
        suma=valor1+valor2;
        System.out.println("La suma es:"+suma);
    }
    
    public void restar() {
        int resta;
        resta=valor1-valor2;
        System.out.println("La resta es:"+resta);
    }
    
    public void multiplicar() {
        int multiplicacion;
        multiplicacion=valor1*valor2;
        System.out.println("La multiplicación es:"+multiplicacion);
    }
    
    public void dividir() {
        int division;
        division=valor1/valor2;
        System.out.println("La división es:"+division);
    }
    
    public static void main(String[] ar) {
        Operaciones opera;
        opera=new Operaciones();
        opera.inicializar();
        opera.sumar();
        opera.restar();
        opera.multiplicar();
        opera.dividir();
    }
}

Retornar