内部类

1.内部类（类中类）

在一个类中定义一个类，那么把这种情况称为内部类。

内部类可以访问外部类的成员，即使外部类用private修饰（私有）；外部类想要访问内部类成员，必须同通过创建内部类对象来访问内部类的成员。

2.关于内部类的分类

成员内部类（非静态）：在外部类的成员位置

在测试类种访问成员内部类的成员方法（非静态）格式：外部类名.内部类名 对象名= 外部对象.内部对象

package org.zst.inter;  
class Outer1{  
    public int num= 100;  
    //成员内部类  
    class Inner1{  
        public void show(){  
            System.out.println(num);  
        }  
    }  
    /*public void show(){ 
        //局部内部类 
        class Inner1{ 
             
        } 
    }*/  
}  
public class InnerTest2 {  
    public static void main(String[]args){  
        //Inner1 i = new Inner1();//Inner1是一个成员内部类  
        Outer1.Inner1 oi = new Outer1().new Inner1();  
        oi.show();  
        }  
    }  

局部内部类：在外部类的局部位置

局部内部类访问局部变量 前局部变量报错,必须用final修饰;为什么用final修饰?

局部变量随着方法的调用而生成的，随着方法的调用完毕消失。局部位置有一个局部内部类要在自己的成员方法位置访问当前的局部变量必须把变量变成一个常量，需要用fianl修饰变成自定义常量，这样的一个局部变量的值永远是固定的。

3.成员内部类的修饰符: 

private :为了保证数的安全性 

    class Outer2{  
        //外部类成员变量  
        private int a = 5;  
        private int b =250;  
        //private修饰内部类，成员内部类静态化  
        private class Inner2{  
            //内部类成员方法  
            public void show(){  
                System.out.println("可以执行！");  
            }  
        }  
        //外部类成员方法  
        public void show2(){  
            if(a<b){  
                Inner2 i = new Inner2();  
                i.show();  
            }  
        }  
    }  
    //测试类  
    public class InnerTest3 {  
        public static void main(String [] args){  
            Outer2 o = new Outer2();  
            o.show2();  
            System.out.println("此次运行合理！");  
        }  
}

如果成员内部类没有被private修饰，创建对象应该是 外部类名.内部类名  对象名 =外部类对象.内部类对象，被private修饰之后不能使用这种方法，可以直接创建外部类对象调用。

static修饰:为了方便调用 

如果成员内部类被static修饰,那么要访问外部类的成员变量,这个变量必须被static修饰 

对于静态的成员内部类来说,无论静态成员内部类中的成员方法是静态还是非静态的,要访问外部类的成员变量,该变量必须被static修饰

* 静态的成员内部类访问该类中的成员方法:  外部类名.内部类名 对象名 = new 外部类名.内部类名() ; 

*或者外部类名.内部类名.变量或方法名。 

class Outer3{  
    public int a = 100;  
    public static int b = 520;  
    //静态内部类  
    public static class Inner3{  
        //内部类中非静态的成员方法  
        public void show(){  
            //System.out.println(a);内部类被static修饰再访问外部类的成员变量会报错，要访问外部类的成员变量，外部类的成员变量也必须被static修饰，静态只能调用静态的方法。  
              System.out.println(b);  
        }  
        //内部类中静态的成员方法  
        public static void show2(){  
            //System.out.println(a);a变量没有被static修饰，报错，无论内部类的成员方法是静态还是非静态，访问外部类的变量都必须被static修饰  
            System.out.println(b);  
        }  
          
    }  
}  
public class InnerTest4 {  
    public static void main(String [] args){  
        //需求：访问静态内部类中的非静态方法和静态方法  
        //外部类名.内部类名 对象名= 外部对象.内部对象  
        //Outer3.Inner3 oi = new Outer3().new Inner3(); //格式错误  
        //正确格式   外部类名.内部类名 对象名 = new 外部类名.内部类名() ;   
        Outer3.Inner3 oi = new Outer3.Inner3();  
        oi.show();  
        oi.show2();  
        System.out.println("-----------");  
        //对于静态的成员方法还有另一种访问方式  
        Outer3.Inner3.show2();  
          
    }  
  
}

4.匿名内部类

内部类的简化格式

前提条件：必须在一个接口或者是一个类（可以是具体类也可以是抽象类）

格式：

   new  接口名或者类名（）{

               方法重写

}