Tipos de clases en Java

Una clase es un modelo en el lenguaje de programación Java a partir del cual se puede construir un objeto individual. En Java, podemos declarar una clase usando la palabra clave class. Los miembros de la clase y las funciones se declaran simplemente dentro de la clase. Las clases son necesarias para la creación de programas Java. El paradigma orientado a objetos (OOP) permite a los usuarios describir objetos del mundo real. Además, una clase a veces se conoce como un tipo de datos definido por el usuario. Los siguientes componentes componen una declaración de clase:

• Modificadores
• Nombre de la clase
• Palabras clave
• El cuerpo de la clase entre corchetes {}.

Tipos de clases

1. Clase final
2. Clase estática
3. Clase abstracta
4. Clase de hormigón
5. Clase POJO
6. Clase única
7. Clase Interna

1. Clase Final

Cuando una variable, función o clase se declara final, su valor persiste durante todo el programa. Declarar un método con la palabra clave final indica que las subclases no pueden anular el método. Esa es una clase que está marcada como final y no puede ser subclase. Esto es muy útil cuando se crean clases inmutables como las clases String. Una clase no se puede mutar a menos que se declare final. 

import java.io.*;
import java.lang.*;
import java.util.*;
 
final class Base {
 
    void Display()
    {
        System.out.print("Method for Base class.");
    }
}
 
class Extended extends Base {
 
    void Display()
    {
        System.out.print("Method of Extended class.");
    }
}
 
class GFG {
 
    public static void main(String[] arg)
    {
        Extended d = new Extended();
        d.Display();
    }
}

2. Clase estática

Static es una palabra de Java que explica cómo se guardan los objetos en la memoria. Un objeto estático pertenece a esa clase en lugar de instancias de esa clase. La función principal de la clase es proporcionar planos para las clases heredadas. Una clase estática solo tiene miembros estáticos. No se puede crear un objeto para una clase estática.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class staticclasses {
    static int s;
    static void met(int x, int y)
    {
        System.out.println(
            "static method to calculate sum");
        s = x + y;
        System.out.println(x + "+" + y);
    }
    static class MyNestedClass {
        static
        {
            System.out.println(
                "static block inside a static class");
        }
        public void disp()
        {
            int x1;
            int y1;
            Scanner sc = new Scanner(System.in);
            System.out.println("Enter two numbers");
            x1 = sc.nextInt();
            y1 = sc.nextInt();
            met(x1, y1);
            System.out.println("Sum of the 2 numbers-" + s);
        }
    }
}
public class GFG {
    public static void main(String args[])
    {
        staticclasses.MyNestedClass nestedclass
            = new staticclasses.MyNestedClass();
        nestedclass.disp();
    }
}

3. Clase abstracta

Una clase que tiene cero o más métodos abstractos y se especifica con la palabra clave abstracta se denomina clase abstracta. Debemos extender rigurosamente las clases abstractas a una clase concreta para poder usarlas porque son clases incompletas. También se pueden incluir constructores y métodos estáticos. Puede tener métodos finales, que obligan a la subclase a mantener el cuerpo del método descolgado.

import java.io.*;
import java.lang.*;
import java.util.*;
 
interface X {
    int product(int x, int y);
}
abstract class Product implements X {
 
    public int product(int x, int y) { return x * y; }
}
class GFG extends Product {
    public static void main(String args[])
    {
        Main ob = new Main();
        int p = ob.product(20, 10);
        System.out.println("Product: " + p);
    }
}

4. Clase concreta

Una clase normal con una implementación para todos sus métodos y sin métodos abstractos se denomina clase concreta. No se les permite tener ningún proceso que no esté en uso en ese momento. Si implementa todos sus métodos, una clase concreta puede extender su padre, una clase abstracta o una interfaz. Es una clase completamente funcional e instanciable.

import java.io.*;
import java.lang.*;
import java.util.*;
 
public class GFG {
    static int sum(int x, int y) { return x + y; }
 
    public static void main(String args[])
    {
        int p = sum(10, 8);
        System.out.println("Sum: " + p);
    }
}

5. Clase POJO

«Objeto Java antiguo simple» es una abreviatura de «Objeto Java antiguo simple». Una clase POJO solo tiene variables privadas con métodos setter y getter para acceder a ellas. Es una estructura de datos pura con campos que pueden anular algunos métodos de Objeto (p. ej., equals) u otras interfaces (p. ej., serializable), pero no tiene un comportamiento propio.

Propiedades de la clase POJO:

