内部类访问规则

内部类定义：

当一个类需要直接访问一个类时，可定义为内部类。

定义了内部类后，他的访问规则也有了小变化，一下举例说明。

定义一个A类为外部类，再定义一个非静态B类为A类中的内部类，B类中有个非静态show()函数。

非静态的外部类A     非静态的内部类B        内部类B中Show()函数

1. Class A
   
2. {
   
3. Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

这时可以分三种情况去访问show()函数：

1、main()函数访问Show()：

分析：B类是A类中的非静态类，要访问B类中的非静态函数，首先要建立B的对象才能访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. A.B temp = New A().new B();//声明一个A类里的B类类型的temp变量接收一
   
6.                            //个A类对象里的B对象。
   
7.     注意：格式发生了小变化
   
8. Temp.Show();
   
9. }
   
10. }

复制代码

打印显示：我是B类的show函数

2、在B类中访问show()：

分析：Show()函数是属于B类的成员，所以可以直接访问。

1. Class A
   
2. {
   
3. Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. Void Temp()
   
10. {
    
11. 
    
12. Show();//本类中函数，可以直接用函数名调用，因为都有个隐式的this.
    
13. }       也可以用this.show();
    
14. }         这一点还是和常规的一样，没有变。
    
15. }

复制代码

3、在A类中访问show():

分析：Show()函数是属于B类的成员,要访问show()函数，也需要建立对象才能访问，              由于B类在A类内，所以可以直接创建B类对象，然后调用Show()函数。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. New B().Show();        //这语句的意思：新建一个B类型的匿名对象，并调用它的
   
6. }         //Show()函数。
   
7. Class B
   
8. {
   
9. Void Show()
   
10. {
    
11. System.out.println(“我是B类的show函数”);
    
12. }
    
13. }
    
14. }

复制代码

以上就是外部类、内部类与内部函数都为非静态的时候。

*

*

非静态的外部类A     静态的内部类B        内部类B中非静态Show()函数

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

1、main()函数访问Show().

分析：B类是A类的成员，成员变成了静态，所以可以直接访问到。但是Show()        函数在B类中非静态，要访问到还需建立其对象才能访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. New A.B().Show();//创建一个A类中的B类匿名对象，并调用Show()函数。
   
6. }         //为什么不这样创建呢？{new A().new B()}
   
7. //因为B类已经静态，所以可以用A.B()直接访问B对        //象，但是        B类的函数没有静态，所以要直接创建B        //类对象，再访问Show().
   
8. }<span style="font-family: 宋体; font-size: 10.5pt; line-height: 1.5; text-indent: 21pt;"> </span>

复制代码

2、B类访问Show().

分析：Show()在静态B类中，B类想访问，只要函数名就可以直接访问。

所以在B类中可以直接Show()或者this.show();访问

3、A类访问Show()

分析：B在A中，B属于A的静态成员，所以A可以直接用B。但是B里面的函数确实非静态的，想要调用还需创建B类对象。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. B b=new B(); //这里也可以简写成new B().Show().
   
6. b.Show();         //由于只调用一次，所以可以用匿名对象来调用函数。
   
7. }
   
8. Static Class B
   
9. {
   
10. Void Show()
    
11. {
    
12. System.out.println(“我是B类的show函数”);
    
13. }
    
14. }
    
15. }

复制代码

这些是当内部类为静态的情况。

如果内部类与内部类的函数都是静态呢？

非静态的外部类A     静态的内部类B        内部类B中静态Show()函数

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Static Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

1、在mian()里访问Show().

分析：静态B是A对象的成员，所以可以直接访问；静态Show()属于B()对象的        成员，所以也可以直接访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. A.B.Show();//外部类类名。内部类类名。函数名  就可以直接访问。
   
6. }
   
7. }

复制代码

2、在B类访问Show().

分析：静态Show()属于静态B类的函数，本类调用函数，只需函数名就可以直接        调用。（注意：但是不能加this.否则会报错）

所以只能够函数名直接访问。

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Static Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. void Temp()
   
10. {
    
11. Show();         //不可以写成this.Show().
    
12. }
    
13. }
    
14. }

复制代码

3、A类中访问Show();

分析：本类中访问本类成员只需成员名可以直接访问。而且又是静态的成员，所以        不用建立对象。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. B.Show();
   
6. }
   
7. Static Class B
   
8. {
   
9. Static Void Show()
   
10. {
    
11. System.out.println(“我是B类的show函数”);
    
12. }
    
13. }
    
14. }

复制代码

以上就是外部类、内部类与内部类中的函数访问规则！

内部类访问规则

内部类定义：

当一个类需要直接访问一个类时，可定义为内部类。

定义了内部类后，他的访问规则也有了小变化，一下举例说明。

