JAVA基础-面向对象进阶（三）

于 2025-06-24 21:09:15 发布
阅读量248 收藏 2
点赞数 10
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjdjjdkd/article/details/148859821

目录

1.内部类

1.1 成员内部类

 1.2 静态内部类

 1.3 局部内部类

1.4 匿名内部类（重点）

 1.4.1 匿名内部类在开发中的使用场景

1.4.2 匿名内部类的拓展

 2.枚举

2.1 枚举的应用场景

3. 泛型

3.1 泛型类

3.2 泛型接口

 3.3 泛型方法

3.4 通配符和上下限

1.内部类

1.1 成员内部类

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

public class Outer {

        //成员内部类

        public class Inner {

        }

}

package com.itheima.innerclass1;
//外部类
public class Outer {
    public static String schoolName = "清华";
    public static void inAddr(){
        System.out.println("我们在北京！");
    }
    private String hobby;
    private double height;
    public void run(){
        System.out.println("run");
    }
    //成员内部类
    //特点：无static修饰，属于外部类的对象持有的
    //必须存在外部类对象，才会有这个成员内部类
    public class Inner{
        private String name;
        private int age;

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }
        //拓展：成员内部类访问外部类的成员特点。
        public void show(){
            //1.成员内部类中，可以直接访问外部类的静态成员
            System.out.println(schoolName);
            inAddr();

            //2.成员内部类中，可以直接访问外部类的实例成员
            System.out.println(hobby);
            System.out.println(height);
            run();
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

package com.itheima.innerclass1;

public class People {
    private int hearBeat = 110;
    //成员内部类
    public class Heart{
        private int heartBeat = 95;
        public void show(){
            int heartBeat = 80;
            System.out.println(heartBeat);//80
            System.out.println(this.heartBeat);//95
            //拿到当前外部类对象：外部类名.this.变量名
            System.out.println(People.this.hearBeat);//110
        }
    }
}

package com.itheima.innerclass1;

public class Test {
    public static void main(String[] args) {
        //目标：掌握成员内部类，搞清楚语法就可以了
        //成员内部类创建对象的语法
        //外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
        Outer.Inner in = new Outer().new Inner();
        in.setName("张三");
        in.show();

        People
    }
}

 1.2 静态内部类

package com.itheima.innerclass2;

public class Outer {
    public static String schoolName = "清华";
    public static void inAddr(){
        System.out.println("我们在北京！");
    }
    //创建属于外部类对象的实例成员
    private double height;
    //静态内部类：有static修饰，属于外部类本身的
    public static class Inner{
        //类有的成员他都有
        private String name;
        private int age;

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            //1.静态内部类中，可以直接访问外部类的静态成员
            System.out.println(schoolName);
            //2.静态内部类中，不能直接访问外部类的实例成员
            //System.out.println(height);//报错
            Outer o = new Outer();
            System.out.println(o.height);
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}

package com.itheima.innerclass2;
//外部类
public class Test {
    public static void main(String[] args) {
        //目标：认识静态内部类，搞清楚其特点
        //外部类名.内部类 对象名 = new 外部类名.静态内部类（）;
        Outer.Inner in = new Outer.Inner();
        in.show();
    }


}

 1.3 局部内部类

1.4 匿名内部类（重点）

 

public class Test {
    public static void main(String[] args) {
        //目标：认识匿名内部类。
        //匿名内部类本质是一个子类，同时会立即创建一个子类对象
        //匿名内部类的名称：当前类名&编号
        Animal a = new Animal() {
            @Override
            public void cry() {
                System.out.println("狗汪汪汪的叫~~~");
            }
        };
        a.cry();

    }
}

//class Dog extends Animal{
//    @Override
//    public void cry() {
//        System.out.println("狗汪汪汪的叫~~~");
//    }
//}
//抽象类不允许创建对象
abstract class Animal{
    public abstract void cry();
}

 1.4.1 匿名内部类在开发中的使用场景

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

public class Test2 {
    public static void main(String[] args) {
        //目标：匿名内部类的使用场景：通常作为一个对象参数传输给方法使用
        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生游泳贼快~~~");
            }
        };
        go(s1);

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师贼慢~~~");
            }
        });
    }

    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}


