第五章：面向对象基础——内部类。

本章目标

• 掌握内部类的优缺点
• 掌握内部类的使用格式
• 掌握static声明内部类的作用
• 可以使用内部类访问方法中的参数

1、具体内容

1.1、什么叫内部类

在一个类的内部还存在另外一个类，则称为内部类。

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() ;                 // 调用外部类的fun()方法
    }
};

输出结果：
hello world

以上程序中，Inner类作为Outer类的内部类存在，并且在外部类的fun()方法之中直接实例化内部类的对象并调用print()方法。
内部类存在的特点：

• 缺点：正常的一个类操作时，在类中最好只定义属性或方法，如果定义一个类的话。则肯定破坏了程序的结构
• 有点：想要发现其优点，则必须通过代码拆分来观察，将以上的内部类和外部类变为两个类的形式，再完成同样的效果。

class Outer{        // 定义外部类
    private String info = "hello world" ;   // 定义外部类的私有属性
    public void fun(){                      // 定义外部类的方法
        new Inner(this).print() ;               // 通过内部类的实例化对象调用方法
    }
    public String getInfo(){                // 增加了一个getter方法取得info内容
        return this.info ;  
    }
};
class Inner{    // 定义内部类
    private Outer out = null ;              // 声明Outer对象
    public Inner(Outer out){
        this.out = out ;
    }
    public void print(){                // 定义内部类的方法
        System.out.println(this.out.getInfo()) ;        // 直接访问外部类的私有属性
    }
};
public class InnerClassDemo02{
    public static void main(String args[]){
        new Outer().fun() ;                 // 调用外部类的fun()方法
    }
};

如果将内部类拿到外部之后，会发现代码增加了，而且复杂度也增加了。使用内部类的最大优点：可以方便访问外部类中的私有属性。
但是，以上的内部类，是无法在外部直接调用的，是无法按照外部类的形式使用的。

1.2、使用static声明内部类

如果一个内部类使用static关键字声明，则此内部类就称为外部类，可以直接通过外部类.内部了进行访问。

class Outer{        // 定义外部类
    private static String info = "hello world" ;    // 定义外部类的私有属性
    static class Inner{ // 使用static定义内部类为外部类
        public void print(){                // 定义内部类的方法
            System.o ut.println(info) ;     // 直接访问外部类的私有属性
        }
    };
    public void fun(){                      // 定义外部类的方法
        new Inner().print() ;               // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo03{
    public static void main(String args[]){
        new Outer.Inner().print() ;                 // 调用外部类的fun()方法
    }
};

输出结果：
hello world

使用static可以声明一个内部类，声明的内部类就称为外部类，可以在类的外部调用，但是如果要想访问外部类中的属性，则此属性必须是static访问权限的。

1.3、在外部访问内部类

一个内部类可以通过外部类直接访问，也可以直接在其他类中调用，但是调用的格式：

• 外部类.内部类 内部类对象 = 外部类实例.new 内部类();

class Outer{        // 定义外部类
    private String info = "hello world" ;   // 定义外部类的私有属性
    class Inner{    // 定义内部类
        public void print(){                // 定义内部类的方法
            System.out.println(info) ;      // 直接访问外部类的私有属性
        }
    };
    public void fun(){                      // 定义外部类的方法
        new Inner().print() ;               // 通过内部类的实例化对象调用方法
    }
};
public class InnerClassDemo04{
    public static void main(String args[]){
        Outer out = new Outer() ;           // 外部类实例化对象
        Outer.Inner in = out.new Inner() ;  // 实例化内部类对象
        in.print() ;                        // 调用内部类的方法
    }
};

输出结果：
hello world

1.4、在方法中定义内部类

一个内部类可以在任意的位置上定义，下面看一下在方法中定义内部类。

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

2、总结

内部类在实际的开发中非常有用处，所以一定要熟悉其语法及其优点。
在Java系统中也会到处看到使用static声明内部类的情况，一定要记住，使用static声明的内部类，是外部类，操作的时候要是用“外部类.内部类”的形式访问。