反射的学习

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量124 收藏
点赞数
分类专栏： java学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48578877/article/details/126253956
版权

需求引出反射

  • 根据配置文件re.properties指定信息，创建Cat对象并调用方法hi
  • 在学习框架时特别多，即通过外部文件配置，在不修改源码情况下，来控制程序，符合设计OCP原则（开闭原则：不修改源码，扩容功能）
classfullpath=com.day02.Cat
method=hi

package com.day02;

public class Cat {
    public Cat() {
    }
    public void hi(){
        System.out.println("Cat 的hi方法");
    }
}

/**
 * 反射问题的引入
 */
@SuppressWarnings({"all"})
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException,
            InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//根据配置文件 re.properties 指定信息, 创建 Cat 对象并调用方法 hi

//传统的方式 new 对象 -》 调用方法
// Cat cat = new Cat();
// cat.hi(); ===> cat.cry() 修改源码.
//我们尝试做一做 -> 明白反射
//1. 使用 Properties 类, 可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
        String methodName = properties.get("method").toString();//"hi"
        System.out.println("classfullpath=" + classfullpath);
        System.out.println("method=" + methodName);
//2. 创建对象 , 传统的方法，行不通 =》 反射机制
//new classfullpath();
//3. 使用反射机制解决
//(1) 加载类, 返回 Class 类型的对象 cls
        Class cls = Class.forName(classfullpath);
//(2) 通过 cls 得到你加载的类 com.hspedu.Cat 的对象实例
        Object o = cls.newInstance();
        System.out.println("o 的运行类型=" + o.getClass()); //运行类型
//(3) 通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象
// 即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodName);
//(4) 通过 method1 调用方法: 即通过方法对象来实现调用方法
        System.out.println("=============================");
        method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)
    }
}

反射机制

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

Java反射机制原理示意图

在这里插入图片描述

java反射机制可完成

  • 在运行时判断任意一个对象所属的类；
  • 在运行时构造任意一个类的对象；
  • 在运行时得到任意一个类所具有的成员变量和方法；
  • 在运行时调用任意一个对象的成员变量和方法；
  • 生成动态代理；

反射相关的主要类

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

反射优点和缺点

  • 优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就失去了底层支持。
  • 缺点:使用反射基本是解释执行，对执行速度有影响。

应用实例

 * 测试反射调用的性能，和优化方案
 */
public class Reflection02 {
    public
    static
    void
    main(String[] args) throws ClassNotFoundException, NoSuchMethodException,
            InvocationTargetException, InstantiationException, IllegalAccessException {
//Field
//Method
//Constructor
        m1();//传统
        m2();//反射
        m3();//反射优化
    }
    //传统方法来调用 hi
    public static void m1() {
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("m1() 耗时=" + (end - start));
    }
    //反射机制调用方法 hi
    public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException,
            NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.day02.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m2() 耗时=" + (end - start));
    }
    //反射调用优化 + 关闭访问检查
    public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException,
            NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.qfedu.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        hi.setAccessible(true);//在反射调用方法时，取消访问检查
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);//反射调用方法
        }
        long end = System.currentTimeMillis();
        System.out.println("m3() 耗时=" + (end - start));
    }
}

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

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

Class类

在这里插入图片描述

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

Class类的常用方法

方法名功能说明
static Class forName（String name）返回指定类名name的Class对象
Object newInstance（）调用缺省构造函数，返回该Class对象的一个实例
getName（）返回此Class所表示的实体（类，接口，数组类，基本类型等）
Class[] getInterfaces()获取当前Class对象的接口
ClassLoader getClassLoader()返回该类的类加载器
Class getSuperclass()返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()返回包含某些Constructor对象的数组
Field[] getDeclaredFields()返回Field对象的一个数组
Method getMethod(String name,class…paramTypes)返回一个Method对象，此对象的形参类型为paramType

