内部类的应用

1.什么事内部类?

答:一个类在另一个类的成员位置或者局部位置上，这个类就叫做另一个类的内部类。

 *当内部类在成员位置上，就可以被成员修饰符所修饰。
 * 比如：private :将内部类在外部类中进行封装。
 * static：内部类就具备了static的特性,只能访问外部类中的static成员。
//外部类
class Outer3{
//内部类，并且私有化内部类。
private   class   Inner3{

}
}

2.什么时候使用内部类？

答：当描述一个事物时，事物中还有事物时，内部事物要使用外部事物，外部事务使用内部事物，使用内部类。

3.内部类与外部类的访问规则

***********

a.内部类访问外部类的规则：

内部类可以直接访问外部类中的成员，包括私有,。
    内部类之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类.this:

class Outer3{
private int  x=3;
class Inner3{
private int  x=5;
void show()
{
int x=8;
//内部类直接调用外部类对象
//当内部类中没有同名成员变量和局部变量时,等效于System.out.println(Outer3.this.x);
//当内部类中存在同名局部变量时，此时调用的是局部变量，否则调用同名内部成员变量

System.out.println(x);

//指定调用内部类的成员变量

System.out.println(this.x);

//指定调用外部类的成员变量
System.out.println(Outer3.this.x);



}
}
}

********************

*******************

b.外部类访问内部类的规则：

外部类要访问内部类必须先建立内部类对象；当内部类定义在外部类的成员位置上，而且私有，可以在外部其他类中建立内部类对象。

public class InnerLianXi {
public static void main(String args[])
{
/*格式：
*外部类名.内部类名. 变量名=外部类对象.内部类对象；
*/
Outer3.Inner3 inn  = new Outer3().new Inner3();
inn.show();
}
}

   c.注意：当内部类中定义了静态成员，该内部类必须是static的。
     当外部类中的静态方法访问内部类时，内部类必须是静态的。

*//外部类直接访问静态内部类成员
//new Outer.Inner().function();
//外部类直接访问静态内部类静态成员
Outer.Inner.function();

4.匿名内部类：

匿名内部类其实就是（子类）内部类的简写格式。该内部类一定是某个类的子类或者实现了某个接口。

//定义一个父类
abstract class Father
{
void fun(){}
}

//定义一个外部类
class OuterSon
{
/*直接定义子类内部类调用内部类的成员
class Son extends Father{
void fun(){System.out.println("132");};
}
public void show()
{
Son son=new Son();
son.fun();
}*/
//使用匿名内部类调用内部类成员
public void show()
{
new Father() {

void fun() {
System.out.println(213);
}
}.fun();//此处等同于Son son=new Son();son.fun();

}

}
public class InnerLianXi2 {
public static void main(String args[])
{

new OuterSon().show();//调用外部类的show方法。
}
}

5.实现接口的匿名内部类：

a.直接定义内部类对象：

//定义一个car接口

interface car
{
void  fun();  
}

//定义内部类

class OuterClass
{
/*直接定义Txcar类实现接口car
class Txcar implements car {
public  void fun(){System.out.println("fun run");}

}

}

public class InnerLianXi3 {
public static void main(String args[])
{

//定义内部类对象，并调用fun方法。
OuterClass.Txcar t=new OuterClass().new Txcar();
t.fun();
}
}

b.使用匿名内部类，在外部类定义car类型的方法返回内部类对象。

interface car
{
void  fun();  
}


class OuterClass
{

//定义functio方法返回一个匿名内部类对象
  car function()
  {
 return new car() {


public void fun() {
System.out.println("fun run...");
}
};
  }
}


public class InnerLianXi3 {
public static void main(String args[])
{

//定义一个匿名内部类对象
OuterClass o=new OuterClass();
//用function返回的对象调用fun方法
o.function().fun();
}

}

c.直接在主函数里传递匿名内部类对象

interface car
{
void  fun();  
}
class OuterClass
{
}


public class InnerLianXi3 {
public static void main(String args[])
{
//在show方法中调用匿名内部类对象
show(new car() {


public void fun() {

System.out.println("run ...");
}
});
}

//定义一个方法传递接收匿名内部类对象
public static void show(car c)
{
c.fun();
}

}