Diferentes tipos de clases en Java con ejemplos

Una clase es un proyecto o prototipo definido por el usuario a partir del cual se crean objetos. Representa el conjunto de propiedades o métodos que son comunes a todos los objetos de un tipo. En general, las declaraciones de clase pueden incluir estos componentes, en orden:  

• Modificadores: una clase puede ser pública o tener acceso predeterminado
• palabra clave de clase: la palabra clave de clase se utiliza para crear una clase.
• Nombre de la clase: El nombre debe comenzar con una letra inicial (en mayúscula por convención).
• Superclase (si existe): el nombre del padre de la clase (superclase), si existe, precedido por la palabra clave extends. Una clase solo puede extender (subclase) un padre.
• Interfaces (si las hay): una lista separada por comas de las interfaces implementadas por la clase, si las hay, precedida por la palabra clave implements. Una clase puede implementar más de una interfaz.
• Cuerpo: el cuerpo de la clase rodeado de llaves, { }.

Podemos definir miembros de clase y funciones dentro de la clase. Diferentes tipos de clases:

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

1. Clase estática

Podemos declarar una clase como estática si y solo si es una clase anidada. Podemos declarar una clase interna con el modificador estático, estos tipos de clases internas se denominan clases anidadas estáticas. En el caso de una clase normal o regular sin el objeto de clase externo existente, no hay posibilidad de que exista un objeto de clase interno, es decir, el objeto de clase interno está fuertemente asociado con un objeto de clase externo. En el caso de clases anidadas estáticas, puede existir la posibilidad de declarar el objeto de clase anidado sin un objeto de clase externo. 

Nota :

Si queremos declarar un objeto de clase anidado desde fuera de la clase externa, podemos crearlo de la siguiente manera

Sintaxis: 

Outerclassname.innerclassname objectvariable= new Outerclassname.innerclass name();

Ejemplo: 

Prueba.Nested n= new Prueba.Nested();

Por lo tanto, se dice que puede haber una posibilidad de que existan objetos de clase anidados sin objetos de clase externos existentes. En las clases internas normales o regulares, no podemos declarar ningún miembro estático, pero en las clases anidadas estáticas podemos declarar miembros estáticos, incluido el método principal, por lo que podemos invocar la clase anidada estática directamente desde el símbolo del sistema. 

Propiedades de la clase estática:

1. no se pueden crear objetos de clase estática.
2. La clase estática solo puede tener miembros estáticos.
3. la clase estática no puede acceder a los miembros (no estáticos) de la clase externa.

Ejemplo :

class Outer {
    static class Nested {
        public static void main(String arg[])
        {
            System.out.println(
                "static method class main method");
        }
    }
  
    public static void main(String arg[])
    {
        System.out.println("Outer class main method");
    }
}

Producción:

2. Clase Final

La clase se puede declarar como final usando la palabra clave ‘final’. Si una clase se declara como final, no podemos ampliar la funcionalidad de esa clase, es decir, no podemos crear una clase secundaria para esa clase, es decir, la herencia no es posible para las clases finales. Todos los métodos presentes dentro de la última clase suelen ser definitivos de forma predeterminada, pero no es necesario que todas las variables presentes dentro de la última clase sean definitivas. Si creamos la clase final no podemos lograr la herencia. Si creamos un método final no podemos lograr el polimorfismo, pero podemos obtener seguridad de que nadie puede cambiar la implementación única de nuestro código, pero la principal desventaja de la palabra clave final es que nos estamos perdiendo los beneficios de la herencia y el polimorfismo. 

Nota : si no hay un requisito específico, no se recomienda utilizar la palabra clave final.

Ejemplo:

final class Sound {
    static int number = 10;
    void message()
    {
        number = 777;
        System.out.println(number);
    }
}
  
class Animal extends Sound {
    static int number = 9;
    void message()
    {
        super.number = 888;
        System.out.println(super.number);
    }
  
    public static void main(String arg[])
    {
        Animal a = new Animal();
        a.message();
    }
}

Producción:

3. Clase abstracta

Podemos declarar una clase como abstracta usando la palabra clave ‘resumen’. Para cualquier clase de Java, si no se nos permite crear un objeto de este tipo de clase, debemos declarar con el modificador abstracto, es decir, para las clases abstractas, la creación de instancias no es posible. Si una clase contiene al menos un método abstracto, entonces es obligatorio declarar una clase como abstracta; de lo contrario, obtendremos un error de compilación. Razón: si una clase contiene al menos un método abstracto, la implementación no está completa y, por lo tanto, no se recomienda crear un objeto. Si necesitamos restringir la creación de instancias de objetos obligatoriamente, debemos declarar la clase como abstracta. Una clase que contiene cero o más métodos abstractos puede ser una clase abstracta si no queremos ninguna instanciación. Ejemplo: HttpServletClass es abstracto pero no contiene ningún método abstracto.

