内部类大全来了

在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类（不经常用）。

非静态内部类

1. 内部类对象依托外部类对象，有内部类对象必然有外部类对象所以内部类的方法里可以直接调用外部类的属性，非静态内部类对象单独属于外部类的某个对象。

2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。

3. 非静态内部类不能有静态方法、静态属性和静态初始化块。

4. 外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。

public class TestClass {
    public static void main(String[] args){
        Outer o=new Outer();//创建外部类对象
        o.setName("小小志 ");
        o.testOuter();
        Outer.Inter in1=new Outer().new Inter();
        //非静态内部类必须先创建外部类的对象
        in1.name="小吴";
        in1.diaoyongouter();
        in1.dothis();
}
class Outer{//外部类
    private String name="xiaowu";
    public void setName(String name) {
    //name被私有了必须添加set方法，外部才能调用
        this.name = name;
    }
    public String testOuter(){
        System.out.println(name+"outer.testOuter()");
      return name;
    }
   /* public Outer(String name){
   使用构造方法，创建内部类对象时报错了
    setName(name);
    }*/
    class Inter{//非静态内部类，就像一个成员一样放在外部类里。
        String  name;
       // static int age;报错非静态内部类中不能有静态属性和方法
        public void diaoyongouter(){
            String name="wujiaxin";
            System.out.println(Outer.this.testOuter());//调用外部类的方法
            System.out.println("外部类的成员变量名字"+Outer.this.name);//调用外部类的属性
            System.out.println("内部类的成员变量名字"+this.name);
            System.out.println("局部变量名字"+name);//局部变量name必须赋值否则报错
        }
        public Outer dothis(){
            return Outer.this;
        }
    }

静态内部类

1、用static修饰的内部类，称为静态内部类，完全属于外部类本身，不属于外部类某一个对象

2、static关键字的作用是把修饰的成员变成类相关，而不是实例相关

3、静态内部类可以包含静态成员，也可以包含非静态成员，但是在非静态内部类中不可以声明静态成员。

4、静态类内部不可以访问外部类的实例成员，只能访问外部类的类成员，即使是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员

5、外部类不可以定义为静态类，Java中静态类只有一种，那就是静态内部类，顶级类不能用static 修饰

6、外部类如何调用静态内部类中的属性和方法

1）外部类可以通过创建静态内部类实例的方法来调用静态内部类的非静态属性和方法

2）外部类可以直接通过“ 外部类.内部类.属性（方法）” 的方式直接调用静态内部类中的静态属性和方法

7、如何创建静态内部类实例

1）在非外部类中：外部类名.内部类名 name = new 外部类名.内部类名();

2）在外部类中：内部类名 name = new 内部类名();
　　　public class StaticDome01 {
private int a = 10;//实例成员
private static int b = 20;//类成员

  static class StaticClass{
        public static int c = 30;
        public int d = 40;
        //类方法
        public static void print(){
            //下面代码会报错，静态内部类不能访问外部类实例成员
            //System.out.println(a);
     
            //静态内部类只可以访问外部类类成员
            System.out.println("静态内部类的静态方法，调用外部类类成员b");
            System.out.println("外部类类成员b="+b);
            
        }
        private void Syso() {
            // TODO Auto-generated method stub

        }
        //实例方法
        public void print01(){
            //静态内部内所处的类中的方法，调用静态内部类的实例方法，属于外部类中调用静态内部类的实例方法
            System.out.println("静态内部类的实例方法，调用静态内部类的实例方法");
            StaticClass sc = new StaticClass();
            sc.print();
        }
        
    }
}
public class Text {
    public static void main(String[] args) {
        /*
         * 要想访问静态内部类的实例成员，需先创建实例对象，才可以调用，因为实例成员是属于实例的， 创建方法：外部类名.内部类名 name = new
         * 外部类名.内部类名()
         * 通过“ 外部类.内部类.属性（方法）” 的方式直接调用静态内部类中的静态属性和方法
         */
        StaticDome01.StaticClass st = new StaticDome01.StaticClass();
        //访问静态内部类的实例方法
        st.print01();
        //访问静态内部类的实例成员
        int i = st.d;
        System.out.println("非外部类调用静态内部类的实例成员d = "+i);
        //访问静态内部类的类成员
        int j = StaticDome01.StaticClass.c;
        System.out.println("非外部类调用静态内部类的类成员C = "+j);
        //访问静态内部类的类方法
        System.out.println("访问静态内部类的类方法：");
        StaticDome01.StaticClass.print();
    }
}