Java系列文章目录

---

Write once,Runanywhere.🔥🔥🔥

💥 💥 💥如果你觉得我的文章有帮助到你，还请【关注➕点赞➕收藏】，得到你们支持就是我最大的动力!!!
💥 💥 💥

⚡版权声明：本文由【马上回来了】原创、在CSDN首发、需要转载请联系博主。
版权声明：本文为CSDN博主「马上回来了」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

🚀🚀🚀 新的知识开始喽🚀🚀🚀

---

---

1.内部类

将一个类定义在一个类或者方法的内部，前者称为内部类，后者称为外部类，内部类也是封装的一种表现。
在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为成员内部类。
内部类的分类：

1. 实例内部类
2. 静态内部类
3. 局部内部类(了解)
4. 匿名内部类

2.实例内部类

未被static修饰的成员内部类。

class OuterClass{
     public int a;
     //未被static修饰，实例成员内部类
    class InnerClass{

        }
 }
1
2
3
4
5
6
7

实例内部类的语法规则：

1. 实例内部类里可以访问外部类的成员和方法
2. 实例内部类在外部类加载时并没有加载，因此实例内部类里不能定义static方法和static成员，如果要定义static成员变量必须用final修饰。
3. 实例内部类的实例化需要通过外部类的对象来实现。
4. 当实例内部类与外部类的变量名相同时，优先访问实例内部类。如果是要访问外部类的成员变量，使用外部类类名.this.变量名(实例内部类的非静态方法中包含了一个指向外部类对象的引用)；如果是访问静态内部类，使用外部类类名.变量名。
5. 外部类中不能直接访问内部类成员，如果要访问必须要先创建内部类对象。
6. 生成的字节码文件：一个类对应一个字节码文件，内部类：外部类$内部类.class
   
   代码：

1.内部类里不能定义静态成员变量，如果要定义则需要加上final修饰
 * 2.内部类里不能定义静态方法
 * 非static的内部类，在外部类加载的时候并不会加载它，所以它里面不能有静态变量或者静态方法
 * 3.内部类实例化
 * 内部类相当于外部类的一个实例成员，依靠外部类的对象而存在
 * 所以先要有外部类的对象才能实例化内部类
 * 内部类实例化方式一：
 * OuterClass outerClass = new OuterClass();
 * OuterClass.InnerClass innerClass = outerClass.new InnerClass();
 *内部类实例化方式二：
 * OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
 *4.访问内部类与外部类同名的成员变量：外部类.this.变量名
 * 5.访问内部类与外部类同名的静态成员变量： 外部类.变量
 *
 *
 */
class OuterClass{
    private int data1 = 1;
    public int data2 = 2;
    static int data3 = 3;

    class InnerClass{
        private int data1 = 4;
        public int data5 = 5;
        public final static int data3 = 6;
        public void fun(){
            //实例内部类可以直接访问外部类的成员和方法
            System.out.println("外部类"+OuterClass.this.data1);// 实例内部类与外部类的实例变量名相同
            System.out.println(this.data1);
            System.out.println(data3);
            System.out.println("外部类"+OuterClass.data3);//实例内部类与外部类的static变量名相同
            System.out.println(data2);
            fun1();
        }

    }
    //外部类访问实例内部类的成员必须通过实例化内部类的对象来实现
    public void fun1(){
        InnerClass innerClass = new InnerClass();
        innerClass.fun();
    }
    
}
public class Test {
    public static void main(String[] args) {
        //实例内部类实例化方式1
//        OuterClass outerClass = new OuterClass();//必须通过外部类的对象引用来实现
//        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        //实例内部类实例化方式2
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        //System.out.println(innerClass.data5);
        innerClass.fun();
    }


}

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

3.静态内部类

被static修饰的内部类为静态内部类。

