集合、枚举、注解、反射

最新推荐文章于 2025-05-23 12:22:17 发布
最新推荐文章于 2025-05-23 12:22:17 发布
阅读量175 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JAVASE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ningmengyouzhi/article/details/125244948

文章目录

集合

我们之前存储很多数据时，最先想到的就是数组，但数组初始化以后，长度就不可变了，不便于扩展。数组中提 供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的 个数。数组存储的数据是有序的、可以重复的。---->存储数据的特点单一；这时就要考虑Java 集合类，可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。保存数据的时候，需要考虑使用集合。

Java 集合可分为 Collection 和 Map 两种体系。Collection接口：单列数据，定义了存取一组对象的方法 的集合List：元素有序、可重复的集合。Set：元素无序、不可重复的集合。Map接口：双列数据，保存 具有映射系“key-value对”的集合。

集合框架
集合
Collection
Map
collections
List
Set
ArrayList
LinkedList
Vector
HashSet
TreeSet
LinkedHashSet
HashMap
Hashtable
LinkedHashMap
TreeMap
Properties

在这里插入图片描述

集合主要是两组(单列集合,双列集合)

 CoLLection 接口有两个重要的子接口List和Set ,他们的实现子类都是单列集合
 Map接口的实现子类是双列集合，存放的K-V

1、Collection接口

既然Collection接口是集合中的顶层接口，那么它中定义的所有功能子类都可以使用。查阅API中描述的 Collection接口。Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序 的，而另一些则是无序的。这里我们不关心具体创建的Collection中的那个子类对象，这里重点演示的是 Collection接口中的方法。

里面可以保存Object

boolean add(E e):确保此 collection 包含指定的元素（可选操作）。

boolean addAll(Collection c):将指定 collection 中的所有元素都添加到 此collection 中（可选操作）。

void clear():移除此 collection 中的所有元素（可选操作）。

boolean contains(Object o):如果此 collection 包含指定的元素，则返回 true 。

boolean containsAll(Collection c):如果此 collection 包含指定 collection 中的 所有元素，则返回 true 。

boolean equals(Object o):比较此 collection 与指定对象是否相等。

int hashCode():返回此 collection 的哈希码值。

boolean isEmpty():如果此 collection 不包含元素，则返回 true 。

Iterator iterator():返回在此 collection 的元素上进行迭代的迭代器。

boolean remove(Object o):从此 collection 中移除指定元素的单个实例，如果存在的话（可 选操作）。 如果传进一个0的话，是看成值而不是下标

boolean removeAll(Collection c):移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean retainAll(Collection c):仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

int size():返回此 collection 中的元素数。

Object[] toArray():返回包含此 collection 中所有元素的数组。

T[] toArray(T[] a):返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定 数组的运行时类型相同

Iterator:迭代器,集合很多，但是每种集合有自己保存数据的数据结构，使用迭代器去除集合中的元素
            先判断集合中是否有元素，如果有，取出
            hasNext:判断是否有下一个元素
            next:获取下一个元素
            remove:移除元素

●Collection接口实现类的特点
public interface Collection extends Iterable

  1. collection实现子类可以存放多个元素，每个元素可以是Object
    2)有些Collection的实现类，可以存放重复的元素，有些不可以
    3)有些Collection的实现类，有些是有序的(List)， 有些不是有序(Set)
  2. Collection接口没有直接的实现子类，是通过它的子接口Set和List来
    实现的

Iterortor

在这里插入图片描述

List接口

List接口时collection接口下的一个接口

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组。一个有序集合（也被称为序列）。 此接口的用户在列表中的每个元素都被插入的地方有精确的控制。用户可以通过它们的整数索引（在列 表中的位置）访问元素，并在列表中搜索元素。 与set不同的是，列表通常允许重复元素。

List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector。

常用方法

void add(int index, E element) ：在列表的指定位置插入指定元素（可选操作）。

