Clases Internas y Locales a un método

Resumen: Usen solamente las Clases Estáticas Anidadas, fin.

Esperemos que no venga en el examen… XD

la verdad es que al ver estas clases me empezo a doler la cabeza un poco, pero me lo tomare con calma.

Lo bueno es que entendi las static :v

Huy esto se puso mas intenso que una novela de televisa

Las clases locales a un método son muy comunes cuando estas creando una interfaz de usuario con Java y quieres personalizar algún objeto gráfico, yo las he usado bastante de esta forma

Take a look to the link below to learn more about inner classes

Esp: https://javadesdecero.es/poo/clases-internas/
Eng: https://www.tutorialspoint.com/java/java_innerclasses

Mis apuntes de la Clase:

• Clases Internas y Locales a un método

  • Clases Internas

    También llamadas Clases anidadas no estáticas. Al no ser una Clase estática, es necesario instanciarla. Ejemplo:

    // Declaración de la Clase Interna
    public class Outer {
        public class Inner {
    
        }
    }
    

    Llamar a la Clase:

    public class Main {
        public static void main(String[] args) {
          Outer outer = new Outer();
          Outer.Inner inner = outer.new Inner();
        }
    }
    

    Para declarar este tipo de Clases hay que instanciar 2 objetos, lo que consume más espacio en memoria, por lo tanto, hay que tener cuidado al usar este tipo de Clases, de hecho este tipo de Clases no son muy comunes.

  • Clases Locales a un Método

    Este tipo de Clases tienen un scope definido para el método al que pertenecen, en el ejemplo de abajo ese método sería el primer void run().

    Si se quiere tener acceso al método run de la Clase Local, hay que crear una instancia de dicha Clase.

    Declarar una Clase Local a un método

    public class Enclosing {
        void run() {
            class Local {
                void run() {
                    ...
                }
            }
            Local local = new Local();
            local.run();
        }
    }
    

    Instanciar una Clase Local a un método

    public class Main {
        public static void main(String[] args) {
        	Enclosing enclosing = new Enclosing();
            enclosing.run();
        }
    }
    

    Este tipo de Clases también consumen más espacio en memoria. Lo recomendable en estos casos es usar Clases estáticas anidadas para hacer un mejor uso de la memoria.

Si con la clase anteriro y esta, estás con la cabeza un poco quemada, no te preocupes, no sos el único. No pares!

Resumen: Si vamos a utilizar una, que sean las clases estáticas anidadas.

Entiendo que sean recomendables usar clases Static pero, en que momento usar las otra? porque por algo están imagino…

Interesante y loco!

Las clases internas son aquellas que se definen dentro de otra clase. Existen dos tipos de clases internas en Java: clases internas estáticas y clases internas no estáticas. Las clases internas estáticas no tienen acceso a los atributos de la clase externa, mientras que las clases internas no estáticas sí.

Las clases locales son aquellas que se definen dentro de un método. No pueden ser accedidas desde fuera del método en el que se definen y suelen utilizarse para crear objetos temporalmente en un método. A diferencia de las clases internas, las clases locales no pueden acceder a los atributos de la clase externa, a menos que se les pase una referencia a la clase externa como un parámetro.

Les comparto mis apuntes de esta clase. espero les sea de ayuda.

Le acabo de preguntar a un amigo que es Senior Java, lleva años trabajando con Java en proyectos grandes para diferentes empresas en mi país, y me dice que jamás en la vida ha usado ese tipo de clases anidadas.

Pero bueno, es valido saber que existen estas formas, capaz encontremos algún caso de uso en un futuro donde podamos aplicar.

🔮 Si utilizamos clases anidadas lo recomendable es usar clases estáticas, esto permite optimizar la memoria.

Pero esas no son todas, faltan las clases anónimas. No?

//como podemos ver el método run() contiene una declaración de
una clase, y contiene las instrucciones para instanciar la clase
y ejecutar un método del objeto instannciado.

En el main, cuando se crea un objeto de clase externa Enclosing,
se puede ejecutar el método que contiene a la clase; cuando se
ejecuta el método contenido por la clase externa, resulta que se
instancia una clase que es local al método. Luego se pueden dar
las instrucciones para que se ejecuten métodos del objeto instanciado.

CLASES LOCALES A UN MÉTODO.

El alcance (scope) es local al método.

public class Enclosing {

void run() {
    
    class Local {
        void run () {
        }   
    }

    Local local = new Local ();
    local.run();

}

}

