内部类的基本介绍
- 一个类的内部又完整的嵌套了另一个类结构，被嵌套的成为内部类，嵌套其他类的类成为外部类
- 内部类是我们类的第五大成员（属性、方法、构造器、代码块和内部类）
- 内部类的最大特点：可以直接访问私有属性，并且可以体现类与类之间的包装关系
内部类的基本语法
内部类的分类
- 定义在外部类局部位置上（一般是方法内）：
局部内部类（有类名）
匿名内部类（没有类名，重点！！！） - 定义在外部类的成员位置上：
成员内部类（没有static修饰）
静态内部类（使用static修饰）
局部内部类的使用
说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名
- 可以直接访问外部类的所有成员，包含私有的
- 不能添加访问修饰符，因为他的地位就是一个局部变量。局部变量不能使用修饰符的。但是可以用final修饰，因为局部变量也可以使用final
- 作用域：仅仅在定义它的方法或代码块中
- 局部内部类–访问–>外部类的成员：直接访问
- 外部类–访问–>局部内部类的成员
访问方式：创建对象再访问（注意:必须在方法/作用域内） - 外部其他类–不能访问–>局部内部类（因为局部内部类地位是一个局部变量）
- 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用：外部类名.this.成员
记住：
1，局部内部类定义在方法中/代码块
2，作用域在方法体/代码块中
3，本质仍是一个类
public class LocalInnerClass {
public static void main(String[] args) {
Outer02 outer02 = new Outer02();
outer02.m1();
}
}
class Outer02 {//外部类
private int n0 = 100;
private int n1 = 100;
private void m2() {//私有方法
System.out.println("Outer02 m2()");
}
public void m1() {
final class Inner02 {//内部类,不能添加访问修饰符,但是可以使用 final 修饰
private int n1 = 800;
public void f1() {
System.out.println("直接访问外部类的属性,包括私有属性" + n0);
m2();
System.out.println("如果外部类和局部内部类的成员(n1)重名时，默认遵循就近原则,访问作用域中n1" + n1);
System.out.println("如果想访问外部类的成员，使用 外部类名.this.成员 去访问" + Outer02.this.n1);
}
}
//外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
结果
匿名内部类的使用（重要！！！）
说明：匿名内部类是定义在外部类的局部位置。比如方法中，并且没有类名
- 1，匿名内部类的基本语法
new 类或接口(参数列表){
类体
}; - 2，匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上就看，它既有定义类的特征，也有创建对象的特征。
- 3，可以直接访问外部类的所成员，包括私有的
- 4，不能添加访问修饰符，因为它的地位就是一个局部变量
- 5，作用域：仅仅定义在它的方法/代码块中
- 6，局部内部类–访问–>外部类的成员：直接访问
- 7，外部其他类–不能访问–>局部内部类（因为局部内部类地位是一个局部变量）
- 8，如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用：外部类名.this.成员
演示匿名内部类的使用
//演示匿名内部类的使用
public class AnonymousInner {
public static void main(String[] args) {
new Outer04().method();
}
}
class Outer04{//外部类
private int n1 = 10;
/**
* 基于接口的匿名内部类
* 1.需求： 想使用 IA 接口,并创建对象
* 2.需求是 Tiger 类只是使用一次，后面再不使用
* 3.可以使用匿名内部类来简化开发
* 4.tiger 的编译类型 ? IA
* 5.tiger 的运行类型 ? 就是匿名内部类 Outer04$
* 我们看底层 会分配 类名 Outer04$1
* class Outer04$1 implements IA {
* @Override
* public void cry() {
* System.out.println("老虎叫唤...");
* }
* }
* 6.jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址返回给tiger
* 7.匿名内部类使用一次，就不能再使用
*/
public void method(){
IA tiger = new IA(){
@Override
public void cry() {
System.out.println("老虎叫唤----");
}
};
System.out.println("tiger 的运行类型= "+ tiger.getClass());
tiger.cry();
}
}
interface IA{
public void cry();
}
结果
演示基于类的匿名内部类
/**
public class AnonymousInner {
public static void main(String[] args) {
new Outer04().method();
}
}
class Outer04{//外部类
private int n1 = 10;
* 演示基于类的匿名内部类
*1.father的编译类型是 Father
*2.father的运行类型是Outer04$2
*3.底层会创建匿名内部类
*class Outer04$2 extends Father{
* @Override
* public void test() {
* System.out.println("匿名内部类重写了 test 方法");
* }
* }
* 4.同时也直接返回了匿名内部类Outer04$2对象
* 5.注意（Jack）参数列表会传递给 构造器
*/
Father father = new Father("Jack"){
@Override
public void test() {
System.out.println("匿名内部类重写了 test 方法");
}
};
System.out.println("father 对象的运行类型="+father.getClass());
father.test();
}
}
class Father{
public Father(String name) {
System.out.println("接收到name"+name);
}
public void test(){
//方法
}
}
基于抽象类的匿名内部类
//基于抽象类的匿名内部类
/**
public class AnonymousInner {
public static void main(String[] args) {
new Outer04().method();
}
}
class Outer04{//外部类
private int n1 = 10;
Animal animal = new Animal() {
@Override
void eat() {
System.out.println("小狗吃骨头~~");
}
};
animal.eat();
}
}
abstract class Animal{
abstract void eat();
}
结果
-注意：匿名内部类的访问和作用域等注意事项同局部内部类！！！
成员内部类的使用
说明：成员内部类是定义在外部类的成员位置，并且没有static修饰
- 1，可以直接访问外部类的所有成员，包括私有的
- 2，可以添加任意修饰符（public、protected、默认、private），因为它的地位就是一个成员
- 3，作用域和外部类的其他成员一样，为整个类体。、
- 4，成员内部类–访问–>外部类成员：直接访问
- 5，外部类–访问–>成员内部类：创建方法，在方法中创建对象，再访问
- 6，如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
}
}
class Outer08 {//外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法~~");
}
public class Inner08 {//内部类
private double sal = 99.4;
private int n1 = 11;
public void say() {
//可以直接访问外部类的所有成员，包含私有的
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
// 可以通过 外部类名.this.属性 来访问外部类的成员
System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
hi();
}
}
//在外部类中访问成员内部类--写方法
public void t1(){
//使用成员内部类
//创建对象，然后使用相关方法
Inner08 inner08 = new Inner08();
inner08.say();
}
}
结果
- 6，外部其他类–访问–>成员内部类：如下三种方法
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
// 外部其他类。使用成员内部类的两种方式
// 1.outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.say();
// 2.在外部类编写一个方法，可以返回Inner08对象
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();
}
}
class Outer08 {//外部类
private int n1 = 10;
public String name = "张三";
private void hi() {
System.out.println("hi()方法~~");
}
public class Inner08 {//内部类
private double sal = 99.4;
private int n1 = 11;
public void say() {
//可以直接访问外部类的所有成员，包含私有的
//如果成员内部类的成员和外部类的成员重名，会遵守就近原则.
// 可以通过 外部类名.this.属性 来访问外部类的成员
System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
hi();
}
}
//在外部类编写一个方法，可以返回Inner08对象
public Inner08 getInner08Instance(){
return new Inner08();
}
}
结果
静态内部类的使用
说明：静态内部类是定义在外部类的成员位置，并且有static修饰
- 1，可以直接访问外部类的所有静态成员，包含私有的，但是不能直接访问非静态成员
- 2，可以添加任意访问修饰符（public、protected、默认、private）因为它的地位就是一个成员
- 3，作用域：同其他的成员，为整个类体
- 4，静态内部类–访问—>外部类：直接访问所有静态成员
- 5，外部类–访问–>静态内部类：创建方法，在方法中创建对象，再访问
- 6，如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，可以使用（外部类.成员）去访问
public class StaticInnerClass {
public static void main(String[] args) {
new Outer10().m1();
}
}
class Outer10{
private int n1 = 10;
private static String name = "张三";
private static void cry(){}
static class Inner10{
private static String name = "加油";
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
public void say(){
System.out.println("可以直接访问外部类的静态属性name="+name+"外部类name="+Outer10.name);
cry();
}
}
//外部类--访问-->静态内部类：创建方法，在方法中创建对象，再访问
public void m1(){
Inner10 inner10 = new Inner10();
inner10.say();
}
}
结果
- 7，外部其他类–访问—>静态内部类 以下两种方式
public class StaticInnerClass {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
//外部其他类。使用静态内部类
//1.因为是静态内部类，是可以通过类名直接访问（前提是满足访问权限）
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//2.编写一个方法，可以返回静态内部类的对象实例
Outer10.Inner10 inner101 = outer10.getInner10();
inner101.say();
}
}
class Outer10 {
private int n1 = 10;
private static String name = "张三";
private static void cry() {
}
static class Inner10 {
private static String name = "加油";
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，
//默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
public void say() {
System.out.println("可以直接访问外部类的静态属性name=" + name + "外部类name=" + Outer10.name);
cry();
}
}
public Inner10 getInner10() {
return new Inner10();
}
结果
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
