一般情况下,类和类之间是相互独立的关系,内部类的意思是打破这种独立,让一个类成为另外一个类的内部成员,和成员变量、成员方法同等级别。
内部类的种类:
1.1 非静态内部类 非静态内部类的使用,就是将内部类作为外部类的一个成员变量/成员方法来使用。所以必须依赖于外部类的对象才能调用,用法和成员变量/成员方法一致的。
package test;
public class OuterClass {
//成员变量
private String outerName;
//成员方法
public void display() {
System.out.println("OuterClass display");
System.out.println(outerName);
}
//内部类
public class InnerClass {
private String innerName;
public void display() {
System.out.println("InnerClass dispaly");
System.out.println(innerName);
}
public InnerClass() {
this.innerName = "inner class";
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
// 错误的 不是一个独立的类,依赖于outerclass
// InnerClass innerClass = new InnerClass();
//非静态内部类的操作
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.display();
//
}
}
####### 为什么需要内部类呢????????
采用内部类这种技术,可以隐藏细节和内部结构,封装性更好,让程序的结构更加合理。
隐藏细节
1.2.局部内部类 基本的内部类还可以在一个方法体中定义
public class OuterClass {
//成员变量
private String outerName;
//成员方法
public void display() {
class InnerClass{
public void print(){
System.out.println("method inner class");
}
}
InnerClass innerClass = new InnerClass();
innerClass.print();
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
}
}
2. 静态内部类
静态内部类的构造不需要依赖外部类对象,类中的所有静态组件都不需要依赖于任何对象,可以直接通过类本身进行构造。
public class OuterClass {
//成员变量
private String outerName;
//成员方法
public void display() {
System.out.println("outerclass display");
System.out.println(outerName);
}
public static class InnerClass{
private String innerName;
public InnerClass(){
innerName = "inner class";
}
public void display(){
System.out.println("innerclass display");
System.out.println(innerName);
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
OuterClass.InnerClass innerClass = new InnerClass();
innerClass.display();
}
}
outerclass display
null
innerclass display
inner class
3.匿名内部类 (主要应用于接口的实现)
public class Test {
public static void main(String[] args) {
//实现类
MyImplement myImplement = new MyImplement();
myImplement.test();
//匿名内部类
MyInterface myInterface = new MyInterface() {
@Override
public void test() {
System.out.println("test");
}
};
myInterface.test();
}
}
每个内部类都能够独立的继承自一个(接口)的实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类并没有影响。更多的是内部类对多重继承的实现,使多重继承得到了保障,或者说更加便利。
(1)内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外围类对象的信息相互独立。
(2)在单个外围类当中,可以让多个内部类以不同的方式实现同一接口。
(3)创建内部类对象的时刻并不依赖于外围类对象的创建。
(4)内部类没有让人感到迷惑的“is-a”关系;它就是一个独立的实体。