(1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。
(3)、静态内部类不能随便的访问外部类的成员变量了,只能访问外部类的静态成员 。
程序编译过后会产生两个.class文件,分别是Out.class和Out$In.class
其中$代表了上面程序中Out.In中的那个 .
Out.In in = new Out().new In()可以用来生成内部类的对象
1.开头的Out是为了标明需要生成的内部类对象在哪个外部类当中
2.必须先有外部类的对象才能生成内部类的对象,因为内部类的作用就是为了访问外部类中的成员变量
//外部类的非静态方法访问成员内部类( 外部类的非静态方法属于外部类的对象,即调用外部类的静态方法已经 创建过外部类的对象,)
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}
外部类的静态方法访问成员内部类,与在外部类外部访问成员内部类一样(成员内部类是外部类的成员,访问非静态成员需要外部类的对象)<-(如下:类名.outer_f4();则并未创建过外部类的对象)
public static void outer_f4(){//step1 建立外部类对象
Outer out = new Outer();
//***step2 根据外部类对象建立内部类对象***
Inner inner=out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}
内部类的基本结构
成员内部类:即作为外部类的一个成员存在,与外部类的属性、方法并列。
注意:成员内部类中不能定义静态变量,但可以访问外部类的所有成员。
非静态内部类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | //外部类 class Out { private int age = 12 ; //内部类 class In { public void print() { System.out.println(age); } } } public class Demo { public static void main(String[] args) { Out.In in = new Out(). new In(); in.print(); //或者采用下种方式访问 /* Out out = new Out(); Out.In in = out.new In(); in.print(); */ } } |
运行结果:12
内部类可以随意使用外部类的成员变量(包括私有)而不用生成外部类的对象,这也是内部类的唯一优点
非静态内部类被private修饰
lass Out { private int age = 12 ; private class In { public void print() { System.out.println(age); } } public void outPrint() { new In().print(); } } public class Demo { public static void main(String[] args) { //此方法无效 /* Out.In in = new Out().new In(); in.print(); */ Out out = new Out(); out.outPrint(); } } |
运行结果:12
如果一个内部类只希望被外部类中的方法操作,那么可以使用private声明内部类
上面的代码中,我们必须在Out类里面生成In类的对象进行操作,而无法再使用Out.In in = new Out().new In() 生成内部类的对象
也就是说,此时的内部类只有外部类可控制
变量访问形式
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | class Out { private int age = 12 ; class In { private int age = 13 ; public void print() { int age = 14 ; System.out.println( "局部变量:" + age); System.out.println( "内部类变量:" + this .age); System.out.println( "外部类变量:" + Out. this .age); } } } public class Demo { public static void main(String[] args) { Out.In in = new Out(). new In(); in.print(); } } |
运行结果:
局部变量:14
内部类变量:13
外部类变量:12
从中可以发现,内部类在没有同名成员变量和局部变量的情况下,内部类会直接访问外部类的成员变量,而无需指定Out.this.属性名
否则,内部类中的局部变量会覆盖外部类的成员变量
而访问内部类本身的成员变量可用this.属性名,访问外部类的成员变量需要使用Out.this.属性名
静态内部类 静态内部类定义在类中,任何方法外。静态内部类可以用public,protected,private修饰
注意:静态内部类中可以定义静态或者非静态的成员
静态的含义是该内部类可以像其他静态成员一样,没有外部类对象时,也能够访问它。静态嵌套类仅能访问外部类的静态成员和方法。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | class Out { private static int age = 12 ; static class In { public void print() { System.out.println(age); } } } public class Demo { public static void main(String[] args) { Out.In in = new Out.In(); in.print(); } } |
运行结果:12
可以看到,如果用static 将内部内静态化,那么内部类就只能访问外部类的静态成员变量,具有局限性
其次,因为内部类被静态化,因此Out.In可以当做一个整体看,可以直接new 出内部类的对象(通过类名访问static,生不生成外部类对象都没关系)
方法内部类: 即在方法中定义的内部类,与局部变量类似,在方法内部类前不加修饰符public或private,其范围为定义它的代码块。
注意:方法内部类中不可定义静态变量,可以访问外部类的局部变量(即方法内的变量),但是变量必须是final的。在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。要想使用局部内部类时需要生成对象,对象调用方法,在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合,用局部内部类来实现接口,并在方法中返回接口类型,使局部内部类不可见,屏蔽实现类的可见性。
在静态方法中定义的内部类也是静态嵌套类,这时候不能在类前面加static关键字,静态方法中的静态嵌套类与普通方法中的内部类的应用方式很相似,它除了可以直接访问外部类中的static的成员变量,还可以访问静态方法中的局部变量,但是,该局部变量前必须加final修饰符。
class Out { private int age = 12 ; public void Print( final int x) { class In { public void inPrint() { System.out.println(x); System.out.println(age); } } new In().inPrint(); } } public class Demo { public static void main(String[] args) { Out out = new Out(); out.Print( 3 ); } } |
运行结果:
3
12
在上面的代码中,我们将内部类移到了外部类的方法中,然后在外部类的方法中再生成一个内部类对象去调用内部类方法
如果此时我们需要往外部类的方法中传入参数,那么外部类的方法形参必须使用final定义
至于final在这里并没有特殊含义,只是一种表示形式而已
(1)、方法内部类只能在定义该内部类的方法内实例化,不可以在此方法外对其实例化。
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。
因为方法的局部变量位于栈上,只存在于该方法的生命期内。当一个方法结束,其栈结构被删除,局部变量成为历史。但是该方法结束之后,在方法内创建的内部类对象可能仍然存在于堆中!例如,如果对它的引用被传递到其他某些代码,并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长,所以内部类对象不能使用它们。
匿名内部类
顾名思义,没有名字的内部类。表面上看起来它们似乎有名字,实际那不是它们的名字。
当程序中使用匿名内部类时,在定义匿名内部类的地方往往直接创建该类的一个对象。匿名内部类的声明格式如下:
new ParentName(){
...// 内部类的定义
}
匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类?如果满足下面的一些条件,使用匿名内部类是比较合适的:一个类用于继承其他类或是实现接口,并不需要增加额外的方法,只是对继承方法的事先或是覆盖。
只用到类的一个实例 。
类在定义后马上用到。
类非常小(SUN推荐是在4行代码以下)
给类命名并不会导致你的代码更容易被理解。
在使用匿名内部类时,要记住以下几个原则:
匿名内部类不能有构造方法。
匿名内部类不能定义任何静态成员、静态方法。
匿名内部类不能是public,protected,private,static。
只能创建匿名内部类的一个实例。
一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类。
因匿名内部类为局部内部类,所以局部内部类的所有限制都对其生效。
注:一个匿名内部类一定是在new的后面,用其隐含实现一个接口或实现一个类,没有类名,根据多态,我们使用其父类名。因他是局部内部类,那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法,所以其使用范围非常的有限。当需要多个对象时使用局部内部类,因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口,那么其运行的类型为实现这个接口的类。
A、继承式的匿名内部类
public class Car { public void drive(){ System.out.println("Driving a car!"); } public static void main(String[] args) { Car car = new Car(){ public void drive() { System.out.println("Driving another car!"); } }; car.drive(); } }结果输出了:Driving another car! Car引用变量不是引用Car对象,而是Car匿名子类的对象。
B、接口式的匿名内部类。
interface Vehicle { public void drive(); } class Test{ public static void main(String[] args) { Vehicle v = new Vehicle(){ public void drive(){ System.out.println("Driving a car!"); } }; v.drive(); } }
上面的代码很怪,好像是在实例化一个接口。事实并非如此,接口式的匿名内部类是实现了一个接口的匿名类。而且只能实现一个接口。
C、参数式的匿名内部类。
class Bar{ void doStuff(Foo f){ f.foo(); } } interface Foo{ void foo(); } class Test{ static void go(){ Bar b = new Bar(); b.doStuff(new Foo(){ public void foo(){ System.out.println("foofy"); } }); } }
1.首先,把内部类作为外部类的一个特殊的成员来看待,因此它有类成员的封闭等级:private ,protected,默认(friendly),public
它有类成员的修饰符: static,final,abstract
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此,它可以访问外部类的一切资源(当然包括private)
外部类访问内部类的成员,先要取得内部类的对象,并且取决于内部类成员的封装等级。
非静态内部类不能包含任何static成员.
3.静态内部类:static inner class,不再包含外部类的this指针,并且在外部类装载时初始化.
静态内部类能包含static或非static成员.
静态内部类只能访问外部类static成员.
外部类访问静态内部类的成员,循一般类法规。对于static成员,用类名.成员即可访问,对于非static成员,只能
用对象.成员进行访问
4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。
类成员有两种static , non-static,同样内部类也有这两种
non-static 内部类的实例,必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用static 内部类的实例, 直接创建即可,没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用
non-static 内部类不允许有static成员
方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表,所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问,方法中不可以有static内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递
为什么需要内部类
典型的情况是,内部类继承自某个类或实现某个接口,内部类的代码操作创建其他外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是:
每个内部类都能独立地继承自一个(接口的)实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题就很难解决。从这个角度看,内部类使得多重继承的解决方案变得完整。接口解决了部分问题,而内部类有效地实现了"多重继承"。
内部类的优点是:内部类可以访问外部类的私有成员变量,而不需要new外部类的对象。
内部类又分为:静态内部类、匿名内部类、局部内部类、成员内部类。
静态内部类的应用场景是:只可以访问外部类的静态成员变量和静态成员方法。
成员内部类的应用场景是:它可以访问它的外部类的所有成员变量和方法,不管是静态的还是非静态的都可以。
局部内部类:像局部变量一样,不能被public, protected, private和static修饰。只能访问方法中定义的final类型的局部变量。
匿名内部类:匿名内部类就是没有名字的局部内部类,不使用关键字class, extends, implements, 没有构造方法。匿名内部类隐式地继承了一个父类或者实现了一个接口。匿名内部类使用得比较多,通常是作为一个方法参数。
- 上一篇 import和import static导包
- 下一篇 Print引用(对象)