//需求：学生和老师要一起参加游泳比赛
interface Swimming{
    void swim();
}

1.4.2 匿名内部类的拓展

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Test3 {
    public static void main(String[] args) {
        //拓展：掌握匿名内部类的真实场景
        //GUI SWING编程：桌面编程
        //1.创建一个窗口
        JFrame win = new JFrame("登录一下");

        JPanel panel = new JPanel();
        win.add(panel);

        JButton btn = new JButton("登录");
        panel.add(btn);

        //给按钮绑定单击时间监听器对象，可以用来监听用户的点击，以便做出反应
        //监听器对象需要的参数是一个接口对象，但是接口不能有对象，所以可以用匿名内部类
        //也可以定义一个实现类来创建接口对象，但是很麻烦
        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("点击我，我要登录了!");
                JOptionPane.showMessageDialog(win,"没事别点我!讨厌你！");
            }
        });

        //2.设计大小，居中提示
        win.setSize(400,300);
        win.setLocationRelativeTo(null);
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }
}

匿名内部类是作为一个对象参数传输给方法使用的，至于什么时候用匿名内部类要看实际开发的需要，遇到了才用，没有遇到不会主动用。

  • 还有一个很重要的作用：简化代码（新技术的基础）

 2.枚举

//枚举类
public enum A {
    //枚举类的第一行必须罗列的是枚举对象的名称
    X, Y, Z;
    //其他成员
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}

 

public class Test {
    public static void main(String[] args) {
        //目标：认识枚举类。搞清楚枚举类的特点
        //A a = new A();//报错
        A a1 = A.X;
        A a2 = A.Y;
        System.out.println(a1);
        System.out.println(a2);

        System.out.println("------------------");
        //values方法拿到枚举类的全部对象，放到一个数组中去返回
        A[] as = A.values();
        for (int i = 0; i < as.length; i++) {
            A a = as[i];
            System.out.println(a);
        }

        A y = A.valueOf("Y");
        System.out.println(y == a2);

        //ordinal拿对象的索引！
        System.out.println(a1.ordinal());//0
        System.out.println(a2.ordinal());//1
    }
}

 

2.1 枚举的应用场景

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

public class Constant {
    public static final int DOWN = 1;
    public static final int UP = 2;
    public static final int HALE_UP = 3;
    public static final int DELETE_LEFT = 4;
}

public class Test {
    public static void main(String[] args) {
        //目标：搞清楚枚举的应用场景:信息标志和信息分类
        //需求：需要你提供一个方法，可以完成向下取整，向上取整，四舍五入，去掉小数部分
        //常量做信息标准和分类，也很优雅，大那是参数值不被约束
        System.out.println(handleData(3.1,Constant.DOWN));
        System.out.println(handleData(5.99,Constant.HALE_UP));
    }

    public static double handleData(double number,int flag){
        switch (flag){
            case Constant.DOWN:
                //向下取整
                number = Math.floor(number);//3.9999 == 3
                break;
            case Constant.UP:
                //向上取整
                number = Math.ceil(number);//3.1 == 4
                break;
            case Constant.HALE_UP:
                //四舍五入
                number = Math.round(number);//3.6 == 4
                break;
            case Constant.DELETE_LEFT:
                //去掉小数部分
                number = (int)number;
                break;
        }
        return number;
    }
}

常量做信息标准和分类，也很优雅，但是handleData方法中的参数不被约束，可任意填写。

但是枚举做信息标准和分类，很优雅，参数值受到约束，最好的信息标志和分类的理想方案。 

