Cuatro conceptos principales de programación orientada a objetos de Java

La programación orientada a objetos generalmente conocida como OOPS es la columna vertebral de Java, ya que Java es un lenguaje completamente orientado a objetos. Java organiza un programa en torno a varios objetos e interfaces bien definidas. Hay cuatro pilares aquí en OOPS que se enumeran a continuación. Estos  conceptos  tienen como objetivo implementar entidades del mundo real en los programas.

• Abstracción
• Encapsulación
• Herencia
• Polimorfismo

La abstracción es un proceso de ocultar detalles de implementación y expone solo la funcionalidad al usuario. En la abstracción, tratamos con ideas y no con eventos. Esto significa que el usuario solo sabrá «qué hace» en lugar de «cómo lo hace».

Hay dos formas de lograr la abstracción en Java

1. Clase abstracta (0 a 100%)
2. Interfaz (100%)

Ejemplo de la vida real: un conductor se concentrará en la funcionalidad del automóvil (Arrancar/Parar -> Acelerar/Frenar), no se preocupa por cómo funciona internamente el mecanismo de aceleración/freno. Y así es como funciona la abstracción.

Se deben recordar ciertos puntos clave con respecto a este pilar de OOPS de la siguiente manera:

• La clase debe ser abstracta si una clase tiene uno o varios métodos abstractos.
• Una clase abstracta puede tener constructores, métodos concretos, método estático y método final.
• La clase abstracta no se puede instanciar directamente con el nuevo operador. Puede ser posible como se muestra en la etiqueta previa a continuación:

A b = new B();

• La clase secundaria debe anular todos los métodos abstractos de los padres; de lo contrario, la clase secundaria debe declararse con una palabra clave abstracta

Ejemplo:

// Abstract class
public abstract class Car {
    public abstract void stop();
}
  
// Concrete class
public class Honda extends Car {
    // Hiding implementation details
    @Override public void stop()
    {
        System.out.println("Honda::Stop");
        System.out.println(
            "Mechanism to stop the car using break");
    }
}
  
public class Main {
    public static void main(String args[])
    {
        Car obj
            = new Honda(); // Car object =>contents of Honda
        obj.stop(); // call the method
    }
}

Pilar 2: Encapsulación

La encapsulación es el proceso de empaquetar código y datos en una sola unidad.

Ejemplo de la vida real:

Una cápsula que es una mezcla de varios medicamentos. Los medicamentos son datos ocultos para el usuario final.

Para lograr la encapsulación en Java, siga ciertos pasos como se propone a continuación:

• Declarar las variables como privadas.
• Declarar los setters y getters para establecer y obtener los valores de las variables

Nota: Hay algunas desventajas de la encapsulación en Java de la siguiente manera:

1. Control sobre los datos: podemos escribir la lógica en el método setter para no almacenar los valores negativos para un número entero. Entonces de esta manera podemos controlar los datos.
2. Ocultación de datos: los miembros de datos son privados, por lo que otra clase no puede acceder a los miembros de datos.
3. Fácil de probar: la prueba unitaria es fácil para clases encapsuladas

Ejemplo:

// A Java class which is a fully encapsulated class.
public class Car
{
      
        // private variable  
        private String name;
      
        // getter method for name  
        public String getName()
    {
           return name;
          
    }
      
        // setter method for name  
        public void setName(String name)
    {
           this.name = name  
    }
      
}
  
  
// Java class to test the encapsulated class.  
public class Test
{
       public static void main(String[] args)
    {
          
            // creating instance of the encapsulated class  
            Car car
            = new Car();
          
            // setting value in the name member  
            car.setName("Honda");
          
            // getting value of the name member  
            System.out.println(car.getName());
          
    }
      
}

Pilar 3: Herencia

La herencia es el proceso de una clase que hereda propiedades y métodos de otra clase en Java. La herencia se usa cuando tenemos una relación entre objetos. La herencia en Java se implementa usando la  palabra clave extends  .

Ejemplo de la vida real:

El planeta Tierra y Marte heredan el Sistema Solar de clase superior y el Sistema Solar hereda la Vía Láctea. Entonces Milky Way Galaxy es la súper clase superior para Class Solar System, Earth y Mars.

Analicemos el uso de la herencia en aplicaciones Java con un ejemplo genérico antes de proponer el código. Por lo tanto, considere un ejemplo que extienda la clase Exception para crear una clase Exception específica de la aplicación que contenga más información, como códigos de error. Por ejemplo  NullPointerException .

Hay 5 tipos diferentes de herencia en Java de la siguiente manera:

1. Herencia única: la clase B hereda la clase B usando la palabra clave extends
2. Herencia multinivel: la clase C hereda la clase B y B hereda la clase A usando la palabra clave extends
3. Herencia de jerarquía: las clases B y C heredan la clase A en orden de jerarquía usando la palabra clave extends
4. Herencia múltiple: la clase C hereda las clases A y B. Aquí, A y B son superclases y C es solo una clase secundaria. Java no admite la herencia múltiple, pero podemos implementarlo mediante interfaces.
5. Herencia híbrida: la clase D hereda la clase B y la clase C. Las clases B y C heredan A. Aquí, de nuevo, la clase D hereda dos superclases, por lo que Java tampoco es compatible con la herencia híbrida.

Ejemplo:

// super class
class Car {
    // the Car class have one field
    public String wheelStatus;
    public int noOfWheels;
  
    // the Car class has one constructor
    public Car(String wheelStatus, int noOfWheels)
    {
        this.wheelStatus = wheelStatus;
        this.noOfWheels = noOfWheels;
    }
  
    // the Car class has three methods
    public void applyBrake()
    {
        wheelStatus = "Stop" System.out.println(
            "Stop the car using break");
    }
  
    // toString() method to print info of Car
    public String toString()
    {
        return ("No of wheels in car " + noOfWheels + "\n"
                + "status of the wheels " + wheelStatus);
    }
}
  
// sub class
class Honda extends Car {
  
    // the Honda subclass adds one more field
    public Boolean alloyWheel;
  
    // the Honda subclass has one constructor
    public Honda(String wheelStatus, int noOfWheels,
                 Boolean alloyWheel)
    {
        // invoking super-class(Car) constructor
        super(wheelStatus, noOfWheels);
        alloyWheel = alloyWheel;
    }
  
    // the Honda subclass adds one more method
    public void setAlloyWheel(Boolean alloyWheel)
    {
        alloyWheel = alloyWheel;
    }
  
    // overriding toString() method of Car to print more
    // info
    @Override public String toString()
    {
        return (super.toString() + "\nCar alloy wheel "
                + alloyWheel);
    }
}
  
// driver class
public class Main {
    public static void main(String args[])
    {
  
        Honda honda = new Honda(3, 100, 25);
        System.out.println(honda.toString());
    }
}

Pilar 4: Polimorfismo en java 

El polimorfismo es la capacidad de realizar muchas cosas de muchas maneras. La palabra polimorfismo proviene de dos palabras griegas diferentes: poli y morfos. “Poly” significa muchos, y “Morphs” significa formas. Entonces polimorfismo significa muchas formas. El polimorfismo también puede estar presente en el caso de la herencia. Las funciones se comportan de manera diferente según la implementación real.

Ejemplo de la vida real:

Un repartidor entrega artículos al usuario. Si es un cartero, entregará las cartas. Si es un repartidor de alimentos, entregará los alimentos al usuario. Como este polimorfismo implementó diferentes formas para la función de entrega.

Hay dos tipos de polimorfismo que se enumeran a continuación:

1. Polimorfismo estático o en tiempo de compilación
2. Polimorfismo dinámico o en tiempo de ejecución

Polimorfismo estático o en tiempo de compilación cuando el compilador puede determinar la función real, se denomina polimorfismo en tiempo de compilación . El polimorfismo en tiempo de compilación se puede lograr mediante la sobrecarga de métodos en Java. Cuando diferentes funciones en una clase tienen el mismo nombre pero firmas diferentes, se llama sobrecarga de métodos. Una firma de método contiene el nombre y los argumentos del método. Entonces, los métodos sobrecargados tienen diferentes argumentos. Los argumentos pueden diferir en los números o el tipo de argumentos.

Ejemplo 1: polimorfismo estático

public class Car{
      
    public void speed() {
    }
      
    public void speed(String accelerator) {
    }
      
    public int speed(String accelerator, int speedUp) {
        return carSpeed;
    }
}

El polimorfismo dinámico o en tiempo de ejecución ocurre cuando el compilador no puede determinar si se trata de un método de superclase o de una subclase; se denomina polimorfismo en tiempo de ejecución . El polimorfismo en tiempo de ejecución se logra mediante la anulación de métodos . Cuando el método de la superclase se anula en la subclase, se denomina anulación del método.

Ejemplo 2: polimorfismo dinámico

import java.util.Random;
  
class DeliveryBoy {
  
    public void deliver() {
        System.out.println("Delivering Item");
    }
  
    public static void main(String[] args) {
        DeliveryBoy deliveryBoy = getDeliveryBoy();
        deliveryBoy.deliver();
    }
  
    private static DeliveryBoy getDeliveryBoy() {
        Random random = new Random();
        int number = random.nextInt(5);
        return number % 2 == 0 ? new Postman() : new FoodDeliveryBoy();
    }
}
  
class Postman extends DeliveryBoy {
    @Override
    public void deliver() {
        System.out.println("Delivering Letters");
    }
}
  
class FoodDeliveryBoy extends DeliveryBoy {
    @Override
    public void deliver() {
        System.out.println("Delivering Food");
    }
}

Delivering Letters