java中的内部类

本文主要讲述java中的内部类

　　老韩介绍

vip

局部内部类：

vip

　　局部类示例代码如下：

 1 public class LocalInnerClass {
 2     public static void main(String[] args) {
 3         Outer02 outer02 = new Outer02();
 4         outer02.OuterWork();
 5         System.out.println("LocalInnerClass中的Outer对象: "+outer02);
 6     }
 7 
 8 }
 9 class Outer02{
10     // 1.可以直接访问外部类的所有成员,包括私有的
11     private int age = 10;
12 
13     private void happy(){
14         System.out.println("Outer的private void happy()");
15     }
16     // 3.作用域，只能在定义内部类的方法体或者代码块中。
17     public void OuterWork(){
18         // 2.不能添加访问修饰符,能添加final关键字
19         final class Inner02 {
20             private int age = 11;
21             public void InnerWork(){
22                 // 7.外部类和内部类的成员变量名称相同，默认就近原则，如果想访问外部类的成员，可以用外部类名.this.外部类成员名
23                 System.out.println("Inner02的age: "+age+" Outer02的age: "+Outer02.this.age);
24                 // 验证outer对象与Outer02.this是否是同一个对象
25                 System.out.println("Outer调用OuterWork()的对象: " + Outer02.this);
26                 // 4.局部内部类直接访问外部类的属性和方法
27                 happy();
28             }
29         }
30         // 5.外部类访问内部类属性，方法，需要创建内部类对象。
31         Inner02 inner02 = new Inner02();
32         inner02.InnerWork();
33     }
34 }

　　运行结果如下：

vip

　　不难看出，Outer02.this与outer对象是同一个对象，因此可以调用Outer的age属性。

匿名内部类

vip

　　（1）基于接口的匿名内部类的使用，示例代码如下：

 1 public class AnonymousInnerClass {
 2     public static void main(String[] args) {
 3 //        new Tiger().cry();
 4         new Outer03().method();
 5 //        new Outer03$1();
 6     }
 7 }
 8 class Outer03 {
 9     private int n1 = 10;
10     public void method(){
11 
12         // 接口的多态
13         // tiger的编译类型是A，运行类型是匿名内部类
14         /*
15             // 匿名内部类的类名是系统分配的
16             class Outer03$1 implements A {
17                 @Override
18                 public void cry() {
19                     System.out.println("老虎叫唤");
20                 }
21             }
22             //类创建完成后，立马创建该类的对象，将对象的地址赋给tiger.
23             A tiger = new Outer03$1();
24          */
25         A tiger = new A(){
26             @Override
27             public void cry() {
28                 System.out.println("老虎叫唤");
29             }
30         };
31         System.out.println("tiger的运行类型: "+tiger.getClass());
32         tiger.cry();
33 
34     }
35 }
36 
37 interface A {
38     public void cry();
39 }
40 
41 // 传统实现接口的方法
42 //class Tiger implements A{
43 //    @Override
44 //    public void cry() {
45 //        System.out.println("老虎叫唤");
46 //    }
47 //}

　　运行结果如下：

vip

　　（2）基于类的匿名内部类的使用，示例代码如下：

 1 public class AnonymousInnerClass {
 2     public static void main(String[] args) {
 3 //        new Tiger().cry();
 4         new Outer03().method();
 5 //        new Outer03$1();
 6     }
 7 }
 8 class Outer03 {
 9     private int n1 = 10;
10     public void method(){
11 
12         // 不加大括号，表示对象
13         Father jack = new Father("jack");
14         // 基于类的匿名内部类
15         // tom的编译类型是Father，运行类型是Outer03$2
16         /*
17             class Outer03$2 extends Father{
18                 @Override
19                 public void test() {
20                     System.out.println("类的匿名内部类的test()");
21                 }
22             }
23             Father tom = new Outer03$2();
24          */
25         Father tom = new Father("tom"){
26             @Override
27             public void test() {
28                 System.out.println("类的匿名内部类的test()");
29             }
30         };
31         tom.test();// 动态绑定机制
32         System.out.println("tom的运行类型: "+tom.getClass());
33 
34     }
35 }
36 
37 class Father {
38     public Father(String name){
39 
40     }
41 
42     public void test(){
43         System.out.println("Father的test()");
44 
45     }
46 }

　　运行结果如下：

vip

　　（3）基于抽象类的匿名内部类，示例代码如下：

 1 public class AnonymousInnerClass {
 2     public static void main(String[] args) {
 3 //        new Tiger().cry();
 4         new Outer03().method();
 5 //        new Outer03$1();
 6     }
 7 }
 8 class Outer03 {
 9     private int n1 = 10;
10     public void method(){
11 
12         // 基于抽象类的匿名内部类
13         /*
14             class Outer03$3 extends Animal{
15                 @Override
16                 public void eat() {
17                     System.out.println("抽象类的匿名内部类的eat()");
18                 }
19             }
20             Animal animal = new Outer03$3();
21          */
22         Animal animal = new Animal(){
23             @Override
24             public void eat() {
25                 System.out.println("抽象类的匿名内部类的eat()");
26             }
27         };
28         animal.eat();
29         System.out.println("animal的运行类型: "+animal.getClass());
30     }
31 }
32 
33 abstract class Animal {
34     // 抽象类中的抽象方法需要用abstract指明
35     public abstract void eat();
36 }