3. 泛型

 

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
//        ArrayList list = new ArrayList<>();
//        list.add("java");
//        list.add("清华大学");
//        list.add(true);
//        list.add(false);
//        list.add(99.5);
//
//        //1.开发中很多时候需要统一数据类型(如果不使用泛型，类型没有办法统一，就需要进行强制转换！)
//        for (int i = 0; i < list.size(); i++) {
//            Object ele = list.get(i);
//            String result = (String)ele;//强制转换
//            System.out.println(result);
//        }

        System.out.println("----------------------");

        //ArrayList<String> list2 = new ArrayList<String>();
        ArrayList<String> list2 = new ArrayList<>();//JDK1.7开始，后面的类型可以不写
        list2.add("java");
        list2.add("清华大学");
        list2.add("我是bbb");

        for (int i = 0; i < list2.size(); i++) {
            String ele = list2.get(i);
            System.out.println(ele);
        }

    }
}

3.1 泛型类

import java.util.ArrayList;

//泛型类
public class MyArrayList<E> {
    private ArrayList list = new ArrayList();
    public boolean add(E e){
        list.add(e);
        return true;
    }

    public boolean remove(E e){
        return list.remove(e);
    }

    @Override
    public String toString() {
        return list.toString();
    }
}

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //目标：掌握泛型类的定义
        //需求：模拟ArrayList集合，自定义一个MyArrayList的泛型类
        MyArrayList<String> list = new MyArrayList();
        list.add("张无忌");
        list.add("赵敏");
        list.add("周芷若");
        //list.add(46);//报错
        list.remove("周芷若");
        System.out.println(list);
    }
}

这是一种装饰设计模式，把别人的对象包装起来

3.2 泛型接口

 

 目标：认识泛型接口的使用架构
需求：必须完成学生，老师数据的增删改查操作。

 3.3 泛型方法

import com.itheima.d9_genericity_interface.Student;

public class Test {
    public static void main(String[] args) {
        //目标：认识泛型方法。
        //需求：要求接受认识对象数组。
        String[] names = {"谢霆锋","陈羽凡","王宝强","贾乃亮"};
        printArrat(names);

        Student[] students = new Student[60];
        printArrat(students);
    }

    public static <T> T printArrat(T[] array){
        return array[0];
    }
}

3.4 通配符和上下限

 

import java.util.ArrayList;

public class Test2 {
    public static void main(String[] args) {
        //目标：通配符和上下限
        //需求：所有汽车要一起参与比赛
        ArrayList<TSL> tsls = new ArrayList<>();
        tsls.add(new TSL());
        tsls.add(new TSL());
        tsls.add(new TSL());
        go(tsls);

        ArrayList<LX> lxes = new ArrayList<>();
        lxes.add(new LX());
        lxes.add(new LX());
        lxes.add(new LX());
        go(lxes);

        //当没有规定泛型时，可以加入其他类型的数据
        ArrayList list = lxes;
        list.add("宝马");

        //泛型不能直接支持基本数据类型，只能支持对象类型（引用数据类型）
        //ArrayList<int> list = new ArrayList<>();//报错
    }

    //虽然LX和TSL是Car的子类，但是ArrayList<TSL>和ArrayList<LX>与ArrayList<Car>没有关系
    //通配符：其实就是？，可以在使用泛型时代表一切类型.E,T,K,V是定义时使用
    //泛型的上下限：? extends Car(上限，? 必须是Car或者Car的子类)
    //           ? super Car(下限，? 必须是Car或者Car的父类)
    public static void go(ArrayList<? extends Car> cars){

    }
}

class Car{
}
class BMW extends Car{
}
class TSL extends Car{
}
class LX extends Car{

}
class Dog{}

 

 泛型在编译时E T K V都会编程object类型，只能接收对象类型的数据，所以不能支持基本数据类型（万物皆对象）

