java进阶day35反射机制、注解

最新推荐文章于 2024-05-23 20:15:22 发布
最新推荐文章于 2024-05-23 20:15:22 发布
阅读量174 收藏
点赞数
分类专栏： 笔记 java 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mzj15101229871/article/details/115460100
版权
笔记 同时被 2 个专栏收录
46 篇文章 5 订阅
订阅专栏
java
28 篇文章 0 订阅
订阅专栏

本章重点是ReflectTest7和ReflectTest10

p822 回顾反射机制

  • 什么是反射机制？有什么用？

通过反射机制可以操作字节码文件，可以操作操作字节码创建对象。使程序更加灵活。

  • 反射机制相关的类在哪些包下？

java.lang.reflect.*

  • 反射机制相关的主要的类？

java.lang.Class
java.lang.reflect.Method
java.lang.reflect.Constructor
java.lang.reflect.Field

  • 在java中获取Class的三种方式

1、Class c = Class.forName（“完整类名”）
2、Class c = 对象.getClass()
3、Class c = 类名.class()

  • 获取了Class后，可以调用无参数构造方法实例化对象

Class c = Class.getClass(“java.util.Date”)
Object obj = c.newInstance()
需要注意的是newInstance底层调用的是该类的无参数构造方法。如果没有这个无参数构造方法，就会出现“实例化异常“
如果只想让一个方法的静态代码块执行，那么可以使用
Class.forName(完整类名)
这样类就加载了，类加载的时候静态代码块会执行

  • 获取文件的绝对路径，但是要求该文件放在类路径下，也就是放在src下。src是文件的根路径

String path = Thread.currentThread().getContextClassLoader().get.Resource(“写从src出发的i相对路径”).getPath();
在这里插入图片描述

  • 直接以流的方式返回

InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(“从rsc出发的相对路径”)

  • IO + Properties ,快速绑定属性资源文件。满足两点要求：1、该文件在src目录下2、该文件以.properties结尾。

ResourceBundle bundle = ResourceBundle.getBundle(“属性资源文件，注意不写扩展名”);
String className = bundle.getString(key);
System.out.println(key)

p823 获取Field【反射属性】

在这里插入图片描述

package com.bjpowernode.java.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class ReflectTest05 {
    public static void main(String[] args) throws Exception{

        //首先拿到整个类
        Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");

        //获取完整类名
        System.out.println("完整名字："+studentClass.getName());

        //获取简单名字
        System.out.println("简略名字:"+studentClass.getSimpleName());

        //拿到所有的public修饰的Field：getFields()
        Field[] fields = studentClass.getFields();
        System.out.println(fields.length);
        Field f = fields[0];//获取到的唯一的一个field是no,因为获取所有的public修饰的Field
        String fieldName = f.getName();
        System.out.println(fieldName);

        //拿到所有的Field：getDeclaredFields()
        //System.out.println(fs.length);
        System.out.println("=========================================");
        Field[] fs = studentClass.getDeclaredFields();

        for (Field field : fs) {
            //获取属性的名字
            System.out.println(field.getName());
            //获取属性的类型
            Class fieldType = field.getType();
            //String fName = fieldType.getName();
            String fName = fieldType.getSimpleName();
            System.out.println(fName);

            //获取属性的修饰符列表
            int i= field.getModifiers();//现在返回的修饰符是一个数字，怎么将他转换为字符串呢
            //静态方法，要使用类名.方法名区调用
            String fModifier = Modifier.toString(i);
            System.out.println(fModifier);

        }
        System.out.println("=========================================");


    }
}

在这里插入图片描述

p824 通过反射机制反编译一个类的Field属性【了解即可，不是重点】

在这里插入图片描述

package com.bjpowernode.java.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
//通过反射机制反编译一个类的Field
public class ReflectTest06 {
    public static void main(String[] args) throws Exception{

        //创建这个是为了拼接字符串
        StringBuilder s = new StringBuilder();

        //先拿到类
        //Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Class studentClass = Class.forName("java.lang.String");

        //s.append("public class Student{");
        //动态获取类名、动态获取修饰符
        s.append(Modifier.toString(studentClass.getModifiers())
                +" class "+studentClass.getSimpleName()+"{\n");

        //拿到全部的Field
        Field[] fields = studentClass.getDeclaredFields();

        //遍历
        for (Field field : fields){
            s.append('\t');//追加换行符
            s.append(Modifier.toString(field.getModifiers()));//追加修饰符
            s.append(" ");//追加空格
            s.append(field.getType().getSimpleName());//追加类型的简单名字
            s.append(" ");//追加空格
            s.append(field.getName());
            s.append(";\n");//追加分号
        }
        s.append("}");
        System.out.println(s);
    }
}

