Analysis of the Role of Java internal classes in GUI Design (1)

We do not know much about Java internal classes. Here we will introduce in detail the role of Java internal classes in GUI Design in the form of actual code.

Java
Internal classes are rarely used in J2EE programming,
However, Window application programming is particularly common and mainly used for event processing. In fact, for non-Gui programming, internal classes are completely unnecessary.

The declaration and access control of internal classes are different from those of external classes. It is still quite difficult to use internal classes to write programs flexibly. Java invented this hard-to-understand thing, in other languages
But in Java, internal classes are also very important. Especially in GUI development, Event Response Processing relies entirely on internal classes.

Functions of internal classes can also be implemented using external classes, but sometimes internal classes are more clever.

Internal classes are divided into the following types based on their locations:

1. (common) internal class (the most common internal class, the definition of internal class is equal to that of Class Members ,)

2. Internal method class

3. Anonymous class

4. static internal class

5. Interface internal class

I. Internal class declaration and access

1. The internal class is declared directly inside the class. It can be declared as private, protected, public, or default access permission. This access permission convention is completely consistent with the external class.
Same.

2. The internal class automatically has access to all the Members (methods and attributes) of its peripheral class. If the name of an internal class is the same as that of an external class member
Use the following method to access: External class name. This. External member name, for example, outer. This. I ++; (see the example)

3. An external class object must be used to create an internal class object instead of a new one.

Format: External Object Name. New internal class Constructor

For example, to create an internal class iner object, you need to do this:

 
 

  
  
Outer outer = new outer ();
  
  
Outer. Inner iner = outer. New inner ();
  
  
 
  
  
/**
  
  
* Internal class creation and initialization
  
  
*
  
  
* @ Author leizhimin 2009-7-17 13:51:52
  
  
*/
  
  
Public class Outer {
  
  
Private int I = 10;
  
  
Private int y = 8;
  
  
 
  
  
Outer (){
  
  
System. Out. println ("Call outer constructor: outer ");
  
  
}
  
  
 
  
  
Public void saymsg (){
  
  
System. Out. println ("outer class! ");
  
  
}
  
  
 
  
  
Class inner {
  
  
Int I = 1000;
  
  
 
  
  
Inner (){
  
  
System. Out. println ("Call inner constructor: inner ");
  
  
}
  
  
 
  
  
Void innermsg (){
  
  
System. Out. println (">>>> inner class! ");
  
  
Saymsg ();
  
  
// Access the Member I of the internal class, which can also be written as this. I ++
  
  
This. I ++;
  
  
// Access the members I and Y of the external class
  
  
Outer. This. I ++;
  
  
Y --;
  
  
}
  
  
 
  
  
Int Geti (){
  
  
Return I;
  
  
}
  
  
}
  
  
 
  
  
Public void test (){
  
  
Inner in = new inner ();
  
  
In. innermsg ();
  
  
}
  
  
 
  
  
Public int Geti (){
  
  
Return I;
  
  
}
  
  
 
  
  
Public void SETI (int I ){
  
  
This. I = I;
  
  
}
  
  
}
  
  
 
  
  
Class test1 {
  
  
Public static void main (string [] ARGs ){
  
  
Outer outer = new outer ();
  
  
Outer. Test ();
  
  
System. Out. println (outer. Geti ());
  
  
System. Out. println ("------- 1 --------");
  
  
 
  
  
Outer. Inner iner = outer. New inner ();
  
  
Iner. innermsg ();
  
  
System. Out. println (INER. Geti ());
  
  
System. Out. println ("------- 2 --------");
  
  
 
  
  
System. Out. println (outer. Geti ());
  
  
}
  
  
}
 
 

Running result:

Call outer constructor: outer

Call the inner constructor: inner

 
 

  
  
>>>>>Inner class!   
  
  
Outer class!   
  
  
11   
  
  
-------1--------  
 
 

Call the inner constructor: inner

 
 

  
  
>>>>>Inner class!   
  
  
Outer class!   
  
  
1001   
  
  
-------2--------   
  
  
12   
  
  
 
  
  
Process finished with exit code 0  
 
 

Ii. Internal classes and interfaces

1. Internal classes can implement interfaces.

2. Internal classes are visible to each other, but not between internal classes.

 
 

  
  
Public interface Foo {
  
  
Void say ();
  
  
}
  
  
 
  
  
Public interface bar {
  
  
Void readme ();
  
  
}
  
  
 
  
  
/**
  
  
* Internal class implementation Interface
  
  
*
  
  
* @ Author leizhimin 2009-7-17 14:57:50
  
  
*/
  
  
Public class Test2 {
  
  
Public static void main (string [] ARGs ){
  
  
Outer outer = new outer ();
  
  
Foo F = outer. genfoo ();
  
  
Bar B = outer. genbar ();
  
  
F. Say ();
  
  
B. readme ();
  
  
}
  
  
}
  
  
 
  
  
Class outer {
  
  
Private class fooimpl implements Foo {
  
  
Public void say (){
  
  
System. Out. println ("say foo! ");
  
  
}
  
  
}
  
  
 
  
  
Private class barimpl implements bar {
  
  
Public void readme (){
  
  
System. Out. println ("say bar! ");
  
  
}
  
  
}
  
  
 
  
  
Public Foo genfoo (){
  
  
Return new fooimpl ();
  
  
}
  
  
 
  
  
Public Bar genbar (){
  
  
Return new barimpl ();
  
  
}
  
  
}
 
 

Input result:

Say foo!

Say bar!

Process finished with exit code 0

Iii. Access Permissions

There are two types of external classes:

An external class embedded with an internal class declaration code is called a direct external class. The other is an external class that has no relationship with the internal class. It is called an external class.

In the same direct external class, all the methods between internal classes are visible to each other, including the main () of the direct external class.

To view the internal class members of a class in an external class, at least the class and member permissions of this internal class must be greater than or equal to protected.

 
 

  
  
/**
  
  
* Internal class implementation Interface
  
  
*
  
  
* @ Author leizhimin 2009-7-17 14:57:50
  
  
*/
  
  
Public class Test2 {
  
  
Public static void main (string [] ARGs ){
  
  
Outer o = new outer ();
  
  
Outer. Bar B = O. genbar ();
  
  
B. readme ();
  
  
}
  
  
}
  
  
 
  
  
Class outer {
  
  
 
  
  
Protected class Foo {
  
  
Protected void say (){
  
  
System. Out. println ("say foo! ");
  
  
}
  
  
 
  
  
Private void test (){
  
  
System. Out. println ("---- test ------");
  
  
}
  
  
}
  
  
 
  
  
Protected class bar {
  
  
Protected void readme (){
  
  
System. Out. println ("say bar! ");
  
  
New Foo (). Test ();
  
  
}
  
  
}
  
  
 
  
  
Public Foo genfoo (){
  
  
Return new Foo ();
  
  
}
  
  
 
  
  
Public Bar genbar (){
  
  
Return new bar ();
  
  
}
  
  
}

 
 


This question is transferred from http://developer.51cto.com/art/201002/183375.htm

I think it's good. Add it to your favorites and hope it can help you.