内部类

内部类概念：

        是定义在类的内部的一种新的新类型，即内部类，在外部的类称为外部类
 又根据定义的类的位置以及修饰词，可以将内部类分为方法内部类，静态内部类，成员内部类以及匿名内部类

(一)方法内部类：

         概念：是定义在方法内的类：相当于局部变量，仅限于方法内使用，定义时不能使用修饰词，可以访问非静态成员变量

 //例：
public class A{   
    String name;   
    int num;public A(String name,int num){    
    this.name = name;    
    this.num = num;
    }
    public void run(){
        class B{    
        String name;    
        int age;
    public B(String name,int age){    
    this.name = name;    
    this.age = age;
    }
    public void showB(){   
    System.out.println(name+","+age+num);
    }
    B b = new ("小明",18);b.showB();
}
//调用：
    public static void main(String[] args){
    A a = new A("小红",12155217);a.run();
    }

通过这个程序,可以发现方法内部类可以使用外部类的非静态成员变量，还可以拥有自己的成员变量以及方法，在main方法里面调用A的方法时，在A方法内部的方法内部类的方法也可以执行，当内部类和外部类都有相同名字的成员变量name时，方法内部类方法输出的是方法内部类的成员变量值，还可以调用外部类非静态成员变量

但若是方法内部类使用的有参构造器，需要先在方法内部类中创建一个实例化对象，调用方法，才能在main方法的A的方法执行中执行方法内部类相应的方法，没有显示调用的方法不执行

（二）静态内部类(不常用)

概念：静态内部类是定义在外部类内的静态内部类，用static修饰，可以直接访问外部类的静态成员

如;
 

public class A{    
String name;
public A(String name){
this.name = name;
    }
public void run(){
    }static class B{
int age;public(int age){
this.age = age;
}public void showB(){
        }
    }
}

ps:

/*静态方法可以访问外部类的静态成员变量，静态内部类不可以直接访问外部类的非静态成员变量，但是可以间接访问，方法是在内部类中实例化一个外部类对象，使用变量名.name来调用*/
System.out.println(age+",");//这里直接写name系统会提示编译错误，如果把外部类的name用static修饰，就不会报错。

(3)成员内部类(常用)

概念：成员内部类是以类的成员来定义的，可以用任何修饰词来修饰

public class Mom{
    String name;
    int age;
/*可以在Mom的类中创建成员内部类的对象*/
    b = new Baby('m');//可以在Mom的方法中调用Baby的成员变量以及方法
    public Mom(String name,int age){
    this.name = name;
    this.age = age;
}
    public void sport(){
    System.out.println(name+b.toString()+b.gender);
//可以在外部类的方法中通过创建内部类对象 来调用内部类的方法和成员变量
}
    public class Baby{
    char gender;
    public Baby(char gener){
    this.gender = gender;
    }
    public void showBaby(){
    System.out.println(gender+Mom.this.name);
    //Baby类中没有定义name，此时可以省略Mom.this.    
 //默认使用，如果内部类定义了name，就要显式使用Mom.this.来区分，否则默认调用的是内部类的成员变量
        }
    }
}

在调用时，子类创建使用
Baby b = Mom.new Baby('m',1);
即：内部类类名 变量名  =  外部类类名.new. 内部类类名(有参传参); 

(4)匿名内部类(常用)

概念：没有名字，修饰词，写在方法内，用于实现接口抽象类，普通类的子类，
只使用一次，所以称之为匿名内部类

public abstract class H {
    public static void main(String[] args) {
        //测试接口的子类型
        X x = new X(){
            public void he(int a,int b){
                int c = a+b;
                System.out.println(c);
            }
            public void chengji(int c,int d) {
                int e = c*d;
                System.out.println(e);                
            }
        };
        x.chengji(8, 2);
        x.he(3,4);
    }
}
interface X{
    public void he(int a,int b);
    public void chengji(int c,int d);
}