您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

【第5章：面向对象基础】_内部类

发布时间：2020-12-13 18:24:00编辑：雪饮阅读（）

 内部类

定义在类的内部的类叫做内部类
class Outer{
       private String info="hello world";
       class Inner{
              public void print(){
                     //内部类可以访问其直属的外部类的属性
                     System.out.println(info);
              }
       }
       public void fun(){
              new Inner().print();
       }
};
public class TestJava{
       public static void main(String args[]){
              new Outer().fun();
       }
}
D:\>javac TestJava.java
 
D:\>java TestJava
hello world
通过分析代码可以发现这是两个类之间方法与属性的互相调用的一个实现。
内部类的作用
内部类的作用也就是为了更好的实现不同类之间方法与属性的互相调用。
假如不用内部类的实现则如：
class Outer{
       private String info="hello world";
       public void fun(){
              new Inner().print();
       }
       public String getInfo(){
              return this.info;
       }
};
class Inner{
       public void print(){
              System.out.println(new Outer().getInfo());
       }
};
public class TestJava{
       public static void main(String args[]){
              new Outer().fun();
       }
}
D:\>javac TestJava.java
 
D:\>java TestJava
hello world
像是这样不用内部类的情况也能实现不同类之间属性与方法的互相调用，但是你会发现这里面new关键字用的比较频繁，那么堆内存开销比较大就不言而喻了。
那么我们再来试着改良下代码：
class Outer{
       private String info="hello world";
       public void fun(){
              new Inner(this).print();
       }
       public String getInfo(){
              return this.info;
       }
};
class Inner{
       private Outer out=null;
       public Inner(Outer out){
              this.out=out;
       }
       public void print(){
              System.out.println(this.out.getInfo());
       }
};
public class TestJava{
       public static void main(String args[]){
              new Outer().fun();
       }
}
D:\>javac TestJava.java
 
D:\>java TestJava
hello world
像是这样，经过改良后new关键字的使用频率明显下降了，但是你会发现代码逻辑更复杂了，更绕圈了。
所以用内部类才是最佳实践。内部类的最大优点就是可以方便的访问外部类中的私有属性。
在外部访问内部类
class Outer{
       private String info="hello world";
       class Inner{
              public void print(){
                     System.out.println(info);
              }
       };
       public void fun(){
              new Inner().print();
       }
       public String getInfo(){
              return this.info;
       }
};
 
public class TestJava{
       public static void main(String args[]){
              new Outer().Inner().print();
       }
}
D:\>javac TestJava.java
TestJava.java:18: 找不到符号
符号： 方法 Inner()
位置： 类 Outer
                new Outer().Inner().print();
                           ^
1 错误
像是这样，直接在外部通过外部类访问内部类默认是不可行的。
要想实现外部直接访问内部类，则对于当前这个类来说要使用static关键字进行修饰，并且其直属的外部类的那个info属性也需要用static关键字修饰。另外这里要纠正下上面调用的时候new关键字后面第一个类名后面是没有括号的。那么正确做法如：
class Outer{
        private static String info="hello world";
       static class Inner{
              public void print(){
                     System.out.println(info);
              }
       };
};
 
public class TestJava{
       public static void main(String args[]){
              //这里Outer后面不要有括号
new Outer.Inner().print();
       }
}
D:\>javac TestJava.java
 
D:\>java TestJava
hello world
不使用static关键字也可以调用内部类，我称之为抽丝剥茧的形式。
class Outer{
        private String info="hello world";
        class Inner{
              public void print(){
                     System.out.println(info);
              }
       };
};
 
public class TestJava{
       public static void main(String args[]){
              Outer out=new Outer();
              Outer.Inner in=out.new Inner();
              in.print();
       }
}
D:\>javac TestJava.java
 
D:\>java TestJava
hello world
方法中的内部类
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 TestJava{
       public static void main(String args[]){
              new Outer().fun(30);
       }
}

这里需要注意的就是在方法中的内部类如果要使用该方法的形参的时候，那个该方法的这个形参就需要用final修饰符进行修饰。