　　运行结果如下：

vip

　　综合示例代码【考察动态绑定，匿名内部类】

 1 public class AnonymousInnerClassDetail02 {
 2     public static void main(String[] args) {
 3         Person p = new Person();
 4         p.work();
 5         System.out.println("调用work的Person类: "+p);
 6     }
 7 
 8 }
 9 class Dog {
10     // 动态绑定机制
11     private int n1 = setN1();
12     public void walk(String name){
13         System.out.println(name+"狗在跑");
14     }
15 
16     // 返回n1的值
17     public int getN1() {
18         return n1;
19     }
20 
21     // 设置n1的值，验证方法的动态绑定机制
22     public int setN1() {
23         return 11;
24     }
25 
26     // 验证方法的动态绑定机制
27     public void say(){
28         System.out.println("the dog is very happy");
29     }
30 }
31 class Person {
32     private int n1 = 10;
33 
34     public void work(){
35         // Person的匿名内部类的n1只能作用于该类的内部，无法在外部访问。
36         /*
37             class Person$1 extends Dog{
38                 private int n1 = 12;
39                 @Override
40                 public void walk(String name) {
41                     super.walk(name);
42                 }
43             }
44             Dog dog = new Person$1();
45             dog.getN1();
46          */
47         // dog的编译类型是Dog，运行类型是匿名内部类Person$1
48         // 调用方法，有动态绑定机制，属性的话，就近原则。
49         Dog dog = new Dog(){
50             private int n1 = 12;
51             @Override
52             public void walk(String name) {
53                 super.walk(name);
54                 // 访问外部类的成员变量，外部类名.this.属性名
55                 System.out.println("Person的年龄是: "+ Person.this.n1);
56                 System.out.println("调用walk的Person类: "+Person.this);
57             }
58 
59             @Override
60             public void say() {
61                 System.out.println("the Person is very happy");
62             }
63 
64             @Override
65             public int setN1() {
66                 return 9;
67             }
68 
69 //            @Override
70 //            public int getN1() {
71 //                return n1;
72 //            }
73         };
74         dog.walk("大白");
75         dog.say(); // 动态绑定机制
76         System.out.println("匿名内部类中的n1是: "+ dog.getN1());
77     }
78 }

　　请自行验证输出结果。

成员内部类

vip

　　成员内部类，示例代码如下：

 1 public class MemberInnerClass {
 2     public static void main(String[] args) {
 3         Person tom = new Person("Tom", 18);
 4         /**
 5          * 非外部类使用成员内部类的对象，方式：
 6          * 1.外部类对象.new 内部类构造器();
 7          * 2.外部类返回内部类对象的方法
 8          */
 9         Person.Dog dog = tom.new Dog("大h", 20);
10         tom.walk(dog);
11 
12     }
13 }
14 
15 class Person {
16     private String name;
17     private int age;
18 
19     public Person(String name, int age) {
20         this.name = name;
21         this.age = age;
22     }
23 
24     public class Dog {
25         private String name = "大白";
26         private int age = 5;
27 
28         public Dog(String name, int age) {
29             this.name = name;
30             this.age = age;
31         }
32 
33         public void run(){
34             System.out.println(name+"狗，在跑,它的主人是: "+Person.this.name);
35         }
36     }
37 
38     public void walk(Dog dog){
39         System.out.println("主人: "+name+"在遛狗,狗的名字: "+dog.name);
40         dog.run();
41     }
42     
43     public Dog dog(){
44         return new Dog("大b",5);
45     }
46 }

　　运行结果如下：

vip

静态内部类

vip

　　静态内部类示例代码如下：

public class StaticInnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.createInner();
        /**
         * 非外部类使用静态内部类对象
         * 方式 1：new 外部类.静态内部类的构造器
         * 方式 2：外部类.返回静态内部类对象的普通方法
         * 方式 3：外部类，返回静态内部类对象的静态方法
         */
        Outer.Inner inner1 = new Outer.Inner();
        inner1.showOuter();

        Outer.Inner inner2 = outer.getInner();
        inner2.showOuter();

        Outer.Inner inner3 = Outer.getInner_();
        inner3.showOuter();


    }
}

class Outer {
    private String name;
    private static int age = 20;

    private static void hello(){
        System.out.println("Outer的hello()");
    }

    // 静态内部类，只能访问父类的所有静态成员
    static class Inner {
        private int age = 10;

        public void showOuter(){
            System.out.println(Outer.age);
            hello();
        }
    }

    public void createInner(){
        Inner inner = new Inner();
        inner.showOuter();
    }

    // 普通方法，既能访问非静态成员，又能访问静态成员
    public Inner getInner(){
        Inner inner = new Inner();
        return inner;
    }

    // 静态方法只能访问静态成员
    public static Inner getInner_(){
        Inner inner = new Inner();
        return inner;
    }
}

posted @ 2022-12-21 11:13 zwGitOne 阅读(130) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

zwgitOne123

java中的内部类

公告