Java内部类总结
【摘要】
小伙伴们，好久没有写文了，一直在学习 Java，写了一篇Java面向对象内部类的文章，如果觉得有用的话点赞收藏+关注哦！！！，开始吧 🥗🍗🎯🌈✔️
如果痛苦的话，不努力也没关系
...
小伙伴们，好久没有写文了，一直在学习 Java，写了一篇Java面向对象内部类的文章，如果觉得有用的话点赞收藏+关注哦！！！，开始吧 🥗🍗🎯🌈✔️
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类成为内部类 (inner class)
在学习内部类之前，先来了解一下类的五大成员
🎯类的五大成员
- 属性
- 方法
- 构造器
- 代码块
- 内部类
💯内部类
定义类在局部位置(方法中/代码块) :
- 局部内部类
- 匿名内部类
定义在成员位置
- 成员内部类
- 静态内部类
🌈局部内部类
局部内部类是定义在外部类的局部位置，通常方法中，并且有类名
- 可以直接访问外部类的所有成员，包含私有的
- 不能添加访问修饰符，但是可以使用final 修饰
- 作用域：仅仅在定义它的方法或代码块中
- 局部内部类可以直接访问外部类的所有成员
- 外部类在方法中可以创建内部类实例，然后调用方法即可
- 外部其他类不能访问局部内部类
- 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果
- 想访问外部类的成员，可以使用：外部类名.this.成员
public class inner05 {
public static void main(String[] args) {
new Outer01().m();
}
}
class Outer01 { //外部类
private int n = 50;
private void f() {
System.out.println("我是外部类的f私有方法，我被调用了");
}
public void m() {
int n = 100; //重名了，访问遵循就近原则
//局部内部类
class Inner01 {
public void f1() {
//可以直接访问外部类的所有成员，包含私有的
System.out.println("n=" + n);
//访问外部类的属性通过 外部类名.this.成员
System.out.println("n=" + Outer01.this.n);
f();
}
}
//在方法中new内部类并调用方法
new Inner01().f1();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
输出：
n=100
n=50
我是外部类的f私有方法，我被调用了
✔️匿名内部类
传统方法，写一个类，实现该接口，并创建对象
新需求，只使用一次，后面不在使用，使用匿名内部类简化开发
cat 的编译类型 AA ，cat 的运行类型是匿名内部类 inner03$1
JDK在底层，创建了匿名内部类inner03$1，new立即就创建了一个inner03$1实例，并且把地址返回给 cat,匿名内部类，使用一次就不能再使用了，但是生成的对象 cat 可以一直使用。
基于接口的匿名内部类
public class inner03 {
public static void main(String[] args) {
AA cat = new AA(){
@Override
public void shot() {
System.out.println("喵喵叫");
}
};
cat.shot();
System.out.println(cat.getClass());
}
}
interface AA { //接口
public void shot();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
输出：
喵喵叫
class innerclass.inner03$1
基于类的匿名内部类
public class inner04 {
public static void main(String[] args) {
//基于类的匿名内部类
Fa f = new Fa("森") {
};
f.say();
System.out.println();
}
}
class Fa {
private String name;
public Fa(String name) {
this.name = name;
}
public void say() {
System.out.println(this.name + "说话了");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
输出：
森说话了
🥗成员内部类
/**
* @Author: liu sen
* @Version: 1.0
* @Date: 2021/09/06/10:26
*/
public class demo08 {
public static void main(String[] args) {
Outer03 outer03 = new Outer03();
outer03.t1();
//外部其他类访问成员内部类
//1
Outer03.Inner03 inner03 = outer03.new Inner03();
inner03.say();
//2，再外部类中编写一个方法
Outer03.Inner03 getinnero3 = outer03.getInnero3();
getinnero3.say();
}
}
class Outer03 {//外部类
private int n1 = 10;
public String name = "小刘";
private void say(){
System.out.println("say");
}
//成员内部类（没有写在方法中或代码块中，就好比是Outer03的一个成员，因此叫成员内部类）
//可以添加四种修饰符，因为它的低位就是类成员
//作用域就是整个外部类，其实成员内部类就相当于类成员，那自然作用域就是这个类
//成员内部类可以直接访问外部类成员(属性和方法)，私有也可以
//外部类访问成员内部类，创建对象，再访问
//外部其他类访问成员内部类
public class Inner03 {
public void say() {
//可以直接访问外部类的所有成员，包含私有的
System.out.println("n1:" + n1 + " name：" + name);
//如果外部类和内部类有重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，可以使用
//外部类名.this.类名 去访问，如下
Outer03.this.say();
}
}
public void t1(){
//使用了成员内部类
Inner03 inner03 = new Inner03();
inner03.say();
}
//方法，返回一个Inner03的实例
public Inner03 getInnero3(){
return new Inner03();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
🍗静态内部类
/**
* @Author: liu sen
* @Version: 1.0
* @Date: 2021/09/06/21:41
*/
public class demo09 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.na();
//外部其他类 访问静态内部类
//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 {//静态内部类
//在外部类的成员位置，使用 static 修饰
//可以直接访问外部类的所有静态成员，包含私有的，但是不能访问非静态的方法
//可以添加任意地访问修饰符，因为它的低位就是一个成员
//作用域：同其他成员，为整个类体
private static String name = "小张";
public void say(){
// System.out.println(n1);//报错，不允许
//外部类和静态内部类重名，静态内部类访问时默认遵循就近原则
System.out.println(name);//OK
//如果想访问外部的成员，可以用(外部类名.成员)
System.out.println(Outer10.name);
//静态内部类访问外部类，直接访问所有静态成员
cry();
}
}
public void na(){
//外部类访问静态内部类，先创建对象，再访问
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10(){
return new Inner10();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
文章来源: blog.csdn.net，作者：周棋洛ყ ᥱ ᥉，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/m0_53321320/article/details/121302437
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）