内部类

这里讨论4个主要的问题：

1，使用内部类的优缺点；

2，内部类的使用格式；

3，static声明内部类的作用；

4，使用内部类访问方法中的参数；

那么什么是内部类？
其实就是在一个类的内部，再定义一个类，这个内部所定义的类就是内部类咯；

1，内部类直接调用其外部类的private属性

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()方法
    }
};

看了这一段代码，似乎就可以得出内部类的使用的优缺点了；

内部类的特点：

缺点：正常一个类操作时，在类中最好只定义属性或方法，如果定义一个类的话，则肯定破坏了类的一个结构。
优点：可以方便的访问其外部类的私有属性，这是使用内部类的最大优点。

内部类是无法在外面，像外部类一样直接使用的，比如看下面代码：

**直接在外部访问内部类，是不允许的。

class Outer{        // 定义外部类
    // 定义外部类的私有属性
    private String info = "hello world" ;

    class Inner{    // 定义内部类
        public void print(){    
            System.out.println(info) ;
        }
    };

    public void fun(){      
        new Inner().print() ;   
    }
};

public class InnerClassDemo03{
    public static void main(String args[]){
        // 调用外部类的fun()方法
        new Outer.Inner().print() ;                 

    }
};

这样的代码运行就会报错：

这表示，这个内部类不能再外部被访问。那如果一定要在外部访问这个内部类该怎么做呢？

其实也是有处理办法的，可以将这个内部类使用static修饰—->如果一个内部类使用了static修饰，则这个内部类就称为外部类，可以直接同通过—《外部类.内部类》的形式进行调用。

2-1：使用static修饰内部类，实现在外部调用内部类：

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

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

上面的代码new Outer.Inner().print() ;是通过将内部类声明为static的才实现了在外部调用内部类，如果不使用static修饰，能再外部调用内部类么？必然是可以的。调用格式“外部类.内部类 内部类对象=外部类实例.new 内部类（）；”

2-2：不使用static修饰内部类，在外部调用这个内部类

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

3，方法中定义内部类，内部类访问方法中的参数，该参数需要声明为final的。

一个内部类可以声明在类的任何位置，当一个内部类声明在方法中时候，如果内部类想要访问方法中的参数，那么该参数需要声明为final的。

class Outer{        // 定义外部类
    private String info = "hello world" ;   // 定义外部类的私有属性
    public void fun(int temp){
    //public void fun(final int temp){      
        // 定义外部类的方法
        // 在方法中定义的内部类
            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) ;   // 调用外部类的方法
    }
};

只需要将这个int temp使用final修饰就好了。

总结：

0，内部类可以直接访问外部类的私有属性。

1，内部类不可以直接在外面被访问，如果外面想要访问可以有两种方式：1，将这个内部类使用static修饰，使用static修饰的内部类称为外部类，在外面访问的时候可以使用new 外部类.内部类的的形式进行调用；

2，如果不想使用static修饰，可以通过 外部类.内部类 内部类对象=外部类实例.new 内部类（）这样的形式进行访问。

3，内部类可以声明在类的任何位置，当内部类声明在方法中，内部类要访问方法中的参数的时候，该方法的参数需要使用final修饰。

内部类使用总结。