Mensajes, agregación y clases abstractas en OOPS

El sistema de programación orientado a objetos (OOPS) es el concepto básico de muchos lenguajes de programación. Es un paradigma basado en el objeto que contiene métodos y datos. Este concepto se utiliza para hacer que la programación sea un modelo de clase y objeto que se comporte como un escenario del mundo real. En este artículo, aprenderemos sobre mensajes, agregación, composición y clases abstractas en el paradigma OOPS.

Paso de mensajes : el paso de mensajes en términos de computadoras es la comunicación entre procesos. Es una forma de comunicación utilizada en la programación orientada a objetos, así como en la programación paralela. El paso de mensajes en Java es como enviar un objeto, es decir, un mensaje de un hilo a otro hilo. Se usa cuando los subprocesos no tienen memoria compartida y no pueden compartir monitores o semáforos o cualquier otra variable compartida para comunicarse. Las siguientes son las principales ventajas de la técnica de paso de mensajes:

1. Este modelo es mucho más fácil de implementar que el modelo de memoria compartida.
2. La implementación de este modelo para construir hardware paralelo es mucho más fácil porque es bastante tolerante con latencias de comunicación más altas.

En OOP, hay muchas formas de implementar la técnica de paso de mensajes, como el paso de mensajes a través de constructores, el paso de mensajes a través de métodos o el paso de diferentes valores. La siguiente es una implementación simple de la técnica de paso de mensajes por los valores:

// Java program to demonstrate
// message passing by value
 
import java.io.*;
 
// Implementing a message passing
// class
public class MessagePassing {
 
    // Implementing a method to
    // add two integers
    void displayInt(int x, int y)
    {
        int z = x + y;
        System.out.println(
            "Int Value is : " + z);
    }
 
    // Implementing a method to multiply
    // two floating point numbers
    void displayFloat(float x, float y)
    {
        float z = x * y;
        System.out.println(
            "Float Value is : " + z);
    }
}
class GFG {
 
    // Driver code
    public static void main(String[] args)
    {
        // Creating a new object
        MessagePassing mp
            = new MessagePassing();
 
        // Passing the values to compute
        // the answer
        mp.displayInt(1, 100);
        mp.displayFloat((float)3, (float)6.9);
    }
}

Int Value is : 101
Float Value is : 20.7

Agregación: Esta es una forma de asociación de una manera especial. La agregación es una asociación estrictamente direccional (es decir), una asociación unidireccional y representa HAS-Arelación entre las clases. Además, en conjunto, terminar una de las clases entre las dos no afecta a otra clase. A menudo se denota como una asociación débil, mientras que la composición se denota como una asociación fuerte. En la composición, el padre posee la entidad secundaria, lo que significa que la entidad secundaria no existirá sin la entidad principal y, además, no se puede acceder directamente a la entidad secundaria. Mientras que, en la asociación, la entidad principal y la secundaria pueden existir de forma independiente. Pongamos un ejemplo para entender este concepto. Tomemos una clase de estudiante y una clase de dirección. La clase de dirección representa la dirección del estudiante. Dado que cada estudiante tiene una dirección, tiene una relación. Sin embargo, la dirección es completamente independiente del estudiante. Si algún estudiante deja la escuela o la universidad, todavía tiene una dirección. Esto significa que la dirección puede sobrevivir de forma independiente sin el alumno. Por lo tanto, esto es una agregación. La siguiente es una implementación del ejemplo anterior:

// Java program to demonstrate
// an aggregation
 
// Implementing the address
// class
class Address {
    int strNum;
    String city;
    String state;
    String country;
 
    // Constructor of the address
    // class
    Address(int street, String c,
            String st, String count)
    {
        this.strNum = street;
        this.city = c;
        this.state = st;
        this.country = coun;
    }
}
 
// Creating a student class
class Student {
    int rno;
    String stName;
 
    // HAS-A relationship with the
    // Address class
    Address stAddr;
    Student(int roll, String name,
            Address addr)
    {
        this.rno = roll;
        this.stName = name;
        this.stAddr = addr;
    }
}
 
class GFG {
 
    // Driver code
    public static void main(String args[])
    {
 
        // Creating an address object
        Address ad
            = new Address(10, "Delhi",
                          "Delhi", "India");
 
        // Creating a new student
        Student st
            = new Student(96, "Utkarsh", ad);
 
        // Printing the details of
        // the student
        System.out.println("Roll no: "
                           + st.rno);
 
        System.out.println("Name: "
                           + st.stName);
 
        System.out.println("Street: "
                           + st.stAddr.strNum);
 
        System.out.println("City: "
                           + st.stAddr.city);
 
        System.out.println("State: "
                           + st.stAddr.state);
 
        System.out.println("Country: "
                           + st.stAddr.country);
    }
}

Roll no: 96
Name: Utkarsh
Street: 10
City: Delhi
State: Delhi
Country: India

Clases abstractas : la abstracción es una técnica utilizada en el paradigma OOPS que muestra solo los detalles relevantes para el usuario en lugar de mostrar información innecesaria en la pantalla, lo que ayuda a reducir la complejidad del programa y los esfuerzos de comprensión. Cada lenguaje implementado por OOPS tiene un tipo diferente de implementación pero tiene el mismo concepto de ocultar datos irrelevantes. Las clases abstractas son una de esas formas en Java para implementar la abstracción. En Java, las clases abstractas se declaran usando abstracty puede tener métodos abstractos y normales, pero las clases normales no pueden tener métodos abstractos declarados. Las clases abstractas tienen una definición o son implementadas por las clases extendidas. Tomemos un ejemplo para entender por qué se implementa la abstracción. En este ejemplo, crearemos automóviles fabricados en un año específico. Puede haber muchos coches fabricados en un año específico. Pero las propiedades de los coches no cambian. Entonces, el nombre del automóvil aquí es abstracto y las propiedades restantes son constantes. La siguiente es una implementación del ejemplo anterior:

// Java program to demonstrate the
// abstract class
 
// Implementing the abstract class
// Car
abstract class Car {
 
    // A normal method which contains
    // the details of the car
    public void details()
    {
        System.out.println(
            "Manufacturing Year: 123");
    }
 
    // The name of the car might change
    // from one car to another. So,
    // implementing an abstract method
    abstract public void name();
}
 
// A class Maserati which
// extends the Car
public class Maserati extends Car {
 
    // Naming the car
    public void name()
    {
        System.out.print(
            "Maserati!");
    }
 
    // Driver code
    public static void main(String args[])
    {
        Maserati car = new Maserati();
        car.name();
    }
}

Maserati!