public class Main {
public static void main (String[] args) {
Enclosing enclosing = new Enclosing();
enclosing.run();
}
}

Yo lo entendí así:
*Clases internas estáticas: Se usan cuando no es necesario definir un objeto de la clase externa para acceder a esta clase interna.
*Clases internas no estáticas no locales a un método: Se usan cuando es necesario definir un objeto de la clase externa para poder acceder a esta clase interna.
*Clases internas no estáticas locales a un método: Se usan cuando es necesario definir un objeto de la clase externa para acceder a esta clase interna, y además, estas clases internas tienen la propiedad de definirse dentro de un método y a su vez crear un objeto una vez se ejecuta este método. Esto último me da a entender que este tipo de clases internas se usan cuando la ejecución de cierto método implica, necesariamente, la creación de un objeto.

muy interesante, pero mejor es con ejemplo

los ejemplos de código que se usan para explicar son muy poco descriptivos,ya es difícil la teoría de por si como para complicarlo más… siempre empiezan los cursos explicando muy bien y muy claro y llega un punto que el profesor empieza a liarlo todo y uno se frustra y se pierde.

mi practica:

public class clases_local {
private int  a = 10;
    void run1(){

        class corre{
            int b = 20;
            void run2(){
                System.out.println(a+b);
            }
        }

        corre c = new corre();
        c.run2();
    }



}

 //CLASES LOCALES A UN METODO
    clases_local cl = new clases_local();
    cl.run1();

Me imagino que las clases dentro de otra clases instancia varios objetos, hay menos eficiencia en la memoria que usarlas estaticas para ser mas concreto, son dos formas de verlas hasta mas facil se ve tener clases anidadas

Para quienes vienen de JavaScript puede salir mucho más fácil aprender Java, en especial si se sabe TypeScript y por ejemplo se ha trabajado con Nest.js o Angular.

Entonces, solo se deben usar Clases Estáticas Anidadas

solo he visto clases estáticas anidadas.

😃 estáticas anidadas

En mi experiencia, hay casos donde hay particularidades del negocio y varias formas de abordarlo: con objetos, con arrays, con clases anidadas, y vale la pena conocerlo, para tener una opción más para aquellos casos particulares que se presentan rara vez.

Clases Internas:
Se instancian las dos clases.
Dependiendo de las clases internas se crearan los objetos ya que una clase depende la otra (si fuera estática no hay necesidad de instanciar).
No son muy comunes.

Clases locales a un método:
Se desperdicia memoria.
Analisis código:
Dentro de Enclosing está el método run y dentro del método run esta la clase local y dentro de la clase local está el método run.
El método run de la clase local solo se puede usar dentro del run de enclosing

Suena muy complicado el manejo de estas clases :c

Las clases anidadas internas y las clases locales a un método no son tan comunes en el desarrollo de software a nivel de aplicaciones empresariales o grandes sistemas, pero pueden ser útiles en algunos casos específicos.

Las clases anidadas internas pueden ser útiles cuando se quiere encapsular el comportamiento de una clase dentro de otra clase y limitar su accesibilidad solo a la clase exterior. Por ejemplo, en una aplicación gráfica, se puede utilizar una clase interna para representar un control en una ventana y limitar su accesibilidad a la clase que representa la ventana.

Las clases locales a un método son útiles cuando se quiere crear una clase para un propósito específico en un método y no se necesita acceder a ella desde otras partes del código. Por ejemplo, en un algoritmo de ordenamiento, se puede utilizar una clase local para comparar elementos y ordenarlos en el método de ordenamiento.

En general, el uso de clases anidadas internas y clases locales a un método debe ser limitado y solo debe ser utilizado cuando realmente aporten claridad y simplicidad al código y cuando se necesite una limitación de acceso o un alcance específico.

Yo habia visto Java hace un tiempo, pero nunca habia visto esto de clases anidadas.

Hablando de eficiencia.
Tengo entendido que lo que declares dentro de un scope {} se borrará al finalizar el scope de esta manera:
{
int x=1; // se crea x

}// se borra x
Entonces no seria mas eficiente declarar e instanciar una clase dentro de un método para que luego al finalizar el scope esta se auto elimine? (Comportamiento de la memoria Stack).

   /*
   public class Outer{
     public class Inner{
     }
   }

   // para acceder a la clase inner, necesito
   1. Crear un objeto outer
   Outer outer = new Outer()

   2. Acceder ahora si, a inner
   Outer.Inner inner = outer.new Inner();
   */

    /* CLASES LOCALES A UN METODO
    public class Enclosing{
     //metodo
     void run(){
     class local{
      void run (){

       }
      }
      //Acceder metodo local
      Local local = new Local();
      local.run();
     }
    }

    // Acceder al metodo, se hace lo mismo

    //Objeto Enclosing
    Enclosing enclosing = new Enclosing()
    enclosin.run()
    * */

