文章目录
- 前言
-
- 一、内部类概述
- 二、内部类使用场景
- 三、内部类的作用
- 四、内部类的类型
- 五、静态内部类（静态只能访问静态，静态内部类也适用这个定义）
-
- 🌿静态内部类格式
-
- ⭐代码演示
- 🌿创建对象的格式
-
- ⭐代码演示
- 🌿静态内部类的访问拓展
- 🌿总结
- 六、成员内部类
-
- 🍁成员内部类定义格式
-
- ⭐代码演示
- 🍁创建对象的格式
-
- ⭐代码演示
- ⚡注意⚡
- 七、局部内部类
-
- 🍃局部内部类定义格式
-
- ⭐代码演示
- 🍃创建对象格式
-
- ⭐代码演示
- 八、匿名内部类（重点）
-
- 🍀 匿名内部类定义格式
- 🍀匿名内部类的作用
- 🍀匿名内部类的优缺点
-
- ⭐代码演示
- 九、匿名内部类的案例
-
- 🌾实现集合排序
- 🌾普通实现接口和匿名内部类实现接口的比较
- 作者：KJ.JK
前言
本文介绍JavaEE里面的所有内部类详细介绍与使用
🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈
🍂个人博客首页： KJ.JK
欢迎大家点赞👍收藏💖评论💬关注🔒
💖源码获取 | 💻学习交流 | 🤝商务合作 | 💨私信作者
一、内部类概述
在Java中，允许一个类定义在另一个类的内部，前者称为"内部类"（寄生类），后者称为"外部类"（宿主类）
(就是在一个类中定义一个类)
举例:在一个类A的内部义一个类B,类B就被称为内部类
二、内部类使用场景
当一个事物内部有一个完整的结构，而该内部结构又只为外部事物提供服务，那么该内部结构可以定义成内部类
比如:人里面有一颗心脏，汽车内部有一个发动机，Cpu和电脑的关系
三、内部类的作用
* 内部类提供了更好的封装性
* 内部类可以用private protectecd等修饰，可以有更安全的权限控制
四、内部类的类型
*静态内部类（static修饰）
*成员内部类（无static修饰）
*局部内部类（语法鸡肋，开发不会用到）
* "匿名内部类"（重点）
五、静态内部类（静态只能访问静态，静态内部类也适用这个定义）
🌿静态内部类格式
有"static"修饰的内部类，类的所有的成分它都能定义 ("属性","方法","构造器","代码块","内部类")
⭐代码演示
public class Car {
String name;
static String age;
//静态内部类
//类的所有成员都可以写在静态内部类中(属性,方法,构造器,代码块,内部类)
public static class Engine{
private String brand;
public void start(){
System.out.println(brand+"发动机启动");
// System.out.println(name); //用不了,因为静态只能访问静态,静态内部类也适用这个定义
// System.out.println(age); //可以使用
}
public static void stop(){
System.out.println("发动机熄火");
}
public Engine(String brand) {
this.brand = brand;
}
public Engine() {
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
}
}
🌿创建对象的格式
格式:
外部类名.内部类名 对象名 = new 外部类名.内部类构造器( );
范例:
Car.Engine e=new Car.Engine("本田");
⭐代码演示
public class Test {
public static void main(String[] args) {
//静态内部类创建对象的格式:
//外部类名.内部类名 对象名 =new 外部类名.内部类构造器();
Car.Engine e=new Car.Engine("本田");
//调用成员方法
e.start();
//调用静态方法
e.stop(); // 不推荐
Car.Engine.stop(); //使用类名调用
}
}
🌿静态内部类的访问拓展
* 静态内部类中是否可以直接访问外部类的静态成员？
答:可以
* 静态内部类中是否可以直接访问外部类的实例成员？
答:不可以，外部类的实例成员必须"创建外部类对象访问"！
如:
public class Car {
String name;
static String age;
public static class Engine{
public void start(){
// System.out.println(name); //用不了,因为静态只能访问静态,静态内部类也适用这个定义
// System.out.println(age); //可以使用
System.out.println(new Car().name); //创建外部类对象访问外部类东西
}
}
}
🌿总结
静态结构（静态方法，静态代码块，静态内部类）都"只能访问静态成员"，"不能访问实例成员"。
🔥系列热门专栏🔥：
⚡《JavaEE进阶序列 | 从小白到工程师》系列文章⚡
⚡《JavaEE项目实战》系列文章⚡
⚡《JavaSwing项目合集》系列文章⚡
⚡《数据分析中的pandas》系列文章⚡
六、成员内部类
🍁成员内部类定义格式
"无static修饰"的内部类，"4种权限修饰符都可以"修饰成员内部类。
⭐代码演示
public class Body {
//成员内部类:心脏
//成员内部类中不能定义静态成员
public class Heart{
private String color;
// private static int a;
//因为静态的东西总是会随着类的调用而产生,而这个是成员内部类,静态先产生没有地方放它,所以不合理
public String getColor() {
return color;
}
//跳动
public void beat(){
System.out.println(color+"的心脏跳动");
}
public void setColor(String color) {
this.color = color;
}
public Heart(String color) {
this.color = color;
}
public Heart() {
}
}
}
🍁创建对象的格式
格式:
外部类名.内部类名 对象名 = new 外部类构造器( ).new 内部构造器( );
范例:
Body.Heart bh=new Body().new Heart();
//成员内部类依赖外部类的,要先创建外部类的对象,才能创建内部类
⭐代码演示
public class Test {
public static void main(String[] args) {
//创建成员内部类对象
//成员内部类依赖外部类的,要先创建外部类的对象,才能创建内部类
//格式1:
Body body=new Body();
Body.Heart h=body.new Heart();
h.setColor("红色");
h.beat();
System.out.println("------");
//简写格式2:
Body.Heart bh=new Body().new Heart();
bh.setColor("绿色");
bh.beat();
}
}
⚡注意⚡
* 成员内部类是依附外部类而存在的，要创建成员内部类的对象，需要先创建外部类的对象
如: Body.Heart bh=new Body().new Heart();
* 成员内部类中不能定义静态成员（但是可以定义静态常量）（JDK17后可以定义）
七、局部内部类
🍃局部内部类定义格式
局部内部类放在方法、代码块、构造器等执行体中
⭐代码演示
public class Test {
public static void main(String[] args) {
//定义在方法中的内部类,叫做局部内部类
//不能加修饰符,因为加不加都只能在这个大括号里面用
class Inner{
public void show(){
System.out.println("局部内部类的方法");
}
}
}
}
🍃创建对象格式
Inner in=new Inner();
in.show();
⭐代码演示
public class Test {
public static void main(String[] args) {
//定义在方法中的内部类,叫做局部内部类
//不能加修饰符,因为加不加都只能在这个大括号里面用
class Inner{
public void show(){
System.out.println("局部内部类的方法");
}
}
//创建对象
Inner in=new Inner();
in.show();
}
}
八、匿名内部类（重点）
🍀 匿名内部类定义格式
* 匿名内部类是指"没有名字的类", "定义类的同时也创建了对象"
* 使用前提:需要存在一个"接口"或"抽象类"
* 格式: new 抽象类名或者接口名() {
//重写方法;
};
* 范例:
Usb u2=new Usb() {
@Override
public void connect() {
System.out.println("鼠标连接");
}
}; //可以看成一个创建对象的过程
🍀匿名内部类的作用
* 匿名内部类一般作为"方法实参"而使用，目的是为了"实现父类或接口中的抽象方法"
* 开发中经常使用匿名内部类简化代码
//匿名内部类实现接口:直接创建接口的匿名内部类 (如果只是想要用这个接口一次的话,用这个就简化)
🍀匿名内部类的优缺点
* 优点:简化代码 (如果只是想要用这个接口一次的话,用这个就简化)
* 缺点:当要使用多次的时候就会显得繁琐 (当使用多次的时候就会显得繁琐)
⭐代码演示
public class Test {
public static void main(String[] args) {
//2.创建实现类的对象
// Usb u1=new Mouse();
//匿名内部类实现接口:直接创建接口的匿名内部类(如果只是想要用这个接口一次的话,用这个就简化)
//优点:简化代码
Usb u2=new Usb() {
@Override
public void connect() {
System.out.println("鼠标连接");
}
}; //可以看成一个创建对象的过程
u2.connect();
//缺点:当要使用多次的时候就会显得繁琐
/*
如:
Usb u2=new Usb() {
@Override
public void connect() {
System.out.println("鼠标连接");
}
};
Usb u22=new Usb() {
@Override
public void connect() {
System.out.println("鼠标连接");
}
};
*/
}
}
//普通使用接口的步骤
//1.定义实现类,实现接口
//class Mouse implements Usb{
//
//
// @Override
// public void connect() {
// System.out.println("鼠标连接");
// }
//}
九、匿名内部类的案例
🌾实现集合排序
import java.util.ArrayList;
import java.util.Comparator;
public class Test {
public static void main(String[] args) {
ArrayList<Integer> list =new ArrayList<>();
list.add(9);
list.add(5);
list.add(1);
list.add(3);
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return 02 -01; //降序
// return 01-02 //升序
}
});
System.out.println(list);
}
}
🌾普通实现接口和匿名内部类实现接口的比较
public interface Usb {
public abstract void connect();
}
class A implements Usb{
@Override
public void connect() {
System.out.println("普通方式实现接口连接");
}
}
public class Test {
public static void main(String[] args) {
Usb u=new A();
useDevice(u);
//用匿名内部类做
//匿名内部类当作方法的实参去使用
Usb u1=new Usb() {
@Override
public void connect() {
System.out.println("匿名内部类连接");
}
};
useDevice(u1);
}
public static void useDevice(Usb usb){
System.out.println("使用设备");
usb.connect();
}
}
作者：KJ.JK
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习
版权声明：程序员胖胖胖虎阿 发表于 2022年9月17日 下午3:00。
转载请注明：【JavaEE进阶系列 | 从小白到工程师】JavaEE里面的所有内部类详细介绍与使用，看这篇即可 | 胖虎的工具箱-编程导航
转载请注明：【JavaEE进阶系列 | 从小白到工程师】JavaEE里面的所有内部类详细介绍与使用，看这篇即可 | 胖虎的工具箱-编程导航
相关文章
暂无评论...
致力于称为最好的程序员导航网站