Si estamos extendiendo la clase abstracta, entonces para todos y cada uno de los métodos abstractos de la clase principal, siempre debemos proporcionar la implementación; de lo contrario, debemos declarar la clase secundaria como abstracta. En este caso, la clase secundaria del siguiente nivel es responsable de proporcionar la implementación.

Ejemplo:

abstract class AbstractClass {
    public abstract void add(int a, int b);
    public abstract void sub(int a, int b);
    public void mul(int a, int b)
    {
        System.out.println("Multiplication of a and b is"
                           + " " + (a * b));
    }
}
class Geek extends AbstractClass {
    public void add(int a, int b)
    {
        System.out.println("Sum of a and b is"
                           + " " + (a + b));
    }
    public void sub(int a, int b)
    {
        System.out.println("Difference of a and b is"
                           + " " + (a - b));
    }
    public static void main(String[] args)
    {
        int a = 6;
        int b = 5;
        Geek g = new Geek();
        g.add(a, b);
        g.sub(a, b);
        g.mul(a, b);
    }
}

Producción:

4. Clase concreta

Una clase concreta no es más que una clase normal o regular en Java. Una clase concreta es una clase que extiende otra clase o implementa una interfaz. En resumen, podemos decir que cualquier clase que no sea abstracta se dice que es una clase concreta. Podemos crear directamente un objeto para la clase concreta.

Nota : Se dice que una clase es una clase concreta si hay una implementación para todos y cada uno de los métodos.

Ejemplo:

public class ConcreteClass
{
    // method of the concreted class
    static int addition(int a, int b) { return a + b; }
  
    public static void main(String args[])
    {
        // method calling
        int p = addition(5, 9);
        System.out.println("The result of a and b is: "
                           + p);
    }
}

Producción:

5. Clase Singleton

Para cualquier clase Java, si se nos permite crear solo un objeto, se afirma que este tipo de clase es una clase singleton.

Ejemplo : tiempo de ejecución, BusinessDelegate, ServiceLocator

ventajas :

• Si varias personas tienen el mismo requisito, no se recomienda crear un objeto separado para cada requisito, tenemos que crear solo un objeto para poder reutilizar un objeto equivalente para cada requisito similar, para que el rendimiento y la utilización de la memoria vayan. Ser mejorado.
• Esta suele ser la idea central de las clases singleton.

También podemos crear nuestras propias clases singleton, para eso nos gustaría poseer  

• Constructor privado
• Variable estática privada y el método de fábrica pública.

Ejemplo:

class Test {
  
    private static Test t = null;
    public String s;
  
    private Test() throws Exception
    {
        s = "I am example of singletonclass";
    }
  