p825 通过反射机制访问一个对象属性【掌握】

在这里插入图片描述

在这里插入图片描述

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.Student;

import java.lang.reflect.Field;

/*
通过反射机制访问java对象的属性？
 */
public class ReflectTest07{
    public static void main(String[] args) throws Exception{
        /*
        不使用反射机制。怎么去访问对象属性'
        =================================================
         */
        Student student = new Student();
        /*
            给属性赋值
            三要素：1、对象student
                    2、属性no
                    3、1234
         */
        student.no=1234;


        //读取属性
        System.out.println(student.no);

        /*
        ==================================================
         */
        /*
        使用反射机制，如何访问对象属性

        /*
            给obj对象(student)的no属性赋值
            三要素：1、obj对象
                    2、noField属性
                    3、219912
        ==================================================
         */
        Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Object obj = studentClass.newInstance();//创建一个student对象(底层调用无参数构造方法)

        //获取no属性（根据属性的名称来获取Field）
        Field noField = studentClass.getDeclaredField("no");


        //给属性赋值
        noField.set(obj,219122);//给obj对象的no属性赋值219122


        /*
        获取属性的值,两个要素
            1、obj对象
            2、属性noField
         */
        System.out.println(noField.get(obj));
          /*
        使用反射机制，如何访问对象属性
        ==================================================
         */

    }
}

p826 访问对象属性【私有属性能否访问】

在这里插入图片描述

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.Student;

import java.lang.reflect.Field;

/*
通过反射机制访问java对象的属性？
 */
public class ReflectTest07{
    public static void main(String[] args) throws Exception{
        /*
        不使用反射机制。怎么去访问对象属性'
        =================================================
         */
        Student student = new Student();
        /*
            给属性赋值
            三要素：1、对象student
                    2、属性no
                    3、1234
         */
        student.no=1234;


        //读取属性
        System.out.println(student.no);

        /*
        ==================================================
         */
        /*
        使用反射机制，如何访问对象属性

        /*
            给obj对象(student)的no属性赋值
            三要素：1、obj对象
                    2、noField属性
                    3、219912
        ==================================================
         */
        Class studentClass = Class.forName("com.bjpowernode.java.bean.Student");
        Object obj = studentClass.newInstance();//创建一个student对象(底层调用无参数构造方法)

        //获取no属性（根据属性的名称来获取Field）
        Field noField = studentClass.getDeclaredField("no");


        //给属性赋值
        noField.set(obj,219122);//给obj对象的no属性赋值219122


        /*
        获取属性的值,两个要素
            1、obj对象
            2、属性noField
         */
        System.out.println(noField.get(obj));

        //访问私有属性
        Field nameField = studentClass.getDeclaredField("name");

        //但是现在不能设置私有属性，如何访问私有属性呢？
        //打破封装。但是有个缺点就是可能会带来安全隐患
        //这样设置之后，在在外部可以访问private。
        nameField.setAccessible(true);
        //给name属性赋值
        nameField.set(obj,"hajinwei");

        //获取name属性
        System.out.println(nameField.get(obj));

        //但是现在不能设置私有属性，如何访问私有属性呢？
          /*
        使用反射机制，如何访问对象属性
        ==================================================
         */



    }
}

p827 可变长度参数

在这里插入图片描述

package com.bjpowernode.java.reflect;

public class argsTest {
    public static void main(String[] args) {

        m();
        m(12);
        m(12,34);

        //m("abc");编译报错

        m3("abs","def","fdehf","gfg");

        System.out.println("=============");
        //可以直接传一个数组
        String[]  strs = {"dfhfj","dfshg","agyu","yurw"};
        m3(strs);
        System.out.println("=============");

        //直接在参数列表new数组
        m3(new String[]{"mazhognjie","hajinwei","zhangxinyue"});

    }

    public static void m(int...args){
        System.out.println("m方法执行了");
    }