获取Class类对象

  • 1.前提：已知一个类名的全类名，且该类在类路径下，可通过Class类的静态方法forName（）获取。Class c1 = Class.forName(“java.lang.Cat”)

    应用场景：多用于配置文件，读取类全路径，加载类。

  • 2.前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高。 Class c2 = Cat.class;

    应用场景：多用于参数传递，比如通过反射得到对应的构造器对象。

  • 3.前提：已知某个类的实例，调用该实例的getClass ()方法获取Class对象。Class c3 = 对象.getClass(“类的全类名”)；

    应用场景：通过创建好的对象，获取Class对象

  • 4.其他方式

    • ClassLoder cl = 对象.getClass().getClassLoder();
    • Class c4 = cl.loadClass(“类的全类名”)；

  • 5.基本数据 （int ，char,boolean,float,double,byte,long,short)按照如下方式得到Class类对象

    Class cls = 基本数据类型.class

  • 6.基本数据类型对应的包装类，可以通过.TYPE得到Class类对象

    Class cls = 包装类.TYPE

有Class对象的类型

  • 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
  • interface：接口
  • 数据
  • enum：枚举
  • annotation：注解
  • 基本数据类型
  • void

类加载

基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。

  • 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
  • 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，则不宝座，降低了依赖性。

类加载时机

  • 当创建对象时（new）//静态加载
  • 当子类加载时，父类也加载//静态加载
  • 调用类中的静态成员时//静态加载
  • 通过反射//动态加载Class.forName(“com.test.Cat”);

类加载过程图

在这里插入图片描述

通过反射获取类的结构信息

第一组：java.lang.Class类

  • getName:获取全类名
  • getSimpleName:获取简单类名
  • getFields:获取所有public修饰的属性,包含本类以及父类的
  • getDeclaredFields:获取本类中所有属性
  • getMethods:获取所有public修饰的方法，包含本类以及父类的
  • getDeclaredMethods:获取本类中所有方法
  • getConstructors: 获取本类所有public修饰的构造器
  • getDeclaredConstructors:获取本类中所有构造器
  • getPackage:以Package形式返回包信息
  • getSuperClass:以Class形式返回父类信息.getlnterfaces:以Class[形式返回接口信息
  • getAnnotations:以Annotation[]形式返回注解信息

第二组：java.lang.reflet.Field类

  • getModifiers:以int形式返回修饰符

​ [说明:默认修饰符是0，public是1，private是2，protected是4,static是8,final是16], public(1) + static (8)= 9

  • getType：以Class形式返回类型
  • getName：返回属性名

第三组：java.lang.reflect.Method类

  • getModifiers:以int形式返回修饰符[说明:默认修饰符是0，public是1，private是2，protected是4,static是8, final是16]
  • getReturnType:以Class形式获取返回类型getName:返回方法名
  • getParameterTypes:以Class[返回参数类型数组

第四组: java.lang.reflect.Constructor类

  • getModifiers: 以int形式返回修饰符getName:返回构造器名(全类名)
  • getParameterTypes:以Class[]返回参数类型数组

通过反射创建对象

  • 方式一：调用类中的public修饰的无参构造器
  • 方式二：调用类中的指定构造器
  • Class类相关方法
    • newInstance：调用类中的无参构造器，获取对应类的对象
    • getConstructor（Class…clazz)根据参数列表，获取对应所有的构造器对象
  • Constructor类相关方法
    • setAccessible：暴破
    • newInstance（Object…object):调用构造器。

案例演示

测试1：通过反射创建某类的对象，要求该类中必须有public的无参构造

测试2：通过调用某个特定构造器的方式，实现创建某类的对象

/*
* 演示通过反射机制创建实例
        */
public class ReflecCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException,
            IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//1. 先获取到 User 类的 Class 对象
        Class<?> userClass = Class.forName("com.day02.User");
//2. 通过 public 的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
//3. 通过 public 的有参构造器创建实例
/*
constructor 对象就是
public User(String name) {//public 的有参构造器
this.name = name;
}
*/
//3.1 先得到对应构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
//3.2 创建实例，并传入实参
        Object hsp = constructor.newInstance("hsp");
        System.out.println("hsp=" + hsp);