No conocía esta forma de anidar

Resumen de esta clase y la clase anterior:

Las clases pueden tener definidas otras clases en el interior.
Existen 2 tipos de clases, las estáticas y las no estáticas.
Las clases estáticas no necesitan ser instanciadas para utilizarse.

Una clase estática sirve principalmente como una estructura de datos de, por ejemplo, c++ o c#.

Es que eso me suene como a mala práctica. Existen pero no sería tan bueno usarlas. No creen ?

Tratando de entender

quede echo nudo, es mejor utilizar solo clases estaticas anidadas según se requiera

No es muy dificil, simplemente necesitar tener un ejemplar para poder obtener un objeto de la clase anidada

minuto : 5.42 🤣🤣🤣

claro. igual esta bueno por si nos llegamos a topar con un problema en el trabajo a resolver

Lo importante es que hay salud!!..

Nooo mentiras, realmente importante antes de conocer a cabalidad su funcionamiento e implementacion, es saber que existen y saber que las podemos encontrar en el camino y que se podrían presentar casos de uso muy específicos donde se implementen.
Pero importante, ya tenemos el concepto!!!
💻
Great Class 💚💚

jajjja ya entiendo por que a la gente no le gusta Java

No sé qué tan correcto sea esto, pero igual se puede hacer

Outer.Inner inner = new Outer().new Inner();

Y así evitamos tener una instancia de la clase Outer solo para instanciar la clase Inner

Nunca habia visto un for como este:

for (Doctor.AvailableAppointment aA: myDoctor.getAvailableAppointments()){ System.out.println(aA.getDate() + " " + aA.getTime()) }

aA es una suerte de variable tipo AvailableAppointment, que va a recorrer myDoctor.getAvailableAppointments?
Alguien puede explicarlo mejor?

Nunca las use, si tengo un objeto dentro de otro, ambas clases las creo por separado.

Confuso este tema :’( , pero con entender las clases estaticas estamos bien xD

Excelente clase, muy buena explicación de las clases anidadas

¿Qué pasó acá?

En la clases Static, como su nombre lo dice, estaremos trabajando siempre sobre las variables estáticas de la clase, es decir, sin multiples instanciaciones en objetos.

Las clases no estáticas las usamos para instanciar objetos.

En el caso de una clase Outer no estática con una Inner, depende de si necesitamos Inner estática para almacenar datos en una única instancia, o si por lo contrario debemos instanciar objetos en los objetos de la clase externa.

Con esta explicación vemos la diferencia entre las clases internas y las clases estáticas y como por eficiencia, es mejor utilizar la última ya que no tenemos que realizar una instancia de esta clase y ocupa menos espacio en memoria.

Sin duda las clases estáticas anidadas es mucho más fácil de realizarlas.😅😅

Wow si esta muy loco las clases locales a un metodo :0

O_O

😃

Definitivamente si se van a usar clases anidadas es mejor usar estaticas, es una forma mucho mas optima de trabajar ademas de evitar dolores de cabeza.

estoy de acuerdo, las clases estaticas son mas eficientes y menos engorrosas!

Algo interesante que note con este tipo de clases anidadas , sobre todo con las locales es que si bien pierdes eficiencia te permite ser mas versátil y riguroso con respecto al encapsulamiento.

Clases Internas: Las clases internas son clases anidadas dentro de
otras clases o métodos.

estas clases se usan en java para producir efectos de programación funcional.

Me duele la cabeza…

Clases locales son algo MÁS loco

Vaya que sí es una locura ésto de las clases locales.

En este enlace se puede aprender más de las clases anidadas, tanto las estáticas como las no estáticas.

https://www.tutorialesprogramacionya.com/javaya/detalleconcepto.php?punto=90&codigo=170&inicio=80

La mejor opción es utilizar las clases anidadas estáticas evitando crear varios objetos desperdiciando espacio de la memoria heap.

wow

Decian aprende Java, es super facil decian.

Se deben conocer las variedades de clases anidadas y reconocer su sintaxis
aunque lo mas común es usar las clases anidadas estáticas, ya que de esta forma se consigue un uso mas directo y mejor gestión de memoria.

Únicamente usar Static tan tan 😃

XD