学Java的bb
关注
5.2 jmu-Java-04面向对象进阶--02-接口-Comparator (5 分)
wzy992981933的博客
04-22 1195
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age 2 编写Comparator类 编写
PTA: jmu-Java-04面向对象进阶--02-接口-Comparator (15 分)
qq_51167577的博客
05-29 535
jmu-Java-04面向对象进阶–02-接口-Comparator (15 分) Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 #1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toS
7-1 jmu-Java-04面向对象进阶--02-接口-Comparator
GZH_mxjx的博客
09-26 911
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable
GZH_mxjx的博客
09-26 689
编写实现接口的类，使其按name以及age排序。
jmu-Java-04面向对象进阶-01-接口-匿名内部类ActionListener
xxn66666666的博客
10-16 398
ActionListener 的实现是通过一个匿名内部类来完成的。// 使用前面创建的 ActionListener。// ActionListener 参数的构造函数。// 实例作为参数来初始化 starter 变量。// 这里假设 MyStarter 类有一个接受。同时重写其方法，而无需显式地声明一个新的类。匿名内部类是一种特殊的类，它没有名字，并且在定义它的地方被立即实例化。这种技术允许你创建一个类的实例，
Java基础---面向对象进阶
JeremyHua的博客
02-16 195
Java基础---面向对象进阶
java学习---面向对象进阶
MTYSYS19990212的博客
08-03 2014
面向对象进阶1、权限访问  1.1 封装对象  1.2 权限修饰符2、代码块 2.1 普通代码块 2.2 构造代码块 2.3 静态代码块3、当前对象和父类对象的访问 3.1 this（当前对象） 3.2 super（父类对象）4、包 4.1 包的含义 4.2 包的使用 4.3 import 关键字5、入口方法详解 1、权限访问   1.1 封装对象      
Java PTA练习:jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
黄佳俊的博客
10-27 1272
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法: public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public b
jmu-Java-04面向对象进阶--02-接口-Comparator
qq_61433567的博客
06-10 1234
jmu-Java-04面向对象进阶--02-接口-Comparator
jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
黑白的黒's Blog
10-05 3893
定义IntegerStack接口，用于描述一个存放Integer元素的栈的常见方法: public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public boo
day12-面向对象进阶语法.xmind
12-03
day12-面向对象进阶语法.xmind
7-1 jmu-Java-04面向对象进阶--02-接口-Comparator (25分)
qq_43622460的博客
07-13 661
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age 2 编写Comparator类 编写N
Java虚拟机解剖：从字节码到机器指令的终极之旅（六）
ldwtxwh的专栏
06-20 1172
/ 实现自定义自旋策略@Overridefor (;;= 0) {// 自适应自旋64 : 0;// 使用CPU等待指令continue;// CAS获取锁@Override// 写操作后插入StoreLoad屏障acquire(1);release(1);// 测试用例// 启动10个线程i < 10;t.start();
「Java EE开发指南」如何用MyEclipse创建一个WEB项目？（二）
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
06-23 418
本教程将为大家介绍如何使用MyEclipse创建一个WEB项目，欢迎下载最新版IDE体验！
【C#】C#中的Type类详解
德仔
06-23 871
C#中的Type类是System命名空间的核心组件，为.NET反射系统提供基础支持。它作为抽象基类，表示各种类型声明，并提供类型元数据访问，包括属性、方法等成员信息。获取Type对象可通过typeof运算符、实例GetType方法或类型名称查找。Type类包含Name、Namespace等关键属性，以及GetMethods()等方法，支持动态类型检查、对象创建、成员调用等反射操作。在插件系统和动态编程中尤为实用，但需注意反射带来的性能开销、安全风险和维护复杂性。合理使用Type类可以增强代码灵活性，但性能敏
Java+GcExcel，生成自定义工作表
最新发布
葡萄城技术团队博客
06-24 503
GcExcel Java为Java开发人员提供了强大的电子表格处理能力，能够高效创建、操作和转换兼容Excel的工作表。该组件具有低内存占用、450+公式计算支持、多格式输出（xlsx/pdf等）以及模板批量生成等特性，适用于Web/桌面/云平台等多种环境。开发人员可通过API实现工作表显示配置、选项卡颜色设置、可见性管理、背景图片添加等自定义功能，还能创建独特的命名样式。GcExcel Java简化了复杂电子表格需求的处理流程，帮助开发者在各类应用中快速生成专业级报表。
springboot中表是以int为主键id的，写了一个生成不重复id的方法
weixin_46528266的博客
06-23 537
springboot中表是以int为主键id的，写了一个生成不重复id的方法
梯度下降路径平滑算法详解（C++）
zxy_ZXY123的博客
06-19 1327
本问主要基于梯度下降平滑算法进行总结分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值