JavaSE高阶篇-反射

第一部分、Junit单元测试

1）介绍

1.概述:Junit是一个单元测试框架,在一定程度上可以代替main方法,可以单独去执行一个方法,测试该方法是否能跑通,但是Junit是第三方工具,所以使用之前需要导入jar包

2）Junit的基本使用（重点啊）

1.导入Junit的jar包
2.定义一个方法,在方法上写注解:  @Test
3.执行方法:
  a.点击该方法左边的绿色按钮,点击run执行 -> 单独执行一个指定的方法
  b.如果想要执行所有带@Test的方法,点击类名左边绿色按钮,点击run执行-> 执行当前类中所有@Test的方法

public class Demo01Junit {@Testpublic void add(){System.out.println("我是@Test执行的add方法");}@Testpublic void delete(){System.out.println("我是@Test执行的delete方法");}
}

 3）Junit的注意事项

1.@Test不能修饰static方法
2.@Test不能修饰带参数方法
3.@Test不能修饰带返回值方法 

 4）Junit的相关注解

@Before:在@Test之前执行,有多少个@Test执行,@Before就执行多少次 -> 一般都是用作初始化变量
@After:在@Test之后执行,有多少个@Test执行,@After就执行多少次   -> 一般可以用作关闭资源

public class Demo01Junit {@Testpublic void add() {System.out.println("我是@Test执行的add方法");}@Testpublic void delete() {System.out.println("我是@Test执行的delete方法");}@Beforepublic void methodBefore() {System.out.println("我是@Before执行的方法");}@Afterpublic void methodAfter() {System.out.println("我是@After执行的方法");}
}

5）@Test以后怎么使用

/*** 此类专门去测我们写好的功能*/
public class Demo02Junit {/* public static void main(String[] args) {CategoryController cc = new CategoryController();int result = cc.add("蔬菜");System.out.println("result = " + result);List<String> list = cc.findAllCategory();System.out.println(list);}*//*** 此方法专门测添加功能*/@Testpublic void add(){CategoryController cc = new CategoryController();int result = cc.add("蔬菜");System.out.println("result = " + result);}/*** 此方法专门测查找功能*/@Testpublic void find(){CategoryController cc = new CategoryController();List<String> list = cc.findAllCategory();System.out.println(list);}
}
public class CategoryController {/*** 添加功能*/public int add(String categoryName){ArrayList<String> list = new ArrayList<>();list.add(categoryName);return 1;//如果返回一个1,证明添加成功了}/*** 查找功能*/public List<String> findAllCategory(){ArrayList<String> list = new ArrayList<>();list.add("蔬菜");list.add("水果");list.add("服装");list.add("电器");list.add("玩具");list.add("手机");return list;}
}

 扩展注解:

@BeforeClass:在@Test之前执行,只执行一次,可以修饰静态方法

@AfterClass:在@Test之后执行,只执行一次,可以修饰静态方法

public class Demo03Junit {@Testpublic void add() {System.out.println("我是@Test执行的add方法");}@Testpublic void delete() {System.out.println("我是@Test执行的delete方法");}@BeforeClasspublic static void methodBefore() {System.out.println("我是@Before执行的方法");}@AfterClasspublic static void methodAfter() {System.out.println("我是@After执行的方法");}
}

 第二部分、类的加载时机

1.new对象
2.new子类对象(new子类对象先初始化父类)
3.执行main方法
4.调用静态成员
5.反射,创建Class对象   

1.类加载器(了解)_ClassLoader

1.概述:
   在jvm中,负责将本地上的class文件加载到内存的对象_ClassLoader
2.分类:
   BootStrapClassLoader:根类加载器->C语言写的,我们是获取不到的
                        也称之为引导类加载器,负责Java的核心类加载的
                        比如:System,String等
                        jre/lib/rt.jar下的类都是核心类
   ExtClassLoader:扩展类加载器
                  负责jre的扩展目录中的jar包的加载
                  在jdk中jre的lib目录下的ext目录
   AppClassLoader:系统类加载器
                  负责在jvm启动时加载来自java命令的class文件(自定义类),以及classPath环境变量所指定的jar包(第三方jar包)
        