//4. 通过非 public 的有参构造器创建实例
//4.1 得到 private 的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
//4.2 创建实例
//暴破【暴力破解】 , 使用反射可以访问 private 构造器/方法/属性, 反射面前，都是纸老虎
        constructor1.setAccessible(true);
        Object user2 = constructor1.newInstance(100, "张三丰");
        System.out.println("user2=" + user2);
    }
}
class User { //User 类
    private int age = 10;
    private String name = "jack";
    public User() {//无参 public
    }
    public User(String name) {//public 的有参构造器
        this.name = name;
    }
    private User(int age, String name) {//private 有参构造器
        this.age = age;
        this.name = name;
    }
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

通过反射访问类中的成员

访问属性

  • 根据属性名获取Field对象

    Field f = clazz对象.getDeclaredField(属性名)；

  • 暴破：f.setAccessible(true);//f是Field

  • 访问f.set(o,值) syso(f.get(o)); //o表示对象

    注意：如果是静态属性，则set和get中的参数o可以写成null

public class ReflecAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException,
            InstantiationException, NoSuchFieldException {
//1. 得到 Student 类对应的 Class 对象
        Class<?> stuClass = Class.forName("com.day02.Student");
//2. 创建对象
        Object o = stuClass.newInstance();//o 的运行类型就是 Student
        System.out.println(o.getClass());//Student
//3. 使用反射得到 age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88);//通过反射来操作属性
        System.out.println(o);//
        System.out.println(age.get(o));//返回 age 属性的值
//4. 使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
//对 name 进行暴破, 可以操作 private 属性
        name.setAccessible(true);
//name.set(o, "jack");
        name.set(null, "jack~");//因为 name 是 static 属性，因此 o 也可以写出 null
        System.out.println(o);
        System.out.println(name.get(o)); //获取属性值
        System.out.println(name.get(null));//获取属性值, 要求 name 是 static
    }
}
class Student {//类
    public int age;
    private static String name;
    public Student() {//构造器
    }
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}

访问方法

  • 根据方法名和参数列表获取Method方法对象: Method m =
    clazz.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法

  • 获取对象:Object o=clazz.newlnstance();

  • 暴破:m.setAccessible(true);

  • 访问:Object returnValue = m.invoke(o,实参列表);//o就是对象

    注意:如果是静态方法，则invoke的参数o，可以写成null!

/* 演示通过反射调用方法
        */