    //必须在最后，且只能有一个
    public static void m2(int i,String...args){
        //
    }
    public static void m3(String...args){
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

p828 反射机制的Method【了解】

package com.bjpowernode.java.reflect;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectTets08 {

    public static void main(String[] args) throws Exception{
        //拿到类
        Class userService = Class.forName("com.bjpowernode.java.service.UserService");

        //创建一个userService对象
        Object obj = userService.newInstance();

        //拿到Method,包括私有的。
        Method[] methods = userService.getDeclaredMethods();
        //System.out.println(methods.length);

        //遍历method
        for (Method method : methods ){
            //获取方法名
            System.out.println(method.getName());
            //获取返回值类型
            System.out.println(method.getReturnType().getSimpleName());

            //获取修饰符列表
            System.out.println(Modifier.toString(method.getModifiers()));

            //获取方法的修饰符列表（一个方法的参数可能有多个）
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parametertype : parameterTypes){
                System.out.println(parametertype.getSimpleName());
            }
        }
    }

}

p829 反编译Method【了解】

package com.bjpowernode.java.reflect;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class ReflectTets09 {
    public static void main(String[] args) throws Exception{

        //准备一个StringBuider类型用来拼接
        StringBuilder s = new StringBuilder();
        //拿到类的信息
        //Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
        Class userServiceClass = Class.forName("java.lang.String");
        //s.append("public class userService {");
        s.append(Modifier.toString(userServiceClass.getModifiers())
                +" class "+userServiceClass.getSimpleName()+"{");

        //获取方法
        //拿到Method,包括私有的。
        Method[] methods = userServiceClass.getDeclaredMethods();

        for (Method  method: methods){
            //public boolean login(String name,String password){}

            //获取修饰符列表（public）

            s.append('\n');
            s.append('\t');
            s.append(Modifier.toString(method.getModifiers())+" ");

            //获取返回值类型
            s.append(method.getReturnType()+" ");

            //获取方法名
            s.append(method.getName()+"(");

            //获取参数类型及参数名String name,String password
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parametertype : parameterTypes){
                //获取参数类型
                s.append(parametertype.getSimpleName()+" ");
                s.append(",");
                //获取参数名字
//                s.append(parametertype.get);
            }
            s.deleteCharAt(s.length() - 1);//删去第二个逗号。删除指定下标的字符
            s.append(")");

        }
        s.append("\n}");
        System.out.println(s);


    }
}

p830 反射机制调用方法【重点】

在这里插入图片描述
在这里插入图片描述

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.service.UserService;

import java.lang.reflect.Method;

/**
 * 通过反射机制调用方法
 */
public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        /*
        不使用反射机制如何调用方法

         */
        //创建对象，调用方法
        UserService userService = new UserService();
        boolean loginSuccess = userService.login("admin","123456");
        //System.out.println(loginSuccess);
        System.out.println(loginSuccess ? "登录成功" : "登录失败");
        userService.logout();


        /*
        使用反射机制调用方法
        三要素：
            1、对象userService
            2、login方法名
            3、实参列表
            4、返回值
         */

        //拿到类
        Class serService = Class.forName("com.bjpowernode.java.service.UserService");

        //创建对象
        Object obj = serService.newInstance();//创建一个student对象(底层调用无参数构造方法)

        //拿到方法名
        Method loginMethod = userService.getClass().getDeclaredMethod("login", String.class, String.class);

        //开始调用。
        Object retValue = loginMethod.invoke(obj,"admin","123456");
        System.out.println(retValue);




    }
}

p831 反射Constructor

package com.bjpowernode.java.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;

/*
通过反射机制反编译
 */
public class ReflectTest11 {

    public static void main(String[] args) throws Exception{

        //创建字符串用来拼接
        StringBuilder s = new StringBuilder();

        //拿到类
        Class vipClass = Class.forName("java.lang.String");

        s.append(Modifier.toString(vipClass.getModifiers())+" class "+vipClass.getSimpleName()+"{\n");//public+
        //s.append("public class Vip {\n");

        /*
        拼接构造方法
         */
        Constructor[] constructors = vipClass.getConstructors();
        for (Constructor constructor :constructors){

            s.append("\t");

            //获取修饰符
            s.append(Modifier.toString(vipClass.getModifiers()));

            //构造方法无返回值，获取方法名
            s.append(" "+vipClass.getSimpleName()+"(");
            //获取参数列表
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class parameterType : parameterTypes){

                //获取参数修饰列表
                s.append(parameterType.getSimpleName()+" ");
                //获取参数名
                s.append(",");

            }
            //s.deleteCharAt(s.length() - 1);//删除参数中的逗号时，这样删除会出现错误。public Vip){}所以删除之前需要判断参数列表长度，如果参数大于1才删除
            if (parameterTypes.length > 1){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");
        }




        s.append("}");
        System.out.println(s);
    }
}

