内部类（三）

内部类（三） 内部类 成员内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。（其本质就是类的一个成员）

可以直接访问外部类的所有成员，包含私有的。可以添加任意访问修饰符（public、proctected、默认、private），因为他的地位就是一个成员。作用域和外部类的其他成员一样，为整个类体。成员内部类访问外部类（如：属性）[访问方式：直接访问]。外部类访问成员内部类[访问方式：创建对象，再访问]。外部其他类访问成员内部类。

//外部其他类使用成员内部类的两种方法
  Outer08 outer08 = new Outer08();
//方法一
  Outer08.Inner08 inner08 = outer08.new Inner08();
//方法二
  Outer08.Inner08 inner08Instance = outer08.getInner08Instance();

如果外部类和成员内部类重名时，内部类访问的话，默认就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）去访问。

例：

package com.z.innerclass;

public class MemberInnerClass {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();

        //外部其他类使用成员内部类的两种方法
        //方法一
        Outer08.Inner08 inner08 = outer08.new Inner08();
        //方法二
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
    }
}
class Outer08{
    private int n1 = 2;
    public String name = "张三";

    private void hi(){
        System.out.println("hi()方法...");
    }

    public class Inner08{
        private double sal = 1.1;
        public void say(){
            System.out.println("n1 = " + n1 + " name = " + name);
            hi();
        }
    }
    public Inner08 getInner08Instance(){
        return new Inner08();
    }
    public void t1(){
        //使用成员内部类
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }

}

输出

n1 = 2 name = 张三
hi()方法...
1.1

静态内部类的使用

说明：成员内部类是定义在外部类的成员位置，并且有static修饰。

可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员。可以添加任意访问修饰符（public、proctected、默认、private），因为他的地位就是一个成员。作用域：同其他成员一样，为整个类体。静态内部类访问外部类（如：静态属性）[访问方式：直接访问所有静态成员]。外部类访问静态内部类[访问方式：创建对象，再访问]。外部其他类访问静态内部类

//外部其他类访问静态内部类
        //方法一
        //因为静态内部类，是可以通过类名直接访问（前提是满足访问权限）
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        //方法二
        //编写一个方法，可以返回静态内部类的实例化对象
        Outer10 outer10 = new Outer10();
        Outer10.Inner10 inner101 = outer10.getInner10();//getInner10()为非静态方法

        Outer10.Inner10 inner10_ = Outer10.getInner10_();//getInner_()为静态方法
        

如果外部类和静态内部类重名时，内部类访问的话，默认就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）去访问。

package com.z.innerclass;

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
        //外部其他类访问静态内部类
        //方法一
        //因为静态内部类，是可以通过类名直接访问（前提是满足访问权限）
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方法二
        //编写一个方法，可以返回静态内部类的实例化对象
        Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("==============");
        inner101.say();

        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("------------");
        inner10_.say();
    }
}
class Outer10{
    private int n1 = 10;
    private static String name = "张三";
    private static void cry(){}
    public static class Inner10{
        public void say(){
            //System.out.println(n1);  错误
            System.out.println(name);
            cry();
        }
    }
    public Inner10 getInner10(){
        return new Inner10();
    }
    public static Inner10 getInner10_(){
        return new Inner10();
    }
    public void m1(){
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
}

输出：

张三
张三
==============
张三
------------
张三