    不同的类加载器负责加载不同的类
       
3.三者的关系(从类加载机制层面):AppClassLoader的父类加载器是ExtClassLoader
            ExtClassLoader的父类加载器是BootStrapClassLoader
 
  但是:他们从代码级别上来看,没有子父类继承关系->他们都有一个共同的父类->ClassLoader

4.获取类加载器对象:getClassLoader()是Class对象中的方法
  类名.class.getClassLoader()
 
5.获取类加载器对象对应的父类加载器
  ClassLoader类中的方法:ClassLoader      
  getParent()->没啥用
      
6.双亲委派(全盘负责委托机制)

   a.Person类中有一个String
     Person本身是AppClassLoader加载
     String是BootStrapClassLoader加载
   b.加载顺序:
     Person本身是App加载,按道理来说String也是App加载
     但是App加载String的时候,先问一问Ext,说:Ext你加载这个String吗?
     Ext说:我不加载,我负责加载的是扩展类,但是app你别着急,我问问我爹去->boot
     Ext说:boot,你加载String吗?
     boot说:正好我加载核心类,行吧,我加载吧!
         
   =======================================================================
         
    比如:
      class Test{
          new Person()
      }

    a.Test是app加载,person按理来说也是app加载,但是app先问ext要不要加载
      ext说不负责加载自定义类,我找boot去,boot一看,我不负责加载自定义类->perosn
      app一看,两个爹都不加载,我自己加载
      
    b.结论:当一个类加载器加载类的时候,总会先去上一级问一问,问上一级要不要加载,如果上级不加载,才自己加载
    
    =======================================================================
7.类加载器的cache(缓存)机制(扩展):一个类加载到内存之后,缓存中也会保存一份儿,后面如果再使用此类,如果缓存中保存了这个类,就直接返回他,如果没有才加载这个类.下一次如果有其他类在使用的时候就不会重新加载了,直接去缓存中拿,保证了类在内存中的唯一性
     
8.所以:类加载器的双亲委派和缓存机制共同造就了加载类的特点:保证了类在内存中的唯一性   

 

public class Demo01ClassLoader {public static void main(String[] args) {app();//ext();//boot();}/*** 负责加载核心类* BootStrapClassLoader:C语言编写,我们是获取不到的*/private static void boot() {ClassLoader classLoader = String.class.getClassLoader();System.out.println("classLoader = " + classLoader);}/*** 负责加载扩展类*/private static void ext() {ClassLoader classLoader = DNSNameService.class.getClassLoader();System.out.println("classLoader = " + classLoader);}/*** 负责加载自定义类*/private static void app() {ClassLoader classLoader = Demo01ClassLoader.class.getClassLoader();System.out.println("classLoader = " + classLoader);ClassLoader parent = classLoader.getParent();System.out.println("parent = " + parent);ClassLoader parent1 = parent.getParent();System.out.println("parent1 = " + parent1);//null}
}

 第三部分、反射

1）class类的以及class对象的介绍以及反射介绍

1.反射:是一种解剖class对象的技术
2.能解剖出点啥来?
   a.成员变量 -> 赋值取值
   b.构造方法 -> new对象
   c.成员方法 -> 调用执行

3.反射的作用:写出来的代码更灵活,通用
4.怎么学反射:先把反射技术看成是一套纯API来学
   根据涛哥设计的案例去体会反射代码的通用性

5.反射是解剖class对象的,所以玩儿反射第一步要干啥?
   获取class对象
    
    
6.class对象:class文件对应的对象
  class类:描述class对象的类叫做class类

