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

This article mainly introduces "how to use Java inner class". In daily operation, I believe many people have doubts about how to use Java inner class. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "how to use Java inner class". Next, please follow the editor to study!

First, how to create inner classes

The inner class, as its name implies, is the class in the class, which defines the class in the outer class:

Public class Animal {class Monkey {private String name = "monkey"; public String getName () {return name;}} class Pig {private String color; Pig (String color) {this.color = color;} String getColor () {return color } public void getAnimal (String note) {Monkey monkey = new Monkey (); Pig pig = new Pig (note); System.out.println (pig.getColor ());} public static void main (String [] args) {Animal animal = new Animal (); animal.getAnimal ("pink");} / * OUTPIT: pink * /

Because the Monkey and Pig classes are defined in the Animal class, using these two inner classes is no different from using a normal class. The following set of code is no stranger to buddies:

Public class Animal {class Monkey {} class Pig {} public Monkey getMonkey () {return new Monkey ();} public Pig getPig () {return new Pig ();} public static void main (String [] args) {Animal animal = new Animal (); Animal.Monkey monkey = animal.getMonkey (); Animal.Pig pig = animal.getPig () }}

Returns a reference to the execution inner class by defining a method. I wonder if the careful little friend has noticed that the reference to the inner class is a little strange: Animal.Monkey. This is also one of the differences between inner classes. If you want to get an object of an inner class outside of the non-static method of the outer class, you need to "specify the type of the object": OuterClassName.InnerClassName

II. Internal and external connection

The inner class exists in the inner layer of the outer class, so it also has certain privileges: the inner class can access all members of the outer object without any special conditions. in addition, the inner class also has access to all elements of the outer class.

Public class OuterArray {private Integer [] ints; private int next = 0; public OuterArray (int size) {ints = new Integer [size];} public void add (int x) {if (next < ints.length) {ints [next++] = x;}} class InnerArray {private int i = 0 Public boolean end () {return I = = ints.length;} public int current () {return ints [I];} public void next () {if (I < ints.length) {iTunes + } public static void main (String [] args) {OuterArray outerArray = new OuterArray (10); for (int I = 0; I < 10; iTunes +) {outerArray.add (I);} InnerArray innerArray = outerArray.new InnerArray () While (! innerArray.end ()) {System.out.print (innerArray.current () + ""); innerArray.next ();}

As we can see in the previous set of code, InnerArray can access every attribute in OuterArray as if it had them, which brings great convenience.

III. New and this

We must be familiar with these two keywords, and we must use new as an object most often.

Public class OuterClass {class InnerClass {} public static void main (String [] args) {OuterClass outer = new OuterClass ();}}

When we need an OuterClass object, we come in with a new OuterClass (), but what if we need an InnerClass object? The answer is:

InnerClass inner = outer.new InnerClass ()

You may find it a little strange why the new here needs to be referenced as an OuterClass object, because the inner class object is secretly connected to the external class object from which it was created, so you must use the object of the external class to create the inner class object. If you create a "nested class" (static inner class), then it does not need a reference to the external class object.

The this keyword is used to generate references to external class objects, so that the resulting references automatically have the correct type:

Public class OuterClass {class InnerClass {public OuterClass getOuterClass () {return OuterClass.this;}} public static void main (String [] args) {OuterClass outer = new OuterClass (); InnerClass inner = outer.new InnerClass (); OuterClass outerClass = inner.getOuterClass ();}}

4. Local inner class

The inner classes we saw above are all defined in the outer class, which is a typical use of the inner class. However, we can also define inner classes in a method or in any scope. This is also known as a local inner class:

Public class OuterClass {public Animal getPig (String color) {class Pig extends Animal {@ Override public void getAnimal (String color) {super.getAnimal (color);}} return new Pig ();} public static void main (String [] args) {OuterClass outerClass = new OuterClass () Animal pink = outerClass.getPig ("pink");}}

The Pig class is part of the getPig () method, not part of OuterClass, so you cannot access the Pig class outside of getPig ().

5. Anonymous inner class

Before we understand what an anonymous inner class is, let's look at a set of code:

Public class OuterClass {public Animal animal () {return new Animal () {private String name= "monkey"; @ Override public String toString () {return "animal {" + "name='" + name +'\'+'}';}} } public static void main (String [] args) {OuterClass outerClass = new OuterClass (); System.out.println (outerClass.animal ());} / * OUTPUT: animal {name='monkey'} * /

The animal () method combines the generation of the return value with the class definition that represents the return value. And this class is anonymous, it doesn't have a name, and the normal form would look like this:

Public class OuterClass {class Monkey extends Animal {private String name= "monkey"; @ Override public String toString () {return "animal {" + "name='" + name +'\'+'}';}} public Animal animal () {return new Monkey ();}}

Anonymous classes revisit the factory:

Public interface Service {void method1 ();} interface ServiceFactory {Service getService ();} class Implementation1 implements Service {private Implementation1 () {} @ Override public void method1 () {System.out.println ("Implementation1.method1 ()";} public static ServiceFactory factory = new ServiceFactory () {@ Override public Service getService () {return new Implementation1 ();} } class Factories {public static void main (String [] args) {ServiceFactory factory = Implementation1.factory; Service service = factory.getService (); service.method1 ();}}

Get the implementation of the external class through the inner class, so that the constructor of the Implementation1 can be private, and there is no need to create a concrete class as a factory, so the resulting syntax is more meaningful and can also be used in the singleton pattern.

VI. Nested classes

If you don't need a connection between the inner class object and the outer class, you can declare the inner class as static, which is often called a nested class. A normal inner class object implicitly holds a reference to the outer class object that created it. However, when the inner class is static, it means:

To create objects of nested classes, you do not need objects of their peripheral classes

Non-static peripheral class objects cannot be accessed from objects of nested classes

Public class NestClass {static class InnerNestClass {} public static InnerNestClass get () {return new InnerNestClass ();} public static void main (String [] args) {InnerNestClass innerNestClass = get ();}}

No NestClass object is required in the main () method, but the method is called using the normal syntax of selecting static members.

Interface inner class

Normally, you cannot place any code inside an interface, but nested classes can be part of an interface. Any class you put into the interface is automatically public and static. Because the class is static, it just places the nested class in the namespace of the interface, which does not violate the rules of the interface. You can even implement the interface of its outer class in the inner class:

Public interface ClassInterface {void test (); class Test implements ClassInterface {@ Override public void test () {System.out.println ("nested classes in the interface");} public static void main (String [] args) {new Test () .test ();}

If you want to create some common code so that it can be shared by all different implementations of an interface, it is convenient to use nested classes within the interface, although you can use default to implement interface methods by default after Java 8.

Inheriting inner classes

Inner classes, as a category, are certainly allowed to inherit. But because the constructor of the inner class must connect to a reference to its outer class object, when inheriting the inner class, the reference to the outer class object must be initialized, and there is no longer a connectable default object in the exported class

As you can see, errors will be reported through this inheritance, and the solution is:

Class ExtendClass {class Inner {} class WithInner extends ExtendClass.Inner {public WithInner (ExtendClass extendClass) {extendClass.super ();}}

So we need to keep in mind that if you want to inherit an inner class, you must use the external class .super () within the constructor to provide the necessary references before the program can be compiled.

8. Overwrite the inner class?

When a subclass inherits the parent class, the subclass can override the methods of the parent class. So the question is, can inner classes be overwritten? Let's look at a set of codes to find the answer:

Public class Flower {class Bud {public Bud () {System.out.println ("Flower.Bud");} public Flower () {System.out.println ("new Flower ()"); new Bud (); test ();} public void test () {System.out.println ("Flower.test ()") } class Flower2 extends Flower {class Bud {public Bud () {System.out.println ("Flower2.Bud");}} public void test () {System.out.println ("Flower2.test ()");} public static void main (String [] args) {new Flower2 () } / * OUTPUT new Flower () Flower.Bud Flower2.test () * /

From this example, we can see that there is no particularly magical change in the inner class when inheriting a peripheral class. These two inner classes are completely separate entities, each in its own namespace.

9. Why use inner classes?

Before we answer this question, let's understand one thing:

"each inner class can inherit an implementation (of the interface) independently, so whether or not the outer class has inherited an implementation (of the interface) has no effect on the inner class."

This sentence clearly illustrates the capabilities of inner classes. Without the ability of inner 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 multiple inheritance solutions complete. The interface solves part of the problem and effectively implements "multiple inheritance" for inner classes.

At this point, the study on "how to use Java inner classes" is over. I hope to be able to solve your doubts. The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

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.