内部类

1.内部类的基本定义结构

2.使用static定义内部类

3.在方法中定义内部类

从开发的角度内部类能少用就少用

一. 概念：在一个类的下面有另一个类。

class Outer{
    private String msg = "Hello word" ;
    class Inner{       //定义一个内部类
         public void print(){
            System.out.println(msg) ; 
         }
    }
    public void fun () {
        new Inner() . print() ;
    }
}
public class Test{
    public static void main(String args[]){
        Outer out = new Outer() ;
       out.fun() ; 
    }
}

 最大的感受：结构上不是很合理。

从类的结构本身是属性与方法组成，可是一个类里面定义一个类，结构不是很合理。

一个很重要的目的，将这个类拿到外面去实现一个一样的功能。

class Outer{
    private String msg = "Hello word" ;
    public String getmsg(){
        return this.msg ;
    }
    public void fun(){
        new Inner ().print() ;
    }
}   
class Inner{
    public void print(){
        System.out.println(new Outer().getmsg()) ;
    }
}
public class Test{
    public static void main(String args[]){
       Outer out = new Outer();
       out.fun();
    }
}

此时产生了两个Outer对象，所以想将第一个实例化对象传过去。

class Outer{
    private String msg = "Hello word" ;
    public String getmsg(){
        return this.msg ;
    }
    public void fun(Outer out){
        new Inner (out).print() ;
    }
}   
class Inner{
    public Outer out ;
    public Inner(Outer out){
        this.out = out ;
    }
    public void print(){
        System.out.println(new Outer().getmsg()) ;
    }
}
public class Test{
    public static void main(String args[]){
       Outer out = new Outer(); 
       out.fun(out);
    }
}

 最终目的是内部类可以访问外部类的私有属性。。

同理外部类也可以轻松访问内部类的私有属性。

class Outer{
    private String msg = "Hello word" ;
    class Inner{
        private String info = "helo zhuopeng" ;      
    }
    public void fun(){
        Inner in = new Inner () ;
        System.out.println(in.info) ;
    }
}   
public class Test{
    public static void main(String args[]){
        Outer out = new Outer() ;
        out.fun() ;
    }
}

 以上都是用外部类的fun方法访问内部类的对象。

内部类能不能像外部对象一样直接产生实例化对象调用呢。此时发现有这么一个文件

此时可以给出内部类对象的实例化语法：：

外部类。内部类  对象  =new 外部类（）。内部类（） ；

class Outer{
    private String msg = "Hello word" ;
    class Inner{
        public void print(){
            System.out.println(Outer.this.msg);    
        }
    }
}   
public class Test{
    public static void main(String args[]){
        Outer.Inner in = new Outer().new Inner();
        in.print() ;
    
    }
}

 如果一个内部类只是希望能够被外部类访问而不希望被外部访问，则可以在前面加上private修饰

private class Inner{}；

new 外部类（） 。内部类（） ；

二。使用static定义内部类

如果一个内部类使用static定义，则这个内部类只能访问外部类的static修饰的成员变量。

class Outer{
    private String msg = "hello world" ; 
    static class Inner{
        public void print() {
            System.out.print(msg); 
        }
    }
}   
public class Test{
    public static void main(String args[]){
           
    }
}

 以上程序错误，不能编译通过。只能访问static修饰的属性

如果想要直接实例化内部类对象则语法：

外部类。内部类 对象 = new 外部类。内部类（） ；

仿佛就变成了一个独立的类。

class Outer{
    private String msg = "hello world" ; 
    static class Inner{
        public void print() {
            System.out.println("hello") ; 
        }
    }
}   
public class Test{
    public static void main(String args[]){
          Outer.Inner in = new Outer.Inner() ;
          in.print() ; 
    }
}

三。在方法中定义内部类

这个是比较常见的形式

范例：

class Outer{
    private String msg = "hello world" ; 
    public void fun(){
    
        class Inner{
            public void print(){
                System.out.println(Outer.this.msg);
            } 
        }
        new Inner().print();
    }
}   
public class Test{
    public static void main(String args[]){
        new Outer().fun() ;          
    }
}

 方法内部类也是可以访问方法的参数和方法的变量，，在JDk1.7及其之前的版本中必须要在变量和方法前面加上“final”一词；

范例：

class Outer{
    private String msg = "hello world" ; 
    public void fun(){
      final  double num = 100 ;   //final
        class Inner{
            public void print(){
                System.out.println(Outer.this.msg);
                System.out.println(num) ;
            } 
        }
        new Inner().print();
    }
}   
public class Test{
    public static void main(String args[]){
        new Outer().fun() ;          
    }
}