注意:纯属个人笔记。
笔记1:常规内部类(有包名)
package cn.hncu.map.inner;
public class MyOuter {
private int x = 100;
// 创建内部类
class MyInner {
private String y = "Hello!";
public void innerMethod() {
System.out.println("内部类中 String =" + y);
System.out.println("外部类中的x =" + x);// 直接访问外部类中的实例变量x
outerMethod();
System.out.println("x is" + MyOuter.this.x);
}
}
public void outerMethod() {
x++;
}
/*
* 通过外部类的函数创建内部类,
* 外部类的函数与内部类其实是兄弟关系,
* 这时可以把内部类看成一个函数,
* newInnerInstance()调用内部类。
*/
public MyInner newInnerInstance() {
// 在外部类方法中创建内部类实例
MyInner inner = new MyInner();
return inner;
}
public static void main(String[] args) {
MyOuter mo = new MyOuter();
/*
* 创建方案一,该方法错误无法创建实例。
*/
// MyInner inner1 = new MyInner();
/*
* 创建方案二,该方法可行。
* 常规内部类需要通过外部类的实例才能创建对象,
* 与实例变量需要通过对象来访问相似。
* 例如:调用x 》》》 mo.x 相当于 mo.new MyInner(),
* 调用内部累的时候就创建实例,且是内名实例,然后将该类返回给inner2。
*/
MyInner inner2 = mo.new MyInner();
/*
* 创建方案三,该方法可行。
*/
MyOuter.MyInner inner3 = mo.new MyInner();
/*
* 创建方案四,该方法可行。
*/
MyOuter.MyInner inner4 = mo.newInnerInstance();
}
}
在bin中生成的"*.class"文件
笔记2:静态内部类
package cn.hncu.collection.mapSystem.inner2;
public class MyOuter {
private int x = 100;
/*
* 创建内部类
* public static这两个都是修士符,
* public是文件的访问权限,
* 没有写修士符,就表明该成员是同包访问,
* 他的父包或子包内的类中的函数无法
* --调用该类的这个成员(java中的包就windows中的文件夹);
* static是类成员的运行时间设置,
* 定义成static后,该成员就会在该实例构造前就生成,
* 所以java的静态函数中不能直接调用非静态的成员。
*/
public static class MyInner {
private String y = "Hello!";
public void innerMethod() {
System.out.println("内部类中 String =" + y);
}
}
/*
* 通过外部类的函数创建内部类,
* 外部类的函数与内部类其实是兄弟关系,
* 这时可以把内部类看成一个函数,
* newInnerInstance()调用内部类。
*/
public MyInner newInnerInstance() {
// 在外部类方法中创建内部类实例
MyInner inner = new MyInner();
return inner;
}
public static void main(String[] args) {
MyOuter mo = new MyOuter();
/*
* 创建方案一,该方法错误无法创建实例。
*/
MyInner inner1 = new MyInner();
/*
* 创建方案二,该方法错误。
*/
//MyOuter.MyInner inner2 = mo.new MyInner();
/*
* 创建方案三,该方法可行。
*/
MyOuter.MyInner inner3 = mo.newInnerInstance();
}
}
包树图片:
笔记三:局部内部类
package cn.hncu.collection.mapSystem.inner3;
public class LocalInner {
private int size = 5, y = 7;
/*
* makeInner-创建局部内部类函数
*/
public Object makeInner(int localVar) {
final int finalLocalVar = localVar;
/*
* finalLocalVar-局部变量
* 只有final才可以被局部内部类直接访问。
* 创建内部类,
* 该类只在makeInner()方法有效,
* 就像局部变量一样。
* 在方法体外部不能创建MyInner类的对象。
*/
class MyInner {
int y = 4;
public String toString() {
return "OuterSize:" + size + "\nfinalLocalVar" + finalLocalVar
+ " " + "this.y=" + this.y;
}
}
return new MyInner();
}
}
class Main {
public static void main(String[] args) {
/*
* 创建Jubu对象obj,
* 并调用它的makeInner()方法,
* 该方法返回一个
*/
Object obj = new LocalInner().makeInner(47);
/*
* 该方法返回一个MyInner类型的的对象obj,
* 然后调用其同toString方法。
*/
System.out.println(obj.toString());
}
}
笔记四:匿名内部类
package cn.hncu.collection.mapSystem.inner4;
/*
* AnomynityInner-匿名内部类
*/
public class AnomynityInner {
private int size = 5;
public Object makeInner(int localVar) {
final int finalLocalVar = localVar;
return new Object() {
// 使用匿名内部类
public String toString() {
return "OuterSize=" + size + "\nfinalLocalVar=" + finalLocalVar;
}
};
}
public static void main(String args[]) {
Object obj = new AnomynityInner().makeInner(47);
System.out.println(obj.toString());
}
}
总结:
定义为public 的内部类可以直接定义类型,不需要通过外部类名来调用。
例如:
包名Exercise01中的类A{
class Inner01 {
}
public class Inner02 {
}
}
包名Exercise02中的类B{
public static void main(String args[]){
A a = new A();
通过A.Inner01 无法调用
通过A.Inner02 就可以调用
也可以直接定义Inner02
例如:
Inner02 in1 = null;
}
}
----但是
超链接:java四种内部类详解