    public static Test getTest()
    {
        if (t == null) {
            try {
                t = new Test();
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        return t;
    }
  
    public String gets() { return s; }
    public void sets(String s) { this.s = s; }
}
  
class Geeks {
  
    public static void main(String arg[])
    {
        Test t1 = Test.getTest();
        Test t2 = Test.getTest();
        Test t3 = Test.getTest();
        t1.getTest();
        System.out.println("Hashcode of t1 is "
                           + t1.hashCode());
        System.out.println("Hashcode of t2 is "
                           + t2.hashCode());
        System.out.println("Hashcode of t3 is "
                           + t3.hashCode());
    }
}

Producción:

6. Clase POJO

POJO significa Plain Old Java Object. Si escribimos una categoría, debe seguir algunas reglas denominadas reglas POJO. se acostumbra a Java para ampliar la legibilidad y la reutilización. Proporciona encapsulación.

Propiedades de la clase POJO:

1. la clase debe ser declarada como pública
2. las propiedades/variables deben declararse como privadas
3. Debe tener un constructor predeterminado público
4. Puede o no tener un constructor de argumentos
5. Cada propiedad debe tener métodos getter y setter públicos.
6. No puede contener anotaciones preespecificadas.

Ejemplo:

class Pojoclass {
  
    private String name = "Geeks for Geeks";
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
}
  
public class PojoExample
{
    public static void main(String args[])
    {
        Pojoclass obj = new Pojoclass();
        System.out.println("The name of an student is "
                           + obj.getName());
    }
}

Producción:

7. Clase Interna

A veces podemos declarar una clase dentro de otra clase, este tipo de clases se denominan clases internas. El concepto de clases internas se introduce para corregir errores de GUI como parte del manejo de eventos, pero debido a las potentes características y beneficios de las clases internas, los programadores también comienzan a usar lentamente en la codificación regular. Sin que exista un tipo de objeto, no hay posibilidad de ejecutar otro tipo de objeto, entonces deberíamos buscar clases internas.

Ejemplo : la universidad consta de varios departamentos, sin una universidad existente no hay posibilidad de que exista un departamento, por lo tanto, tenemos que declarar la clase de departamento dentro de la clase universitaria.

Class University{
  // code
    Class Department{
        // code
    }
}

Se dice que la relación entre la clase externa y la clase interna es una relación Has-A. Según la posición de la declaración y el comportamiento, todas las clases internas se dividen en cuatro tipos.

• Clases normales o regulares
• Método clases internas locales
• Clases internas anónimas
• Clases estáticas anidadas

Clases internas normales y regulares:

Si estamos declarando cualquier clase con nombre directamente dentro de una clase sin el modificador estático, este tipo de clase interna se denomina clase interna Normal o Regular.

Ejemplo:

class Outer1 {
    class Inner {
        public void m1()
        {
            System.out.println("Inner class method");
        }
    }
  
    public static void main(String arg[])
    {
        Outer1 o = new Outer1();
        Outer1.Inner i = o.new Inner();
        i.m1();
    }
}

Producción:

Anidamiento de clases internas:

Dentro de las clases internas, podemos declarar otra clase interna, es decir, es posible anidar clases internas.

Ejemplo:

class A {
    class B {
        class C {
            public void m1()
            {
                System.out.println(
                    "Innermost class method");
            }
        }
    }
}
  
class Test {
    public static void main(String arg[])
    {
        A a = new A();
        A.B b = a.new B();
        A.B.C c = b.new C();
        c.m1();
    }
}

Salida :

Clases internas locales del método:

A veces podemos declarar una clase dentro de un método, estos tipos de clases internas se denominan clases internas locales de método. El objetivo principal de la clase interna local del método es definir la funcionalidad repetida específica del método. Las clases internas locales de método son las más adecuadas para cumplir con los requisitos de clase anidada. Podemos acceder al método, clases internas locales, solo dentro del método donde declaramos, fuera del método al que no podemos acceder y usar su método de menor alcance, las clases internas locales son el tipo de clases internas que se usa con menos frecuencia.

Nota : el único modificador aplicable para las clases internas locales de métodos es final, abstract, Strictfp. Si estamos tratando de aplicar cualquier otro modificador, obtendremos un error de compilación.

Ejemplo:

class Outer2 {
    public void m1()
    {
        class Inner {
            public void sum(int x, int y)
            {
                System.out.println("The sum"
                                   + " " + (x + y));
            }
        }
  
        Inner i = new Inner();
        i.sum(10, 20);
        i.sum(100, 200);
        i.sum(1000, 2000);
    }
  
    public static void main(String arg[])
    {
        Outer2 t = new Outer2();
        t.m1();
    }
}

Producción:

Nota : podemos declarar la clase interna local del método dentro de la instancia y el método estático. Si declaramos la clase interna dentro del método de instancia, entonces desde esa clase interna local del método, podemos acceder directamente a los miembros estáticos y no estáticos de la clase externa.

Clases internas anónimas:

A veces declaramos clases internas sin nombre, estos tipos de clases internas se denominan clases internas anónimas. El propósito principal de las clases internas anónimas es solo para uso instantáneo. Según la declaración y el comportamiento, hay tres tipos de clases internas anónimas

1. Clase interna anónima que extiende una clase
2. Clase interna anónima que implementa una interfaz
3. Clase interna anónima que define el argumento interno

Ejemplo:

class ThreadDemo {
    public static void main(String arg[])
    {
        new Thread(
            new Runnable()
            {
                public void run()
                {
                    for (int i = 0; i <= 5; i++)
                    {
                        System.out.println("Child Thread");
                    }
                }
            })
            .start();
  
        for (int i = 0; i <= 5; i++)
        {
            System.out.println("Main thread");
        }
    }
}

Producción:

Clases anidadas estáticas:

Podemos declarar clases internas con modificadores estáticos, estos tipos de clases internas se denominan clases anidadas estáticas.

Ejemplo:

class StaticNested1 {
  
    private static String str = "Geeks for Geeks";
  
    static class Nested {
        public void m1() { System.out.println(str); }
    }
  
    public static void main(String args[])
    {
        StaticNested1.Nested obj
            = new StaticNested1.Nested();
        obj.m1();
    }
}

Producción: