Shulou(Shulou.com)06/02 Report--

This article is about why inner classes are needed in Java. The editor thinks it is very practical, so share it with you as a reference and follow the editor to have a look.

Inner class: a class defined inside a class

Why do you need inner classes?

Typically, the inner class inherits from a class or implements an interface, and the code of the inner class manipulates the object of its outer class. So you can assume that the inner class provides some kind of window into its outer class.

The inner classes and interfaces in java can be added together to achieve multiple inheritance.

You can make some coding roots concise.

Hide what you don't want others to know.

The most attractive reasons for using inner classes are:

Each inner class can inherit from an implementation independently, so whether or not the outer class inherits an implementation has no effect on the inner class. Without the ability of internal classes to inherit multiple concrete or abstract classes, some design and programming problems are difficult to solve. From this point of view, inner classes make the solution of multiple inheritance complete. Interface solves part of the problem, while inner classes effectively implement "multiple inheritance".

The inner class is divided into member inner class, static nested class, method inner class and anonymous inner class.

Features:

First, the inner class is still a separate class, and after compilation, the inner class will be compiled into a separate .class file, but preceded by the class life of the external class and the $symbol.

Second, the inner class can access the properties and methods of the external class directly or by reference, including private properties and methods (but the static inner class cannot access the non-static member variables and methods of the external class). The value of the external property accessed by the inner class is determined by the external class object at the time of construction.

Third, if the outer class wants to access the members of the inner class, it can only be done by reference. You can ask all the members of the inner class.

Fourth, access mechanism:

System.out.println (this.x); or System.out.println (x); / / the inner class accesses member variables or member methods of the inner class. System.out.println (OuterClass.this.x); / / this method can be used when an inner class accesses a variable of the same name of an outer class, if no System.out.println (x) is available with the same name

Fifth, the inner class can use any scope limit: public/private/protected class InnerClass, and strictly according to these access rights to control the scope that the inner class can use. The scope limit of a normal class can only be public or not.

6. the naming of the inner class is not allowed to have the same name as the outer class. the inner class can inherit the inner class of the same level or other classes (except the inner class and the outer class).

An inner class can be defined as an interface, and another class can be defined to implement it

An inner class can be defined as an abstract class, and another inner class can be defined to inherit it

9. Inner class is decorated with static and automatically upgraded to * * class. External class cannot be modified with static, but OuterClass.InnerClass inner=new OuterClass.InnerClass () is used to create an instance. The inner class can also be defined as final.

Internal classes can be defined again (basically not used)

11. Inner classes in the method:

Inner classes within a method cannot be scoped (protected public private)

Inner classes in methods cannot add static modifiers

An inner class within a method can only build its instance within a method.

If an inner class within a method accesses a method local variable, the local variable must be decorated with final

1) static inner classes (static nested classes)

Technically, static nested classes do not belong to inner classes. Because the inner class shares a special relationship with the external class, or more specifically, the sharing relationship with the instance. Static nested classes do not have the above relationship. It is only located inside another class, so it is also called a * nested class.

Static means that the inner class, like other static members, can be accessed when there is no external class object. Statically nested classes cannot access members and methods of external classes.

Grammar

