学习目标：
学习java基础部分中的四种内部类
学习内容：
理解并掌握javaOOP中的四种内部类*
学习产出：
韩顺平java基础12个视频
笔记
10.9 内部类
如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类 定义在成员位置 (1) 成员内部类 (2)
10.9.1 基本介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class), 嵌套其他类的类称为外部类(outer
class)。 是我们类的第五大成员[思考:类的五大 成员是哪些?[属性、方法、构造器、代码块、内部类]]，内部类最大的特点就是可
以直接访问私有属性，并且可以体现类与类之间的包含关系， 注意:内部类是学习的 难点，同时也是重点，后面看底层源码时，有大量的内部类.
10.9.2 基本语法
class Outer{//外部类
class Inner{//内部类
}
}
class other{//外部其他类
}
10.9.4 内部类的分类
➢定义在外部类局部位置上(比如方法内) :
1)局部内部类(有类名)
2)匿名内部类(没有类名，重点!!!
➢定义在外部类的成员位置上:
1)成员内部类(没用static修饰)
2)静态内部类(使用static修饰)
10.9.5 局部内部类的使用
说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。
1.可以直接访问外部类的所有成员，包含私有的
2.不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用 修饰符的。 但是可以使用final修饰，因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类-访问—>外部类的成员[访问方式:直接访问]
5.外部类-访向----局部内部类的成员 访问方式:创建对象，再访问(注意:必须在作用域内) 记住:(1)局部内部类定义在方法中/代码块 (2)作用域在方法体或者代码块中 (3)本质仍然是一个类
6.外部其他类—不能访—局部内部类(因为局部内部类地位是一一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成 员，则可以使用 (外部类名.this.成员) 去访问[演示] System.out.println( "外部类的n2=”+外部类名. this.n2);
代码实现:
public class LocalInnerClass {
public static void main(String[] args) {
Outer02 outer02 = new Outer02();
outer02.m1();
//7.外部其他类不能访问局部内部类(因为局部内部类地位是一个局部变量)
//new Inner02
}
}
class Outer02{//外部类
private int n1 = 100;
private void m2(){//私有方法
System.out.println("Outer02 m2()");
}
public void m1(){//方法\
//1.局部内部类时定义在外部类的局部位置，通常在方法中
//3.不能添加访问修饰符，但是可以使用final修饰
//4.作用域:仅仅在定义它的方法或代码块中
final class Inner02{//内部类
//2.可以直接访问外部类的所有成员,包含私有的
private int n1=800;
public void f1(){
//5.局部内部类可以直接访问外部类的成员,比如下面 外部类n1 和 m2()
//7.如果外部类和内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
//可以使用 外部类名.this.成员 去访问
System.out.println(n1);
System.out.println(Outer02.this.n1);
m2();
}
}
//6.外部类在方法中,可以创建Inner02对象,然后调用方法即可
Inner02 inner02 = new Inner02();
inner02.f1();
}
}
10.9.6 匿名内部类的使用(重要!!!)
public class AnonymousInnerClass {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04{
private int n1=10;
public void method(){
//基于接口的匿名内部类
//1.需求： 想使用 IA 接口,并创建对象
//2.传统方式，是写一个类，实现该接口，并创建对象
//3.需求是 Tiger/Dog 类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
//5. tiger 的编译类型 ? IA
//6. tiger 的运行类型 ? 就是匿名内部类 Outer04$
//7. jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址
// 返回给 tiger
//8. 匿名内部类使用一次，就不能再使用
IA tiger = new IA(){
@Override
public void cry() {
System.out.println("老虎嗷嗷叫~");
}
};
tiger.cry();
Father father= new Father("jack"){
@Override
public void h1() {
System.out.println("匿名内部类被调用");
}
};
father.h1();
Aninamls aninamls = new Aninamls(){
@Override
public void fly() {
System.out.println("抽象方法的匿名内部类被调用");
}
};
aninamls.fly();
}
}
interface IA{
void cry();
}
class Father{
private String name;
public Father(String name) {
this.name = name;
}
public void h1(){
System.out.println("Father类 的h1()方法被调用");
}
}
abstract class Aninamls{
public abstract void fly();
}
匿名内部类的细节:
1.匿名内部类的基本语法 new类或接口(参数列表){ 类体 };
2.匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点因此可以调用匿名内部类方法。
3.可以直接访问外部类的所有成员，包含私有的。
4.不能添加访问修饰符，因为它的地位就是一个局部变量。
5.作用域:仅仅在定义它的方法或代码块中。
6.匿名内部类—访向—>外部类成员[访问方式:直接访问]
7.外部其他类—不能访----匿名内部类(因为匿名内部类地位是一个局部变量)
8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问
10.9.7 匿名内部类的最佳实践
public class InnerClassExercise01 {
public static void main(String[] args) {
//当做实参直接传递，简洁高效
f1(new Il() {
@Override
public void say() {
System.out.println("这个东西太神奇了");
}
});
}
public static void f1(Il il){
il.say();
}
}
interface Il{
void say();
}
10.9.9 成员内部类的使用
说明:成员内部类是定义在外部类的成员位置，并且没有static修饰。
1.可以直接访问外部类的所有成员，包含私有的。
2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地 位就是一个成员。
3. 作用域:和外部类的其他成员一样，为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法.
4. 成员内部类-- -访问— >外部类成员(比如:属性) [访问方式:直接访问(说明)
5.外部类----访问----成员内部类(说明) 访问方式:创建对象， 再访问
6.外部其他类-访—>成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问。
代码实现:
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
//外部其他类使用成员内部类的两种方式
//第一种方式
//outer08.new Inner08();相当于把 new Inner08()当做是outer08成员
Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.p1();
//第二种方式 在外部类中，编写一个方法，返回Inner08对象
Outer08.Inner08 inner081 = outer08.getInner08();
inner08.p1();
}
}
class Outer08 {//外部类
private int n1 = 10;//私有属性
public String name = "jack";//公开类
//成员内部了可以添加任意访问修饰符,因为它的地位就是一个成员
class Inner08 {//成员内部类
private int n1 = 66;
public void p1() {//成员内部类的方法
//可以直接访问外部类的所有成员，包含私有的
System.out.println("n1=" + n1 + " name=" + name+" 外部类的n1="+Outer08.this.n1);
}
}
public void t1() {//外部类的方法
//使用内部类
Inner08 inner08 = new Inner08();//创建内部类对象
inner08.p1();//调用内部类的方法
}
//返回一个Inner08的实例
public Inner08 getInner08() {
return new Inner08();
}
}
10.9.10 静态内部类的使用
说明:静态内部类是定义在外部类的成员位置，并且有static修饰
1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员。
2.可以添加任意访问修饰符(public、protected、 默认、private),因为它的地位就是 一个成员。
3.作用域:同其他的成员，为整个类体 静态内部类–访----外部类(比如:静态属性) [访问方式:直接访问所有静 态成员]。
4.静态内部类—访向---->外部类(比如:静态属性)访问方式:直接访问所有静
态成员]。
5. 外部类–一访-----静态内部类访问方式创建对象，再访问
6.外部其他类-- -访向---- >静态内部类
7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近 原则，如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问
代码实现:
public class StaticInnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.t1();
//外部其他类，使用静态内部类
//方式一
//因为静态内部类,可以直接通过类名访问(前提是满足访问权限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式二
//编写一个方法，可以返回静态内部类的对象实例
Outer10.Inner10 inner101 = outer10.getInner10();
}
}
class Outer10{
private int n1=10;
private static String name="张三";
static class Inner10{
public void say(){
System.out.println(name);
//不能直接访问外部类的非静态成员
// System.out.println(n1);
}
}
public void t1(){
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10(){
return new Inner10();
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
