Inner class

来源：互联网发布：修改telnet端口编辑：程序博客网时间：2024/06/06 00:22

1.用外围类创建内部类对象时，此内部类对象会秘密的捕获一个指向外围类的引用，于是，可以通过这个引用来访问外围类的成员。

2. 内部类中得到当前外围类对象的引用，可以使用.this关键字

3.create Inner class Object:

public class First {
public class Contents{
public void f(){
System.out.println("In Class First's inner Class Contents method f()");
}
public void getStr(){
System.out.println("First.str="+str);
}
}
public static void main(String [] args){
First first = new First();
First.Contents contents = first.new Contents(); //创建内部类对象
contents.f();
}
}

必须通过外围类First的对象first来创建一个内部类的对象
而且需要注意的是，在创建外围类对象之前，不可能创建内部类的对象

4.内部类在接口中的应用

public interface Shape {
public void paint();
}
public class Painter {
private class InnerShape implements Shape{
public void paint(){
System.out.println("painter paint() method");
}
}
public Shape getShape(){
return new InnerShape();
}
public static void main(String []args){
Painter painter = new Painter();
Shape shape = painter. getShape();
shape.paint();
}
}

5.匿名内部类

public class Painter {
ublic Shape getShape(){
return new Shape(){
public void paint(){
System.out.println("painter paint() method");
}
};
public static void main(String [] args){
Painter painter = new Painter();
Shape shape = painter.getShape();
shape.paint();
}
}
public interface Shape {
ublic void paint();
}

public class B {
public A getA(final int num){
return new A(num){
public int getNum(){
return num;
}
};
}
}
public class A {
private int num;
public A(int num){
this.num = num;
}
public A(){
}
}
//可以为A的构造方法传入一个参数。在匿名内部类中，并没有使用到这个参数。
如果使用到了这个参数，那么这个参数就必须是final的。

6.嵌套类

static的内部类就叫做嵌套类
前面提到了很多次，嵌套类是个例外
使用嵌套类时有两点需要注意：
a、创建嵌套类对象时，不需要外围类
b、在嵌套类中，不能像普通内部类一样访问外围类的非static成员

public class StaticClass {
private int num;
private static int sum = 2;
private static class StaticInnerClass{
public int getNum(){
//只能访问sum，不能访问num
return sum;
}
}
}
public class Test {
public static void main(String [] args){
//可以直接通过new来创建嵌套类对象
StaticClass.StaticInnerClass inner = new StaticClass.StaticInnerClass();
inner.getNum();
}
}

9、为何要内部类？
a、内部类提供了某种进入外围类的窗户。
b、也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外围类是否已经继承了某个接口。
因此，内部类使多重继承的解决方案变得更加完整。
在项目中，需要多重继承，如果是两个接口，那么好办，接口支持多重继承。
如果是两个类呢？这时只有使用内部类了。

public interface One {
public void inOne();
}
public interface Two {
public void inTwo();
}
//两个接口，用普通类就可实现多重继承
public class CommonClass implements One,Two {
public void inOne(){
System.out.println("CommonClass inOne() method");
}
public void inTwo(){
System.out.println("CommonClass inTwo() method");
}
}
public abstract class Three {
public abstract void inThree();
}
public abstract class Four {
public abstract void inFour();
}
//两个抽象类，使用普通类无法实现多重继承
//使用内部类可以实现
public class Contents extends Three {
public void inThree(){
System.out.println("In Contents inThress() method");
}
public class InnerFour extends Four{
public void inFour(){
System.out.println("In Contents");
}
}
}

0 0