内部类

内部类的作用

每个内部类都能独立的继承自一个类（接口）的实现，所以无论外部类是否已经继承了某个类（接口），对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的抽象的类的能力，一些设计与编程问题就恨难解决。从这个角度来看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”，重点就是间接实现了“多重继承”。

缺点：

内部类破话了类原有的结构（成员变量+方法），并且使得代码读起来特别复杂。

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）匿名内部类为局部的，所以局部内部类的所有限制都对其生效