内部类

内部类的作用
每个内部类都能独立的继承自一个类（接口）的实现，所以无论外部类是否已经继承了某个类（接口），对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的抽象的类的能力，一些设计与编程问题就恨难解决。从这个角度来看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”，重点就是间接实现了“多重继承”。
缺点：
内部类破话了类原有的结构（成员变量+方法），并且使得代码读起来特别复杂。

1 在一个类中定义一个类
代码如下

public class Inner {
    public static void main(String[] args) {
        A a =new A();
        //内部类的声明   方法1
        A.B b=null;
        b=a.new B();
        //内部类的申明 方法2 调用一个方法，在方法中对内部类进行声明
        a.desc();
        a.class_diaoyong();

    }

}
class A {
    public void desc(){
        System.out.println("AAAAAAAAAAAAA");
    }
    class B {
        public void desc2(){
        System.out.println("BBBBBBBBBB");}
    }
    public void class_diaoyong(){
        B b =new B();
        b.desc2();
    }
}

2 方法内部类
内部类可以作为一个类的成员外，还可以把类放在方法内定义。
注意：
（1） 方法内部类只能在定义该内部类的方法实例化，不可以在此方法外对其实例化

具体代码如下

public class inner_class {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        A1 a1 =new A1();
        a1.inner_class();
    }
}
class A1{
    String name;
    //定义一个方法，在方法中定义一个方法内部类
     public void inner_class(){
        class B{
            public void desc(){
                System.out.println("BBBBBBBBBBB");
            }
        }   
        //方法内部类只能在该内部类的方法内实例化，不可以在次方法外对其实例化
        new B().desc();
    }
}

（2） 方法内部类对象不能使用该内部类所在方法的非final局部变量,
就是在方法内部类中，假如方法定义的成员变量不是final的，该内部类不能访问，要访问的话必须定义为final，另外内部类所在的方法假如有参数，内部类如果要调用这个参数的话，必须把方法的参数定义为final.

//假如方法有参数，必须定义为final
 public void inner_class2(final String s){
            class B{
                public void desc(){
                    System.out.println("BBBBBBBBBBB"+s);
                }
            }   
            //方法内部类只能在该内部类的方法内实例化，不可以在次方法外对其实例化
            new B().desc();
        }
}

3 静态内部类
在一个类内部定义一个静态内部类：
静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能访问它。静态嵌套类仅能访问外部类的静态成员和方法。

代码如下

public class static_inner {

    public static void main(String[] args) {
        //因为加了static关键字，那么内部类的声明直接就是外部类加上静态类的名称 
        StaticInnerClass.class1 c1 =new StaticInnerClass.class1();
        c1.desc();
        //假如内部类前面加了privae关键字，那么在类中定义一个方法，在方法中对内部类进行声明       
        StaticInnerClass c2 =new StaticInnerClass();
        c2.diaoyong();
    }
}
class StaticInnerClass{
    private String name;
    static class class1{
        public void desc(){
            System.out.println("静态内部类的方法");
        }
    }
    private static class class2{
        public void desc(){
            System.out.println("静态内部类的方法");
        }
    }
    public void diaoyong(){
        class2 c2 =new class2();
        c2.desc();
    }
}

总结一下 static 关键字
1）static关键字可以修饰变量
2）static关键字可以修饰方法
3）static关键字可以修饰类，这个类必须是内部类

4 匿名内部类
匿名内部类就是没有名字的内部类。
匿名内部类的三种情况：
（1）继承式的匿名内部类
（2）接口式的匿名内部类
（3）参数式的匿名内部类

继承式的匿名内部类代码如下：

public class annoy_class{

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //1 继承式匿名内部类
        annoy1 a =new annoy1(){
        public  void desc1(){
            System.out.println("我是属于继承的匿名内部类");
        }
        };
        a.desc1();
        //2 接口式匿名内部类
        Child child =new Child() {          
            @Override
            public void talk() {
                // TODO Auto-generated method stub
                System.out.println("我的名字叫马忠义");
            }
        };
        child.talk();
    }
}
class annoy1{ 
    String s =null;
    public  void desc1(){
        System.out.println("父类的方法");
    }
    class annoy2 extends annoy1{
        public void desc1(){
            System.out.println("子类的方法");
        }
    }
}
interface Child{
    public void talk();
}

在使用匿名内部类时，要注意以下几个原则：
（1）不能有构造方法，只能有一个实例。
（2）不能定义任何静态成员、静态方法。
（3）不能是public,protected,private,static.
（4）一定是在new的后面，用其隐含实现一个借口或者实现一个类
（5）匿名内部类为局部的，所以局部内部类的所有限制都对其生效