JavaSE：内部类

目录

内部类

1.实例内部类 

2 静态内部类 

3.局部内部类

对象的打印 

代码汇总 ： 

---

 

内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现 

class OutClass {
    class InnerClass{
    }
}
// OutClass是外部类
// InnerClass是内部类

【注意事项】
1. 定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

class A{

}

class B{

}
// A 和 B是两个独立的类，彼此之前没有关系

2. 内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件(一个类生成一个字节码文件)

 

内部类：

1.实例内部类

2.静态内部类

3.本地内部类（了解即可）

4.匿名内部类（学完接口才能够知道）

在与人交流时说到内部类时，带上前缀！！！更专业

public class OutClass {
    // 成员位置定义：未被static修饰 --->实例内部类
    public class InnerClass1{
    }

    // 成员位置定义：被static修饰 ---> 静态内部类
    static class InnerClass2{
    }

    public void method(){
// 方法中也可以定义内部类 ---> 局部内部类：几乎不用
        class InnerClass5{
        }
    }
}

根据内部类定义的位置不同，一般可以分为以下几种形式：
1. 成员内部类(普通内部类：未static修饰的成员内部类 和 静态内部类：被static修饰的成员内部类)
2. 局部内部类(不谈修饰符)、匿名内部类

1.实例内部类 

即未被static修饰的成员内部类 ：

class OuterClass {
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;

    /*
     *实例内部类
     *1.实例内部类中不能定义静态的成员变量
     *  如果定义这个静态成员需要被Final定义:public final static int date6
     *2.实例内部类当中不能定义静态的成员方法
     * 
     *3.如何实例化，实例化内部类
     *         外部类类名.内部类       变量       = 外部类引用.new 内部类();
     *         OuterClass.InnerClass innerClass = out.new InnerClass();
     */
    class InnerClass{
        public int date4 = 4;
        public int date5 = 5;
        //public static int date6 = 6;error

        public InnerClass(){
            System.out.println("实例内部类的构造方法！");
        }

        public void innerFunc(){
            System.out.println(date1);
            System.out.println(date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println("实例内部类的普通方法！");
        }
        //不能
        //public static void staticFunc(){
        //   error
        //}
    }
}

public class Test {

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //先要有外部类的对象，通过外部类的对象来调用
        OuterClass.InnerClass innerClass = out.new InnerClass();
        innerClass.innerFunc();
    }
}

当外部类和内部类中定义了相同的变量时：

是就近访问的，但是我们可以通过其他方法来调用外部类中的date1的

如何访问实例内部类和外部类同名的变量 
* 外部类类目.this.变量 
* 实例内部类当中包含了外部类的this

System.out.println("外部类的"+OuterClass.this.date1);

如果是同名的静态的：通过外部类类目去拿到

System.out.println("外部类的"+OuterClass.date1);

*实例内部类
*1.实例内部类中不能定义静态的成员变量
*  如果定义这个静态成员需要被Final定义:public final static int date6
*2.实例内部类当中不能定义静态的成员方法
*
*3.如何实例化，实例化内部类
*         外部类类名.内部类       变量       = 外部类引用.new 内部类();
*         OuterClass.InnerClass innerClass = out.new InnerClass();
*4.如何访问实例内部类和外部类同名的变量
* 外部类类目.this.变量
* 实例内部类当中包含了外部类的this
*
*5.如果是同名的静态的：通过外部类类目去拿到

【注意事项】
1. 外部类中的任何成员都可以被在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问

OuterClass.this.date1
4. 实例内部类对象必须在先有外部类对象前提下才能创建:

OuterClass.InnerClass innerClass = out.new InnerClass();
5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

class OuterClass {
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;

    
    class InnerClass{
        public int date1 = 11111;
        public int date3 = 333333;
        public int date5 = 5;
        //public static int date6 = 6;error

        public InnerClass(){
            System.out.println("实例内部类的构造方法！");
        }

        
    }
    public void func2(){
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.date1);
    }
}

2 静态内部类 

class OuterClass{
        public int date1 = 1;
        private int date2 = 2;
        public static int date3 = 3;
        /*
         *静态内部类
         * 1.如何拿到所对应的静态内部类的对象呢？
         * 外部类.内部类            变量       = new 外部类.内部类()
         * OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
         * 2.不能再内部类当中直接访问外部类非静态的数据成员
         */
        static class InnerClass{//不依赖于外部类对象
            public int date4 = 4;
            private int date5 = 5;
            public static int date6 = 6;
            private OuterClass outerClass;//2-->