boolean addAll(int index, Collection c) ：将指定 collection 中的 所有元素都插入到列表中的指定位置。

E get(int index) ：返回列表中指定位置的元素。

int indexOf(Object o) ：返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元 素，则返回 -1。

int lastIndexOf(Object o) ：返回此列表中最后出现的指定元素的索引；如果列表不包含此元 素，则返回 -1。

ListIterator listIterator() ：返回此列表元素的列表迭代器（按适当顺序）。 E remove(int index) ：移除列表中指定位置的元素（可选操作）。

E set(int index, E element) ：用指定元素替换列表中指定位置的元素（可选操作）。

List subList(int fromIndex, int toIndex) ：返回列表中指定的 fromIndex （包括 ）和 toIndex （不包括）之间的部分视图。

default void sort(Comparator c) ：分类列表使用提供的 Comparator比较元 素。

List 实现子类

Collection接口：单列集合，用来存储一个一个的对象。

List接口：存储有序的、可重复的数据。 -->“动态”数组,替换原有的数组。

ArrayList:底层是数组,7是再创建集合的时候，10个长度的Object类型的数组就被创建了，后面扩容是原来长度的一半.循环遍历比较高
LinkedList:链表结构  Node. 插入和删除效率比较高
Vector:底层也是数组 ，古老的类，线程安全的，效率比较低 ,不常用 , 扩容是原来长度的一倍.
       即使需要使用一个 线程安全的list,也会将ArrayList做一个转换Collections.synchronizedList(list); 此时得到的集合就是一个线程安全的集合。

主要看这三个类的底层代码

ArrayList底层

构造函数：

 public ArrayList(int initialCapacity)：根据这个数字创建一个长度数组，若小于0会报错

 public ArrayList()：生成默认空数组

 public ArrayList(Collection<? extends E> c)：会先看是不是同一个元素再依次复制

 public void trimToSize()：重置大小，因为每次添加如果需要扩容的话，就是扩容1.5倍，存在空间浪费，该方法就是去掉为null的元素空间

枚举与注解

枚举

引出：

 和我们一致使用的类差不多，但平常使用的类，我们课以随便创建对象，这里的枚举就有限制，比如一个季节类，如果也可以随便创建的话，那么春天、夏天、红天、绿天…很显然不合理。

一般用两种实现方法：

 自定义类

 枚举类

自定义枚举类，利用类实现

package 枚举和注解.枚举;
//自定义实现枚举
public class Demo1 {
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
    }
}
//自定义枚举
class Season{
    private String name;
    private String desc;
    //1、构造私有化
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    //2、无set方法，因为季节不可改
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    //3、直接在内部创建固定对象
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season SUMMER = new Season("夏天", "炎热");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season WINTER = new Season("冬天", "寒冷");
        //简写

