内部类

基本概念：(inner1)
所谓的内部类指的是在一个类的内部继续定义了类的结构所形成的代码形式.
类的组成结构：属性和方法，但是又多了一个类，会破坏类的程序的结构。
观察它的优点（inner2）
class Outer1{
private String msg="hello world";
public void fun() {
new Inner1().print();
}
}
class Inner1{
public void print() {
System.out.println(msg);
}
}
1.在Inner类之中的print（）方法里，如果要想输出Outer类的msg属性，那么应该首先在Outer类中加一个getMsg（private String msg）方法
class Outer1{
private String msg="hello world";
public void fun() {
new Inner1().print();
}
public String getMsg() {
return this.msg;
}
}
}
2.如果要想在Inner类之中调用getMsg()方法，那么必须存在Outer类对象，把主方法out对象传递给Inner类之中，
如果要想操作Inner类，则必须有一个Outer对象，所以在Inner类增加一个Outer类对象。
private Outer1 tmep;
在Inner类里面定义一个构造方法，通过此构造方法传递Outer类对象
public Inner1(Outer1 tmep) {
this.temp=temp;
}
在print（）方法里面使用temp这个Outer类对象调用getMsg()方法
在Outer类实例化Inner类的时候传递当前对象（this）
package inner;
class Outer1{
private String msg="hello world";
public void fun() {
new Innera(this).print();
}
public String getMsg() {
return this.msg;
}
}
class Innera{
private Outer1 temp;
public Innera(Outer1 temp) {
this.temp=temp;
}
public void print() {
System.out.println(this.temp.getMsg());
}

}
public class Inner2 {
public static void main(String args[]) {
Outer1 out=new Outer1();
out.fun();

}
}
内部类的最大优点，可以方便的访问内部类之中定义的私有成员，同理，外部类可以方便的访问内部类的私有成员。(inner3)
package inner;
class Outeraa{//外部类
private String msg="hello world";
class Inner{//内部类
private int num=100;//内部类私有成员
public void print() {//内部类中定义的方法
System.out.println(msg);//输出数据
}
}
public void fun() {
Inner in=new Inner();
in.print();
System.out.println(in.num);
}
}
public class Inner3 {


public static void main(String[] args) {
// TODO Auto-generated method stub
Outeraa out=new Outeraa();
out.fun();
}


}
从访问属性的角度上讲，一直强调；只要是访问类之中的属性一定要加上“this”,如果直接使用“this属性”表示的是Inner类的属性。明显是
是错误的，所以下面应该使用”外部类this属性“才表示内部类访问外部类的属性。
class Inner{//内部类
private int num=100;//内部类私有成员
public void print() {//内部类中定义的方法
System.out.println(Outer.this.msg);//输出数据
}
}
以上的所有代码定义的内部类最终都是在Outer类之中的方法里面操作的，那么在java里面类也可以通过主方法直接调用
外部类.内部类 内部类对象=new 外部类（）.new 内部类（）；
先实例化外部类，后实例化内部类，而所有的属性一定要在关键字new之后才会分配空间
由外部操作内外部:
package inner;
class Outerab{//外部类
private String msg="hello world";
class Inner{//内部类
public void print() {
System.out.println(msg);
}
}
}
public class Inner4 {


public static void main(String[] args) {
// TODO Auto-generated method stub
Outer.Inner in=new Outer().new Inner();
in.print();
}


}
有private声明，所有外部无法取使用内部类
class Outerab{//外部类
private String msg="hello world";
private class Inner{//内部类
public void print() {
System.out.println(msg);
}
}
}
使用static定义内部类
如果说现在一个内部类不希望受到外部类之中的控制，而可以直接取实例化对象，那么在定义内部类的时候就可以使用static关键字声明，
而且使用static关键字声明的内部类严格来讲就是一个外部类，只能够调用所在外部类的static属性。
使用static定义
class Outerab{//外部类
static private String msg="hello world";
static class Inner{//内部类
public void print() {
System.out.println(msg);
}
}
}
定义格式也要发生变化
//外部类.内部类 内部类对象=new 外部类（）.new 内部类（）；
/外部类.内部类 内部类对象=new 外部类.内部类（）；
public static void main(String[] args) {
// TODO Auto-generated method stub
Outerab.Inner in=new Outerab.Inner();
in.print();
}


在方法中定义内部类
理论上讲内部类可以在任意的位置上定义，这就包括类中，代码块中，方法中
package inner;
class Oute{
private static String msg="hello World";
public void fun() {
class Inne{
public void print() {
System.out.println(Oute.this.msg);
}
}
new Inne().print();
}
}
public class Inner5 {


public static void main(String[] args) {
// TODO Auto-generated method stub
new Outer().fun();
}


}
但是在方法之中定义的内部类如果要想访问方法的参数或者方法定义的变量，则参数或变量前应该加上一个关键字”final“(此处final只是一个标记，并不是其真实使用)；
package inner;
class Oute{
private static String msg="hello World";
public void fun(final int num) {//普通方法
class Inne{//方法里定义内部类
public void print() {
System.out.println(Oute.this.msg);
System.out.println(num);
}
}
new Inne().print();//实例化内部类对象调用方法
}
}
public class Inner5 {


public static void main(String[] args) {
// TODO Auto-generated method stub
new Oute().fun(100);
}

}