p832 反射机制调用构造方法【非重点】

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.Vip;

import java.lang.reflect.Constructor;
import java.util.concurrent.ExecutionException;

/*
使用反射机制new对象
 */
public class ReflectTest12 {
    public static void main(String[] args) throws Exception {
        /*
        不使用反射机制new对象
         */
        Vip vip1 = new Vip();
        Vip vip2 = new Vip(123);
        Vip vip3 = new Vip(1234,"mazhongjie");
        Vip vip4 = new Vip(12345,"hgajinwei","19970410",true);


        /*
        使用反射机制创建对象
         */

        //拿到类
        Class c = Class.forName("com.bjpowernode.java.bean.Vip");

        //调用无参数构造方法
        Object obj = c.newInstance();
        System.out.println(obj);

        //调用带参数构造方法
        //先获取到这个有参数的构造方法
        Constructor constructor = c.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);

        //调用构造方法new对象
        Object newobj = constructor.newInstance(110,"jack","1997-04-10",true);
        System.out.println(newobj);


        //获取无参构造方法
        Constructor con2 = c.getDeclaredConstructor();
        Object newobj2 = con2.newInstance();
        System.out.println(newobj2);
    }
}

p833 获取父类和父接口

在这里插入图片描述

反射机制结束

p834 注解怎么定义，怎么使用

在这里插入图片描述
在这里插入图片描述

p835 override注解【jdk内置注解】

java.lang下的注解
override方法只能注解方法。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

p836 元注解【注解注解的注解】在这里插入图片描述

在这里插入图片描述

p837 Deprecated注解

在这里插入图片描述

package com.bjpowernode.java.annotation;

//表示这个类已经过时
@Deprecated
public class AnnotationTest03 {
    public static void main(String[] args) {

    }

    @Deprecated
    public static void doSome(){
        System.out.println("do something");
    }


    public static void doOther(){
        System.out.println("do Other");
    }
}
class T{
    public static void main(String[] args) {

        AnnotationTest03 at = new AnnotationTest03();
        at.doSome();

        AnnotationTest03.doOther();
        AnnotationTest03.doSome();
    }
}

在这里插入图片描述

p838 注解中定义属性

在这里插入图片描述
在这里插入图片描述

p839 属性是value时可以忽略

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

p840 value属性的忽略

在这里插入图片描述

可以省略的前提是前面的注解中只有一个属性，并且是value。不能有多个。

p841 属性是一个数组

在这里插入图片描述
在这里插入图片描述

p842 反射注解

package com.bjpowernode.java.annotation5;

//只允许该注解可以标注类，方法

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//Target元注解时一个value数组，其中的数组是一个枚举类型。ElementType.Type表示只能注解类。
@Target(value = {ElementType.TYPE,ElementType.METHOD})

//希望这个注解可以被反射
@Retention(RetentionPolicy.RUNTIME)
//@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {

    /*
    vaule属性
     */
    String value() default "北京大兴区";
}


package com.bjpowernode.java.annotation5;

@MyAnnotation("上海浦东区")
public class MyAnnotationTest {

    //不能注解Field
//    @MyAnnotation
//    int i;


    //不能出现在构造方法上
//    @MyAnnotation
//    public MyAnnotationTest() {
//    }

    @MyAnnotation
    public void doSome(){

    }
}


package com.bjpowernode.java.annotation5;

//反射机制反射
public class ReflectAnnotationTest {
    public static void main(String[] args) throws Exception{

        //拿到类
        Class c = Class.forName("com.bjpowernode.java.annotation5.MyAnnotationTest");

        //判断MyAnnotationTest类上面是否有Annotation
        System.out.println(c.isAnnotationPresent(MyAnnotation.class));//true

        //如果有注解，如何获取注解
        if (c.isAnnotationPresent(MyAnnotation.class)){
            //获取该注解对象
            MyAnnotation myAnnotation = (MyAnnotation) c.getAnnotation(MyAnnotation.class);

            //拿到注解对象
            System.out.println("类上面的注解对象："+myAnnotation);

            //获取注解对象的属性，和调接口没区别
            String value = myAnnotation.value();
            System.out.println(value);



        }



        //判断String类上面是否有Annotation
        Class stringClass = Class.forName("java.lang.String");
        System.out.println(stringClass.isAnnotationPresent(String.class));//false
    }
}