public class ReflecAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException,
            InstantiationException, InvocationTargetException, NoSuchMethodException {
//1. 得到 Boss 类对应的 Class 对象
        Class<?> bossCls = Class.forName("com.day02.Boss");
//2. 创建对象
        Object o = bossCls.newInstance();
//3. 调用 public 的 hi 方法
//Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到 hi 方法对象
        Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
        hi.invoke(o, "jack~");
//4. 调用 private static 方法
//4.1 得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
//4.2 因为 say 方法是 private, 所以需要暴破，原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o, 100, "张三", '男'));
//4.3 因为 say 方法是 static 的，还可以这样调用 ，可以传入 null
        System.out.println(say.invoke(null, 200, "李四", '女'));
//5. 在反射中，如果方法有返回值，统一返回 Object , 但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal 的运行类型=" + reVal.getClass());//String
//在演示一个返回的案例
        Method m1 = bossCls.getDeclaredMethod("m1");
        Object reVal2 = m1.invoke(o);
        System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster
    }
}
class Monster {}
class Boss {//类
    public int age;
    private static String name;
    public Boss() {//构造器
    }
    public Monster m1() {
        return new Monster();
    }
    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }
    public void hi(String s) {//普通 public 方法
        System.out.println("hi " + s);
    }
}
println("reVal2 的运行类型=" + reVal2.getClass());//Monster
    }
}
class Monster {}
class Boss {//类
    public int age;
    private static String name;
    public Boss() {//构造器
    }
    public Monster m1() {
        return new Monster();
    }
    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }
    public void hi(String s) {//普通 public 方法
        System.out.println("hi " + s);
    }
}
囨誌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反射机制学习
weixin_49893703的博客
02-09 1524
反射机制
反射基础知识
qq_44333590的博客
02-22 117
Class对象 创建Class实例的三种方法： //方法一：根据类名.class属性获取到该类的字节码对象，该类对象是在虚拟机加载类时创建 Class<Student> c1 = Student.class; //方法二：调用Class类的静态方法forName，通过类的完整名称字符串获取Class实例,?不知道类型 Class<?> c2 = Class.forName("com.entor.reflection.Student")
Java反射学习
Huhui's Blog
12-12 1081
1. Class类 Java程序中的各个类属于同一类事物，描述这类事物的Java类名就是Class。Class类代表各个类和接口在内存中的字节码，比如ArrayList类的字节码，一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的。 如何获得各个字节码对应的实例对象？ 类名.class，例如，Sy
基于准反射学习的哈里斯鹰优化算法
心升明月的博客
07-26 3759
文章目录一、理论基础1、哈里斯鹰优化算法2、改进哈里斯鹰优化算法（1）基于反向学习（2）基于准反向学习（3）基于准反射学习二、仿真实验与分析三、参考文献四、Matlab仿真程序 一、理论基础 1、哈里斯鹰优化算法 请参考这里。 2、改进哈里斯鹰优化算法 （1）基于反向学习 Tizhoosh[1]首先提出了基于反对的学习(OBL)。其主要思想是生成可行解的反向解，评价反向解，选择更好的候选解。一般来说，相反的数比随机数更接近最优解。具体计算公式如下： 设xix_ixi​为个体的可行解，xiox_i^oxio​
C#反射学习
以梦为马 不负韶华
04-21 1727
定义：反射就是动态获取程序集中的元数据和类型并创建对象调用成员 1、关键类：Type Type类可以获取类中的所有信息包括方法、属性等。可以动态调用类的属性方法，Type是对类的描述，主要针对类 2、如何获取一个类的Type对象： 1）如果该类有实例化的对象，则通过对象.GetType方法获取 2）如过该类没有创建对象...
Java反射学习.pdf
09-30
Java 反射学习 Java 反射是 Java 程序设计语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说 "自审 "，并能直接操作程序的内部属性。Java 反射的能力在实际应用中非常有价值，例如，使用它能获得 ...
反射学习笔记
07-25
反射学习笔记是深入理解这一关键特性的重要资源。以下是对"反射学习笔记"中可能包含的知识点的详细阐述： 1. **什么是反射**：反射是Java提供的一种机制，能够在运行时获取类的信息（如类名、属性、方法等）并动态...
Java高级特性之反射学习总结
12-22
老规矩我们还是先提出几个问题，一门技术必然要能解决一定的问题，才有去学习掌握它的价值 　一、 什么是反射? 　二、反射能做什么? 　一、 什么是反射? 　用在Java身上指的是我们可以于运行时加载、探知、使用...
Java反射学习和反射的应用场景干货都在这里
12-21
Java反射是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作，如创建对象、调用方法、访问属性等。在本文中，我们将深入理解Java反射的概念，掌握其核心实现，并探讨它在实际开发中的...
Java反射学习笔记
12-22
Java反射是Java编程语言中的一个强大特性，允许程序在运行时动态地获取类的信息并操作类的对象。在Java中，反射主要用于以下场景：动态加载类、访问私有成员...在学习和使用反射时，理解其工作原理和应用场景至关重要。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 407
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 141
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 326
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1889
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
准反射学习策略初始化种群.
08-05
准反射学习策略初始化种群是基于反向学习的一种简单方式。根据引用中的描述，当初始化进化算法种群的N个个体时，建立N个反向个体，每个反向个体相应于N个初始个体中的一个。这种方法可以增加种群的多样性，并且有助...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值