    //4、重写toString
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

枚举类

package 枚举和注解.枚举;

public class Demo2 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        WeekDays weekDays1 = WeekDays.FRI;
        WeekDays weekDays2 = WeekDays.FRI;
        System.out.println(weekDays1 == weekDays2);//true
    }
}
//枚举类
enum Season2{
    //注意三点，和平常类的区别
    //1、class改成enum
    //2、对象创建有区别，用，间隔
    //3、对象创建在最上面
    SPRING("春天", "温暖"),
    SUMMER("夏天", "炎热"),
    AUTUMN("秋天", "凉爽"),
    WINTER("冬天", "寒冷");
    private String name;
    private String desc;
    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {
        return "Season2{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
//还是上面的枚举类，如果对象还有接口需要实现呢
enum Season3 implements info{
    //注意三点，和平常类的区别
    //1、class改成enum
    //2、对象创建有区别，用，间隔
    //3、对象创建在最上面
    SPRING("春天", "温暖"){
        public void show(){
            System.out.println("");
        }
    },
    SUMMER("夏天", "炎热"){
        public void show(){
            System.out.println("");
        }
    },
    AUTUMN("秋天", "凉爽"){
        public void show(){
            System.out.println("");
        }
    },
    WINTER("冬天", "寒冷"){
        public void show(){
            System.out.println("");
        }
    };
    //可以每个对象都重写一下接口方法，当然也可以直接枚举类中实现
    private String name;
    private String desc;
    private Season3(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {
        return "Season2{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}
interface info{
    public void show();
}
//如果将上面的枚举再简化一点呢
enum WeekDays {
    MON,TUE,WED,THR,FRI,STA,SUN;
    //这个就相当于，创建了对象，这些对象全部调用无参构造方法；
    //这样使用一般都是把里面内容当成自定义常量来使用

}

注解

1)注解(Annotation)也被称为元数据(Metadata),用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。
2)和注释一 样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息。
3)在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替java EE旧版中所遗留的繁冗代码和XML配置等。

使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
三个基本的Annotation:

  1. @Override：限定某个方法，是重写父类方法，该注解只能用于方法
  2. @Deprecated：用于表示某个程序元素(类，方法等)已过时
  3. @SuppressWarnings：抑制编译器警告

注：@interface不是interface,是注解类是jdk5之后加入的

@Override

这个就不举例了，我们经常遇到

1、表示重写父类方法、不一定是直接父类

2、不写@Override的话，重写方法也不会影响

3、那么@Override作用是什么呢？@Override表示接下来要重写方法，防止本来打算重写的方法写错，

比如父类中存在say方法，你本来打算重写该方法，但不小心写错了写成了see方法，如果不加@Override，那么就会把see方法当成自己的方法，不看成是重写，但如果加上@Override的话，就会报错，说明要重写的方法，并不存在。

@Deprecated

@Deprecated:用于表示某个程序元素(类，方法等)已过时

package 枚举和注解.注解;

public class Demo2 {
    A a = new A();

}
//1. @Deprecated 修饰某个元素(包、类、方法、元素、等)，表示该元素已经过时
//2.即不在推荐使用，但是仍然可以使用
//3、作用：jdk版本会更新，可能有的方法现在是jdk8很流行，然后jdk升级到10了，有些方法会过时，那可以直接淘汰吗？
// 当然不行，如果直接淘汰，那么之前写的代码就会出现问题，所以就要存在过渡，不推荐用，但还是能用
@Deprecated
class A{
    public void f(){
        System.out.println(" ");
    }
}

@SuppressWarnings

@SuppressWarnings:抑制编译器警告

package 枚举和注解.注解;

import java.util.ArrayList;
import java.util.List;

public class Demo3 {
    @SuppressWarnings({"all"})//抑制所有警告，平时我们写代码，会存在很多警告不美观，直接all
    public static void main(String[] args) {
        //1. 当我们不希望看到这些警告的时候，可以使用SuppressWarnings注解来抑制警告信息
        //2. 在{""}中，可以写入你希望抑制(不显示)警告信息
        //3. 作用范围，放在main方法这里，那么只对main方法有效；当然也可以直接方法类、属性上
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        int i;
    }
}

元注E解的基本介绍
JDK的元Annotation用于修饰其他Annotation
元注解:本身作用不大，讲这个原因希望同学们，看源码时，可以知道他是干什么.
元注解的种类(使用不多，了解，不用深入研究)

  1. Retention //指定注解的作用范围，三种SOURCE,CLASS,RUNTIME
  2. Target //指定注解可以在哪些地方使用
  3. Documented //指定该注解是否会在javadoc体现
    韩顺平
  4. Inherited //子类会继承父类注解
    教育

暂时实现的注解还没有实现什么功能

反射

问题引入：

 现在给你一个文件，里面写了一个类的全路径，和这类的相关方法，现在需要你创建这个类的对象，并调用这个方法；

 根据我们以前学的内容直接new 类名()；但不在同一路径下的类显然不能直接创建对象；

 可能又会想到，可以把类的路径读出来，然后根据这个路径new对象，但读到的内容是一个字符串，可以用字符串直接new对象吗？显然不行

 那怎么办呢？这就需要我们今天的学习内容。可能暂时不知道为啥会有这样的问题，但学到后面的框架时，这样的问题将会很多。

快速入门

接下来根据上面的需求，实现以下代码，先体验一下

package 反射;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sing(){
        System.out.println("喵喵喵");
    }
}
//假设只给你一个文件里面有这个类的绝对路径，以及相关方法，让你创建这个类，怎么办？
/*
首先把相关信息读出来，这部分就不演示了，直接给出
classPath = "反射.Cat.java"
method = "eat"
 */
class Test{
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        String classPath = "反射.Cat";
        String methodName = "eat";
        //(1) 加载类，返回Class类型的对象cls
        Class cls = Class.forName (classPath);//这里可能存在字符串读不出类，所以需要抛异常
        //(2) 通过cls得到你加载的类反射.Cat.java 的对象实例
        Object o = cls.newInstance();//抛异常
        System.out.println("o的运行类型=" + o.getClass()); //运行类型
        //(3) 通过cls得到你加载的类反射.Cat.java 的methodName"eat" 的方法对象
        //即:在反射中，可以把方法视为对象( 万物皆对象)
        Method method1 = cls.getMethod (methodName) ;
        //(4) 通过method1 调用方法:即通过方法对象来实现调用方法
        System.out.println("=============================") ;
        method1.invoke(o); //传统方法对象。方法()，反射机制方法。invoke(对象)
        //如果需要调用这个类中的其他方法，也不用修改代码，直接在信息文件中修改即可
		//这里存在很多注释，实现的话也就时4步
    }
}

