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

This article introduces the relevant knowledge of "how to use the internal and external classes of java". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

First, why use inner classes

Inner classes provide better encapsulation, and only external classes can access them

An inner class can inherit an interface independently, regardless of whether the external class inherits the interface or not

Properties and methods in inner classes cannot be accessed directly even if they are external classes. On the contrary, inner classes can directly access properties and methods of external classes, even if private

It is convenient to write callback function.

An example of an inner class:

Public class OuterClass {private String outerName; private int outerAge; public class InnerClass {private String innerName; private int innerAge;}} II. The relationship between the inner class and the outer class 2.1.The inner class is a relatively independent entity, not an is-a relationship with the external class.

The inner class is a compile-time concept. After compilation, the external class and its inner class generate two separate class files: OuterClass.class and OuterClass$InnerClass.class. I compiled the above OuterClass with the javac compiler:

D:\ > javac OuterClass.class

The compiled result:

2.2 the inner class can directly access the elements of the outer class, but the outer class cannot directly access the element of the inner class public class OuterClass {private String outerName; private int outerAge; public class InnerClass {private int innerName; InnerClass () {/ / the inner class can access the element outerName= "I am outer class" of the outer class; outerAge=23 } public void display () {System.out.println (outerName+ "and my age is" + outerAge);} public static void main (String [] args) {OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass = outerClass.new InnerClass (); innerClass.display ();}}

In the above example, we can see that the inner class has direct access to the external class properties, even though the external class properties are decorated with private. This is because when you create an external class, the inner class automatically captures a reference to the external class, so the inner class accesses the external class element, actually through the external class reference it holds. In java, we can get references to external classes through OuterClass.this, as shown in the following example:

Public class OuterClass {public void display () {System.out.println ("this is OuterClass...");} public class InnerClass {/ / get the reference to the external class public OuterClass getOuterClass () {return OuterClass.this } public void innerDisplay () {/ / the inner class can also access the external element getOuterClass (). Display () through the reference of the external class;}} public static void main (String [] args) {OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass = outerClass.new InnerClass (); innerClass.innerDisplay () External class can indirectly access inner class element public class OuterClass {public void display () {/ / external class access inner class element. You need to access InnerClass innerClass=new InnerClass (); innerClass.innerDisplay ();} public class InnerClass {public void innerDisplay () {System.out.println ("I am inner class") through inner class reference. }} public static void main (String [] args) {OuterClass outerClass=new OuterClass (); outerClass.display ();}} III. Create an inner class 3.1 create an internal object outside the outer class (or the external class main method)

In fact, we have seen how to create an inner class in the 2.2 example above. If you want to create an inner class object, you must use outerClass.new to create:

1 OuterClass outerClass = new OuterClass ()

2 OuterClass.InnerClass innerClass = outerClass.new InnerClass ()

In fact, we can do it in one step: OuterClass.InnerClass innerClass=new OuterClass (). New InnerClass ()

Example of an inner class creation method:

Public static void main (String [] args) {/ / create an external class object first, and then create an inner class object OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass1 = outerClass.new InnerClass (); innerClass1.innerDisplay (); / / create OuterClass.InnerClass innerClass2=new OuterClass (). New InnerClass (); innerClass2.innerDisplay ();} 3.2 create an inner class in the outer class

Just like the display () method in the 2.3code, create an inner class inside an outer class, just as you would create a normal object:

InnerClass innerClass=new InnerClass ()

Fourth, the types of internal classes:

In Java, the inner class is mainly divided into member inner class, method inner class, anonymous inner class and static inner class.

4.1 member inner class

The member inner class is also the most common inner class, it is a member of the outer class, so he can access all the member properties and methods of the outer class without restriction. Although it is private, the outer class needs to access the member properties and methods of the inner class through the instance of the inner class.

There are two points to note in the inner class of a member:

There cannot be any static variables and methods in the inner class of a member

The inner class of the member is attached to the outer class, so the inner class can be created only if the outer class is created first.

4.2 method inner class

The inner class of the method is defined in the method of the external class, the local inner class and the member inner class are basically the same, but their scope is different, the method inner class can only be used in this method, without this method will be invalid. The use of this class is mainly to apply and solve more complex problems. We want to create a class to assist our solution. At that time, we do not want this class to be publicly available, so a local inner class is generated.

4.3 Anonymous inner class

An anonymous inner class is actually a method inner class without a name, so it conforms to all the constraints of the method inner class. For the first time, there are a few things to note:

Anonymous inner classes do not have access modifiers.

An anonymous inner class must inherit an abstract class or implement an interface

There cannot be any static members or methods in an anonymous inner class

An anonymous inner class has no constructor because it does not have a class name.

The general scenario for using anonymous inner classes is that there is only one abstract method for the interface to inherit or implement, such as adding a listener:

Public class Button {public void click () {/ / anonymous inner class, which implements the ActionListener interface new ActionListener () {public void onAction () {System.out.println ("click action...");}. OnAction () } / / Anonymous inner class must inherit or implement an existing interface public interface ActionListener {public void onAction ();} public static void main (String [] args) {Button button=new Button (); button.click ();}} 4.4 static inner class

The keyword static can modify member variables, methods, and code blocks, but it can also modify inner classes, which are called static inner classes using static. The biggest difference between a static inner class and a non-static inner class is that we know that after compilation, the non-static inner class implicitly holds a reference that points to the periphery where it was created, but the static inner class does not. The absence of this quote means:

The creation of static inner classes does not need to depend on peripheral classes, but can be created directly.

Static inner classes cannot use non-static member variables and methods of any outer class, while inner classes can

Public class OuterClass {private static String outerName; public int age; static class InnerClass1 {/ * static members can exist in static inner classes * / public static String _ innerName = "static variable" Public void display () {/ * * static inner classes can only access static member variables and methods of external classes * cannot access non-static member variables and methods of external classes * / System.out.println ("OutClass name:" + outerName) }} class InnerClass2 {/ * A static member cannot exist in a non-static inner class * / public String _ innerName = "no static variable"; / * any member of an external class can be called in a non-static inner class, whether static or non-static * / public void display () {System.out.println ("OuterClass name:" + outerName) System.out.println ("OuterClass age:" + age);} public void display () {/ * external classes can directly access static inner class static elements * / System.out.println (InnerClass1._innerName); / * static inner classes can directly create instances without relying on external classes * / new InnerClass1 () .display () / * creation of non-static internals depends on external classes * / OuterClass.InnerClass2 inner2 = new OuterClass (). New InnerClass2 (); / * members of non-static inner classes need to use instances of non-static inner classes to access * / System.out.println (inner2._innerName); inner2.display () } public static void main (String [] args) {OuterClass outer = new OuterClass (); outer.display ();}} "how to use inner and outer classes of java" ends here. Thank you for reading. If you want to know more about the industry, you can follow the website, the editor will output more high-quality practical articles for you!

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.