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

This article mainly introduces the relevant knowledge of Java internal class instance analysis, the content is detailed and easy to understand, the operation is simple and fast, and has a certain reference value. I believe you will gain something after reading this Java internal class instance analysis article. Let's take a look at it.

Inner class:

In fact, as the name implies, the inner class is the class in the class, and there is also a class in a class.

There are four internal categories:

1. Ordinary inner class

two。 Static inner class

3. Method inner class

4. Anonymous inner class

Let's learn about it one by one.

A, ordinary inner class:

Let's take a look at the code first:

Package InternalClass;/** * inner class * / public class Car {public int a = 10; public int b = 20; / / method public void method () {System.out.println of the external class ("I am the common method of the external class Car!") ; bus b = new bus (); / / create an object of the inner class b.internalMethod ();} / / the inner class (bus class in the Car class) public class bus {int b = 30; / / the inner class method public void internalMethod () {System.out.println ("* * this is the common method of the bus inner class!") ; System.out.println ("* * I am the inner class, and now I am visiting the a:" + an of the outer class Car); System.out.println ("* * I am the inner class, and now I am accessing the b:" + this.b of the inner class bus); System.out.println ("* * I am the inner class, and I am now accessing the b:" + Car.this.b of the outer class bus) / / Note: if you need to use the properties of the external class in the inner class, you must use the external class to this the properties of the external class}} / / the program entry: public static void main (String [] args) {Car car = new Car (); / / create an object of the external class car.method () / / running the above code will output: I am the normal method of the external class Car! / / run the inner class method / / an object of the inner class bus has been created in the above method method / / here is to new an inner class object bus b = car.new bus () by using the object car of the outer class Car / / use the method through the inner class object b to b.internalMethod (); / / output: / * this is the common method of bus inner class! * * I am the inner class, and now I am accessing the bazaar 10 of the outer class Car * * I am the inner class bus * * I am the inner class, and now I am accessing the bazaar 20 minutes /} of the outer class bus

B. Static inner class:

The static inner class, as its name implies, also modifies the inner class into static with static. It can be called directly with the external class name without creating an object:

Package InternalClass;public class Person {String name = "Xiao Wang"; static int age = 20; / / create static inner class public static class Student {String name = "Xiao Hong"; / / static inner class method public static void study () {Person p = new Person () / / create objects of external classes / / static access non-static requires the use of objects to call System.out.println ("Internal class static methods access external non-static members:" + p.name); System.out.println ("internal class static methods access external static members:" + Person.age) System.out.println ("Internal class static method access internal non-static member:" + new Student () .name);}} / / Program run entry public static void main (String [] args) {/ / static use method does not need to create an object Student.study () } / * output: internal class static method access external non-static member: Xiao Wang internal class static method access external static member: 20 internal class static method access internal non-static member: Xiao Hong * /}

C. Method inner class:

The inner class of a method, as its name implies, also creates a new class in the method body of the outer class:

Package InternalClass;/** * method inner class * / public class Student {/ / method public void study () {int age = 20; String name = "Xiao Wang"; / / write the class inside the method: method inner class class child {/ / method inner class public void play () {System.out.println ("Children like to play!") ;}} / / create an object that generates the inner class child in the method of the outer class study, and use the method child c = new child (); c.play ();} / / the program execution entry public static void main (String [] args) {Student stu = new Student () / / after calling the study method here, I created the child object in the study method body and called the play method stu.study ();}} / / output: my name is: Xiao Wang this year: 20 I love to learn / / children love to play!

Summary of inner classes (there are many limitations, so you should pay attention to the use of scenarios):

1. Class cannot be preceded by an access modifier

two。 Can only be used within this method

3. Unable to create static information

4. Local variables and parameters within a method can be accessed directly, but cannot be modified

5. You can access any information of the external class at will

D, anonymous inner class:

An anonymous inner class is an inner class without a name:

Define an interface first:

Public interface USB {void read ();} package InternalClass;/** * anonymous inner class * / public class Child {public static void main (String [] args) {USB u = new USB () {@ Override public void read () {System.out.println ("this is an anonymous inner class, an unnamed subclass of the USB interface, and the interface must be rewritten for concrete implementation") }; u.read ();}}

Four points to note for anonymous inner classes:

1. Anonymous inner classes cannot define any static members or methods

two。 Methods in anonymous inner classes cannot be abstract

3. An anonymous inner class must implement all abstract methods of an interface or abstract parent class

4. External class member variables or member methods accessed by anonymous inner classes must be decorated with static

Summary of internal classes: first, why use internal classes?

The inner class has the basic characteristics of the class: it can inherit the parent class and implement the interface. In practical problems, we will encounter some problems that can not be solved by the interface. At this time, we can use the inner class to inherit a concrete or abstract class. Indirectly solve a series of problems caused by the class can not inherit more.

Second, the benefits of the inner class:

The inner class can use multiple instances, and each instance has its own state information, and the internal class is independent of the information of other peripheral objects. The internal class does not have a confusing "is-a" relationship. It is an independent entity internal class that provides a better encapsulation. Except for the outer class, the time when other classes cannot access the creation of internal class objects does not depend on the creation of peripheral class objects.

This is the end of the article on "Internal Class instance Analysis of Java". Thank you for reading! I believe you all have a certain understanding of the knowledge of "Java internal class case analysis". If you want to learn more knowledge, you are welcome to follow the industry information channel.

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.