反射机制

1.反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息(比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
2.加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象) ,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为:反射

可能大家对Class类感觉很奇怪，这里没啥奇怪的，就和我们平常接触到的类时一样的，比如Math、Arrays…，只不过这个类的名字很奇怪；

就像是他的名字叫张三，你的名字叫李四，我的名字就叫名字，诶你说气不气

图解
在这里插入图片描述

反射相关的主要类:

  1. java.lang.Class:代表一 个类，Class对象表示某个类加载后在堆中的对象
  2. java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
  3. java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量
  4. java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器
package 反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Cat {
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sing(){
        System.out.println("喵喵喵");
    }
}
class Test{
    public static void main(String[] args) throws Exception{
        String classPath = "反射.Cat";
        String methodName = "eat";
        //加载类，返回Class类型的对象cls
        Class cls = Class.forName (classPath);//这里可能存在字符串读不出类，所以需要抛异常
        //通过cls得到你加载的类反射.Cat.java 的对象实例
        Object o = cls.newInstance();//抛异常
        System.out.println("o的运行类型=" + o.getClass());
        //得到方法
        Method method1 = cls.getMethod (methodName) ;
        method1.invoke(o); //调用方法
        //得到成员变量，getField不能得到私有的属性
        Field nameField = cls.getField("age"); //
        System.out.println(nameField.get(o)); //调用变量
        //构造方法
        Constructor constructor = cls.getConstructor() ;//里面可以传参数，不传参数得到的就是无参构造方法
        System.out.println(constructor);


    }
}

反射优点和缺点
1.优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活，没有反射机制，框架技术就失去底层支撑。
2.缺点:使用反射基本是解释执行，对执行速度有影响.

那么怎么优化呢？ 反射调用优化+关闭访问检查

