【java】【面对对象高级4】内部类、枚举、泛型

春天的菠菜

已于 2023-07-27 17:25:29 修改

阅读量590

点赞数 1

分类专栏： java 文章标签： java 开发语言

于 2023-07-27 17:24:06 首次发布

本文链接：https://blog.csdn.net/legend818/article/details/131955366

版权

java 专栏收录该内容

83 篇文章 30 订阅

订阅专栏

1.4.2.2 匿名内部类在开发中实际场景

3.2.1 如何自己定义泛型类（一般架构师做）

3.2.2 模仿ArrayList写一个简单的MyArrayList泛型类

3.2.3 写一个定义2个类型的泛型类Myclass2

3.2.4 MyClass3泛型类，使用继承

3.3.6 实现学生类StudentData

3.5 泛型的注意事项：擦除问题、基本数据类型问题

3.5.1 擦除问题

3.5.2 基本数据类型问题

前言：java的内部类（静态内部类、局部内部类、匿名内部类）、枚举、泛型的语法使用

1、内部类

1.1 成员内部类【了解】

1.1.1 定义

1.1.2 扩展变量

1.2 静态内部类【了解】

1.2.1 定义

1.2.2 扩展变量

1.3 局部内部类【了解】

1.4 匿名内部类【重点】

1.4.1 定义

1.4.1.1 常规写法

1.4.1.2 匿名内部类改造

1.4.2 匿名内部类的常见使用场景

1.4.2.1 作为一个参数传输给方法

简化一下：

1.4.2.2 匿名内部类在开发中实际场景

package com.runa.staticdemo;

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

public class TestDesk {
    public static void main(String[] args) {
        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) {
//                JOptionPane.showMessageDialog(win,"登录成功~");
//            }
//        });
        // 最终目的是简化代码
        btn.addActionListener(e -> JOptionPane.showMessageDialog(win,"登录成功~"));


        win.setSize(400,400);
        win.setLocationRelativeTo(null);
        win.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        win.setVisible(true);
    }
}

2、枚举类

2.1 认识枚举

2.2 枚举类特点

2.3 抽象枚举

2.4 枚举实现单例模式

2.5 枚举的应用场景

2.5.1 常规做法1：

2.5.2 常规做法2-常量方式

2.5.3 枚举实现

3、泛型

3.1 认识泛型

package com.runa.staticdemo;

import java.util.ArrayList;

public class TestE {
    public static void main(String[] args) {
//        ArrayList list = new ArrayList<>();
//        list.add("小马");
//        list.add("次奥");
//        list.add("小曹");
//        list.add(new Cat());
//
//        for (int i = 0; i < list.size(); i++) {
//            String e = (String) list.get(i);
//            System.out.println(e);
        System.out.println("-------------------------------------");
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("小米");
        list1.add("小马");
        list1.add("字符串");
        //        list1.add(new Cat());
        for (int i = 0; i < list1.size(); i++) {
            String e = (String) list1.get(i);
            System.out.println(e);
        }

        System.out.println("-------------------------------------");
        ArrayList<Cat> list2 = new ArrayList<>();
        list2.add(new Cat());

    }
}

class Cat{
    
}

3.2 泛型类

3.2.1 如何自己定义泛型类（一般架构师做）

3.2.2 模仿ArrayList写一个简单的MyArrayList泛型类

package com.runa.staticdemo;

// 泛型类
public class MyArrayList<E> {
    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]; //强转
    }
}

3.2.3 写一个定义2个类型的泛型类Myclass2

package com.runa.staticdemo;

public class Myclass2<E, T> {
    public void put(E e, T t){

    }
}

3.2.4 MyClass3泛型类，使用继承

package com.runa.staticdemo;

public class MyClass3<E extends Animal> {
}

3.2.5 主函数

package com.runa.staticdemo;

public class TestAL {
    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("java");
        list.add("python");
        String ele = list.get(1);
        System.out.println(ele);

        Myclass2<String, String> list2 = new Myclass2<>();
        
        MyClass3<Animal> a  = new MyClass3<>();
        MyClass3<Dog> d  = new MyClass3<>();

    }
}

class  Animal{

}
class Dog extends Animal{

}
class Cat2 extends Animal{

}

3.3 泛型接口

3.3.1 如何写泛型接口

3.3.2 写一个泛型接口

package com.runa.staticdemo;

import java.util.ArrayList;

//泛型接口
public interface DataE<T> {
    void add(T t);
    ArrayList<T> getByName(String name);
}

3.3.3 学生类StudentE

package com.runa.staticdemo;

public class StudentE {
}

3.3.4 老师类TeacherE

package com.runa.staticdemo;

public class TeacherE {
}

3.3.5 实现类TeacherData

package com.runa.staticdemo;

import java.util.ArrayList;

public class TeacherData  implements DataE<TeacherE>{
    @Override
    public void add(TeacherE teacherE) {
        
    }

    @Override
    public ArrayList<TeacherE> getByName(String name) {
        return null;
    }
}

3.3.6 实现学生类StudentData

package com.runa.staticdemo;

import java.util.ArrayList;

public class StudentData implements DataE<StudentE>{
    @Override
    public void add(StudentE studentE) {
        
    }

    @Override
    public ArrayList<StudentE> getByName(String name) {
        return null;
    }
}

3.4 泛型方法、泛型通配符、上下限

3.4.1 写一个泛型方法

3.4.2 一个例子

3.4.2.1 Car类

package com.runa.staticdemo;

public class Car {
}

3.4.2.1 BMW类

package com.runa.staticdemo;

public class BMW extends Car{
}

3.4.2.2 BENZ类

package com.runa.staticdemo;

public class BENZ extends Car {
}

3.4.2.3 主程序

package com.runa.staticdemo;

import java.util.ArrayList;

public class TestF {
    public static void main(String[] args) {
        ArrayList<Car> cars = new ArrayList<>();
        cars.add(new BMW());
        cars.add(new BENZ());
        go(cars);

        ArrayList<BMW> bmws = new ArrayList<>();
        bmws.add(new BMW());
        bmws.add(new BMW());
        go(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

    }
    // 这个没有限定 ，可能将其他对象传进来了
//    public static<T> void go(ArrayList<T> cars){
//
//    }

    // 这个限定只能是Car或者Car子类
//    public static<T extends Car> void go(ArrayList<T> cars){
//
//    }

//    // 通配符
//    public static void go(ArrayList<?> cars){
//
//    }

    //    // 通配符 + extends Car上限 spuer Car是下限
    public static void go(ArrayList<? extends Car> cars){

    }




}