            public InnerClass(OuterClass outerClass){//2-->在这里作为参数后在在上面提供一个OuterClass outerClass成员
                System.out.println("静态内部类的构造方法！");
                this.outerClass = outerClass;
            }
            public void test(){
                //无法总结调用外部类对象
                //System.out.println(date1);   error
                //1-->new一个外部类对象，再调用外部类成员;OuterClass outerClass = new OuterClass();

                //只要给一个外部类引用就可以了
                System.out.println(outerClass.date1);
                System.out.println(outerClass.date2);

                System.out.println(date3);
                System.out.println(date4);
                System.out.println(date5);
                System.out.println(date6);

                System.out.println("test方法执行了！");
            }
        }
    }



    public class Test {
        public static void main(String[] args) {
            OuterClass.InnerClass innerClass = new OuterClass.InnerClass(new OuterClass());
            innerClass.test();
        }
    }

/*
 *静态内部类
 * 1.如何拿到所对应的静态内部类的对象呢？
 * 外部类.内部类            变量       = new 外部类.内部类()
 * OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
 * 2.不能再内部类当中直接访问外部类非静态的数据成员
 */

【注意事项】
1. 在静态内部类中只能访问外部类中的静态成员
2. 创建静态内部类对象时，不需要先创建外部类对象

3.局部内部类

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

public class OutClass {
    int a = 10;
    public void method(){
        int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
// 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
    }
}

 【注意事项】
1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class
4. 几乎不会使用

对象的打印 

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    public void show(String name,String gender,int age){
        System.out.println("name:"+name+" gender:"+gender+" age:"+age);
    }
    public static void main(String[] args) {
        Person person = new Person("wenwen","男", 18);
        person.show("wenwen","男", 18);
    }
}

 

 

如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

                        

  当我们自己重新实现了这个toSring方法之后，编译器就会第哦啊用我自己实现的这个toString方法

 

代码汇总 ： 

 

class OuterClass {
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;
    /*
     /* *实例内部类
*1.实例内部类中不能定义静态的成员变量
*  如果定义这个静态成员需要被Final定义:public final static int date6
*2.实例内部类当中不能定义静态的成员方法
*
*3.如何实例化，实例化内部类
*   外部类类名.内部类       变量       = 外部类引用.new 内部类();
*   OuterClass.InnerClass innerClass = out.new InnerClass();
*4.如何访问实例内部类和外部类同名的变量
* 外部类类目.this.变量
* 实例内部类当中包含了外部类的this
*
*5.如果是同名的静态的：通过外部类类目去拿到*/


    class InnerClass {
        public int date1 = 11111;
        public int date3 = 333333;
        public int date5 = 5;
        //public static int date6 = 6;error

        public InnerClass() {
            System.out.println("实例内部类的构造方法！");
        }

        public void innerFunc() {
            System.out.println(date1);
            System.out.println("外部类:"+OuterClass.this.date1);
            System.out.println(date2);
            System.out.println(date3);
            System.out.println("外部类:" + OuterClass.date3);
            System.out.println(date5);

        }
    }
    public void func2() {
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.date1);
    }
}

public class Test {

    public static void main(String[] args) {
        OuterClass out = new OuterClass();
        //先要有外部类的对象，通过外部类的对象来调用
        OuterClass.InnerClass innerClass = out.new InnerClass();
        innerClass.innerFunc();
    }
}

-------------------------------------------------------------------------------------------------------------------------

 class OuterClass{
        public int date1 = 1;
        private int date2 = 2;
        public static int date3 = 3;
        
         *静态内部类
         * 1.如何拿到所对应的静态内部类的对象呢？
         * 外部类.内部类            变量       = new 外部类.内部类()
         * OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
         * 2.不能再内部类当中直接访问外部类非静态的数据成员
         
        static class InnerClass{//不依赖于外部类对象
            public int date4 = 4;
            private int date5 = 5;
            public static int date6 = 6;
            private OuterClass outerClass;//2-->

            public InnerClass(OuterClass outerClass){//2-->在这里作为参数后在在上面提供一个OuterClass outerClass成员
                System.out.println("静态内部类的构造方法！");
                this.outerClass = outerClass;
            }
            public void test(){
                //无法总结调用外部类对象
                //System.out.println(date1);   error
                //1-->new一个外部类对象，再调用外部类成员;OuterClass outerClass = new OuterClass();

                //只要给一个外部类引用就可以了
                System.out.println(outerClass.date1);
                System.out.println(outerClass.date2);

                System.out.println(date3);
                System.out.println(date4);
                System.out.println(date5);
                System.out.println(date6);

                System.out.println("test方法执行了！");
            }
        }
    }



    public class Test {
        public static void main(String[] args) {
            OuterClass.InnerClass innerClass = new OuterClass.InnerClass(new OuterClass());
            innerClass.test();
        }
    }

-------------------------------------------------------------------------------------------------------------------------

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    @Override
    public String toString() {
        return "名字:"+name+"  性别:"+gender+"  年龄:"+age;
        /*"Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';*/
    }

    /* public void show(String name,String gender,int age){
            System.out.println("name:"+name+" gender:"+gender+" age:"+age);
        }*/
    public static void main(String[] args) {
        Person person = new Person("wenwen","男", 18);
        //person.show("wenwen","男", 18);
        System.out.println(person.toString());
    }
}