内部类与静态内部类区别及举例_静态内部类和内部类的区别

1.内部类与静态内部类的区别

1. 静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中的变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。 但是可以直接访问静态变量，调用静态的方法。

2. 普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。

3. 如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。

4. 如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个内部类的对象作为一个属性，外部类可以通过属性调用普通内部类的方法或者访问普通内部类的属性。

5. 如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。

2.举例说明

2.1 内部类

public class Father {
    private String name;
   
    public Father(String name) {
        this.name = name;
    }

    public void say(String dogName) {
         Dog dog = new Dog(dogName);
        System.out.println("i am " + name + ", i have a dog " + dog.dogName);
    }
    
    public void feed() {
        System.out.println("feed in Father");
    }
    
    public  class Dog {
        private String dogName;

        public Dog(String dogName) {
            this.dogName = dogName;
        }

        public void bark() {
            feed();
            System.out.println("i am " + dogName + ", i am belong to " + name);
        }
        public String getDogName() {
            return dogName;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

对于第2条，普通内部类作为成员，可以直接访问外部类的变量，调用其方法。可以看到Dog内中的bark()方法可以直接使用变量name，可以调用feed方法。

对于第3条，我们在Father类中，想要使用Dog类中的属性dogName，必须先实例化一个dog对象，然后通过该对象调用方法，获取变量。

对于第4条，那先创建一个外部类

public class YYTest {
    
    public static void main(String[] args)  {
        final Father zhangsan = new Father("zhangsan");
        Father.Dog gg = zhangsan.new Dog("GG");
        gg.getDogName();
        gg.bark();
    }
}
1
2
3
4
5
6
7
8
9

可以看到，通过对象zhangsan.new Dog()方法实例化一个内部类对象gg，通过该内部类对象可以访问变量，调用方法。

2.2 静态内部类

public class Father {
    private String name;
   private static String sex = "female";
    public Father(String name) {
        this.name = name;
    }

    public void say(String dogName) {
         Dog dog = new Dog(dogName);
        System.out.println("i am " + name + ", i have a dog " + dog.dogName);
    }
    
    public void feed() {
        System.out.println("feed in Father");
    }
    
    public static class Dog {
        private String dogName;

        public Dog(String dogName) {
            this.dogName = dogName;
        }

        public void bark() {
            Father lisi = new Father("lisi");
            lisi.feed();
            System.out.println("i am " + dogName + ", i am belong to " + lisi.name + ", his sex is " + sex);
        }

        public String getDogName() {
            return dogName;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

对于第1点，可以看到bark()方法中想要使用name属性，需要先实例化Father对象，通过对象调用。而访问静态变量则不需要通过实例化对象，可以直接访问。

对于第1点

public class YYTest {
    
    public static void main(String[] args)  {
        Father.Dog hh = new Father.Dog("HH");
        hh.bark();
    }
}
1
2
3
4
5
6
7

直接实例化静态内部类即可。注意实例化方法即可。
静态类只能是内部的。