定义一个A类为外部类，再定义一个非静态B类为A类中的内部类，B类中有个非静态show()函数。

非静态的外部类A     非静态的内部类B        内部类B中Show()函数

1. Class A
   
2. {
   
3. Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

这时可以分三种情况去访问show()函数：

1、main()函数访问Show()：

分析：B类是A类中的非静态类，要访问B类中的非静态函数，首先要建立B的对象才能访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. A.B temp = New A().new B();//声明一个A类里的B类类型的temp变量接收一
   
6.                            //个A类对象里的B对象。
   
7.     注意：格式发生了小变化
   
8. Temp.Show();
   
9. }
   
10. }

复制代码

打印显示：我是B类的show函数

2、在B类中访问show()：

分析：Show()函数是属于B类的成员，所以可以直接访问。

1. Class A
   
2. {
   
3. Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. Void Temp()
   
10. {
    
11. 
    
12. Show();//本类中函数，可以直接用函数名调用，因为都有个隐式的this.
    
13. }       也可以用this.show();
    
14. }         这一点还是和常规的一样，没有变。
    
15. }

复制代码

3、在A类中访问show():

分析：Show()函数是属于B类的成员,要访问show()函数，也需要建立对象才能访问，              由于B类在A类内，所以可以直接创建B类对象，然后调用Show()函数。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. New B().Show();        //这语句的意思：新建一个B类型的匿名对象，并调用它的
   
6. }         //Show()函数。
   
7. Class B
   
8. {
   
9. Void Show()
   
10. {
    
11. System.out.println(“我是B类的show函数”);
    
12. }
    
13. }
    
14. }

复制代码

以上就是外部类、内部类与内部函数都为非静态的时候。

*

*

非静态的外部类A     静态的内部类B        内部类B中非静态Show()函数

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

1、main()函数访问Show().

分析：B类是A类的成员，成员变成了静态，所以可以直接访问到。但是Show()        函数在B类中非静态，要访问到还需建立其对象才能访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. New A.B().Show();//创建一个A类中的B类匿名对象，并调用Show()函数。
   
6. }         //为什么不这样创建呢？{new A().new B()}
   
7. //因为B类已经静态，所以可以用A.B()直接访问B对        //象，但是        B类的函数没有静态，所以要直接创建B        //类对象，再访问Show().
   
8. }<span style="font-family: 宋体; font-size: 10.5pt; line-height: 1.5; text-indent: 21pt;"> </span>

复制代码

2、B类访问Show().

分析：Show()在静态B类中，B类想访问，只要函数名就可以直接访问。

所以在B类中可以直接Show()或者this.show();访问

3、A类访问Show()

分析：B在A中，B属于A的静态成员，所以A可以直接用B。但是B里面的函数确实非静态的，想要调用还需创建B类对象。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. B b=new B(); //这里也可以简写成new B().Show().
   
6. b.Show();         //由于只调用一次，所以可以用匿名对象来调用函数。
   
7. }
   
8. Static Class B
   
9. {
   
10. Void Show()
    
11. {
    
12. System.out.println(“我是B类的show函数”);
    
13. }
    
14. }
    
15. }

复制代码

这些是当内部类为静态的情况。

如果内部类与内部类的函数都是静态呢？

非静态的外部类A     静态的内部类B        内部类B中静态Show()函数

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Static Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. }
   
10. }

复制代码

1、在mian()里访问Show().

分析：静态B是A对象的成员，所以可以直接访问；静态Show()属于B()对象的        成员，所以也可以直接访问。

1. Class MainTest
   
2. {
   
3. Public static void main(String[] args)
   
4. {
   
5. A.B.Show();//外部类类名。内部类类名。函数名  就可以直接访问。
   
6. }
   
7. }

复制代码

2、在B类访问Show().

分析：静态Show()属于静态B类的函数，本类调用函数，只需函数名就可以直接        调用。（注意：但是不能加this.否则会报错）

所以只能够函数名直接访问。

1. Class A
   
2. {
   
3. Static Class B
   
4. {
   
5. Static Void Show()
   
6. {
   
7. System.out.println(“我是B类的show函数”);
   
8. }
   
9. void Temp()
   
10. {
    
11. Show();         //不可以写成this.Show().
    
12. }
    
13. }
    
14. }

复制代码

3、A类中访问Show();

分析：本类中访问本类成员只需成员名可以直接访问。而且又是静态的成员，所以        不用建立对象。

1. Class A
   
2. {
   
3. Void Temp()
   
4. {
   
5. B.Show();
   
6. }
   
7. Static Class B
   
8. {
   
9. Static Void Show()
   
10. {
    
11. System.out.println(“我是B类的show函数”);
    
12. }
    
13. }
    
14. }

复制代码

以上就是外部类、内部类与内部类中的函数访问规则！