What is the purpose of local classes in java?

What is a local class?

According to the doc :

Local classes are classes that are defined in a block , which is a group of zero or more declarations between { }balances. They are usually defined in the body of a method.

A local class is declared locally within a Java code block, rather than as a member of a class. Typically, a local class is defined inside a method, but it can also be defined inside a static initializer or an instance initializer of a class.

Because all Java code blocks appear inside class definitions, all local classes are nested inside the classes they contain. For this reason, local classes share many of the characteristics of member classes. However, it is often more appropriate to think of them as a class entirely separate from the inner class. A local class has roughly the same relationship to a member class that a local variable has to a class instance variable.

The defining characteristic of a local class is that it is local to a block of code. Like a local variable, a local class is only valid within the scope defined by its enclosing block.

If, for example, a member class is used only within a single method of its containing class, there is usually no reason why it cannot be coded as a local class, rather than a member class.

The example below shows how we can modify the LinkedStack class's enumerate() method so that it defines Enumerator as a local class instead of a member class. By doing this, we move the class definition even closer to where it is used and hopefully improve the clarity of the code much more. For brevity, the example shows only the method enumerate(), not the entire class LinkedStackthat contains it.

// Este método crea y retorna un objeto Enumeration
public java.util.Enumeration enumerate() {

  // Aquí se define Enumerator  como una clase local
  class Enumerator implements java.util.Enumeration {
    Linkable current;
    public Enumerator() { current = head; }
    public boolean hasMoreElements() {  return (current != null); }
    public Object nextElement() {
      if (current == null) throw new java.util.NoSuchElementException();
      Object value = current;
      current = current.getNext();
      return value;
    }
  }

  // Ahora retorna una instancia de la clase Enumerator definida más arriba 
  return new Enumerator();
}

Characteristic

Characteristics of local classes

Local classes have the following interesting features:

• Like member classes, local classes are associated with a containing instance and can access all members, including private members, of the containing class.

• In addition to accessing fields defined by the containing class, local classes can access any local variables, method parameters, or exception parameters that are within the scope of the local method definition and declared final ( final).

restrictions

Local classes are subject to the following restrictions:

• A local class is visible only within the block that defines it; can never be used outside of that block.

• Local classes cannot be declared public, protected, private, or static. These modifiers are for class members; they are not allowed with local variable declarations or local class declarations.

• Like member classes, and for the same reasons, local classes cannot contain static fields, methods, or classes. The only exception is for constants that are declared static and final.

• Interfaces cannot be defined locally.

• A local class, such as a member class, cannot have the same name as any of its enclosing classes.

• As mentioned above, a local class can use the local variables, method parameters, and even exception parameters that are in its scope, but only if those variables or parameters are declared final. This is because the lifetime of an instance of a local class can be much longer than the execution of the method in which the class is defined. For this reason, a local class must have a private internal copy of all the local variables it uses (these copies are automatically generated by the compiler). The only way to ensure that the local variable and the private copy are always the same is to insist that the local variable is final.

When to use them?

The Java doc says the following

Use them if you need to create more than one instance of a class, access its constructor, or introduce a new named type (because, for example, you need to call additional methods later).

Helpful Links

• Java Documentation: Local Classes
• Local classes in docstore.mik.ua (part of this answer is translated from that interesting article)

Class Taxonomy

This image shows the taxonomy of classes in Java:

are they similar to anonymous java classes or are they different?

They are similar in that, outside of the code where they are defined, you cannot reference them.

In general, what could I use them for?

The difference is that with an anonymous class you can't reference it even where you define it; you can only create one instance.

The code shows you a good example; you create multiple instances of PhoneNumberand define variables with that type. With anonymous classes you would find that:

• You can only create one instance for each class

• You can't define a variable of that class, you can only use a superclass (this means that, although possible, defining new public methods in an anonymous class doesn't make sense; unless you use reflection you won't be able to call them).

Having said that, I personally am in favor of not abusing anonymous and local classes for readability reasons, and in the case of local ones I always prefer to use a nested class , defined at the class level. But it is a matter of preference.

The purpose of a nested class is, for you to understand, a method with enough complexity to decide to convert it into a class, in this way the behavior is different, having said this, I answer:

the nested class only exists as long as the outer class exists, you can't make an egg without breaking the shell, that explains it all