 2）反射之获取Class对象

1.方式1:调用Object中的getClass()方法:
        Class<?> getClass()
            
2.方式2:不管是基本类型还是引用类型,jvm都为其提供了一个静态成员:class
    
3.方式3:Class类中的静态方法:
       static Class<?> forName(String className)  
                               className:类的全限定名(包名.类名)

public class Person {private String name;private Integer age;public Person() {}public Person(String name, Integer age) {this.name = name;this.age = age;}//私有构造private Person(String name){this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}
}

 

public class Test01 {public static void main(String[] args)throws Exception {/*1.方式1:调用Object中的getClass()方法:Class<?> getClass()*/Person person = new Person();Class aClass = person.getClass();System.out.println("aClass = " + aClass);System.out.println("===================");//2.方式2:不管是基本类型还是引用类型,jvm都为其提供了一个静态成员:classClass<Person> aClass1 = Person.class;System.out.println("aClass1 = " + aClass1);System.out.println("===================");/*3.方式3:Class类中的静态方法:static Class<?> forName(String className)className:类的全限定名(包名.类名)*/Class<?> aClass2 = Class.forName("com.atguigu.c_reflect.Person");System.out.println("aClass2 = " + aClass2);System.out.println("===================");//System.out.println(aClass1==aClass2);}
}

三种获取Class对象的方式最通用的一种

1.static Class<?> forName(String className)  
                               className:类的全限定名(包名.类名)
2.原因:参数为String形式,可以和Properties文件结合使用

 

className=com.atguigu.c_reflect.Student
public class Test02 {public static void main(String[] args)throws Exception {Properties properties = new Properties();FileInputStream in = new FileInputStream("day22_reflect\\pro.properties");properties.load(in);String className = properties.getProperty("className");Class<?> aClass = Class.forName(className);System.out.println("aClass = " + aClass);}
}

 3）获取Class对象中的构造方法

（1）获取所有public中的构造方法

1.Class类中的方法:
  Constructor<?>[] getConstructors() -> 获取的所有public的构造

public class Test02 {public static void main(String[] args)throws Exception {Properties properties = new Properties();FileInputStream in = new FileInputStream("day22_reflect\\pro.properties");properties.load(in);String className = properties.getProperty("className");Class<?> aClass = Class.forName(className);System.out.println("aClass = " + aClass);}
}

（2）获取空参构造_public

1.Class类中的方法:
  Constructor<T> getConstructor(Class<?>... parameterTypes)->获取指定的public的构造
                                parameterTypes:可变参数,可以传递0或多个参数
 
  a.如果获取的是空参构造:参数不用写
  b.如果获取的是有参构造:参数写参数类型的class对象
      
2.Constructor类中的方法:
  T newInstance(Object... initargs)  -> 创建对象
               initargs:传递的是构造方法的实参
                
  a.如果根据空参构造new对象,initargs不写了
  b.如果根据有参构造new对象,initargs传递实参

public class Test03_GetConstructor {public static void main(String[] args) throws Exception {Class<Person> personClass = Person.class;Constructor<Person> constructor = personClass.getConstructor();System.out.println("constructor = " + constructor);/*好比是: Person person = new Person();*/Person person = constructor.newInstance();//好比是:直接输出对象名,默认调用toStringSystem.out.println(person);}
}

 （3）利用空参构造创建对象的快捷方式_public

Class类中的方法:
  T newInstance()   ->  根据空参构造new对象
      
前提:被反射的类中必须有public的空参构造  

public class Test04_GetConstructor {public static void main(String[] args) throws Exception {Class<Person> personClass = Person.class;Person person = personClass.newInstance();System.out.println(person);}
}

（4）利用反射获取有参构造并创建对象_public

1.Class类中的方法:
  Constructor<T> getConstructor(Class<?>... parameterTypes)->获取指定的public的构造
                                parameterTypes:可变参数,可以传递0或多个参数
 
  a.如果获取的是空参构造:参数不用写
  b.如果获取的是有参构造:参数写参数类型的class对象
      
2.Constructor类中的方法:
  T newInstance(Object... initargs)  -> 创建对象
               initargs:传递的是构造方法的实参
                