p843 通过反射获取注解对象属性的值

package com.bjpowernode.java.annotation6;

import com.bjpowernode.java.annotation4.MyAnnotation;

import java.lang.reflect.Method;

public class MyAnnotationTest {


    @Myannotation(username = "admin",password = "454545")
    public void doSome(){

    }

    public static void main(String[] args) throws Exception{
        //通过反射机制取注解上的属性值
        //第一步，拿到类
        Class c = Class.forName("com.bjpowernode.java.annotation6.MyAnnotationTest");
        //System.out.println(c.getName());

        //拿到doSome（）方法
        Method doSomeMethod = c.getDeclaredMethod("doSome");

        //判断该方法上是否有注解？
        if (doSomeMethod.isAnnotationPresent(Myannotation.class)){
            //如果有注解，如何拿到注解.使用doSomeMethod.getAnnotation（）拿到Annotation类型的注解，
            // 然后强转为MyAnnotation类型。
            Myannotation myannotation = (Myannotation)doSomeMethod.getAnnotation(Myannotation.class);
            //拿到doSome()方法上的注解对象属性
            System.out.println(myannotation.username());
            System.out.println(myannotation.password());


        }


    }


}


package com.bjpowernode.java.annotation6;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Myannotation {


    /**
     * username属性
     *
     */
    String username();


    /**
     * password属性
     *
     */
    String password();


}

p844 注解在实际开发中的作用

在这里插入图片描述

参考这个案例
> 参考
完结2021.4.7

