java基础(二):java内部类

　　内部类像寄生虫一样生存在其他类【外部类】的内部。定义在类的内部的类叫内部类，它缩小了可见性。根据内部类定义结构的不同，可以把内部类分为

成员内部类和局部内部类。成员内部类定义的地方和外部类的成员变量和成员方法类似，就好像类的一个成员一样。局部类内部类则定义在方法体内，仅属于局部范围所有。

　　成员内部类又可以分为：实例内部类和静态内部类。局部内部类有可以分为：普通局部内部类和匿名内部类。

---

一：实例内部类

　　1.定义

　　和实例成员变量定义位置一样。可以用四种修饰符修饰。可以再实例内部类里面定义成员变量和成员方法【静态成员变量和静态成员方法除外】。

实例内部类它属于一个具体的对象，只有外部类的实例创建出来了它才会被加载到JVM虚拟机。

//外部类
public class outer {
  private String path；
  //实例内部类
  class Inner {
　　　　
  }     

}

　　2.创建对象

　　实例内部类的对象的创建比较特殊，必须先创建一个外部类的实例，通过外部类的实例创建。

　　

Outer out = new Outer();
Inner in = out.new Inner();

　　如果在外部类内部创建实例内部类对象可以直接new。

　　3.访问

　　（1）：外部内访问实例内部类的变量和方法

　　　　通过内部类的对象访问。

　　（2）：实例内部类访问外部类

　　　　直接可以访问外部类的所有成员方法和成员变量。

　　　特殊情况：如果内部类有实例成员变量和实例成员方法和外部类同名怎么办？用代码说明：

先定义外部类和内部类。

package com.briup.bean;

public class InstanceOuter {

	private String path = "outer";

	public void outer() {
		System.out.println("outer function");
	}

	public class Inner {
		private String path = "inner";

		public String getPath() {
			return path;
		}

		public void nameLike() {
			System.out.println(InstanceOuter.this.path);
			System.out.println(this.path);
		}

		public void inner() {
			InstanceOuter.this.outer();
			System.out.println("inner function");
		}

	}

	public String getPath() {
		return path;
	}

}

测试代码：

package com.briup.jtest;

import com.briup.bean.InstanceOuter;
import com.briup.bean.InstanceOuter.Inner;

public class Test1 {
	public static void main(String[] args) {
		InstanceOuter outer = new InstanceOuter();
		Inner inner = outer.new Inner();
		inner.nameLike();
		inner.inner();
	}
}

控制台输出结果：

如果实例内部类要调用同名的外部类变量和方法，需要加"类名.this.变量或方法"。

二：静态内部类

　　1.定义

　　　　静态内部类使用static修饰。静态内部类随外部类加载而被jvm虚拟机加载。它的完整类名是："包名.外部类类名.静态内部类类名",编译后的文件为"外部类类名$静态内部类类名.class",由于静态内部类是静态的，它无法访问外部类的非静态成员变量和方法。静态内部类相对于外部类来说，几乎是独立的。可以在没有外部类对象的情况下创建一个内部类对象。

//外部类
public class Outter {
  //静态内部类
  static class inner {
  }
}

　　2.创建

　　通用公式："内部类名称 对象名 = new 外部类类名.内部类类名()" ;

　　外部类内部可以直接new 出来。

　　

　　3.访问

　　　　（1）：外部类访问静态内部类

　　　　　　通过静态内部类对象访问，私有的也可以直接访问。

　　　　（2）：静态内部类访问内部类

　　　　　　直接可访问外部类的静态成员方法和变量。

三：普通的局部内部类

　　1.定义

　　　　普通局部内部类没有范围概念，仅在定义的方法里有效。

public void init(String path) { //方法
　　class Inner {}  //普通的局部内部类
}

　　　　本质上说，局部内部类也是独立的类，不过它的使用受到了限制。列如：不能使用static修饰，只能用final 和 abstract关键字。仅可以访问方法中final关键字的局部变量【jdk1.8新特性：可以访问不带final的局部变量，当它是final的】。

　　2.创建

　　　　它的可见范围是方法体内，在方法体内可以像普通类一样创建。

　　3.访问

　　　　仅可以访问方法中final关键字的局部变量【jdk1.8新特性：可以访问不带final的局部变量，当它是final的】。可以访问任意的外部类的成员变量。

四：匿名内部类

　　1.定义

　　　　如果一个局部类没有名称，它就是匿名内部类。

public void init(
   new OneInterface {} //直接new 一个接口。 

)

　　　匿名内部类编译后的class文件命名按照匿名内部类的排列顺序来进行的，直接在外部类后加上 '$' 和 序号。如：Outer$1.class。

　　2.使用

　　　　匿名内部类可以做什么呐？可以避免修改接口而实现同一个类中两种同名方法的调用。举一个列子说明：

　　比如中国人见面问候是  "xxx,你吃饭了吗" ,美国人是 "hello,xxx"。

　　接口：

package com.briup.bean;

public interface OneInterface {

    public abstract String say();
}

　　　　bean类：

package com.briup.bean;

public class People {

    private String name;
    //国家
    private String nation;

    public People(String name, String nation) {
        super();
        this.name = name;
        this.nation = nation;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNation() {
        return nation;
    }

    public void setNation(String nation) {
        this.nation = nation;
    }

    public void say(OneInterface one) {
        System.out.println(one.say());
    }
}

测试类：

package com.briup.jtest;

import com.briup.bean.OneInterface;
import com.briup.bean.People;

public class Test3 {

    public static void main(String[] args) {
        //中国人
        People china = new People("小明", "中国");
        People america = new People("jack", "America");

        china.say(new OneInterface() {

            @Override
            public String say() {
                return "你好,吃饭了吗？ " + america.getName();
            }
        });

        america.say(new OneInterface() {

            @Override
            public String say() {
                return "hello " + china.getName() ;
            }
        });
    }

}

总结：

　　1.实例内部类可以和实例成员变量和实例成员方法类比，实例成员方法可以直接访问所有成员，实例内部类也可以。

　  2.静态内部类访问可以总结成一句话：不能在静态上下文中访问非静态的成员方法和变量。静态内部类相对于外部类来说，仅仅是包含关系，缩小了命名空间，完整的类名多了一个外部类的类名。本质上是两个独立的类，JVM也不知道它们的包含关系。某种程度来说：公开的静态内部类就相当于一个普通的类。

　 3.内部类的作用：

　　　　(1):内部类可以很好的实现隐藏

　　 　　　　一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

　　　　(2):内部类拥有外围类的所有元素的访问权限

　　　　(3):可是实现多重继承

　　　　(4)可以避免修改接口而实现同一个类中两种同名方法的调用。