内部类

一、 内部类的基本概念
1、 内部类就是在一个类的内部定义的类
2、 成员内部类格式：
Class Outer
{
Class Inner{}
}
3、编译上述代码会产生两个文件Outer.class和OuterInner.class二、在外部创建内部类对象1、内部类除了可以子啊外部类中产生实例化对象，还可以在外部类的外部来实例化2、那么根据内部类生成的∗.class文件，OuterInner.class
3、”$”在程序运行中替换成“.”
4、所以内部类的访问：通过“外部类.内部类”的方式访问
5、Outer outer = new Outer();//产生外部实例
Outer.Inner in = null;//声明内部类对象
In = outer.new Inner();//实例化内部对象
三、 方法内部类
1、 内部类可以作为一个类的成员外还可以把类放在方法内部来定义
2、 格式如下：class Outer{
Public void dosomething()
{
Class Inner();
}
}
3、 方法内部类只能在定义该类所在的方法内实例化，不可以在方法外实例化
4、 方法内部类对象不能使用该类所在的方法的非final局部变量
四、 静态内部类
1、 在一个类的内部定义一个静态内部类，该静态内部类可以向其他静态成员一样没有外部类对象时也能够访问他，静态内部类只能访问外部类的静态成员和方法
2、
五、 匿名内部类
1、 匿名内部类就是没有名字的内部类
2、 匿名内部类有三种情况：
（1） 继承式的匿名内
（2） 接口式的匿名内
（3） 参数式的匿名内
六、 内部类的作用（实现了多重继承）
1、 每个内部类都能独立的继承自一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响，如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决，从这个角度看，内部类使得多重继承的解决方案变得完整，接口解决了部分问题，而内部类实现了“多重继承”。
代码如下：
成员内部类：
/**
内部类：成员内部类
*/

class InnerClassDemo
{
public static void main(String[] args)
{
Dog d = new Dog(“花花”);
//该方法一般不用，只用于面试
Dog.ChildDog cd = d.new ChildDog();
cd.talk();
System.out.println(“—————-“);
d.ChildTalk();
}
}
class Dog
{
private String name;
public Dog(String name)
{
this.name = name;
}
public void say()
{
System.out.println(“我是一条狗，名字；叫”+name);
}
//成员内部类
class ChildDog
{
public void talk()
{
System.out.println(“我是一条狗，我妈；叫”+name);
}
}
//在外部类的内部对内部类实例化，方便调用
public void ChildTalk()
{
ChildDog child = new ChildDog();
child.talk();
}
}
方法内部类：
/**
内部类：方法内部类
*/

class InnerClassDemo
{
public static void main(String[] args)
{
Dog d = new Dog(“花花”);
d.childTalk(“小花花”);
}
}
class Dog
{
private String name;
private Child child;//child接口作为Dog的属性
public Dog(String name)
{
this.name = name;
}
public void say()
{
System.out.println(“我是一条狗狗，我主人叫我：”+name);
}
//在方法内部定义类叫：方法内部类
//方法内部类不能调用该方法内的非final修饰的局部变量
public void childTalk(final String childName)
{
final int age = 10;
class ChlidDog implements Child
{
public void talk()
{
System.out.println(“我是一条狗狗，我妈妈的名字叫：”+name);
System.out.println(“age=”+age);
System.out.println(“我是一条狗狗，我的名字叫：”+childName);
}
}
Child child = new ChlidDog();//也可以用ChildDog child = new ChildDog()
child.talk();
}
}
interface Child
{
public void talk();//抽象类
}
静态内部类：

/**
内部类：静态内部类，就相当于外部类
*/
class InnerClassDemo
{
public static void main(String[] args)
{
//方式一：
Dog.ChildDog d = new Dog.ChildDog();
d.talk();
//方式二：
Dog.chilkTalk();
}
}
class Dog
{
private String name;
public Dog(String name)
{
this.name =name;
}
public void say()
{
System.out.println(“我是一条狗狗，主任叫我：”+name);
}
//静态内部类
static class ChildDog
{
public void talk()
{
System.out.println(“我是一条狗狗”);
}
}
public static void chilkTalk()
{
ChildDog d = new ChildDog();
d.talk();
}
}
匿名内部类：
/**

内部类：匿名内部类

*/
class InnerClassDemo
{
public static void main(String[] args)
{
//一、继承式匿名内部类
Dog d1 = new Dog(“花花”){
public void say()
{
System.out.println(“我是一条母狗，主人叫我：”);
}
};
d1.say();
//二、接口式匿名内部类
Child d2 = new Child(){
public void talk()
{
System.out.println(“我是一条狗狗”);
}
};
d2.talk();
//三、参数式匿名内部类
childTalk(new Child(){
public void talk()
{
System.out.println(“我是一条狗狗”);
}

    });}public static void childTalk(Child c)    {        c.talk();    }

}
class Dog
{
String name;
public Dog(String name)
{
this.name = name;
}
public void say()
{
System.out.println(“我是一条狗狗，主人叫我：”+name);
}
}
class WomanDog extends Dog
{
public WomanDog(String name)
{
super(name);
}
public void say()
{
System.out.println(“我是一条母狗狗，主任叫我：”+name);
}
}
interface Child
{
public void talk();//抽象方法
}