只会写bug的菜鸡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java进阶——反射机制
LiLi的博客
12-05 473
反射机制（比较简单，因为只要会查帮助文档，就可以了） 反射机制有什么用？ 通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。（可以读和修改字节码文件） 通过反射机制可以操作代码片段。（class文件） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类有哪些？ java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。
Java进阶 —— 注解与反射
荔枝当大佬的博客
07-24 125
在了解完Java中的集合和IO流之后，荔枝继续梳理有关Java反射的知识，这个基础知识点也是在面试中可能会考到滴哦~~~在这篇文章中，荔枝主要梳理了有关Java反射、动态代理类的实现和注解的相关知识。其中Java反射中通过反射来获取指定方法、属性、父类和接口等内容需要掌握，还有一个重点就是如何实现动态代理类。
Java 进阶day13 单元测试(JUnit)、反射、注解、动态代理
weixin_44504809的博客
04-06 167
Java 进阶day13 单元测试(JUnit)、反射、注解、动态代理
【HM-02Java进阶-day14-Junit单元测试-反射-注解】
weixin_43317534的博客
10-08 132
java反射
java进阶-day10
m0_52405419的博客
10-16 189
反射机制 通过反射机制，可以操作字节码文件（读和改）。 在java.lang.reflect包下。 Class：整个这个class文件 Construcrot：字节码文件中的构造方法 Method:字节文件中的方法 Field：字节码文件中的属性 获取class文件第一：Class c=Class.forName(“java.lang.String”);这个方法是一个静态方法，参数是一个字符串，字符串需要是一个完整的类名。完整类名必须带有包名。 获取class文件第二：String s=“abc”；Cla
13天Java进阶笔记-day12-JUnit单元测试、反射、注解、动态代理
qq_36178962的博客
06-11 1239
单元测试是指程序员写的测试代码给自己的类中的方法进行预期正确性的验证。单元测试一旦写好了这些测试代码，就可以一直使用，可以实现一定程度上的自动化测试。单元测试一般要使用框架进行。 什么是框架？ 框架是前人或者一些牛逼的技术公司在实战或者研发中设计的一些优良的设计方案或者成型的 代码功能，作为一个完整的技术体系发行出来称为框架。框架可以让程序员快速拥有一个强大的解决方案，可以快速的开发功能，提高效率并且直接就有了很好的性能。单元测试的经典框架：是什么单元测试概念单元测试框架的作用Junit框架的使用步骤:下载
Java进阶16 单元测试&XML&注解
最新发布
summer_9823的博客
05-23 1048
单元测试Junit、XML文件编写语法规则、约束、解析、注解、自定义注解
java进阶开发-----单元测试、反射、注解、动态代理
weixin_65489884的博客
01-14 331
单元测试（不用main方法来测试，直接@Test）、反射（获取类的全部成分）、注解（新型方法）、动态代理（一个对象，用来对被代理的行为额外作一些辅助工作）
No_0616 Java进阶学习——Java注解学习
lutianfei的专栏
06-17 1478
注解定义 注解中的成员 元注解 —- 修饰注解的注解 注解案例—-银行最大转账金额 注解示例2—jdbc连接
java进阶13天资料.zip
08-08
Java进阶13天资料 day01-复习回顾、静态、继承、引用类型使用 day02-抽象类、接口、代码块，final、单例、枚举 day03-多态、包、权限修饰符、内部类，Object类，Date类 day04-常用API、正则表达式，泛型、Collection...
02-java语言进阶源码
04-26
6. **注解与反射** (day15-注解_反射): 注解是元数据的一种形式，可以提供编译时或运行时的附加信息。反射则允许程序在运行时动态地获取类的信息并操作类的对象，这对于框架开发、动态代理和元编程至关重要。 7. **...
Java_day15上课资料.zip
04-01
【Java_day15上课资料】...这些知识点是Java开发中的基础，通过深入学习和实践，可以提升编程技能，为后续的Java进阶学习打下坚实的基础。同时，配合视频教程《BV1Tp4y187ND》学习，将理论与实际操作相结合，效果更佳。
Java_day13上课资料.zip
04-01
【Java_day13上课资料.zip】是一个包含Java学习资源的压缩包，主要针对初学者或有一定基础的学习者，提供了一天课程的知识点...逐步掌握这些内容，将使你具备解决实际问题的能力，为后续的Java进阶学习打下坚实基础。
day13javacode
05-27
标签"day13javacode"再次强调了这是一个关于Java编程的教学内容，可能涉及的是进阶主题或者是对之前学习的回顾和深化。由于没有具体的文件内容，我们只能根据常规的编程学习路径来推测可能包含的知识点。 在学习...
特征融合方法
不要回答的博客
03-05 8859
概述 基本概念 在很多工作中，融合不同尺度的特征是提高分割性能的一个重要手段。低层特征分辨率更高，包含更多位置、细节信息，但是由于经过的卷积更少，其语义性更低，噪声更多。高层特征具有更强的语义信息，但是分辨率很低，对细节的感知能力较差。如何将两者高效融合，取其长处，弃之糟泊，是改善分割模型的关键。 很多工作通过融合多层来提升检测和分割的性能，按照融合与预测的先后顺序，分类为早融合(Early fusion)和晚融合(Late fusion)。 早融合(Early fusion): 先融合多层的特征，然后在
计算机网络【java面试题】
不要回答的博客
09-11 3357
1、计算机网络中的七层模型以及每一层的作用？ OSI七层模型 功能 对应的网络协议 应用层 应用层是网络体系中最高的一层，也是唯一面向用户的一层，也可视为为用户提供常用的应用程序，每个网络应用都对应着不同的协议 HTTP、TFTP, FTP, NFS, WAIS、SMTP 表示层 主要负责数据格式的转换，确保一个系统的应用层发送的消息可以被另一个系统的应用层读取，编码转换，数据解析，管理数据的解密和加密，同时也对应用层的协议进行翻译 Telnet, Rlogin, SNMP, Goph
2020最新Spring框架教程【IDEA版】-Spring框架从入门到精通
不要回答的博客
06-21 2932
第一章：认识Spring 01p/102p Spring认识框架 02p/102p Spring官网浏览以及资源介绍 03p/102p 框架内部模块 第二章 IoC控制反转 04p/102p IoC概念 05p/102p 创建对象的方式 06p/102p IoC的实现技术 07p/102p 第一个例子创建对象 08p/102p 创建spring配置文件 09p/102p 创建容器对象ApplicaitonContext【拿到spring创建的对象】 @Test publi
深度学习中参数和超参数的区别
不要回答的博客
03-05 2724
参数：就是模型可以根据数据可以自动学习出的变量，应该就是参数。比如，深度学习的权重，偏差等。 超参数：就是用来确定模型的一些参数，超参数不同，模型是不同的(比如说：假设都是CNN模型，如果层数不同，模型不一样，虽然都是CNN模型。)，超参数一般就是根据经验确定的变量。在深度学习中，超参数有：学习速率，迭代次数，层数，每层神经元的个数等等。 ...
Java枚举、注解、反射与单元测试详解
"该资源是关于Java编程的教程，涵盖了枚举、注解、反射以及单元测试和Lombok工具的使用。" 在Java编程中，枚举（Enumeration）是一种特殊的类，从Java 1.5版本开始引入，它提供了一种更安全、更规范的方式来表示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值