Java面向对象(基础编)：内部类

内部类
一．内部类的基本定义
在类内部可以定义方法和成员变量，而且在类内部也可以定义另一个类。

如果在类Outer 的内部再定义7一个类Inner，此时列Inner就称为内部类，而类Outer则称为外部类。

内部类可声明成public或private。

当内部类声明成public或private时，对其访问的权限与成员变量和成员方法完全相同。

格式如下：
标识符class外部类的名称{
//外部类的成员
标识符class内部类的名称{
//内部类的成员
}
}
【定义内部类】
class Outer
{
private String info="hello world！！";
class Inner
{
public void print(){
System.out.println(info);
}
};
public void fun(){
new Inner().print();
}
};
public class InnerClassDemo01
{
public static void main(String args[]){
new Outer().fun();
}
}
运行结果：
hello world！！
从程序运行结果中可以清楚地发现，Inner类作为Outer类的内部类存在，并且在外部类的fun()方法之中直接实例化内部类的对象并调用方法print()，但是从以上代码中可以明显地发现，内部类的存在实际上已经破坏了一个类的基本结构，因为类是由属性及方法组成的，所以这是内部类的一个缺点，那么内部类有什么优点呢？如果现在把内部类拿到外面，就能发现其优点。

代码如下：
【将内部类拿到外部】
class Outer
{
private String info="hello World!!!";
public String getInfo(){
return ;
}
public void fun(){
new Inner(this).print();
}
}
class Inner
{
private Outer out=null;
public Inner(Outer out){
this.out=out;
}
public void print(){
System.out.println(out.getInfo());
}
};
public class InnerClassDemo02
{
public static void main(String args[]){
new Outer().fun();
}
}
运行结果：
hello World!!!
以上程序完成了与内部类同样的功能，但是代码明显比之前的更加复杂，所以内部类的唯一好处就是可以方便地访问外部类中的私有属性。

二．使用static定义内部类
使用static声明的内部类就变成了外部类，但是用static声明的内部类不能访问非static 的外部类属性。

【使用static声明内部类】
class Outer
{
private static String info="hello World!";
static class Inner
{
public void print(){
System.out.println(info);
}
};
};
public class InnerClassDemo03
{
public static void main(String args[]){
newOuter.Inner().print();
}
}
运行结果：
hello World!
以上程序将info属性定义成为static类型，这样程序中就可以通过static声明的内部类直接访问此static属性。

三．在外部访问内部类
一个内部类除了可以通过外部类访问，也可以直接在其他类中进行调用，调用的基本格式为：
外部类.内部类内部类对象=外部类实例.new内部类();
以上的操作格式中，首先要找到外部类的实例化对象之后，才可以通过外部类的实例化对象去实例化内部类的对象。

注意：在内部类定义之后，生成的class文件是以Outer$Inner.class的形式存在的，在Java中只要在文件中存在$，则在程序中应将其替换为“.”。

【在外部访问内部类】
class Outer{
private String info="hello world!!";
class Inner
{
public void print(){
System.out.println(info);
}
};
};
public class InnerClassDemo04
{
public static void main(String args[]){
Outer out=new Outer(); //实例化外部类对象
Outer.Inner in=out.new Inner(); //实例化内部类对象
in.print(); //调用内部类的方法
}
}
运行结果：
hello world!!
四．在方法中定义内部类
也可以在方法中定义一个内部类，但是在方法中定义的内部类不能直接访问方法中的参数，如果方法中的参数要想被内部类访问，中无参数前面必须加上final关键字。

【在方法中定义内部类】
class Outer{ // 定义外部类
private String info = "hello world" ; // 定义外部类的私有属性
public void fun(final int temp){ // 定义外部类的方法
class Inner{ // 在方法中定义的内部类
public void print(){ // 定义内部类的方法
System.out.println("类中的属性：" + info) ; // 直接访问外部类的私有属性
System.out.println("方法中的参数：" + temp) ;
}
};
new Inner().print() ; // 通过内部类的实例化对象调用方法}
};
public class InnerClassDemo05{
public static void main(String args[]){
new Outer().fun(30) ; // 调用外部类的方法
}
};
运行结果;
类中的属性：hello world
方法中的参数：30。