Android（java）学习笔记111：成员位置的内部类的介绍

1.内部类的定义

 1 /*
 2     内部类概述:
 3         把类定义在其他类的内部，这个类就被称为内部类。
 4         举例：在类A中定义了一个类B，类B就是内部类。
 5
 6     内部的访问特点：
 7         A:内部类可以直接访问外部类的成员，包括私有。
 8         B:外部类要访问内部类的成员，必须创建对象。
 9
10 */
11 class Outer {
12     private int num = 10;
13
14     class Inner {
15         public void show() {
16             System.out.println(num);
17         }
18     }
19
20     public void method() {
21         //找不到符号
22         //show();
23
24         Inner i = new Inner();
25         i.show();
26     }
27
28 }
29
30 class InnerClassDemo {
31     public static void main(String[] args) {
32
33     }
34 }

2.内部类的位置

 1 /*
 2     内部类位置
 3         成员位置:在成员位置定义的类，被称为成员内部类。
 4         局部位置:在局部位置定义的类，被称为局部内部类。
 5
 6
 7     成员位置:在成员位置定义的类，被称为成员内部类。
 8
 9 */
10 class Outer {
11     private int num = 10;
12
13     //成员位置
14     /*
15     class Inner {
16
17     }
18     */
19
20
21     public void method() {
22         //局部位置
23         class Inner {
24
25         }
26     }
27 }
28
29 class InnerClassDemo2 {
30     public static void main(String[] args) {
31
32     }
33 }

 1 /*
 2     成员内部类:
 3         如何直接访问内部类的成员。
 4         外部类名.内部类名 对象名 = 外部类对象.内部类对象;
 5 */
 6 class Outer {
 7     private int num = 10;
 8
 9     class Inner {
10         public void show() {
11             System.out.println(num);
12         }
13     }
14 }
15
16 class InnerClassDemo3 {
17     public static void main(String[] args) {
18         //需求：我要访问Inner类的show()方法
19         //Inner i = new Inner();
20         //i.show();---这样的方式是错误的
21
22         //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
23         Outer.Inner oi = new Outer().new Inner();
24         oi.show();
25     }
26 }

3.实例梳理成员内部类的修饰符

 1 /*
 2     成员内部类的修饰符：
 3         private 为了保证数据的安全性
 4         static 为了方便访问数据
 5             注意：静态内部类访问的外部类数据必须用静态修饰。
 6
 7     案例：我有一个人(人有身体，身体内有心脏。)
 8
 9         class Body {
10             private class Heart {
11                 public void operator() {
12                     System.out.println("心脏搭桥");
13                 }
14             }
15
16             public void method() {
17                 if(如果你是外科医生) {
18                     Heart h = new Heart();
19                     h.operator();
20                 }
21             }
22         }
23
24         按照我们刚才的讲解，来使用一下
25         Body.Heart bh = new Body().new Heart();
26         bh.operator();//但是我们是不希望外界对我们自己身体内部"心脏"进行操作的，怎么样才能实现这个？
27         //加了private后，就不能被访问了，那么，怎么玩呢?
28         Body b =  new Body();
29         b.method();
30 */
31 class Outer {
32     private int num = 10;
33     private static int num2 = 100;
34
35     //内部类用静态修饰是因为内部类可以看出是外部类的成员
36     public static class Inner {
37         public void show() {
38             //System.out.println(num);//静态内部类访问外部类数据必须是静态修饰的，num不是静态，所以不能访问，num2可以访问
39             System.out.println(num2);
40         }
41
42         public static void show2() {
43             //System.out.println(num);
44             System.out.println(num2);
45         }
46     }
47 }
48
49 class InnerClassDemo4 {
50     public static void main(String[] args) {
51         //使用内部类
52         // 限定的新静态类，下面这样写法是错误的，内部类加了静态static修饰之后，是不能通过外部对象访问的，直接调用类名访问
53         //Outer.Inner oi = new Outer().new Inner();
54         //oi.show();
55         //oi.show2();
56
57         //成员内部类被静态修饰后的访问方式是:
58         //格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
59         Outer.Inner oi = new Outer.Inner();
60         oi.show();
61         oi.show2();
62
63         //show2()的另一种调用方式
64         Outer.Inner.show2();
65     }
66 }

4.面试题

 1 /*
 2     面试题：
 3         要求请填空分别输出30，20，10。
 4
 5     注意：
 6         1:内部类和外部类没有继承关系。
 7         2:通过外部类名限定this对象
 8             Outer.this
 9 */
10 class Outer {
11     public int num = 10;
12     class Inner {
13         public int num = 20;
14         public void show() {
15             int num = 30;
16             System.out.println(num);
17             System.out.println(this.num);
18             //System.out.println(new Outer().num);//这个是也是可以实现的
19             System.out.println(Outer.this.num);
20         }
21     }
22 }
23 class InnerClassTest {
24     public static void main(String[] args) {
25         Outer.Inner oi = new Outer().new Inner();
26         oi.show();
27     }
28 }