Package com.tarena.day13; import com.tarena.day13.Foo.Koo; / * static class internal syntax demo * / public class StaticInner {public static void main (String [] args) {Koo koo = new Koo (); System.out.println (koo.add ()); / / 4}} class Foo {int a = 1; static int b = 3 / * * static inner class, whose scope is similar to static variables, belongs to * / static class Koo {public int add () {/ / a, and cannot access a return bread1;}

2) member inner class

* 1 the inner class of a member must be created using an external class instance

* 2 Internal classes of members can share instance variables of external classes

Import com.tarena.day13.inn.Goo.Moo; public class InnerClassDemo {public static void main (String [] args) {/ / Moo moo = new Moo (); / / compilation error, you must create an instance of Goo Goo goo = new Goo (); Moo moo = goo.new Moo (); / / create an Moo instance using goo instance Moo moo1 = goo.new Moo () / / instance variables System.out.println (moo.add ()) that moo and moo1 share the same goo instance; / / 2 System.out.println (moo1.add ()); / / 2 Goo goo1 = new Goo (); goo1.a = 8; Moo M1 = goo1.new Moo (); Moo m2 = goo1.new Moo (); System.out.println (m1.add ()); / / 9 System.out.println (m2.add ()) / / 9}} class Goo {int a = 1; / * member inner class * / class Moo {public int add () {return astat1;}

3) Local inner class (method inner class)

(1) the inner class of a method can only be instantiated within the method that defines the inner class, not outside this method.

(2) the inner class object of a method cannot use the non-final local variable of the method in which the inner class is located.

Because the local variable of the method is on the stack, it only exists during the lifetime of the method. When a method ends, its stack structure is deleted and the local variable becomes history. But after the method ends, the inner class objects created within the method may still exist in the heap! For example, if a reference to it is passed to some other code and stored in a member variable. Because the lifetime of local variables is not guaranteed to be as long as that of method inner class objects, inner class objects cannot use them. Usage

Package com.tarena.day13.inn; import java.util.Comparator; / * partial inner class * / public class LocalInnerClassDemo {public static void main (String [] args) {int a = 5; final int b = 5 / / Local inner class, defined inside the method, scope is similar to the local variable / / visible only inside the method / / the local final variable in the local inner class can be accessed in the local inner class class Foo {public int add () {return bounding / correct / / return / return / compilation error}} Foo foo = new Foo () / / temporary custom comparison rule class ByLength implements Comparator {public int compare (String o1) string O2) {return o1.length ()-o2.length ();}}

4) Anonymous inner class

As the name implies, an inner class without a name. On the surface, they seem to have names, but in fact that is not their names.

An anonymous inner class is an inner class without a name. Under what circumstances do you need to use anonymous inner classes? It is appropriate to use anonymous inner classes if some of the following conditions are met:

Only one instance of the class is used.

Class is used immediately after definition.

Class is very small (SUN recommends less than 4 lines of code)

Naming a class does not make your code easier to understand

When using anonymous inner classes, keep the following principles in mind:

Anonymous inner classes cannot have constructors.

Anonymous inner classes cannot define any static members, methods, and classes.

Anonymous inner class cannot be public,protected,private,static.

Only one instance of an anonymous inner class can be created.

An anonymous inner class must be behind new, implicitly implementing an interface or implementing a class.

Because the anonymous inner class is a local inner class, all restrictions on the local inner class take effect.

A. inherited anonymous inner class and interface anonymous inner class.

Import java.util.Arrays; import java.util.Comparator; / * * Anonymous Inner Class Syntax * / public class AnnInnerClass {public static void main (String [] args) {/ / TODO Auto-generated method stub Yoo yoo = new Yoo (); / / create an instance of Yoo Yoo y1 = new Yoo () {} / / new Yoo () {} create an anonymous class instance / / anonymous class new Yoo () {} inherits the Yoo class, and at the same time creates an object / / new Yoo () {} is a subtype of Yoo, where {} is the class body (class Body) / / the syntax within any class can be defined, such as: properties, methods, method overloading, method overloading, etc. / / subtypes do not have names, so they are called anonymous classes! Yoo y2 = new Yoo () {public String toString () {/ / method overrides return "y2"; / / y2 is an instance of a subclass}}; System.out.println (y2) / / "y2", calling anonymous class object toString () / anonymous inner class can inherit / implement classes, abstract classes, interfaces, etc. / / according to inherited syntax, subtypes must implement all abstract methods / / Xoo x = new Xoo () {}; / / compilation error, no implementation method final int b = 5 Xoo xoo = new Xoo () {/ / implements the interface and creates an anonymous class instance instead of creating the interface object public int add (int a) {/ / the abstract method return astatb in the interface; / / to access the local variable b, you can only access the final variable}; System.out.println (xoo.add (5)) / / 10, the method / / Comparator interface of the object can also be called in the form of anonymous class Comparator byLength = new Comparator () {public int compare (String o1) string O2) {return o1.length ()-o2.length ();}; String [] names = {"Andy", "Tom", "Jerry"}; Arrays.sort (names,byLength); System.out.println (Arrays.toString (names)) / / it can also be written like this. Arrays.sort (names,new Comparator () {public int compare (String o1MagneString O2) {return o1.length ()-o2.length ();});} is commonly used in work.

An interface-style anonymous inner class is an anonymous class that implements an interface. And only one interface can be implemented.

b. An anonymous inner class with a parameter.

Class Bar {void doStuff (Foo f) {} interface Foo {void foo ();} class Test {static void go () {Bar b = new Bar (); b.doStuff (new Foo () {public void foo () {System.out.println ("foofy");}}) }}

The methods to construct inner class objects are:

1. The inner class applies the following form when constructing an object in the static method of its external class or in another class:

(1)

OuterClass out = new OuterClass (); OuterClass.InnerClass in = out.new InnerClass ()

(2)

OuterClass.InnerClass in=new OuterClass () .new InnerClass ()

Where OuterClass is the outer class and InnerClass is the inner class.

2. When an inner class is in a non-static method of the external class in which it is located or is defined as a member variable of the external class, the object can be constructed in the following ways:

InnerClass in = new InnerClass ()

3. If the inner class is static, the function can be constructed in the following form:

OuterClass.InnerClass in = new OuterClass.InnerClass ()

There is no need to use objects of external classes to construct inner class objects. If static inner classes need to construct objects in static methods or other classes, they must be initialized in the above way.

Thank you for reading! This is the end of this article on why inner classes are needed in Java. I hope the above content can be of some help to you, so that you can learn more knowledge. if you think the article is good, you can share it for more people to see!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.