●反射调用优化关闭访问检查

  1. Method和Field、 Constructor对象都有setAccessible(方法
  2. setAccessible作用是启动和禁用访问安全检查的开关
    3.参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值
    为false则表示反射的对象执行访问检查

 以调用方法为例，只需要在Method method1 = cls.getMethod (methodName) ;时，再加一句method1.setAccessible(true);但并不会优化很多，和我们以前调用方法还是差了很多

  1. Class也是类，因此也继承Object类[类图]
  2. Class类对象不是new出来的，而是系统创建的[演示]
  3. 对于某个类的Class类对象， 在内存中只有一份，因为类只加载一 次[演示]
    4.每个类的实例都会记得自己是由哪个Class实例所生成
    5.通过Class对象可以完整地得到一个类的完整结构，通过一系列API
  4. Class对象是存放在堆的
    7.类的字节码二进制数据，是放在方法区的，
    有的地方称为类的元数据(包括方法代码，
    变量名，方法名，访问权限等等) https:/ /www.zhihu.com/question/38496907

在这里插入图片描述

常用方法

package 反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Cat {
     public String name = "花花";
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sing(){
        System.out.println("喵喵喵");
    }
}
class Test{
    public static void main(String[] args) throws Exception{

        String classPath = "反射.Cat";
        //1。获取到Car类对应的Class对象
        //<?>表示不确定的Java类型
        Class<?> cls = Class.forName (classPath) ;
        //2. 输出cLs
        System.out.println(cls); // 显示cls对象，是哪个类的Class对象 反射.Cat
        System.out.println(cls.getClass()); //输出cLs运行类型java.Lang.Class
        //3. 得到包名
        System.out.println(cls.getPackage().getName());//包名
        //4.得到全类名
        System.out.println(cls. getName());
        //5. 通过cLs创建对象实例
        Cat cat = (Cat)cls.newInstance() ;
        System.out.println(cat);
        //6.通过反射获取属性brand
        Field brand = cls. getField("name");
        System.out.println(brand.get(cat));//花花
        //7.通过反射给属性赋值
        brand.set(cat, "小白");
        System.out.println(brand.get(cat));//小白
        //8我希望大家可以得到所有的属性(字段)
        Field[] fieLds = cls.getFields();//得到所有的变量名
        for (Field f : fieLds) {
            System.out.println(f.getName());//名称
        }




    }
}

获取class类对象的方式

package 反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Cat {
     public String name = "花花";
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sing(){
        System.out.println("喵喵喵");
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        //1、Class.forName()就是上面的例子  多用于配置文件，读取类全路径，加载类.  编译阶段
        String classPath = "反射.Cat";
        Class<?> cls1 = Class.forName(classPath);
        System.out.println(cls1);

        //2、类名.class  多用于参数传递，比如通过反射得到对应构造器对象.  加载阶段
        Class cls2 = Cat.class;
        System.out.println(cls2);

        //3、对象.getClass()  通过创建好的对象，获取Class对象.  运行阶段
        Cat cat = new Cat();
        Class cls3 = cat.getClass();
        System.out.println(cls3);

        //4. 通过类加载器[4种]来获取到类的CLass对象
        //(1)先得到类加载器car
        ClassLoader classLoader = cat.getClass().getClassLoader() ;
        //(2)通过类加载器得到CLass对象
        Class cls4 = classLoader.loadClass (classPath);
        System.out.println(cls4);

        //cls1、cls2、cls3、cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5.基本数据(int, char, booLean, float , double, byte, long, short) 按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booLeanCLass = boolean.class;
        System.out.println(integerClass);//int
        //6.基本数据类型对应的包装类，可以通过.TYPE 得到CLass类对象
        Class<Integer> type1 = Integer. TYPE;
        Class<Character> type2 = Character. TYPE;
        System.out.println(type1);
        System.out.println(integerClass.hashCode());//?
        System.out.println(type1.hashCode());//?  相等 




    }
}

哪些类型有class对象

1.外部类，成员内部类，静态内部类，局部内部类，匿名内部类

2。interface :接口
3.数组

4enum :枚举
5.annotation :注解
6.基本数据类型

7void

package 反射;

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Cat {
     public String name = "花花";
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sing(){
        System.out.println("喵喵喵");
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        Class<String> cls1 = String.class;//外部类
        Class<Serializable> cls2 = Serializable.class;//接口
        Class<Integer[]> cls3 = Integer[].class;//数组
        Class<float[][]> cls4 = float[][].class;//二维数组
        Class<Deprecated> cls5 = Deprecated.class;//注解
        //枚举
        Class<Thread.State> cls6 = Thread.State.class;
        Class<Long> cls7 = Long.class;//基本数据类型
        Class<Void> cls8 = void.class;//void数据类型
        Class<Class> cls9 = Class.class;//类

        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls6);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);




    }
}

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。
1.静态加载:编译时加载相关的类，如果没有则报错，依赖性太强（new 类）
2.动态加载:运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性（forName）

