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

Today, I will talk to you about how to understand the internal classes of Java. Many people may not know much about it. In order to make you understand better, the editor has summarized the following contents for you. I hope you can get something according to this article.

An inner class (inner class) is a class defined in another class. Why use inner classes? There are two main reasons: 1. Inner classes can be hidden from other classes in the same package. two。 Inner class methods can access data in the scope that defines the class, including data that would otherwise be private.

Next, I will lead you to learn several common internal classes in Java, hoping to have some harvest for you!

one。 Instance inner class 1. Define

What is an instance inner class? As the name implies, another class is defined inside a normal class, that is, an instance inner class.

Such as:

Class OuterClass {public int data1=1; public static int data2=2; class InnerClass {public int data3=3;}}

However, it should be noted that there can be no static member variables modified by static in the inner class of the instance, and we can regard the inner class of the instance as an instance member of the class, so when we call it, we can think that the process of calling is dependent on the object, but static does not depend on the object, so we can introduce fields that cannot be modified by static. If you have to use static, then you must add final, that is, decorated with static final, because the value modified with final cannot be changed, and can be treated as a constant, that is, its value can be determined during compilation, so that it will not be reported incorrectly.

two。 How to get the reference to the object of the inner class of the instance

After creating an inner class, how do we access the member properties in the inner class? Generally, the object is obtained through new twice:

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

Of course, we can also get it directly through the method of anonymous object:

OuterClass.InnerClass innerClass2 = new OuterClass () .new InnerClass ()

The grammar here is still rather round. if you really can't understand it, just remember it.

3. Matters needing attention

When there is a member variable with the same name as the outer class in the inner class of the instance, accessing the member variable through the inner class of the instance will access the inner class of the instance, for example:

Class OuterClass {public int data1=1; public static int data2=2; class InnerClass {public int data1=10;}} public class TestDemo {public static void main (String [] args) {OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass = outerClass.new InnerClass (); System.out.println (innerClass.data1);}}

The running result is:

So how do we access the data1 in the external class through the reference of the inner class of the instance? The methods are as follows:

Class OuterClass {public int data1=1; public static int data2=2; class InnerClass {public int data1=10; public void func () {System.out.println (data1); System.out.println (this.data1); / / this is the reference System.out.println (OuterClass.this.data1) of your own object / / this is a reference to the external class object} public class TestDemo {public static void main (String [] args) {OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass = outerClass.new InnerClass (); innerClass.func ();}}

The print result is as follows:

two。 Static inner class 1. Define

Like the instance inner class, we can think of the static inner class as a member property of the external class, but static

The code is demonstrated as follows:

Class OuterClass {public int data1=1; public static int data2=2; static class InnerClass {public int data1=10; public static int data2=20; public void func () {System.out.println (data1); System.out.println (this.data1); System.out.println (OuterClass.this.data1);}

Note that static member properties can be defined in static inner classes.

two。 How to get a reference to the object of a static inner class

It's similar to the method of getting a class object reference inside an instance, but with a slight change: OuterClass.InnerClass innerClass=new OuterClass.InnerClass ()

3. Matters needing attention

Similarly, we have some issues to pay attention to. In static inner classes, we cannot access non-static data members of external classes.

Because the static inner class does not depend on the object, while the outer class is not static, it is dependent on the object. If we have to access it, we can construct a reference out of the external class object in the inner class.

The code example is as follows:

Class OuterClass {public int data1=1; public static int data2=2; static class InnerClass {public int data1=10; public static int data2=20; public OuterClass out; public InnerClass (OuterClass o) {this.out=o;} public void func () {System.out.println (data1); System.out.println (this.out.data1) } public class TestDemo {public static void main (String [] args) {OuterClass outerClass = new OuterClass (); OuterClass.InnerClass innerClass=new OuterClass.InnerClass (outerClass); innerClass.func ();}

The print result is as follows:

three。 Anonymous inner class 1. Define

An anonymous inner class is a class that is relatively simple to use. Examples of writing are as follows:

Class OuterClass {public void func () {System.out.println ("anonymous inner class");}} public class TestDemo {public static void main (String [] args) {new OuterClass () {/ / anonymous inner class};}}

Of course, you can also override methods in an external class in an anonymous inner class:

Lass OuterClass {public void func () {System.out.println ("anonymous inner class");}} public class TestDemo {public static void main (String [] args) {new OuterClass () {@ Override public void func () {System.out.println ("here is the overridden func method");}};}}

The steps to call the overridden method are as follows:

Public static void main (String [] args) {new OuterClass () {@ Override public void func () {System.out.println ("here is the overridden func method");} .func ();}

Print the results:

Note that the anonymous inner class is only defined once and has no name

two。 Common usage interface A {public void func ();} An a = new A () {@ Override public void func () {System.out.println ("currently an anonymous inner class, implements interface A, overrides interface methods");}}

The code in the above part is an anonymous inner class, which implements interface An and rewrites the methods in interface A.

3. Matters needing attention

There is a variable capture mechanism in the anonymous inner class, that is, the value of the variable in the anonymous inner class cannot be modified.

Public static void main (String [] args) {int flag=1; new OuterClass () {@ Override public void func () {System.out.println ("here is the overridden func method"); System.out.println (flag);} .func ();}

At this point, our program can run normally, and the printed result is 1.

However, when we change the value of flag, the program reports an error:

Therefore, you need to keep in mind the variable capture mechanism in the anonymous inner class, that is, you cannot modify the value of the variable twice!

After reading the above, do you have any further understanding of how to understand the inner classes of Java? If you want to know more knowledge or related content, please follow the industry information channel, thank you for your support.

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.