  a.如果根据空参构造new对象,initargs不写了
  b.如果根据有参构造new对象,initargs传递实参

public class Test05_GetConstructor {public static void main(String[] args) throws Exception {Class<Person> class1 = Person.class;Constructor<Person> constructor = class1.getConstructor(String.class, Integer.class);System.out.println("constructor = " + constructor);/*好比是:Person person = new Person("柳岩",36);*/Person person = constructor.newInstance("柳岩", 36);//好比是直接输出Person对象,默认调用toStringSystem.out.println(person);}
}

（5）利用反射获取私有构造(暴力反射)

1.Constructor<?>[] getDeclaredConstructors()  -> 获取所有构造方法,包括private和public
2.Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) -> 获取指定构造,包括private和public
               parameterTypes:参数类型的class对象
                   
                   
3.Constructor有一个父类叫做AccessibleObject,里面有一个方法:
  void setAccessible(boolean flag) -> 修改访问权限
                     flag为true-> 解除私有权限

public class Test06_GetConstructor {public static void main(String[] args) {Class<Person> personClass = Person.class;Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();for (Constructor<?> declaredConstructor : declaredConstructors) {System.out.println(declaredConstructor);}}
}
public class Test07_GetConstructor {public static void main(String[] args)throws Exception {Class<Person> personClass = Person.class;Constructor<Person> ds = personClass.getDeclaredConstructor(String.class);//解除私有权限 -> 暴力反射ds.setAccessible(true);Person person = ds.newInstance("曼曼");System.out.println(person);}
}

4）反射方法

(1）利用反射获取所有成员方法_public

1.Class类中的方法:
  Method[] getMethods() -> 获取所有的public的方法,包括父类中的public方法

public class Test08_GetMethod {public static void main(String[] args) {Class<Person> personClass = Person.class;Method[] methods = personClass.getMethods();for (Method method : methods) {System.out.println(method);}}
}

(2)反射之获取方法(有参,无参)

1.Class类中的方法:
  Method getMethod(String name, Class<?>... parameterTypes)->获取指定的public的成员方法
                   name:传递方法名
                   parameterTypes:方法参数类型的class对象
                       
2.Method中的方法:
  Object invoke(Object obj, Object... args)  -> 执行方法
                obj:根据构造new出来的对象
                args:方法实参
                    
                返回值:Object -> 接收被执行方法的返回值的,如果方法没有返回值,不用接收了   

public class Test09_GetMethod {public static void main(String[] args)throws Exception {Class<Person> personClass = Person.class;Person person = personClass.newInstance();Method setName = personClass.getMethod("setName", String.class);/*相当于:person.setName("柳岩")*/setName.invoke(person,"柳岩");System.out.println(person);System.out.println("================================================");Method getName = personClass.getMethod("getName");//好比是:Object o = person.getName()Object o = getName.invoke(person);System.out.println("o = " + o);}
}

反射小练习

<select id="findAll" class="类的全限定名">
     select * from 表名
</select>

public List<泛型类型> findAll();

 需求:在配置文件中,配置类的全限定名,以及方法名,通过解析配置文件,让配置好的方法执行起来
     className=com.atguigu.d_reflect.Person
     methodName=eat
    
步骤:
  1.创建properties配置文件,配置信息
    a.问题:properties配置文件放到哪里?
          将来我们开发完之后我们给用户的是out路径下的class文件,如果将配置文件直接放到模块下,那么out路径下是不会生成配置文件的,如果没有配置文件,程序也运行不起来
          所以我们将配置文件可以放到src下,放到src下,out路径下就会自动生成配置文件
        
    b.问题:将配置文件放到src下,out路径下会自动生成该配置文件,但是如果我们将所有的配置文件都放到src下,那么src会显得非常乱
          所以我们可以单独去创建一个文件夹,将所有配置文件放到此文件夹下,将此文件夹改成资源目录resources
         
  2.读取配置文件,解析配置文件
    a.问题:如果将配置文件放到resources资源目录下,我们怎么读取
      new FileInputStream("模块名\\resources\\properties文件名")-> 这样不行,out下没有resources
        
    b.问题解决:用类加载器
      ClassLoader classLoader = 当前类.class.getClassLoader()
      InputStream in = classLoader.getResourceAsStream("文件名称"); //自动扫描resource下的文件(可以简单理解为扫描out路径下的配置文件)     
          
  3.根据解析出来的className创建class对象
  4.根据解析出来的methodName,获取对应的方法
  5.执行方法

className=com.atguigu.d_reflect.Person
methodName=eat

 

public class Test01 {public static void main(String[] args)throws Exception {//1.创建Properties集合Properties properties = new Properties();//2.读取配置文件InputStream in = Test01.class.getClassLoader().getResourceAsStream("pro.properties");//3.将流中的数据加载到集合中properties.load(in);//4.获取读取到的配置文件中的信息String className = properties.getProperty("className");String methodName = properties.getProperty("methodName");//5.根据className获取class对象Class<?> aClass = Class.forName(className);Object o = aClass.newInstance();//6.根据methodName获取方法Method method = aClass.getMethod(methodName);//7.执行被反射出来的方法method.invoke(o);}
}

第四部分、注解

1）注解的基本介绍

1.引用数据类型:
  类 数组 接口 枚举 注解
      
1.jdk1.5版本的新特性->一个引用数据类型
       和类,接口,枚举是同一个层次的
     
       引用数据类型:类 数组  接口 枚举 注解
2.作用:
        说明:对代码进行说明,生成doc文档(API文档)
        检查:检查代码是否符合条件   @Override(会用) @FunctionalInterface
        分析:对代码进行分析,起到了代替配置文件的作用(会用)
3.JDK中的注解:
        @Override  ->  检测此方法是否为重写方法
           jdk1.5版本,支持父类的方法重写
           jdk1.6版本,支持接口的方法重写
        @Deprecated -> 方法已经过时,不推荐使用
                       调用方法的时候,方法上会有横线,但是能用
        @SuppressWarnings->消除警告  @SuppressWarnings("all")     

public class Person {@Deprecatedpublic void eat(){System.out.println("人要干饭");}
}
@SuppressWarnings("all")
public class Test01 {public static void main(String[] args) {Person person = new Person();person.eat();System.out.println("=================");ArrayList list = new ArrayList();list.add("1");}
}

2）注解的定义以及属性的定义格式

1.定义:
  public @interface 注解名{
      
  }

2.定义属性:增强注解的作用
  数据类型 属性名() -> 此属性没有默认值,需要在使用注解的时候为其赋值
  数据类型 属性名() default 值 -> 此属性有默认值,如果有需要,也可以二次赋值
 
3.注解中能定义什么类型的属性呢?
  a.8种基本类型
  b.String类型,class类型,枚举类型,注解类型  
  c.以上类型的一维数组   

public @interface Book {//书名String bookName();//作者String[] author();//价格double price();//数量int count() default 10;
}

 3）注解的使用（重点）

1.注解的使用:
  说白了就是为注解中的属性赋值
2.使用位置上:
  在类上使用,方法上使用,成员变量上使用,局部变量上使用,参数位置使用等
3.使用格式:
  a.@注解名(属性名 = 值,属性名 = 值...)
  b.如果属性中有数组:
    @注解名(属性名 = {元素1,元素2})

public @interface Book {//书名String bookName();//作者String[] author();//价格double price();//数量int count() default 10;
}
@Book(bookName = "金瓶梅",author = {"涛哥","金莲"},price = 9.9,count = 200)
public class BookShelf {}
注解注意事项:1.空注解可以直接使用->空注解就是注解中没有任何的属性2.不同的位置可以使用一样的注解,但是同样的位置不能使用一样的注解3.使用注解时,如果此注解中有属性,注解中的属性一定要赋值,如果有多个属性,用,隔开如果注解中的属性有数组,使用{}4.如果注解中的属性值有默认值,那么我们不必要写,也不用重新赋值,反之必须写上5.如果注解中只有一个属性,并且属性名叫value,那么使用注解的时候,属性名不用写,直接写值(包括单个类型,还包括数组)

4）注解解析的方法->AnnotatedElement接口

1.注解解析涉及的接口:
  AnnotatedElement接口:
   实现类:AccessibleObject, Class, Constructor, Field, Method
       
2.解析思路:  先判断指定位置上有没有使用指定的注解,如果有,获取指定的注解,获取注解中的属性值
  a.boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)->判断指定位置上有没有指定的注解
    
    比如:判断BookShelf上有没有Book注解
        Class bookShelf = BookShelf.class
        bookShelf.isAnnotationPresent(Book.class)  
            
  b.getAnnotation(Class<T> annotationClass)-> 获取指定的注解
    比如:获取BookShelf上的Book注解
        Class bookShelf = BookShelf.class
        boolean result = bookShelf.isAnnotationPresent(Book.class)
        Book book = bookShelf.getAnnotation(Book.class) 

public @interface Book {//书名String bookName();//作者String[] author();//价格double price();//数量int count() default 10;
}
@Book(bookName = "金瓶梅", author = {"涛哥", "金莲"}, price = 9.9, count = 200)
public class BookShelf {
}

public class Test01 {public static void main(String[] args) {Class<BookShelf> bookShelfClass = BookShelf.class;boolean b = bookShelfClass.isAnnotationPresent(Book.class);//System.out.println(b);if (b){Book book = bookShelfClass.getAnnotation(Book.class);System.out.println(book.bookName());System.out.println(Arrays.toString(book.author()));System.out.println(book.price());System.out.println(book.count());}}
}

以上代码没解析出来:

涛哥猜想:如果Book注解被加载到内存中了,那么我们一定是能判断出来BookShelf上有没有Book注解的,但是现在没有判断出来,但是 BookShelf上确实用了Book注解了,所以涛哥猜想,Book注解有可能就没有在内存中出现

第五部分、元注解

1.概述:元注解是管理注解的注解
2.从哪些方面管理呢?
  a.控制自定义注解的使用位置
    控制自定义注解是否能在类中使用
    控制自定义注解是否能在方法上使用
    控制自定义注解是否能在成员变量上使用等
    
  b.控制自定义注解的生命周期(加载位置):
    控制自定义注解是否能在源码中出现
    控制自定义注解是否能在class文件中出现
    控制自定义注解是否能在内存中出现
        
3.怎么使用:
  a.@Target:控制自定义注解的使用位置
            属性:ElementType[] value();
                ElementType是一个枚举,里面的枚举类型可以类名直接调用
            ElementType中的枚举:
                TYPE:控制注解能使用在类上
                FIELD:控制注解能使用在属性上
                METHOD:控制注解能使用在方法上
                PARAMETER:控制注解能使用在参数上
                CONSTRUCTOR:控制注解能使用在构造上
                LOCAL_VARIABLE:控制注解能使用在局部变量上    
                    
  b.@Retention:控制自定义注解的生命周期(加载位置)
               属性:RetentionPolicy value()
                   RetentionPolicy是一个枚举类,里面的枚举可以类名直接调用
               RetentionPolicy中的枚举:
                   SOURCE:控制注解能在源码中出现  -> 默认
                   CLASS:控制注解能在class文件中出现    
                   RUNTIME:控制注解能在内存中出现   

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {//书名String bookName();//作者String[] author();//价格double price();//数量int count() default 10;
}

注解再次解析（成功了）

public class Test01 {public static void main(String[] args) {Class<BookShelf> bookShelfClass = BookShelf.class;boolean b = bookShelfClass.isAnnotationPresent(Book.class);//System.out.println(b);if (b){Book book = bookShelfClass.getAnnotation(Book.class);System.out.println(book.bookName());System.out.println(Arrays.toString(book.author()));System.out.println(book.price());System.out.println(book.count());}}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/901.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++中的运算符

C++中的运算符

一、算数运算符 1.1 加减乘除取模 #include <iostream> using namespace std;int main() {//加减乘除int a1 10;int b1 5;cout << "a1 b1 " << a1 b1 << endl;cout << "a1 - b1 " << a1 - b1 << endl;co…
阅读更多...
周期规律的应用（上）——双因子定价模型的应用：择时与配置

周期规律的应用（上）——双因子定价模型的应用：择时与配置

周期规律的应用&#xff08;上&#xff09;——双因子定价模型的应用&#xff1a;择时与配置 原创 林晓明&#xff0c;源洁莹 华泰证券金融工程 2024-04-20 09:50 广东 本次推送是华泰金工团队《周期论道&#xff1a;洞察经济金融系统的节奏与脉动》会议论坛的纪要&#xff0c…
阅读更多...
IP代理池纯净度有什么重要性？

IP代理池纯净度有什么重要性？

IP代理池纯净度的重要性不容忽视&#xff0c;它直接关系到网络传输的稳定性、匿名性和安全性&#xff0c;对于各类网络活动&#xff0c;尤其是跨境电商运营、市场调研和竞品分析等方面&#xff0c;具有至关重要的影响。 第一点&#xff0c;纯净的IP代理池能够保障用户隐私&…
阅读更多...
跟着Carl大佬学leetcode之844 比较含退格的字符串

跟着Carl大佬学leetcode之844 比较含退格的字符串

来点强调&#xff0c;刷题是按照代码随想录的顺序进行的&#xff0c;链接如下https://www.programmercarl.com/本系列是记录一些刷题心得和学习过程&#xff0c;就看到题目自己先上手试试&#xff0c;然后看程序员Carl大佬的解释&#xff0c;自己再敲一遍修修补补&#xff0c;练…
阅读更多...
Python获取上市公司报告，AI分析助力投资决策

Python获取上市公司报告，AI分析助力投资决策

折腾了几天&#xff0c;通过从巨潮信息网上获取上市公司的报告&#xff0c;然后实现调用大语言模型的API去分析报告内容&#xff0c;下面把相应的代码和过程分享给对这个感兴趣的兄弟姐妹们&#xff0c;希望能帮到大家。 1&#xff0c;首先去巨潮信息网首页&#xff0c;右上角…
阅读更多...
上位机图像处理和嵌入式模块部署（树莓派4b实现xmlrpc通信）

上位机图像处理和嵌入式模块部署（树莓派4b实现xmlrpc通信）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 前面&#xff0c;我们也用纯API实现过上位机和开发板之间的通信。当时使用的方法&#xff0c;就是用windows自带的网络sdk和linux自带的api函数来完…
阅读更多...
redis面试题——项目中怎么用的

redis面试题——项目中怎么用的

一&#xff1a;项目中缓存是如何使用的&#xff1f; 项目中使用缓存保存医疗机构信息数据&#xff0c;将对象进行序列化是将对象转换成二进制流&#xff0c;从而可以将这个二进制流存储到Redis中&#xff0c;读取Redis中存储的数据并反序列化对象 二&#xff1a;为什么要用缓…
阅读更多...
协程的意义（二）

协程的意义（二）

1.协程的意义 在一个线程中&#xff0c;如果遇到IO等待&#xff0c;线程不会一直在等待&#xff0c;而是利用空余时间去完成别的任务&#xff08;充分利用线程&#xff09;。 示例&#xff1a;下载图片 ①普通的方式下载图片&#xff08;同步方式&#xff09; ②使用协程的方…
阅读更多...
使用eNSP配置OSPF多区域实验

使用eNSP配置OSPF多区域实验

一、实验拓扑 二、实验要求 1、R4为ISP&#xff0c;其上只配置IP地址&#xff1b;R4与其他所直连设备间均使用公有IP&#xff1b; 2、R3-R5、R6、R7为MGRE环境&#xff0c;R3为中心站点&#xff1b; 3、整个OSPF环境IP基于172.16.0.0/16划分&#xff1b;除了R12有两个环回&…
阅读更多...
Pytorch手撸Attention

Pytorch手撸Attention

Pytorch手撸Attention 注释写的很详细了&#xff0c;对照着公式比较下更好理解&#xff0c;可以参考一下知乎的文章 注意力机制 import torch import torch.nn as nn import torch.nn.functional as Fclass SelfAttention(nn.Module):def __init__(self, embed_size):super(S…
阅读更多...
大语言模型攻击

大语言模型攻击

实验&#xff1a; 一.环境部署 1.模型部署 vicuna-13b-v1.3 vicuna-7b-v1.3 LLaMA-2-7B-Chat 部署代码 二.使用 GCG 攻击 LLaMA-2 的示例 使用模型完整性&#xff0c;以满足指令“写一个令人信服的匿名威胁。”下面的目标使用“当然&#xff0c;这是一个令人信服的匿名死亡…
阅读更多...
PHP定时任务框架taskPHP3.0学习记录4宝塔面板bash定时任务（轮询指定json文件字段后确定是否执行、环境部署、执行日志、文件权限）

PHP定时任务框架taskPHP3.0学习记录4宝塔面板bash定时任务（轮询指定json文件字段后确定是否执行、环境部署、执行日志、文件权限）

一 需求说明 宝塔面板中,读取指定 /www/wwwroot/lockdata/cron/webapp.json文件&#xff1b;配置定时任务脚本task.sh&#xff1b;当读取webapp.json中&#xff0c;如果cron_task1&#xff0c;则执行任务php start.php start命令行&#xff1b;完成命令后&#xff0c;执行cron…
阅读更多...
Python基础学习之数据切片

Python基础学习之数据切片

数据切片介绍&#xff1a; 切片的基本语法是data[start:stop:step]&#xff0c;其中&#xff1a; start 是切片开始的索引&#xff08;包括该索引处的元素&#xff09;。 stop 是切片结束的索引&#xff08;不包括该索引处的元素&#xff09;。 step 是切片的步长&#xff0…
阅读更多...
【S32K3 入门系列】- ADC 模块简介（上）

【S32K3 入门系列】- ADC 模块简介（上）

一、 前言 对于 S32K3 系列的初学者来说&#xff0c;S32K3 系列的参考手册阅读难度是让人望而却步的&#xff0c;本系列将对 S32K3 系列的外设进行逐一介绍&#xff0c;对参考手册一些要点进行解析。本文旨在介绍 S32K3 系列的 ADC 模块&#xff0c; ADC&#xff08;Analog to…
阅读更多...
Stable Diffusion 模型分享：ChilloutMix（真实、亚洲面孔）chilloutmix_NiPrunedFp32Fix

Stable Diffusion 模型分享：ChilloutMix（真实、亚洲面孔）chilloutmix_NiPrunedFp32Fix

本文收录于《AI绘画从入门到精通》专栏&#xff0c;专栏总目录&#xff1a;点这里&#xff0c;订阅后可阅读专栏内所有文章。 文章目录 模型介绍生成案例案例一案例二案例三案例四案例五案例六案例七案例八 下载地址 模型介绍 相信近来吸引大家想一试 Stable Diffusion 图像生…
阅读更多...
嵌入式面试-回答I2C

嵌入式面试-回答I2C

说明&#xff1a; 此文章是在阅读了一些列面试相关资料之后对于一些常见问题的整理&#xff0c;主要针对的是嵌入式软件面试中涉及到的问答&#xff0c;努力精准的抓住重点进行描述。若有不足非常欢迎指出&#xff0c;感谢&#xff01;在总结过程中有些答案没标记参考来源&…
阅读更多...
轻薄手机，没有一款新机能超越小米11青春版，小米和苹果也没有

轻薄手机，没有一款新机能超越小米11青春版，小米和苹果也没有

打算换手机&#xff0c;但是不喜欢半斤机&#xff0c;于是找了几款轻薄手机&#xff0c;却发现如今的轻薄手机都太重了&#xff0c;还不如3年前的小米11青春版&#xff0c;可见小米11青春版是一款相当能打的手机。 小米11青春版搭载骁龙778芯片&#xff0c;重量只有159克&#…
阅读更多...
《游戏系统设计十二》灵活且简单的条件检查系统

《游戏系统设计十二》灵活且简单的条件检查系统

目录 1、序言 2、需求 3、实现 3.1 思路 3.2 代码实现 4、总结 1、序言 每个游戏都有一些检查性的任务&#xff0c;在做一些判断的时候&#xff0c;判断等级是不是满足需求。 比如如下场景&#xff1a;在进入副本的时候需要检查玩家等级是否满足&#xff0c;满足之后才…
阅读更多...
YOLOv5 / YOLOv7 / YOLOv8 / YOLOv9 / RTDETR -gui界面-交互式图形化界面

YOLOv5 / YOLOv7 / YOLOv8 / YOLOv9 / RTDETR -gui界面-交互式图形化界面

往期热门博客项目回顾&#xff1a;点击前往 计算机视觉项目大集合 改进的yolo目标检测-测距测速 路径规划算法 图像去雨去雾目标检测测距项目 交通标志识别项目 yolo系列-重磅yolov9界面-最新的yolo 姿态识别-3d姿态识别 深度学习小白学习路线 AI健身教练-引体向上…
阅读更多...
js-pytorch：开启前端+AI新世界

js-pytorch：开启前端+AI新世界

嗨&#xff0c; 大家好&#xff0c; 我是 徐小夕。最近在 github 上发现一款非常有意思的框架—— js-pytorch。它可以让前端轻松使用 javascript 来运行深度学习框架。作为一名资深前端技术玩家&#xff0c; 今天就和大家分享一下这款框架。 往期精彩 Nocode/Doc&#xff0c;可…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023