内部类的定义及使用

内部类的基本概念

内部类指的是一个类的内部进行其他类嵌套的操作语法形式。理论上就跟盗墓空间一样，一层层进行类的嵌套形式

范例：内部类的基本使用

class Outer{//定义一个外部类
 private String msg="Hello World!";
 //*********************
 class Inter{//此时定义了一个内部类
  public void print(){//定义一个普通方法
   System.out.println(msg);
  }
 }
 //*********************
 //在外部类中定义一个方法，这个方法负责产生内部类的对象和调用print();方法
 public void fun(){
  Inter in=new Inter();//内部类的对象
  in.print();//内部类提供的print()方法
 }
}
public class Newbegin{
 public static void main(String args[]) {
  Outer out=new Outer();//外部类对象
  out.fun();//外部类方法
 }
}

程序结构有点混乱！虽然内部类破坏了程序结构从整体上来讲不好，但从另一个方面来说

内部类的优点在于外部类的私有访问

范例：将以上程序的内部类提取到外部，要求实现同样的功能

class Outer{
 private String msg="Hello World!";
 public String getMsg(){//通过此方法才可以取得msg的内容
  return this.msg;
 }
 public void fun(){//3.现在由out对象调用了fun()方法
  Inter in=new Inter(this); //4.this表示当前对象，
  in.print();//7.调用方法
 }
}
class Inter{
 private Outer outer;
 public Inter(Outer outer){//5.Inter.out=main.out;
  this.outer=outer; //6.引用传递
 }
 public void print(){//8.执行此方法
  System.out.println(this.out.getMsg());
 }
}
public class OuterDemo{
 public static void main(String args[]){
  Outer out=new Outer();//1.实例化Outer
  out.fun();//2.调用Outer类方法
 }
}

对内部类的操作

1.通过以上代码可以发现，当前的内部类的访问必须通过外部类的方法才可以完成，如果不想通过

外部类的方法调用，那么就必须按照如下形容进行创建：

语法：外部类.内部类 内部类对象=new 外部类().new 内部类（）;　

class Outer{//定义一个外部类
 private String msg="Hello World!";
 class Inner{//此时定义了一个内部类
  public void print(){//定义一个普通方法
   System.out.println(msg);
  }
 }
}
public class Newbegin{
 public static void main(String args[]) {
  //声明内部类对象
  Outer.Inner in=new Outer().new Inner();
  in.print();
 }
}

1.因为外部类中有属性，这些属性只能实例化才能调用，

2.如果一个内部类只想被外部类使用，即：不希望直接产生内部类的实例化对象，那么可以使用private定义

class Outer{//定义一个外部类
 private String msg="Hello World!";
 private class Inner{//此时定义了一个内部类
  public void print(){//定义一个普通方法
   System.out.println(msg);
  }
 }
 public void fun(){
  Inner in=new Inner(); 
  in.print();
 }
}
public class Newbegin{
 public static void main(String args[]) {
  //声明内部类对象
  new Outer().fun(); 
 }
}

3.在进行属性访问时要加上this. 如果想要在内部类明确的使用this

就要外部类.this.属性表示外部类当前对象的属性

public void print(){//定义一个普通方法
   System.out.println(Outer.this.msg);
 }

static定义内部类

 内部类中如果使用了static进行定义，那么就表示其就是一个外部类的形式，

这个外部类的名称就是“外部类.内部类”。同时该内部类只允许访问外部类中的static 操作， 

范例：使用static定义内部类

class Outer{//定义一个外部类
 private static String msg="Hello World!";
 static class Inner{//内部类=“外部类”
  public void print(){
   //此时只能够使用外部类中的static操作
   System.out.println(msg); 
  }
 }
}
public class Newbegin{
 public static void main(String args[]) {
  Outer.Inner in=new Outer.Inner();//static来定义内部类
  in.print();
 }
}

外部类.内部类 内部类对象=new 外部类.内部类（）;

在方法中定义内部类

理论上内部类可以定义在类中的任意位置，在方法中定义内部类的形式是最多的

范例：在方法中定义内部类

class Outer{//定义一个外部类
    private String msg="Hello World!";
    public void fun(final int num){
        class Inner{
            public void print(){
                System.out.println("num="+num);
                System.out.println("msg="+msg);
            }
        }
        new Inner().print();//产生内部类对象调用方法
    }
}
public class Newbegin{
    public static void main(String args[]) {
        new Outer().fun(100);
    }
}
//此方法在JDk1.8是正常的，但是在JDK1.8之前就错误的
//在JDK1.7及之前，内部类要使用方法的参数，那么就必须用final定义

总结：

1.破坏了程序的结构；

2.方便进行私有属性的访问；不受private 限制