Java基础之内部类

什么是内部类？为什么要使用内部类？

 内部类是指在类的内部可以定义另一个类。内部类可以申明成public或private，其访问权限和成员变量和成员方法完全相同。
额外补充：
访问控制符的权限

	private	default	proteced	public
同一类	✅	✅	✅	✅
同一包中的类	❌	✅	✅	✅
不同包中的子类	❌	❌	✅	✅
其他包中的类	❌	❌	❌	✅

 使用内部类的主要原因：

• 内部类方法可以访问该类定义所在作用域中的数据，包括私有的数据。
• 内部类可以对同一包中的其他类隐藏起来。
• 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。

 内部类的定义格式

public class OuterAndInner {
private String name;
private int age;
public class innerClass{
private String grade;
private String classes;
}
}

 内部类可以直接访问外部类的元素，但是外部类不可以直接访问内部类的元素。

package outerAndInner;

public class OuterAndInner {

    private String name;
    private int age;
    
    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }

    public OuterAndInner(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public class innerClass{
        private String doSomeThing;
        
        public String getDoSomeThing() {
            return doSomeThing;
        }

        public innerClass(String doSomeThing) {
            super();
            this.doSomeThing = doSomeThing;
        }
        public void setDoSomeThing(String doSomeThing) {
            this.doSomeThing = doSomeThing;
        }
        
        public void infor() {
            System.out.println("我的名字是 "+ name +",  今年 "+age +",现在正在 "+doSomeThing);
        }
        
    }
    
    
    public static void main(String[] args) {
        OuterAndInner outerAndInner = new OuterAndInner("琪琪", 18);
        OuterAndInner.innerClass innerClass = outerAndInner.new innerClass("参加高考");//调用内部类中的方法
        innerClass.infor();
        
    }

}

 通过以上的示例可以看出内部类可以直接访问外部类属性，尽管外部类属性是用private修饰的。

内部类的特殊语法规则
OutClass.this:表示外围类的引用
outObject.new InnerClass(××)；内部对象构造器
OutClass.InnerClass:引用内部类。

四种内部类

1）静态内部类

• 必须以static关键字修饰
• 用static修饰的内部类不能访问非static修饰的外部类的成员变量和方法。
• 不能直接实例化内部类，要通过外部类来实例化内部类:
  OuterClass.innerClass inter = new outerClass.innerClass();
• 静态内部类中可以定义静态或者非静态的成员
  e.g.

package outerAndInner;

public class StaticOuter {
    private static String name = "岳岳";
    private int age;

    
    public void getInfo() {
        staticInnerClass innerClass = new staticInnerClass(); 
        innerClass.staticInner("参加面试");//调用静态内部类中的方法
    }
    
    
    /**静态内部类*/
    public static class staticInnerClass{
        public static void staticInner(String donthing) {
            System.out.println(name +"现在正在" + donthing);
            
        }
    }
    
    public static void main(String[] args) {
        StaticOuter outer = new StaticOuter();
        outer.getInfo();
                
    }

}

 由以上例子可以得出：今天内部类中不能调用非静态的外部成员变量或方法。当然也可以在方法中第一内部类的，这里例子就省略了。

2）成员内部类

 成员内部类中不能定义静态变量和方法，但是可以访问外部类中的所有成员。如果外部类想要访问内部类中的成员和方法，可以通过实例化来实现。
e.g.

package outerAndInner;

public class MemberOuter {
    
    private String name ;
    private static int age;
    
    public void outerMethod() {
        System.out.println("(⊙v⊙)，这个是外部方法");
    }
    
    
    public class MemberInner{
        public void innerMethod() {
            name = "琪琪";
            age = 23;//直接使用外部成员变量
            System.out.println("内部输出： "+name+" , 今年 "+age +"岁");
            outerMethod();//直接使用外部成员方法。
        }
    }
    
    public static void main(String[] args) {
        MemberOuter memberOuter = new MemberOuter();
        MemberOuter.MemberInner memberInner = memberOuter.new MemberInner();//实例化访问内部类的方法
        memberInner.innerMethod();
    }
    

}

3）局部内部类

 如果一个内部类只在一个方法中使用到了，那么我们可以将这个类定义在方法内部，这种内部类被称为局部内部类。其作用域仅限于该方法。
 注意:
 1) 局部内类不允许public ,private ,protected 访问权限修饰符进行申明。
 2)局部内部类对外部世界可以完全地隐藏起来。
 3)局部内部类不仅可以访问包含它们的外部类，还可以访问用final申明的局部变量，但是不可定义静态变量。
e.g.

package outerAndInner;

public class LocalOuter {
    private String name;
    private int age;
    
    public void OuterClass(){
        System.out.println("这是一个外部方法");

        class LocalInner{
            String address = "成都市双流区";
            public void InnerClass(final String donthings) {
                System.out.println("这是一个在外部方法中定义的一个局部内部类");
                name = "琪琪";
                age = 23;//直接使用外部成员变量
                System.out.println("内部输出： "+name+" , 今年 "+age +"岁,现在在 "+address+","+donthings);
                System.out.println(this.address);//用"this.变量名" 访问内部类变量
                System.out.println(LocalOuter.this.name);//用外部"外部类类名.this.变量名" 访问外部类变量
            }
        }
        
        LocalInner localInner = new LocalInner();
        localInner.InnerClass("正在码代码");
        
    }
    
    
    
    public static void main(String[] args) {
        LocalOuter localOuter = new LocalOuter();
        localOuter.OuterClass();
    }

}

运行结果:

这是一个外部方法
这是一个在外部方法中定义的一个局部内部类
内部输出： 琪琪 , 今年 23岁,现在在 成都市双流区,正在码代码
成都市双流区
琪琪

4）匿名内部类

 1) 匿名内部类是没有访问修饰符的。
 2) 必须继承一个抽象类或者实现一个接口
 3) 匿名内部类中不能存在任何静态成员或方法,因为匿名内部类属于局部内部类，所以局部内部类的所有限制都对匿名内部类有效。
 4) 匿名内部类是没有构造方法的，因为它没有类名。
e.g.

package outerAndInner;

public class AnonymousOuter {
    
      public InnerClass getInnerClass(final int age,String name){
//        继承一个抽象类或者实现一个接口
          return new InnerClass() {
            @Override
             public String getinfo(){
                return name + ",今年"+age +"岁";
            }
        };
       }
      
      public static void main(String[] args) {
          AnonymousOuter anonymousOuter = new AnonymousOuter();
          InnerClass innerClass = anonymousOuter.getInnerClass(23, "琪琪");
                  
          System.out.println(innerClass.getinfo());
          
    }
    
}

    //申明一个接口
    interface InnerClass {
        String getinfo();
    }

---

    总结不到位的地方，请各位多多指教