一、成员内部类

//成员内部类
public class Circle {

//成员内部类是最普通的内部类，它的定义位于某个类的内部
private double radius=0;
private String desc="CircleDesc";

public Circle(double radius){
this.radius =radius;
getDrawInstance().drawShape();//必须先创建成员内部类的对象，再进行访问
    }

//Circle称为外部类 Draw称为内部类 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private和静态）
class Draw{
private String desc="drawDesc";
public void drawShape(){
System.out.println(radius);
System.out.println("drawshape");

//成员内部类拥有和外部类同名的成员变量或方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员
System.out.println("内部类desc:"+desc);
System.out.println("外部类desc:"+Circle.this.desc); //若要访问外部类的同名成员
        }
    }

//外部类要访问成员内部类，必须先创建一个成员内部类的对象，再通过这个对象的引用来访问
private Draw getDrawInstance(){
return new Draw();
    }

public static void main(String[] args) {
//成员内部类是依附外部类而存在的，如果创建成员内部类的对象，前提是必须存在外部类对象
Circle circle=new Circle(1.5);
Draw draw=circle.new Draw();
    }

}


 

二、局部内部类（方法内部类）

局部内部类只能在方法内部中使用（注意理解，不能在外部类创建对象），一旦方法执行完毕，局部内部类就会从内存中删除。

必须注意：如果局部内部类中要使用它所在方法中的局部变量，那么就需要将这个局部变量定义成final

局部内部类像局部变量一样，不能被public 、protected、private以及static修饰，只能访问方法中定义为final类型的局部变量

//局部内部类
public class Outter {

public void test(){
final  int c=5;  
class Inner {
int age=0;
void show(){
System.out.println("局部内部类的方法中");
System.out.println(c); 
/*
* 若c不定义成final
成员内部类 Cannot refer to a non-final variable c inside an inner class defined in a different method
*/

       }
    }
Inner inner =new Inner();
inner.show();

  }

public static void main(String[] args) {
Outter out=new Outter();
out.test();
  }

}


三、匿名内部类

 

public abstract class Person {
public abstract void eat();


}


public class Train {

public static void main(String[] args) {
Person p=new  Person(){

public void eat() {
// TODO Auto-generated method stub
System.out.println("eat something");
      }

    };

p.eat();
  }
}
interface Person1 {
public void eat();

}

public class train1 {

public static void main(String[] args) {
Person1 p=new Person1(){

public void eat() {
// TODO Auto-generated method stub
System.out.println("eat something");
      }

    };
p.eat();
  }
}


使用匿名内部类的过程中，需要注意以下几点：

1.使用匿名内部类时，必须继承一个类或实现一个接口，但是两者不可兼得

2.匿名内部类中是不能定义构造函数的

3.匿名内部类中不能存在任何的静态成员变量和静态方法

4.匿名内部类为局部内部类（即方法内部类），所以局部内部类的所有限制同样对匿名内部类生效

5.匿名内部类不能是抽象的，它必须要实现继承的类或实现接口的所有抽象方法

四、静态内部类

public class SOuter {

private int a=99;
static int b=1;
public static class SInner{
int b=2;
public void test(){
System.out.println(b);//当内部类和外部类有相同变量时，默认是内部变量
System.out.println(SOuter.b);//想要访问外部变量，类名.静态变量
System.out.println(new SOuter().a);//静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员的方式访问
    }
  }

public static void main(String[] args) {
SInner si=new SInner();
si.test();
  }

}