Lift Java Inner Class May Many people are not familiar, in fact, similar concepts are also in C , that is, nested class, the difference between the two, which will be compared in the following. Internal classes look from the surface, that is, a class is defined in the class (hereinafter seeing, the internal class can be defined in many places), and actually is not as simple, suddenly it seems to be a little excess, its It may not be so significant for beginners, but with the in-depth understanding of it, you will find that Java designer is indeed good to work in internal classes. Learn to use internal classes to master part of Java's advanced programming, which allows you to design your program structure more elegant. The following are the following aspects:
First meeting
public interface Contents {int value ();} public interface Destination {String readLabel ();} public class Goods {private class Content implements Contents {private int i = 11; public int value () {return i;}} protected class GDestination implements Destination {private String label; private GDestination (String whereTo) {label = whereTo;} public String readLabel () {return label;}} public Destination dest (String s) {return new GDestination (s);} public Contents cont ( ) {Return new content ();}} class testgoods {public static void main (string [] args) { Goods p = new goods (); contents c = p.cont (); destination d = p.dest ("beijing");}} In this example, CONTENT and GDestination are defined inside the class Goods and have respectively. Protected and private modifiers control the access level. Content represents the content of Goods, while GDestination represents the destination of Goods. They achieve two interfaces Content and Destination respectively. In the later main method, use CONTENTS C and DESTINATION D to operate, and even the names of these two internal classes have not seen it! In this way, the first advantage of the internal class is reflected - hiding you don't want others to know the operation, that is, encapsulation.
At the same time, we also found the first method of getting internal objects outside the externally role range, which is created and returned by the method of its external class. The CONT () and DEST () methods in the above example are done. So there is any other way? Of course, its grammar format is as follows:
OuterObject = New OuterClass (Constructor parameters); OuterClass.innerClass InnerObject = OuterObject.new InnerClass (Constructor parameters); Note When you create a non-static internal class object, you must create a corresponding external class object first. For the reasons, we will lead to our next topic -
Non-static internal class objects have references to its external class objects
Slightly modified the examples just now:
public class Goods {private valueRate = 2; private class Content implements Contents {private int i = 11 * valueRate; public int value () {return i;}} protected class GDestination implements Destination {private String label; private GDestination (String whereTo) {Label = WHERETO;} public string readlabel ()} public destination de (String s) {return new gdestination (s);} public contents last ();}
The modified part is displayed in red. Here we add a private member variable value value to the Goods class, which is the value coefficient of the goods, multiplied it when the internal CONTENT method value () calculates the value. We found that Value () can access Valuerate, which is the second benefit of internal classes -
An internal class object can access the content of the created external class object, even private variables! This is a very useful feature that provides more ideas and shortcuts for us. To implement this feature, the internal class object must have a reference to the external class object. When you create an internal class object, the Java compiler is implicitly passed in and has been saved. This allows the internal class object to always access its external class object, and this is why the external class object must be created in the external class scope must first create the reason why the external class object is created.
Some people will ask, if a member variable in the internal class is the same name, that is, the external class member variable is blocked, what should I do? Nothing, Java uses the following format to express the external class reference:
Outerclass.this
With it, we are not afraid of this shield.
The static internal class and ordinary class, the internal class can also be static. However, compared with non-static internal classes, the difference is that the static internal classes have no references to the outside. This is actually very similar to the nested classes in C , the biggest difference between the Java internal classes and C nested classes is whether there is a reference to the outside, of course, from the perspective of the design, and some details Difference. In addition, in any non-static internal class, there is no static data, static method, or still another static internal class (nesting of the internal class, more than one layer). However, the static internal class can have all this. This is also the second difference between the two.
Local internal class
Yes, the internal class of the Java can also be partial, which can be defined within one method or even a block.
public class Goods1 {public Destination dest (String s) {class GDestination implements Destination {private String label; private GDestination (String whereTo) {label = whereTo;} public String readLabel () {return label;}} return new GDestination (s) Public static void main (string [] args) {goods1 g = new goods1 (); destination d = g.dest ("beijing");}}
The above is such an example. In the method DEST we define an internal class, and finally the object returns to this internal class by this method. If we only need to create an object and create it to the outside when using an internal class, you can do this. Of course, the internal classes defined in the method can make design diversification and use is not just at this point.
There is a spoken example below:
public class Goods2 {private void internalTracking (boolean b) {if (b) {class TrackingSlip {private String id; TrackingSlip (String s) {id = s;} String getSlip () {return id;}} TrackingSlip ts = new TrackingSlip ("SLIP"); string s = ts.getslip ();}} public void track () {INTERNALTRACKING (TRING ";} public static void main (string [] args) {goods2 g = new goods2 (); g. You cannot create this internal class object outside of the IF because it has exceeded its scope. However, in the compilation, internal class trackingslip is compiled simultaneously, but it is ineffective by its own scope, which is exceeded, in addition to this and other internal classes.
Anonymous internal class
Java's anonymous internal classes seem to have a certain quirky, just like an anonymous array, when you only need to create a class object and use the internal class, use the internal class to make the code look simple and clear. Its syntax rules are like this:
NEW interfacename () {...}; or new superclassname () {...};
The following will continue to exemplify the example:
Public Class Goods3 {Public Contents Cont () {Return New Contents () {Private INT i = 11; Public Int Value () {Return I;}};
Here method CONT () uses an anonymous internal class to return a subject that implements the class Contents, which looks very simple.
In an anonymous adapters for Java's event processing, anonymous internal classes are used in a large number of uses. For example, add such a code when you want to close the window:
Frame.addwindowlistener (new windowadapter () {public void window {system.exit (0);}});
One thing to note is that because there is no name, anonymous internal classes do not construct a function (but if this anonymous internal class inherits a parent class containing only parameter constructor, these parameters must be taken, and Use the super key to call the corresponding content during the implementation). If you want to initialize its member variable, there are several ways: If it is an anonymous internal class in a method, you can use this method to pass the parameters you want, but remember that these parameters must be declared as Final.
Transform anonymous internal class into a local internal class of the name so that it can have a constructor.
In this anonymous internal class, the initialization code block is used.
Why do I need internal classes?
What is the benefits of the internal classes of the Java? Why do I need internal classes?
First, give a simple example, if you want to implement an interface, a method in this interface and the name of a method in this class, the parameter, what should you do? At this time, you can build an internal class to implement this interface. Since all content of the internal class is accessible to the external class, do this can do all the functions you directly implement this interface.
However, you may have to question, can you change the way?
Indeed, in this regard as the reason for designing internal classes, there is really no persuasion.
The real reason is that in this case, the internal classes and interfaces in Java add together, and can solve a problem that is often complained in Java by C programmers - there is not much inheritance. In fact, C 's multi-inheritance is complex, while Java adds an interface through internal classes, it can achieve more inheritance effects.
The purpose of this article is to introduce you to the concept of internal classes and how to use, in subsequent articles, will be more specific examples in this article, and how to build an Applicaton Framework using internal classes.
