Java面向对象编程（内部类）

0.内部类

描述：

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。是类的第五大成员,内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系.

分类：

如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类

定义在成员位置 (1) 成员内部类 (2) 静态内部类

1.局部内部类

说明:

局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。
1.可以直接访问外部类的所有成员,包含私有的
2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用
修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类---访问---->外部类的成员[访问方式:直接访问]5.外部类---访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)
6.外部其他类---不能访问----->局部内部类（因为局部内部类地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

class Outer02{
    private int n1 = 800;
    public void m2(){
        System.out.println("外部类的m2方法");
    }
    public void m1(){
        class Inner02{//不能使用访问修饰符，但可以使用Final来阻止别的类来继承
            private int n1 = 300;
            public void f1(){
                Outer02.this.n1 = n1;//Outer02.this---->指向外部类的对象
                System.out.println(n1);
                m2();
                System.out.println(Outer02.this);
            }//可以访问外部类的所有成员，包括private;
        }//局部内部类
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
    {
        class Inner02{//局部内部类作用域在 仅仅在方法或者代码块中

        }
    }
}

2.匿名内部类

描述：

(1)本质是类(2)内部类(3)该类没有名字(4)同时还是一个对象
说明:匿名内部类是定义在外部类
的局部位置，比如方法中，并且没有类名

说明：

1.匿名内部类的基本语法
new类或接口(参数列表){
    类体
}
2.匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义,
同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点,因此可以调用匿名内部类方法。
3.可以直接访问外部类的所有成员,包含私有的[案例演示]4、不能添加访问修饰符,因为它的地位就是一个局部变量。
5.作用域:仅仅在定义它的方法或代码块中。
6.匿名内部类---访问---->外部类成员[访问方式:直接访问]
7.外部其他类---不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)
8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 o = new Outer05();
        o.f1();
    }
}

class Outer05{
    private int n1 = 99;
    public void f1(){
        Person person = new Person(){
            @Override
            public void hi() {
                System.out.println("匿名类 hi()");;
            }
        };person.hi();//动态绑定
        new Person(){//匿名对象继承Person类
            @Override
            public void hi(){
                n1 = 800;
                Outer05.this.n1 = n1;
                System.out.println(n1);
                super.hi();
                System.out.println("匿名内部类.hi()");
            }
        }.hi();
    }
}

class Person{
    public void hi(){
        System.out.println("Person hi()");
    }
}

3.成员内部类

描述：

成员内部类是定义在外部类的成员位置,并且没有static修饰。

说明：

1.可以直接访问外部类的所有成员，包含私有的
2.可以添加任意访问修饰符(public、protected、默认、private),因为它就是一个成员。
3.作用域 MemberlnnerClass01.java和外部类的其他成员一样,为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象,再调用方法.
4.成员内部类---访问---->外部类成员(比如属性)[访问方式:直接访问]
5.外部类---访问------>成员内部类(说明)访问方式:创建对象，再访问
6.外部其他类---访问---->成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
 

public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        System.out.println("====================");
        //外部访问成员内部类的方式
        //01
        Outer08.Inner08 inner08 =  outer08.new Inner08();
        //02写一个方法返回Inner08
        Outer08.Inner08 inner08_1 = outer08.getInner08();
        inner08_1.say();
    }
}

class Outer08{
    //属性
    private int n = 100;
    private String name = "张三";
    //成员内部类
    class Inner08{//public ,默认 ,protectde , private ,
        private double n1 = 959595.2;
        public void say(){
            System.out.println("n =" + n + "\tname =" + name);
        }
    }
    public void t1(){
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.n1);
    }
    public Inner08 getInner08(){
        Inner08 inner08 = new Inner08();
        return inner08;
    }
}

4.静态内部类

描述：

静态内部类是定义在外部类的成员位置,并且有static修饰

说明：

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2.可以添加任意访问修饰符(public.protected、默认、private),因为它的地位就是一个成员。
3.作用域:同其他的成员，为整个类体
4.静态内部类---访问---->外部类(比如:静态属性)[访问方式:直接访问所有静态成员]
5．外部类---访问------>静态内部类访问方式:创建对象，再访问
6．外部其他类---访问----->静态内部类
7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近
原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

class Outer10{
    static private int n = 10;
    static private String name = "李四";
    static public void hi(){
        System.out.println("外部类方法");
    }
    //Inner10 就是静态内部类 
    // 1. 放在外部类的成员位置 
    // 2. 使用 static 修饰 
    // 3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员 
    // 4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员 
    // 5. 作用域 ：同其他的成员，为整个类体
    public static class Inner10{
        private int n = 100;
        public void say(){
            Outer10.n = n;
            System.out.println("静态内部类  我叫" + name + Outer10.n);
        }
    }
    public Inner10 getInner10(){
        Inner10 inner10 = new Inner10();
        return inner10;
    }
    static Inner10 getInner10_(){
        Inner10 inner10 = new Inner10();
        return inner10;
    }
}