1. 内部类的定义
/*
内部类概述:
把类定义在其他类的内部，这个类就被称为内部类。
举例：在类A中定义了一个类B，类B就是内部类。 内部的访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类要访问内部类的成员，必须创建对象。 */
class Outer {
private int num = 10; class Inner {
public void show() {
System.out.println(num);
}
} public void method() {
//找不到符号
//show(); Inner i = new Inner();
i.show();
} } class InnerClassDemo {
public static void main(String[] args) { }
}
2. 内部类的位置
/*
内部类位置
成员位置:在成员位置定义的类，被称为成员内部类。
局部位置:在局部位置定义的类，被称为局部内部类。 成员位置:在成员位置定义的类，被称为成员内部类。 */
class Outer {
private int num = 10; //成员位置
/*
class Inner { }
*/ public void method() {
//局部位置
class Inner { }
}
} class InnerClassDemo2 {
public static void main(String[] args) { }
}
/*
成员内部类:
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
*/
class Outer {
private int num = 10; class Inner {
public void show() {
System.out.println(num);
}
}
} class InnerClassDemo3 {
public static void main(String[] args) {
//需求：我要访问Inner类的show()方法
//Inner i = new Inner();
//i.show();---这样的方式是错误的 //格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
3. 实例梳理成员内部类的修饰符
/*
成员内部类的修饰符：
private 为了保证数据的安全性
static 为了方便访问数据
注意：静态内部类访问的外部类数据必须用静态修饰。 案例：我有一个人(人有身体，身体内有心脏。) class Body {
private class Heart {
public void operator() {
System.out.println("心脏搭桥");
}
} public void method() {
if(如果你是外科医生) {
Heart h = new Heart();
h.operator();
}
}
} 按照我们刚才的讲解，来使用一下
Body.Heart bh = new Body().new Heart();
bh.operator();//但是我们是不希望外界对我们自己身体内部"心脏"进行操作的，怎么样才能实现这个？
//加了private后，就不能被访问了，那么，怎么玩呢?
Body b = new Body();
b.method();
*/
class Outer {
private int num = 10;
private static int num2 = 100; //内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner {
public void show() {
//System.out.println(num);//静态内部类访问外部类数据必须是静态修饰的，num不是静态，所以不能访问，num2可以访问
System.out.println(num2);
} public static void show2() {
//System.out.println(num);
System.out.println(num2);
}
}
} class InnerClassDemo4 {
public static void main(String[] args) {
//使用内部类
// 限定的新静态类，下面这样写法是错误的，内部类加了静态static修饰之后，是不能通过外部对象访问的，直接调用类名访问
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2(); //成员内部类被静态修饰后的访问方式是:
//格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2(); //show2()的另一种调用方式
Outer.Inner.show2();
}
}
4. 面试题
/*
面试题：
要求请填空分别输出30，20，10。 注意：
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
Outer.this
*/
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println(new Outer().num);//这个是也是可以实现的
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}