是什么
java语言中,把一个类定义到另外一个类的内部,在类里面的这个类就叫内部类,外面的类就叫外部类。这种情况下,这个内部类可以看做外部类的一个成员。
还有一种类被称为顶层类,指的是类定义代码不嵌套在其他类定义中的类。
分类
class outerClass{
static class innerClass{} //静态内部类
}
class outerClass{
class innerClass{} //成员内部类
}
class outerClass{
public void menberFunction{
static class innerClass{} /局部内部类
}
}
public class MyFrame extends Frame{//外部类
public MyFrame(){
addWindowsLister(new WindowsAdapter()){ //匿名内部类
public void windowsClosing(WindowEvent e){
dispose(); System.exit(0);
}
}
}
}
静态内部类是指被声明为static的内部类,它可以不依赖内部类而实例化,而通常的内部类需要实例化外部类,从而实例化。静态内部类不可以有与外部类有相同的类名。不能访问外部类的普通成员变量,但是可以访问静态成员变量和静态方法(包括私有类型)
一个 静态内部类去掉static 就是成员内部类,他可以自由的引用外部类的属性和方法,无论是静态还是非静态。但是不可以有静态属性和方法、
局部内部类 就是定义在一个代码块的内类,他的作用范围是所在代码块,是内部类中最少使用的一类型。局部内部类跟局部变量一样,不能被public ,protected,private以及static修饰,只能访问方法中定义final类型的局部变量。
在使用匿名内部类时,需要牢记以下几个原则。
1》内部类没有构造方法
2》匿名内部类不能定义静态成员,方法和类
3》匿名内部类不能是public protected private static
4》只能创建匿名内部类的一个实例
5》一个匿名内部类可以在new后面,这个匿名类必须继承一个父类或实现接口
6》因为匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效
————————————————————————————————————————
例子:
内部类
package cn.itcast.demo01;
public class Outer{
private int a =1;
//在外部类成员的位置定义内部类
class Inner{
public class void fun(){
System.out.println(a); //内部类可以使用外部类的成员。
}
}
}
package cn.itcast.demo01;
public class Test{
public static void main(){
//调用外部类中的内部类的方法
Outer.Inner inn = new Outer().new Inner(); //创建内部类的对象的格式。
inn.fun(); // 1
}
class Inner{
System.out.println(a);
}
}
注意:生成两个class文件:Outer.class、Outer$Inner.class。内部类编译完了也是class文件。
内部类中同名变量的调用
//1.java
package cn.itcast.demo01;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(a); //3
}
}
}
//2.java
package cn.itcast.demo02;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(this.a); //2
}
}
}
//3.java
package cn.itcast.demo01;
public class Outer(){
private int a = 1;
class Inner(){
private int a = 2;
public void fun(){
int a = 3;
System.out.println(Ouer.this.a); //1
}
}
}
局部内部类,定义在成员方法里面
package cn.itcast.demo01;
public class Outer(){
public void out(){
class Inner{
public void fun(){
System.out.println("aaaa");
}
}
Inner inn = new Inner(); //在方法内部使用这个类。否则在main中没法使用这个类。
inn.fun();
}
}
package cn.itcast.demo01;
public class Test{
Outer o = new Outer();
o.out(); //aaaa
}
匿名内部类
//Smoking.java 正常接口使用方法
package cn.itcast.demo01;
public interface Smoking{
public abstract void smoking();
}
//Person.java
public class Person implements Smoking{
public void smoking(){
System.out.println("aaaa");
}
}
//Test.java
public class Test{
public static void main(){
Person p = new Person();
p.smoking(); //aaaa
}
}
//分析。这么写太麻烦。希望:定义实现类、重写方法、创建实现类对象一步搞定。
//Smoking.java 匿名内部类使用方法
package cn.itcast.demo01;
public interface Smoking{
public abstract void smoking();
}
//Test.java
public class Test{
public static void main(){
new Smoking(){
public void smoking(){
System.out.println("aaaa");
}
}.smoking();
}
}
//输出结果:aaaa
匿名内部类的使用举例
//Animal.java
package cn.itcast.demo01;
public interface Animal{
public abstract void eating();
public abstract void sleeping();
}
//Test.java
public class Test{
public static void main(){
Animal a = new Animal(){
public void eating(){
System.out.println("eating...");
}
public void sleeping(){
System.out.println("sleeping...");
}
};
a.eating();
a.sleeping();
}
}
参考: