深入解析：JAVA_TWELVE_面向对象高级三

一内部类

定义：

如果一个类定义在另一个类的内部，这个类就是内部类。

一成员内部类

定义：

就是类中的一个普通成员，类似前面我们学习过的普通成员变量，成员方法

public class Outer{
//成员内部类
public class Inner{
}
}

创建对象方法：外部类名.内部类名对象名 =new 外部类（…）.new 内部类（…）；

特点：

可以直接访问外部类的实例成员，静态成员

可以拿到当前外部类对象，格式是：外部类名.this。

二静态内部类

定义：

有static修饰的内部类，属于外部类自己持有。

public class Outer{
//静态内部类
public static class Inner{
}
}

创建对象方法：外部类名.内部类名对象名 =new 外部类.内部类（…）;

特点：

可以直接访问外部类的静态成员，不能直接访问外部类的实例成员

三匿名内部类

定义：

就是一种特殊的局部内部类；所谓匿名：指的是程序员不需要为这个类声明名字

new 类或接口（参数值）{ 类体（一般是方法重写）；

}

特点：

匿名内部类本质就是一个子类，并会立即创建一个子类对象

作用：

用于更方便的创建一个子类对象

常见使用场景：

通常作为一个参数传输给方法

狗狗游泳举例代码

public class Test2 {
public static void main(String[] args) {
/*        Swimming swimming=new Swimming() {
@Override
public void swim() {
System.out.println("小狗在游泳~");
}
};
go(swimming);*/
go(new Swimming() {
@Override
public void swim() {
System.out.println("小狗在游泳~");
}
});
}
public static void go(Swimming s){
System.out.println("---------开始-----------");
s.swim();
}
}
interface Swimming{
void swim();
}

GUI编程举例代码

public class Test {
public static void main(String[] args) {
//拓展,搞清楚匿名内部类在开发中的真实使用场景
//GUI编程
//1.创建窗口
JFrame win=new JFrame("登录页面");
JPanel panel=new JPanel();
win.add(panel);
JButton button=new JButton("登录");
panel.add(button);
//给按钮绑定单击事件检测器
/*    button.addActionListener(new AbstractAction() {  //匿名内部类
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(win,"登录成功");
}
});*/
//最终目的 简化代码
button.addActionListener(e ->JOptionPane.showMessageDialog(win,"登录成功"));
win.setSize(400,400);
win.setLocale(null);
win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
win.setVisible(true);
}
}

四枚举

定义：

枚举是一种特殊的类

格式：

修饰符 enum 枚举类名{ 名称1，名称2，… ;

其他成员…

}

注意：

1.枚举类中的第一行，只能写一些合法的标识符（名称），多个名称用逗号隔开。

2.这些名称，本质是常量，每个常量都会记住枚举类的一个对象

3.枚举都是最终类，不可以被继承

4.枚举中的构造器都是私有的，因此，枚举对外不能创建对象

5.枚举类中，从第二行开始，可以定义类的其他各种成员

6.编译器为枚举类新增了几个方法，并且枚举类都是继承：Java.lang.Enum类的，从enum类中也会继承一些方法

常见应用场景：

用来表示一组信息，然后作为参数进行传输、

常见应用场景举例代码

public class Test {
public static void main(String[] args) {
//目标：掌握枚举的应用场景；做信息标志和分类
check(Constant.BOY);
}
public static void check(Constant sex){
switch (sex){
case BOY:
System.out.println("是男孩");
break;
case GIRL:
System.out.println("是女孩");
break;
}
}
}

枚举

public enum Constant {
BOY,GIRL;
}

五泛型

认识泛型

定义类，接口，方法时，同时声明了一个或者多个类型变量（如：<E>）,称为泛型类、泛型接口、泛型方法、它们统称为为泛型

public class ArrayList{
...
}

作用：

泛型提供了编译阶段约束所能操纵的数据类型，并自动进行检查能力，这样可避免因强制类型转换，及其可能出现的异常。

泛型的本质：

把具体的数据类型作为参数传给类型变量。

泛型类

修饰符 class 类名<类型变量，类型变量，…>{

}

public class ArrayList{
...
}

泛型类举例代码

public class Test {
public static void main(String[] args) {
MyArrayList list=new MyArrayList<>();
list.add("java1");
list.add("java2");
String ele= list.get(1);
System.out.println(ele);
System.out.println("-----------");
MyClass2 c2=new MyClass2<>();
System.out.println("------------");
MyClass3 c3=new MyClass3<>();
MyClass3 c4=new MyClass3<>();
}
}

public class MyArrayList {
private Object[] arr=new Object[10];
private int size;
public boolean add(E e){
arr[size++]=e;
return true;
}
public E get(int index){
return (E) arr[index];
}
}

public class MyClass2 {
public void put(E e,T t){
}
}

public class MyClass3 {
}

public class Animal {
}

public class Cat extends Animal{
}

public class Dog extends Animal{
}

泛型接口

修饰符 interface 接口名<类型变量,类型变量,…>{ }

public interface A{
...
}

泛型接口举例代码

public class Test {
public static void main(String[] args) {
//目标：掌握泛型接口的定义和使用
//场景：系统需要处理学生和老师的数据，需要提供两个功能，保存对象数据和根据名称查询数据
}
}

public interface Data {
void add(T t);
ArrayList getByName(String name);
}

import java.util.ArrayList;
public class StudentData implements Data{
@Override
public void add(Student student) {
}
@Override
public ArrayList getByName(String name) {
return null;
}
}

public class Student {
}

import java.util.ArrayList;
public class TeacherData implements Data{
@Override
public void add(Teacher teacher) {
}
@Override
public ArrayList getByName(String name) {
return null;
}
}

public class Teacher {
}

泛型方法

修饰符<类型变量，类型变量，…> 返回值类型方法名（形参列表）{

}

public static  void test(T t){
...
}

通配符：

就是 “?” ,可以在“使用泛型“的时候代表一切泛型；E T K V 是在定义泛型的时候使用。

泛型的上下限：

泛型上限：？extends Car :? 能接收的必须是Car或者子类。

泛型下限：？super Car :? 能接收的必须是Car或者父类。

注意事项：

1.泛型是工作在编译阶段的，一旦程序被编译成class文件，class文件中就不存在泛型了，这就是泛型擦除。

2.泛型不支持基本数据类型，只能支持对象类型（引用数据类型）。

posted @ 2025-08-06 11:33 wzzkaifa 阅读(4) 评论(0) 收藏举报

刷新页面返回顶部

wzzkaifa

深入解析：JAVA_TWELVE_面向对象高级三

一 内部类

定义：

一 成员内部类

定义：

特点：