●类加载时机
1.当创建对象时(new) //静态加载
2.当子类被加载时,父类也加载//静态加载
3.调用类中的静态成员时//静态加载
4.通过反射//动态加载
在这里插入图片描述

第十六章：Java之反射和枚举
快乐江湖的博客
10-12 867
Java反射(reflection)：反射机制是指在运行状态中，对于任意一个类，我们都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称之为Java的反射机制在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。
集合(collection)和枚举(enumerator)
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
01-15 840
集合(collection)和枚举(enumerator) 集合和枚举接口---对集合中对象进行不同方式的操作 1.集合:   对集合中的对象进行处理 .   对象单个获取(Item),   .   集合中对象的个数(count) .   增加/删除对象 .   获取枚举接口(Enum) 2.   枚举:   按顺序取得集合中的对象. .   Next .   Skip .   Reset .  
集合枚举
weixin_30810583的博客
08-29 172
采用二进制进行集合枚举： 例如可以用二进制表示集合{2,3，6,1,7},二进制第i位对应集合第i个元素，1代表在，0代表不在集合中。上述集合全集为s=111112=31,例如子集A={2,1,7}可以表示为： 100112=25.而B={2,3,6,7}可以表示为:111012=23,.下面利用位运算完成对集合的运算： A&B=10011&11101=10...
19 枚举集合
代码啥东东
03-22 612
1.枚举集合中的元素 下例用foreach语句列出一个简单数组的数据项： int[] pins = {9,3,7,2}; foreach (int pin in pins) { Console.Writel ine(pin); } foreach极大简化了需要编写的代码，但它只能在特定情况下使用一只能 遍历可枚举集合。 什么是可枚举集合?简单地说，就是实现了System.C...
C#编程中枚举与集合的使用与理解
weixin_42560991的博客
05-23 158
本文通过C#编程实例深入探讨了枚举（enums）和集合（collections）的概念、用法以及它们在编程中的重要性。通过对代码片段的分析和解答，文章揭示了如何在Windows Forms中创建可交互的界面，以及如何利用List和数组等数据结构进行数据的存储和处理。同时，文章还对枚举和集合的特性进行了比较，解释了它们在实际编程中的应用差异，并通过具体代码示例，展示了如何通过实现接口让集合能够对自定义对象进行排序。
枚举类和集合
gh_xiaohe的博客
09-20 1080
😹 作者: gh-xiaohe 😻 gh-xiaohe的博客 😽 觉得博主文章写的不错的话，希望大家三连（✌关注，✌点赞，✌评论），多多支持一下！！！
JAVA | 集合、泛型、枚举
weixin_72525373的博客
11-07 600
list1 集合中的元素数量：3 list2 集合中的元素数量：3 removeAll() 方法之后 list2 集合中的元素数量：2 list2 集合中的元素如下： two、four、 removeAll() 方法之后 list1 集合中的元素数量：2 list1 集合中的元素如下： one、three、List 是一个有序、可重复的集合，集合中每个元素都有其对应的顺序索引。List 集合默认按元素的添加顺序设置元素的索引，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。
java中的枚举
m0_56069948的博客
03-07 2310
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 枚举的理解 枚举是一组常量的集合，可以理解：枚举属于一种特殊的类，里面包含一组有限的特定对象 枚举定义的两种方式(自定义枚举和enum关键字枚举) 第一种枚举的自定义的实现步骤和注意事项 不要提供Setxxx方法，因为枚举对象值通常为只读 对枚举对象的属性使用：publi
【Java高级】枚举、泛型、注解、反射、异常处理、多线程、IO流
weixin_64275663的博客
02-03 1270
Java高级编程部分知识点:枚举、泛型、注解、反射、异常处理、多线程、IO流
JDK5.0新特性 常量 、枚举、 for each、反射
07-13
总结起来，JDK 5.0引入的常量注解、枚举、for each循环和反射特性，极大地丰富了Java语言的特性和表达能力，提升了开发效率和代码质量。通过理解并熟练应用这些特性，开发者可以编写出更加高效、安全和易于维护的...
自定义枚举以及如何在反射中获取枚举值
热门推荐
清箫的专栏
06-13 2万+
枚举也是类，在定义枚举的时候，其实是定义了一个枚举集合，然后在这个集合中包含一些列枚举值。比如性别可以是一个枚举集合，可能中包含男性、女性等枚举值。定义枚举集合以性别这个枚举集合为例，先来定义两个枚举值，分别为MALE和FEMALE：publicenum Gender { MALE, FEMALE } JAVA编译器会把这MALE和FEMALE转成两个枚举值。枚举类-Enum(name,
【Java基础笔记】枚举和注解.docx
10-25
在Java编程语言中，枚举（Enum）和注解（Annotation）是两种非常重要的特性，它们分别用于定义固定的常量集合和提供元数据信息。以下是对这两个概念的详细说明： **一、枚举类** 1. **定义**： - 自定义枚举类：...
枚举与集合：编程中的数据管理艺术
最新发布
weixin_31749299的博客
05-23 916
本章节深入探讨了在程序设计中如何有效地组织和管理数据。通过枚举类型（enum）和集合的概念，展示了如何处理大量数据，以及如何通过限制值集合来提高代码的健壮性和可维护性。通过实例讲解了枚举的定义、使用以及如何与集合相结合，为处理复杂数据提供了清晰的解决方案。
Day22初识集合
yjp1240201821的博客
03-20 915
本节主要讲解初识集合，帮助更好地理解集合和使用集合。
很重要！MySQL的复杂数据类型，学会使用再也不怕复杂场景了、枚举(ENUM)、集合(SET)、JSON、空间数据类型
小白的大数据之旅的博客
11-22 1165
MySQL数据库作为关系型数据库管理系统（RDBMS）中的佼佼者，提供了多种数据类型以满足不同应用场景的需求。本文将深入探讨MySQL中的枚举类型（ENUM）、集合类型（SET）、JSON类型以及空间数据类型
Java集合，泛型，枚举详解
惊鸿的技术博客
03-18 533
Java集合详解 为了保存数量不确定的数据，以及保存具有映射关系的数据（也被称为关联数组），Java 提供了集合类。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。Java 所有的集合类都位于 java.util 包下，提供了一个表示和操作对象集合的统一构架，包含大量集合接口，以及这些接口的实现类和操作它们的算法。 集合类和数组不一样，数组元素既可以是基本类型的值，也可以是对象（实际上...
Java基础面试题1
weixin_58276266的博客
10-04 694
Java基础面试题
mysql基本类型之枚举enum与集合set
weixin_46407419的博客
01-25 304
基本数据类型之枚举与集合类型 1、枚举 # 定义：提前定义好数据之后 后续录入只能录定义好的内容之一 # 注意：枚举只能从定义好的数据中选一个 (多选一) 关键字： enum(数据,数据,数据....) 实例： 创建表： create table t1( id int, name char(6), gender enum('male','female','others'...
JDK5.0新特性深度解析：反射与枚举的应用示例
资源摘要信息:"JDK5.0新特性 反射、枚举.rar" JDK 5.0（也被称为Java 1.5），是Java语言发展史上的一个重要的里程碑版本，它引入了许多新特性和改进，这些特性极大地增强了Java语言的表达能力和易用性。其中，反射...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值