• Al escribir una clase POJO, se requieren métodos públicos setter y getter.
• Las variables privadas deben usarse para todas las variables de instancia.
• No debería extender clases que ya han sido definidas.
• No debe implementar interfaces que hayan sido predefinidas.
• No debe haber anotaciones predefinidas.
• Puede que no tenga una función Object() { [código nativo] } que no tome argumentos.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class POJO {
    private int value = 365;
    public int getValue() { return value; }
    public void setValue(int value) { this.value = value; }
}
public class GFG {
    public static void main(String args[])
    {
        POJO p = new POJO();
        System.out.println(p.getValue());
    }
}

6. Clase Singleton

Una clase singleton es aquella que tiene solo un objeto en cualquier momento. Aún así, si intentamos crear una instancia nuevamente, la instancia recién creada se refiere a la anterior. Cualquier modificación que hagamos a la clase a través de cualquier instancia también afecta las variables en esa instancia específica. Se usa comúnmente para administrar el acceso mientras se trabaja con conexiones de bases de datos y programación de sockets.

Lo siguiente se usa para hacer Singleton Class:

• Cree una función Object() { [código nativo] } que solo esté disponible para usted.
• Cree una función estática que devuelva el objeto de la clase singleton (utilizando la inicialización diferida).

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Singleton {
 
    private static Singleton single_instance = null;
 
    public String s;
 
    private Singleton()
    {
        s = "This is a string part of Singleton class";
    }
    // here a private constructor is used
 
    // Method
    public static Singleton Singleton()
    {
        if (single_instance == null) {
            single_instance = new Singleton();
        }
        return single_instance;
    }
}
 
// Main class
class GFG {
    public static void main(String args[])
    {
        Singleton x = Singleton.Singleton();
        Singleton y = Singleton.Singleton();
 
        // change var of x
        x.s = (x.s).toUpperCase();
 
        System.out.println("String from x is -->" + x.s);
        System.out.println("String from y is -->" + y.s);
        System.out.println("\n");
 
        y.s = (y.s).toLowerCase();
 
        System.out.println("String from x is -->" + x.s);
        System.out.println("String from y is -->" + y.s);
    }
}

7. Clase Interna

Podemos definir una clase dentro de una clase en Java, y estas clases se conocen como clases anidadas. Se utiliza para organizar clases de forma lógica y lograr la encapsulación. La clase interna puede acceder a los miembros de la clase externa (incluidos los privados). 

Sintaxis:

import java.io.*;
 
class OuterClass {
    // Write the code
    class NestedClass {
        // Write the code
    }
}

Hay 4 tipos de clases internas:

• Clase interna anidada
• Clases internas anónimas
• Clases estáticas anidadas
• Método Clases internas locales

A. Clase interna anidada:

Tiene acceso a las variables de instancia privada de una clase externa. Los modificadores de acceso privado, protegido, público y predeterminado se pueden aplicar a cualquier variable de instancia.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    class Inner {
        public void show()
        {
            System.out.println("Inside a nested class");
        }
    }
}
 
class GFG {
    public static void main(String[] args)
    {
        Outer.Inner in = new Outer().new Inner();
        in.show();
    }
}

B. Clase Interna Anónima:

Básicamente, estas clases se declaran sin ningún nombre.

Ejemplo 1: uso de subclase

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    void show()
    {
        System.out.println("Show method of super class");
    }
}
 
class GFG {
 
    static Outer o = new Outer() {
        void show()
        {
            super.show();
            System.out.println("Demo class");
        }
    };
 
    public static void main(String[] args) { o.show(); }
}

Ejemplo 2: Uso de la interfaz

import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
    static Hello h = new Hello() {
        public void show()
        {
            System.out.println(
                "This is an anonymous class");
        }
    };
 
    public static void main(String[] args) { h.show(); }
}
 
interface Hello {
    void show();
}

C. Clase anidada estática:

Estas clases son como miembros estáticos de la clase externa.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
    static int data = 100;
    static class Inner {
 
        void msg()
        {
            System.out.println("data is " + data);
        }
    }
 
    public static void main(String args[])
    {
        GFG.Inner obj = new GFG.Inner();
        obj.msg();
    }
}

D. Método Clase interna local:

Una clase interna se puede declarar dentro de un método de una clase externa.

import java.io.*;
import java.lang.*;
import java.util.*;
 
class Outer {
    void outerMethod()
    {
        System.out.println("Outer Method");
        class Inner {
            void innerMethod()
            {
                System.out.println("Inner Method");
            }
        }
 
        Inner y = new Inner();
        y.innerMethod();
    }
}
class GFG {
    public static void main(String[] args)
    {
        Outer x = new Outer();
        x.outerMethod();
    }
}