class OuterClass{
    public int a=1;
  //static修饰的静态成员内部类
    static class InnerClass{
    //静态内部类的成员变量
        public int d=4;
        private int e=5;
        static int f=6;
       //静态内部类的构造方法
        public InnerClass() {

        }
//静态内部类的普通方法
        public void fun(){
            System.out.println("静态内部类的方法");
            System.out.println(OuterClass.c);

        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

静态内部类注意：

1. 在实例化静态内部类时不需要依靠外部内部类的对象引用。
2. 静态内部类能直接访问外部类静态的属性和方法，不能直接访问静态内部类的非静态属性和方法，如果要访问则需要在静态内部类中创建外部类对象或者传外部类对象的引用。
3. 外部类与静态内部类的非static成员变量名相同时，如果要在静态内部类里访问外部类的成员变量，先实例化外部类，然后使用引用.变量名(static内部类与static方法一样没有this引用)；如果是外部类与静态内部类的static成员变量名相同，要在静态内部类里访问外部的变量，使用外部类名.变量
4. 外部类访问静态内部类的成员和方法也需要先在外部类当中实例化出静态内部类的对象，然后才能访问。

一段代码：

class OuterClass{
    //外部类成员属性
    public int a=1;
    private int b=2;
    //静态成员属性
    publi static int c=3;
    public void fun(){
        System.out.println("外部类方法");
    }
    static class InnerClass{
        //静态内部类里的成员变量
        public int d=4;
        private int e=5;
        static int f=6;
//静态内部类里的无参构造方法
        public InnerClass() {

        }
//静态内部类里的普通成员方法
        public void fun(){
            System.out.println("静态内部类的方法");
         //静态内部类里的成员 可以直接访问
            System.out.println(d);
            System.out.println(e);
            System.out.println(f);
            //静态内部类里可以直接访问外部类的静态成员变量
            System.out.println(OuterClass.c);
             //构造外部类对象 访问外部类的非static成员
            OuterClass outerClass = new OuterClass();
            System.out.println("外部类"+outerClass.a+" "+outerClass.b);
         
        }
        //静态内部类里的静态方法 静态方法只能直接访问静态属性和方法 对于非static的方法和属性依赖对象的引用来访问
        public static void test(){
            System.out.println(f);//访问静态内部类的静态变量
            System.out.println(OuterClass.c);//访问外部类的静态变量
            //创建外部类对象的引用 再来访问外部类的非static属性
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.a);
        }
    }

    //外部类访问静态内部类 需要实例化出静态内部类的对象
    public void fun1(){
        //实例化出静态内部类的对象
        OuterClass.InnerClass innerClass = new InnerClass();
                //访问静态内部类非静态类的成员
        System.out.println(innerClass.d);
       //访问静态内部类的静态成员和方法
        System.out.println(innerClass.f);
        innerClass.test();
    }
}
public class Test {
    public static void main(String[] args) {
        //静态内部类的实例化不需要依靠外部类对象的引用
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
        //通过静态内部类引用访问静态内部类里的成员方法
        innerClass.fun();
       //通过外部类类名.静态内部类类名的类名来访问静态内部类的静态方法
       OuterClass.InnerClass.test();
        //innerClass.test();//静态方法不推荐通过对象的引用来调用
        //创建外部类的对象引用
        OuterClass outerClass = new OuterClass();
        outerClass.fun1();
    }
}
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

传对象引用参数实现：static内部类访问外部类非static

class OuterClass{
    public int a = 10;
    static class InnerClass{
        public int a = 20;
        public int b = 20;
        public OuterClass outerClass;
//带参数的构造方法
        public InnerClass(OuterClass outerClass) {//接收外部对象引用
            this.outerClass = outerClass;//将外部的引用的值传给静态内部类的引用
        }

        public void fun(){
            System.out.println(a);
            System.out.println(outerClass.a);//通过引用访问
        }

    }
    public void test(){


    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass(new OuterClass());//实例化外部对象
        innerClass.fun();
    }
}

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

4.局部内部类

局部内部类定义在外部类的方法体或者{}中，该内部类只能在其定义的位置使用，一般使用的非常少，此处简单了解一下语法格式。
注意：

1. 局部内部类不能被public、static等访问修饰限定符修饰
2. 只能在方法体内或者{}内使用，其他位置不可使用
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
   
   4.几乎不使用

public class Test {
    //定义一个静态方法
    public static void fun(){
        //在静态方法内的一个类---》局部类
        class A{
            public int data = 10;
            public void p(){
                System.out.println(this.data);
            }
        }
        //只能在这个静态方法里面使用
        A a = new A();
        a.p();
    }

    public static void main(String[] args) {
        //静态方法不依赖于对象，直接调用
        fun();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5 匿名内部类

到后面的章节再来介绍。

6 对象的打印

看下面的代码：

class A{
    public String name = "000";
    public int num1=1;
    //自己写了一个方法来打印A类里的成员变量  当是当类的成员变量很多时，那么这样的方法是和繁琐的
    public void p(){
        System.out.println(name+" "+num1);
    }
}
public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.p();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们右击鼠标：

再看代码：

class A{
    public String name = "000";
    public int num1=1;

    @Override
    public String toString() {
        return "A{" +
                "name='" + name + '\'' +
                ", num1=" + num1 +
                '}';
    }

}
public class Test {
    public static void main(String[] args) {
        A a = new A();
        //方式1：通过ret来接收
        String ret = a.toString();
        System.out.println(ret);
        //方式2：直接打印引用
        System.out.println(a);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：

当我们没有重写toString时：

打印出来的结果是一个文件路径和一个哈希值：

因为没重写tosString时调用的是object类的toString所以打印的是哈希值：

而当我们重写了这个toString之后，就会调用我们自己写的toString，打印出被我们之前所选中的字符串。

---

🌏🌏🌏今天的你看懂这里又学到了很多东西吧🌏🌏🌏

🌔 🌔 🌔下次见喽🌔 🌔 🌔