Java 중첩 클래스 및 Lambda 표현식

A nested class is a class within another class, i.e. a member of its enclosing class. It is divided into two categories: non-static and static.

1. Non-static nested classes are called inner classes. They have access to other members of the enclosing class, even if they are declared private.
2. Nested classes that are declared static are called static nested classes. They DO NOT have access to other members of the enclosing class.
3. As a member of the outer class, a nested class can be declared private , public , protected or package-private .
4. Note that outer classes can only be declared public or package-private .

1. It is a way of logically grouping classes that are only used in one place.
2. It increases encapsulation.
3. It can lead to more readable and maintainable code.

1. An inner class is associated with an instance of its enclosing class and has direct access to that object's methods and fields.
2. As an inner class is associated with an instance, IT CANNOT DEFINE ANY STATIC MEMBERS ITSELF..
3. Objects that are instances of an inner class exist within an instance of the outer class. Thus an instance of an inner class can only exist within an instance of the outer class and has direct access to the methods and fields of the enclosing instance.
4. To instantiate an inner class, the outer class must first be instantiated.
5. There are two special kinds of inner classes: local classes and anonymous classes.

public class OuterClass {
    private class InnerClass {
        // class content here
    }
}

1. As with class methods, a static nested class is associated with its outer class.
2. A static nested class cannot refer directly to instance variables or methods defined in its enclosing class. It can use them only through an object reference.
3. A static nested class interacts with the instance members of its outer class and other classes just like any other top level class. Thus a static nested class is behaviorally a top-level class that has been nested in another top-level class for packaging convenience.

public class OuterClass {
    static class StaticNestedClass {
       // class contents here
    }
}

1. There are two types of inner classes : local and anonymous. An inner class within the body of a method is called a local class. An inner class can also be declared inside the body of a method without naming them, i.e. an anonymous class.
2. The same modifiers used for other members of the outer class can be used for an inner class. For instance the access modifiers private , public , package-private protected can be used in an inner class just like how they are used for the instance fields of the outer class.

1. Lambda Expressions enables developers to treat functionality as a method argument, or code as a data.
2. For classes with only one method, an anonymous class, much more a named class is a bit excessive and cumbersome. Lambdas express instances of single-method classes more compactly.

A functional interface is any interface that contains only one abstract method. It may contain one or more default methods or static methods. Because it only contains one abstract method, the name can be omitted when implementing it. By doing this instead of using an anonymous class expression, a lambda expression is used. The JDK defines several standard functional interfaces which can be found in the package java.util.function .

Lambdas can be used to create anonymous methods. However, there are times when it does nothing but call an existing method. In these cases, it is often clearer to refer to the existing method by name, called method referencing. They are compact, easy-to-read lambdas for methods that already have a name.
For instance this can be done in sorting an array of Person objects by age.

Arrays.sort(personListAsArray, Person::compareByAge);

The method reference Person::compareByAge is semantically the same as the lambda expression where compareByAge is a static method of the Person class.

(person1, person2) -> Person.compareByAge(person1, person1)

Nested Classes enable the logical grouping of classes that are only used in one place, increase the use of encapsulation, create more readable and maintainable code. Local classes, anonymous classes and lambda expressions also share the same advantages but they are usually used for more specific situations:

• Local Class . Used if creating more than one instance of a class is needed, access its constructor and/or introduce a new, named type.
• Anonymous Class . Used if declared fields or additional methods are needed

• Lambda Expressions .

  • Used for encapsulating a single unit of behavior that is passed to the other parts of the code.
  • Used if a simple instance of a functional interface is needed and some other criteria like constructor, named type, fields or additional methods are not needed

• Nested Class . Used for reasons similar to those of local classes, i.e. it is necessary to make the type more widely available, and access to local variables or method parameters are not needed.

  • Inner class should be used if access to an enclosing instance's non-public fields and methods are required.
  • Static class should be used if there is no instance field that needs to be accessed from the class.

Getting used and familiar with nested classes and advanced lambdas with generics certainly takes a lot of reading code and practice. We will eventually get there.

As always, cheers to continued growth and learning 🍷!