Day26

Day26

注解

什么是注解

java.annotation包Annotation是从JDK1.5开始引入的新技术，注解即可以对程序员解释又可以对程序解释

注解与注释的区别

注释：对程序员解释代码信息注解：对程序和程序员解释代码信息

注解的所用

  1. 不是程序本身，可以对程序作出解释（与注释(comment)类似）2. 可以被其他程序（编译器）读取

注解的格式

注解是以“@注释名”在代码中存在的，还可以添加一些参数例如：@SuppressWarnings(value=“unchecked”)

注解的应用

可以附加在package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制实现对这些数据的访问

知识点：内置注解

理解：Java给我们提供的注解

@Override - 重写父类方法的注解
@SuppressWarnings - 镇压警告的注解
@Deprecated - 已弃用的注解

	@Deprecatedpublic void method02(){}@SuppressWarnings("all")public void method01(){ArrayList list = new ArrayList();list.add(100);list.add(123.123);}@Overridepublic String toString() {return super.toString();}

元注解

元注解的作用：负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明

这些类型和它们所支持的类在java.lang.annotation包中可以找到

（@Target，@Retention，@Documented，@Inherited )

*@Target*：用于描述注解的使用范围(即:被描述的注解可以用在什么地方）

*@**Retention*：表示需要要在什么级别保存该注择信息，用于描述注解的生命周期

(SOURCE < CLASS < *RUNTIME*)

@Document：说明该注解将被包含在javadoc中

@lnherited：说明子类可以继承父类中的该注解

知识点：自定义注解

@interface用来声明一个注解，格式：public @interface注解名{定义内容}

其中的每一个方法实际上是声明了一个配置参数.

方法的名称就是参数的名称.

返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）

可以通过default来声明参数的默认值

如果只有一个参数成员，一般参数名为value()

注解元素必須要有值，我们定义注解元素时，经常使用空字符串.0作为默认值

    @Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MyAnnotaction {}@MyAnnotactionpublic void method01() {}

@Target({TYPE,FIELD,CONSTRUCTOR,METHOD,PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotaction {String value();
}
@MyAnnotaction("aaa")public class Test01 {/*** 知识点：自定义注解*/@MyAnnotaction("aaa")String str;@MyAnnotaction("aaa")public Test01() {}@MyAnnotaction(value = "aaa")public void method01() {}@MyAnnotaction("aaa")public void method02(@MyAnnotaction("aaa") int i) {}
}
@Target(METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotaction {String value() default "abc";
}public class Test01 {/*** 知识点：自定义注解*/@MyAnnotaction(value = "aaa")public void method01() {}@MyAnnotaction("aaa")public void method02() {}@MyAnnotaction()public void method03() {}@MyAnnotactionpublic void method04() {}
}

@Target(METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotaction {String[] value();
}public class Test01 {/*** 知识点：自定义注解*/@MyAnnotaction(value = "aaa")public void method01() {}@MyAnnotaction({"aaa","bbb","ccc"})public void method02() {}@MyAnnotaction(value={"aaa","bbb","ccc"})public void method03() {}
}

@Target(METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotaction {String[] name();
}public class Test01 {/*** 知识点：自定义注解*/@MyAnnotaction(name = "aaa")public void method01() {}@MyAnnotaction(name = {"aaa","bbb","ccc"})public void method02() {}}

@Target(METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotaction {String name();String info() default "xxx";
}public class Test01 {/*** 知识点：自定义注解*/@MyAnnotaction(name = "aaa",info="xxx")public void method01() {}@MyAnnotaction(name = "aaa")public void method02() {}
}

反射

反射机制

知识点：反射机制

前言：
使用到一个类，JVM会将该类的class文件加载到方法区(一次)，
同时会在堆中创建一个该类的class对象，该类的class对象作为
该class文件的访问入口。

class文件里有什么？
该类中所有的信息，都在class文件里
比如：类信息、属性信息、方法信息…

理解：反射机制就是获取到class对象，通过class对象操作class文件里的任意内容

学习路线：概念获取class对象操作属性操作构造方法操作方法操作参数、返回值操作泛型操作数组案例

知识点：获取class对象

public static void main(String[] args) throws ClassNotFoundException {//方式一：直接通过类名调用Class<? extends Student> clazz1 = Student.class;//方式二：通过该类的对象的getClass()获取该类的class对象Student stu = new Student();Class<? extends Student> clazz2 = stu.getClass();//方式三：Class<?> clazz3 = Class.forName("com.qf.reflex01.Student");System.out.println(clazz1 == clazz2);//trueSystem.out.println(clazz1 == clazz3);//true}

知识点：获取class对象 + 配置文件

public class Test02 {/*** 知识点：获取class对象 + 配置文件*/public static void main(String[] args) throws ClassNotFoundException, IOException {//创建properties对象Properties p = new Properties();//加载配置文件p.load(Test02.class.getClassLoader().getResourceAsStream("BeanConfig.properties"));//获取属性值String className = p.getProperty("className");Class<?> clazz = Class.forName(className);System.out.println(clazz);}
}

知识点：封装工具 + 配置文件 -> 获取class对象

public class Test03 {/*** 知识点：封装工具 + 配置文件 -> 获取class对象*/public static void main(String[] args) {Class<?> clazz = ReflexUtil.getClazz();System.out.println(clazz);}
}/*** 反射工具类* @author 何老师**/
public final class ReflexUtil {//配置文件里类的全限定名private static String className;//初始化配置文件static{Properties p = new Properties();try {p.load(ReflexUtil.class.getClassLoader().getResourceAsStream("BeanConfig.properties"));} catch (IOException e) {e.printStackTrace();}className = p.getProperty("className");}private ReflexUtil() {}/*** 获取配置文件里配置的class对象* @return class对象*/public static Class<?> getClazz(){return getClazz(className);}/*** 获取指定的class对象* @param className 类的全限定名* @return class对象*/public static Class<?> getClazz(String className){try {Class<?> clazz = Class.forName(className);return clazz;} catch (ClassNotFoundException e) {e.printStackTrace();}return null;}

操作属性

public class Test04 {/*** 知识点：操作属性*/public static void main(String[] args) {//获取class对象
//		Class<?> clazz = ReflexUtil.getClazz();//获取本类及其父类公有的属性对象
//		Field[] fields = clazz.getFields();
//		for (Field field : fields){
//			System.out.println(field);
//		}//获取本类所有的属性对象
//		Field[] fields = clazz.getDeclaredFields();
//		for (Field field : fields) {
//			System.out.println(field);
//		}//获取本类及其父类所有的属性对象
//		for(Class<?> c = clazz;c != null;c = c.getSuperclass()){
//			Field[] fields = c.getDeclaredFields();
//			for (Field field : fields) {
//				System.out.println(field);
//			}
//		}//通过属性名获取本类及其父类公有的属性对象
//		try {
//			Field field = clazz.getField("classId");
//			System.out.println(field);
//		} catch (NoSuchFieldException e) {
//			e.printStackTrace();
//		} catch (SecurityException e) {
//			e.printStackTrace();
//		}//通过属性名获取本类指定的属性对象
//		try {
//			Field field = clazz.getDeclaredField("classId");
//			System.out.println(field);
//		} catch (NoSuchFieldException e) {
//			// TODO Auto-generated catch block
//		} catch (SecurityException e) {
//			e.printStackTrace();
//		}//通过属性名获取本类及其父类指定的属性对象
//		for(Class<?> c = clazz;c != null;c = c.getSuperclass()){
//			try {
//				Field field = c.getDeclaredField("name");
//				System.out.println(field);
//				
//				//获取属性修饰信息
//				int modifiers = field.getModifiers();
//				System.out.println("判断属性是否使用public修饰：" + Modifier.isPublic(modifiers));//false
//				System.out.println("判断属性是否使用protected修饰：" + Modifier.isProtected(modifiers));//false
//				System.out.println("判断属性是否使用private修饰：" + Modifier.isPrivate(modifiers));//true
//				System.out.println("判断属性是否使用static修饰：" + Modifier.isStatic(modifiers));//false
//				System.out.println("判断属性是否使用final修饰：" + Modifier.isFinal(modifiers));//false
//				System.out.println("判断属性是否使用transient修饰：" + Modifier.isTransient(modifiers));//false
//				System.out.println("判断属性是否使用volatile修饰：" + Modifier.isVolatile(modifiers));//false
//				
//			} catch (NoSuchFieldException e) {//不输出错误信息，子类找不到没关系，直接去找父类
//			} catch (SecurityException e) {
//			}
//		}//封装工具类 -- 通过属性名获取本类及其父类指定的属性对象
//		Field field = ReflexUtil.getField(clazz, "name");
//		System.out.println(field);//操作属性 -- 获取、设置
//		Student stu = new Student();
//		Field nameField = ReflexUtil.getField(clazz, "name");
//		
//		nameField.setAccessible(true);//设置操作权限
//		try {
//			//设置stu对象里面的name属性为侯小康
//			nameField.set(stu, "侯小康");
//		} catch (IllegalArgumentException e) {
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			e.printStackTrace();
//		}
//		System.out.println(stu);//封装工具类 -- 操作属性 -- 获取、设置Student stu = new Student();ReflexUtil.setField(stu, "name", "侯小康");ReflexUtil.setField(stu, "sex", '男');ReflexUtil.setField(stu, "age", 23);ReflexUtil.setField(stu, "classId", "2402");ReflexUtil.setField(stu, "id", "001");System.out.println(stu);}
}

ReflexUitl.java里添加：

/*** 获取属性对象* @param clazz class对象* @param name 属性名* @return 属性对象*/public static Field getField(Class<?> clazz,String name){for(Class<?> c = clazz;c != null;c = c.getSuperclass()){try {Field field = c.getDeclaredField(name);return field;} catch (NoSuchFieldException e) {} catch (SecurityException e) {}}return null;}/*** 设置属性* @param obj 目标对象* @param name 属性名* @param val 属性值*/public static void setField(Object obj,String name,Object val){Class<? extends Object> clazz = obj.getClass();Field field = getField(clazz, name);field.setAccessible(true);try {field.set(obj, val);} catch (IllegalArgumentException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();}}

操作构造方法

创建对象

反射机制中传入的基本数据类型会自动装箱，而使用类方法获取构造器时参数为class对象数组，且里面的元素是包装类，所以要先设计一个参数类型处理的方法

/*** 参数类型处理器* @param parameterVals 参数数据的可变参数* @return 参数类型的数组*/private static Class<?>[] parameterValsHandle(Object... parameterVals){ArrayList<Class<?>> list = new ArrayList<>();for (Object object : parameterVals) {Class<? extends Object> parameterType = object.getClass();if(parameterType == Byte.class){parameterType = byte.class;} else if(parameterType == Short.class){parameterType = short.class;} else if(parameterType == Integer.class){parameterType = int.class;} else if(parameterType == Long.class){parameterType = long.class;} else if(parameterType == Float.class){parameterType = float.class;} else if(parameterType == Double.class){parameterType = double.class;} else if(parameterType == Character.class){parameterType = char.class;} else if(parameterType == Boolean.class){parameterType = boolean.class;} list.add(parameterType);}Class<?>[] parameterTypes = new Class[list.size()];list.toArray(parameterTypes);return parameterTypes;}

思路为通过获取的class对象创建构造器，再用构造器去创建对象。

public static <T> T newInstance(Class<T> clazz,Object...parameterVals){Class<?>[] parameterTypes = parameterValsHandle(parameterVals);try {Constructor<T> constructor = clazz.getDeclaredConstructor(parameterTypes);constructor.setAccessible(true);T t = constructor.newInstance(parameterVals);return t;} catch (NoSuchMethodException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (SecurityException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (InstantiationException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalAccessException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (IllegalArgumentException e) {// TODO Auto-generated catch blocke.printStackTrace();} catch (InvocationTargetException e) {// TODO Auto-generated catch blocke.printStackTrace();}return null;}

public class Test05 {/*** 知识点：操作构造方法*/@SuppressWarnings("all")public static void main(String[] args) {//获取class对象Class<Student> clazz = (Class<Student>) ReflexUtil.getClazz();//获取本类公有的构造方法
//		Constructor<?>[] constructors = clazz.getConstructors();
//		for (Constructor<?> constructor : constructors) {
//			System.out.println(constructor);
//		}//获取本类所有的构造方法
//		Constructor<?>[] constructors = clazz.getDeclaredConstructors();
//		for (Constructor<?> constructor : constructors) {
//			System.out.println(constructor);
//		}//获取本类及其父类所有的构造方法
//		for(Class<?> c = clazz;c != null;c = c.getSuperclass()){
//			Constructor<?>[] constructors = c.getDeclaredConstructors();
//			for (Constructor<?> constructor : constructors) {
//				System.out.println(constructor);
//			}
//		}//获取无参构造方法对象，利用无参构造方法对象创建该类的对象
//		try {
//			//获取无参构造方法对象
//			Constructor<?> constructor = clazz.getDeclaredConstructor();
//			//利用无参构造方法对象创建该类的对象
//			Student stu = (Student) constructor.newInstance();
//			System.out.println(stu);
//		} catch (NoSuchMethodException e) {
//			e.printStackTrace();
//		} catch (SecurityException e) {
//			e.printStackTrace();
//		} catch (InstantiationException e) {
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			e.printStackTrace();
//		} catch (IllegalArgumentException e) {
//			e.printStackTrace();
//		} catch (InvocationTargetException e) {
//			e.printStackTrace();
//		}//利用无参构造方法对象创建该类的对象
//		try {
//			Student stu = (Student) clazz.newInstance();
//			System.out.println(stu);
//		} catch (InstantiationException e) {
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			e.printStackTrace();
//		}//获取有参构造方法对象，利用有参构造方法对象创建该类的对象
//		try {
//			//获取有参构造方法对象
//			Constructor<?> constructor = clazz.getDeclaredConstructor(String.class,char.class,int.class,String.class,String.class);
//			//设置操作权限
//			constructor.setAccessible(true);
//			//利用有参构造方法对象创建该类的对象
//			Student stu = (Student) constructor.newInstance("侯小康",'男',23,"2402","001");
//			System.out.println(stu);
//		} catch (NoSuchMethodException e) {
//			e.printStackTrace();
//		} catch (SecurityException e) {
//			e.printStackTrace();
//		} catch (InstantiationException e) {
//			e.printStackTrace();
//		} catch (IllegalAccessException e) {
//			e.printStackTrace();
//		} catch (IllegalArgumentException e) {
//			e.printStackTrace();
//		} catch (InvocationTargetException e) {
//			e.printStackTrace();
//		}//封装工具类 -- 创建对象
//		Student stu = ReflexUtil.newInstance(clazz);
//		System.out.println(stu);//封装工具类 -- 创建对象Student stu = ReflexUtil.newInstance(clazz, "侯小康",'男',23,"2402","001");System.out.println(stu);}
}

操作方法、参数、返回值及泛型

知识点：操作方法

public class Test06 {/*** 知识点：操作方法*/@SuppressWarnings("all")public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {//获取class对象Class<Student> clazz = (Class<Student>) ReflexUtil.getClazz();//获取本类及其父类的公有方法对象
//		Method[] methods = clazz.getMethods();
//		for (Method method : methods) {
//			System.out.println(method);
//		}//获取本类的所有方法对象
//		Method[] methods = clazz.getDeclaredMethods();
//		for (Method method : methods) {
//			System.out.println(method);
//		}//获取本类及其父类所有方法对象
//		for(Class<?> c = clazz;c != null;c = c.getSuperclass()){
//			Method[] methods = c.getDeclaredMethods();
//			for (Method method : methods) {
//				System.out.println(method);
//			}
//		}//通过方法名获取方法对象
//		try {
//			Method method = clazz.getDeclaredMethod("setClassId", String.class);
//			method.setAccessible(true);
//			System.out.println(method);
//			
//			//获取方法修饰信息
//			int modifiers = method.getModifiers();
//			System.out.println("判断方法是否使用public修饰：" + Modifier.isPublic(modifiers));//true
//			System.out.println("判断方法是否使用protected修饰：" + Modifier.isProtected(modifiers));//false
//			System.out.println("判断方法是否使用private修饰：" + Modifier.isPrivate(modifiers));//false
//			System.out.println("判断方法是否使用static修饰：" + Modifier.isStatic(modifiers));//false
//			System.out.println("判断方法是否使用final修饰：" + Modifier.isFinal(modifiers));//false
//			System.out.println("判断方法是否使用abstract修饰：" + Modifier.isAbstract(modifiers));//false
//			System.out.println("判断方法是否使用synchronized修饰：" + Modifier.isSynchronized(modifiers));//false
//			
//		} catch (NoSuchMethodException e) {
//			e.printStackTrace();
//		} catch (SecurityException e) {
//			e.printStackTrace();
//		}//调用成员方法
//		Student stu = ReflexUtil.newInstance(clazz, "侯小康",'男',23,"2402","001");
//		Method getClassIdMethod = clazz.getDeclaredMethod("getClassId");
//		getClassIdMethod.setAccessible(true);
//		Object getClassIdMethodReturnVal = getClassIdMethod.invoke(stu);
//		System.out.println(getClassIdMethodReturnVal);//2402
//		
//		Method setClassIdMethod = clazz.getDeclaredMethod("setClassId", String.class);
//		setClassIdMethod.setAccessible(true);
//		Object setClassIdMethodReturnVal = setClassIdMethod.invoke(stu, "2403");
//		System.out.println(setClassIdMethodReturnVal);//null
//		
//		System.out.println(stu);//调用静态
//		Method method = clazz.getDeclaredMethod("method", String.class,int.class);
//		method.setAccessible(true);
//		Object methodReturnVal = method.invoke(null, "abc",888);
//		System.out.println(methodReturnVal);//封装工具类 -- 调用成员方法
//		Student stu = ReflexUtil.newInstance(clazz, "侯小康",'男',23,"2402","001");
//		Object getClassIdMethodReturnVal = ReflexUtil.invoke(stu, "getClassId");
//		System.out.println(getClassIdMethodReturnVal);//2402
//		
//		Object setClassIdMethodReturnVal = ReflexUtil.invoke(stu, "setClassId", "2403");
//		System.out.println(setClassIdMethodReturnVal);//null
//		System.out.println(stu);//封装工具类 -- 调用静态Object methodReturnVal = ReflexUtil.invoke(clazz, "method", "abc",888);System.out.println(methodReturnVal);}
}

工具类相关方法创建：

/*** 获取方法对象* @param clazz class对象* @param name 方法名* @param parameterTypes 方法参数类型数组* @return 方法对象*/public static Method getMethod(Class<?> clazz,String name,Class<?>... parameterTypes){for(Class<?> c = clazz;c != null;c = c.getSuperclass()){try {Method method = c.getDeclaredMethod(name, parameterTypes);return method;} catch (NoSuchMethodException e) {} catch (SecurityException e) {}}return null;}/*** 调用静态方法* @param clazz class对象* @param name 方法名* @param parameterVals 参数数组* @return 返回值*/public static Object invoke(Class<?> clazz,String name,Object... parameterVals){Class<?>[] parameterTypes = parameterValsHandle(parameterVals);Method method = getMethod(clazz, name, parameterTypes);try {Object returnVal = method.invoke(null, parameterVals);return returnVal;} catch (IllegalAccessException e) {e.printStackTrace();} catch (IllegalArgumentException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}return null;}/*** 调用成员方法* @param obj 对象* @param name 方法名* @param parameterVals 方法参数数组* @return 返回值*/public static Object invoke(Object obj,String name,Object... parameterVals){Class<? extends Object> clazz = obj.getClass();Class<?>[] parameterTypes = parameterValsHandle(parameterVals);Method method = getMethod(clazz, name, parameterTypes);try {Object returnVal = method.invoke(obj, parameterVals);return returnVal;} catch (IllegalAccessException e) {e.printStackTrace();} catch (IllegalArgumentException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}return null;}

知识点：操作方法的参数和返回值

public class Test07 {/*** 知识点：操作方法的参数和返回值*/@SuppressWarnings("all")public static void main(String[] args) {//获取class对象Class<Student> clazz = (Class<Student>) ReflexUtil.getClazz();Method method = ReflexUtil.getMethod(clazz, "method", String.class,int.class);//获取参数信息 -----------------------------------------------------------------------//获取参数列表的类型
//		Class<?>[] parameterTypes = method.getParameterTypes();
//		for (Class<?> c : parameterTypes) {
//			System.out.println(c);
//		}//获取参数对象数组
//		Parameter[] parameters = method.getParameters();
//		for (Parameter parameter : parameters) {
//			
//			Class<?> type = parameter.getType();//参数类型
//			String name = parameter.getName();//参数名（注意：参数名不会随着编译而编译到class文件里）
//			System.out.println(type + " -- " + name);
//		}//获取参数个数
//		int parameterCount = method.getParameterCount();
//		System.out.println("获取参数个数：" + parameterCount);//2//获取返回值信息 -----------------------------------------------------------------------Class<?> returnType = method.getReturnType();System.out.println(returnType);//class java.lang.StringType genericReturnType = method.getGenericReturnType();System.out.println(genericReturnType);//class java.lang.String}
}

知识点：操作泛型

public class Test08 {/*** 知识点：操作泛型*/public static void main(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
//		Class<Student> clazz = Student.class;Class<?> clazz = ReflexUtil.getClazz("Student");//获取属性上的泛型类型Field mapField = clazz.getDeclaredField("map");Type mapFieldGenericType = mapField.getGenericType();//获取属性类型ParameterizedType mapFieldPT = (ParameterizedType) mapFieldGenericType;//强转为子接口的类型Type[] actualTypeArguments = mapFieldPT.getActualTypeArguments();//获取泛型类型数组for (Type type : actualTypeArguments) {System.out.println(type);}//获取参数上的泛型类型Method method = clazz.getDeclaredMethod("method", ArrayList.class,ConcurrentHashMap.class);Parameter[] parameters = method.getParameters();for (Parameter parameter : parameters) {Type type = parameter.getParameterizedType();ParameterizedType pt = (ParameterizedType) type;Type[] ata = pt.getActualTypeArguments();for (Type t : ata) {System.out.println(t);}}//获取返回值上的泛型类型Type genericReturnType = method.getGenericReturnType();ParameterizedType pt = (ParameterizedType) genericReturnType;Type[] actualTypeArguments2 = pt.getActualTypeArguments();for (Type type : actualTypeArguments2) {System.out.println(type);}}
}

操作数组

知识点：操作数组

理解：Array类是Java提供的反射数组类

public static void main(String[] args) {//创建数组int[] arr = (int[]) Array.newInstance(int.class, 10);//获取长度System.out.println("获取长度：" + Array.getLength(arr));//10//循环遍历 - 设置数据for (int i = 0; i < Array.getLength(arr); i++) {Array.set(arr, i, i+1);//设置数据}//循环遍历 - 获取数据for (int i = 0; i < Array.getLength(arr); i++) {Object element = Array.get(arr, i);System.out.println(element);}}

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

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

相关文章

【C语言】9.C语言函数栈帧的创建和销毁

【C语言】9.C语言函数栈帧的创建和销毁

C语言函数栈帧的创建和销毁 看完本文你能了解什么? 局部变量是怎么创建的&#xff1f;为什么局部变量的值是随机值&#xff1f;函数是怎么传参的&#xff1f;传参的顺序是怎么样的&#xff1f;实参和形参是什么关系&#xff1f;函数调用是怎么做的&#xff1f;函数调用结束后怎…
阅读更多...
LeetCode hot100-57-G

LeetCode hot100-57-G

17. 电话号码的字母组合 给定一个仅包含数字 2-9 的字符串&#xff0c;返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下&#xff08;与电话按键相同&#xff09;。注意 1 不对应任何字母。不会&#xff0c;放IDEA里执行了一下大概理解了流程 …
阅读更多...
『大模型笔记』KV缓存：Transformer中的内存使用！

『大模型笔记』KV缓存：Transformer中的内存使用！

『大模型笔记』KV缓存：Transformer中的内存使用！ 文章目录 一. KV缓存：Transformer中的内存使用！1.1. 介绍1.2. 自注意力机制回顾1.3. KV 缓存的工作原理1.4. 内存使用和示例1.4.1. 存储键值缓存需要多少内存1.4.2. Example: OPT-30B（300亿参数）四. 参考文献进一步阅读：…
阅读更多...
深圳比创达电子｜EMC与EMI滤波器：电子设备的“电磁防护罩”

深圳比创达电子｜EMC与EMI滤波器：电子设备的“电磁防护罩”

在电子科技日新月异的今天&#xff0c;电磁兼容性&#xff08;EMC&#xff09;问题越来越受到工程师和技术人员的关注。其中&#xff0c;电磁干扰&#xff08;EMI&#xff09;和电磁干扰抑制&#xff08;即EMI滤波器&#xff09;是实现良好EMC性能的关键技术之一。 一、EMC与E…
阅读更多...
KineFX —— 简介

KineFX —— 简介

KineFX是绑定和动画的框架和工具集&#xff0c;可在SOP级别创建和编辑角色&#xff1b;可从头创建自己的KineFX角色&#xff0c;或使用特定的KineFX SOP和常规的SOP去编辑导入的角色和动画&#xff1b; 程序化绑定 KineFX构建与程序化绑定的原则上&#xff0c;可快速非破坏性迭…
阅读更多...
AI绘画Stable Diffusion【艺术写真】：蒙版法图生图，局部重绘实现AI艺术写真

AI绘画Stable Diffusion【艺术写真】：蒙版法图生图，局部重绘实现AI艺术写真

大家好&#xff0c;我是设计师阿威 之前我分享过几篇使用SD插件换脸方式实现AI写真的教程&#xff0c;主要存在2个大的问题。 &#xff08;1&#xff09;人脸相似度 &#xff08;2&#xff09;生成的图片整体色调有时候会比较怪异 对于上面的问题&#xff0c;在对图片质量要…
阅读更多...
一些图形界面的工具可以帮助你模拟点击和进行其他浏览器自动化操作

一些图形界面的工具可以帮助你模拟点击和进行其他浏览器自动化操作

1. Selenium IDE Selenium IDE 是一个用于记录、编辑和调试测试的集成开发环境。它有一个图形界面，允许你通过点击和录制来创建测试用例。它支持Chrome和Firefox浏览器。 安装和使用步骤： 在Chrome或Firefox的扩展商店中搜索“Selenium IDE”并安装。打开Selenium IDE扩展。…
阅读更多...
每天写两道(二)LRU缓存、数组中最大的第k个元素

每天写两道(二)LRU缓存、数组中最大的第k个元素

146.LRU 缓存 . - 力扣&#xff08;LeetCode&#xff09; 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存…
阅读更多...
类中使用QtConcurrent::run

类中使用QtConcurrent::run

在QtConcurrent::run中调用类的成员函数时&#xff0c;你需要注意几个关键点&#xff1a; 对象生命周期&#xff1a;你需要确保在QtConcurrent::run调用的整个期间&#xff0c;类对象都是有效的。如果对象在成员函数执行期间被销毁&#xff0c;将会导致未定义行为。成员函数访…
阅读更多...
在table表格中如何给tr的每一个子元素加haver效果

在table表格中如何给tr的每一个子元素加haver效果

效果图&#xff1a; 核心代码&#xff1a; tbody tr :hover {background-color: #d5d5d5; } 改变子元素 tbody tr:hover {background-color: #d5d5d5; } 改变父元素 两段代码看起来一样&#xff0c;其实不一样&#xff0c;其中差了一个空格字符 希望可以帮到大家
阅读更多...
多线程新手村3--多线程代码案例

多线程新手村3--多线程代码案例

1.1 单例模式 单例模式是设计模式中非常经典的一种。那么有同学肯定就会好奇了&#xff0c;什么是设计模式呢&#xff1f; 设计模式简单的说就是程序员的“棋谱”&#xff0c;我们下象棋时肯定或多或少都背过棋谱&#xff0c;例如当头炮、马后炮等&#xff0c;设计模式也是这…
阅读更多...
接口性能测试复盘：解决JMeter超时问题的实践

接口性能测试复盘：解决JMeter超时问题的实践

在优化接口并重新投入市场后&#xff0c;我们面临着一项关键任务&#xff1a;确保其在高压环境下稳定运行。于是&#xff0c;我们启动了一轮针对该接口的性能压力测试&#xff0c;利用JMeter工具模拟高负载场景。然而&#xff0c;在测试进行约一分钟之后&#xff0c;频繁出现了…
阅读更多...
新人学习笔记之（函数2）

新人学习笔记之（函数2）

一、函数的参数 1.形参和实参 &#xff08;1&#xff09;在声明函数时&#xff0c;可以在函数名称后面的小括号中添加一些参数&#xff0c;这些参数被称为形参&#xff0c;而在调用该函数时&#xff0c;同样也需要传递相应的参数&#xff0c;这些参数被称为实参 参数说明形参形…
阅读更多...
【前端之npm镜像地址】

【前端之npm镜像地址】

npm镜像地址 淘宝镜像地址华为镜像地址腾讯云镜像地址 淘宝镜像地址 npm config set registry https://registry.npmmirror.com查看镜像设置: npm config get registry 华为镜像地址 npm config set registry https://mirrors.huaweicloud.com/repository/npm/ 腾讯云镜像地…
阅读更多...
【机器学习】分值融合方法

【机器学习】分值融合方法

举例假设现有图片的预测分数文本的预测分数。为了合理地融合图片和文本的预测分数&#xff0c;可以采取多种方法&#xff0c;包括加权平均、直接相加或相乘等&#xff0c;但需要注意两者是否在同一空间。以下是一些常见的方法和考虑因素&#xff1a; FROM GPT4 1. 确定预测分…
阅读更多...
Mysql数据库创建自增序列

Mysql数据库创建自增序列

创建序列表 CREATE TABLE sequence (name varchar(50) NOT NULL,current_value bigint(30) NOT NULL,increment int(11) NOT NULL DEFAULT 1 ) ENGINEInnoDB DEFAULT CHARSETutf8 ROW_FORMATDYNAMIC COMMENT序列表;创建函数 查询当前序列名的序列值 CREATE DEFINERroot% FUNC…
阅读更多...
Lambda表达式及Stream的使用

Lambda表达式及Stream的使用

前言&#xff1a; 函数式编程是一种编程范式&#xff0c;它将计算过程视为函数应用的连续组合。函数式编程强调使用纯函数&#xff08;Pure Function&#xff09;&#xff0c;避免使用可变状态和副作用&#xff0c;倡导将计算过程抽象为函数&#xff0c;便于代码的理解、测试和…
阅读更多...
Pytorch训练LeNet模型MNIST数据集

Pytorch训练LeNet模型MNIST数据集

如何用torch框架训练深度学习模型&#xff08;详解&#xff09; 0. 需要的包 import torch from torch.nn import CrossEntropyLoss from torch.optim import SGD from torch.utils.data import DataLoader from torchvision import datasets, transforms1. 数据加载和导入 …
阅读更多...
Python图形界面(GUI)Tkinter笔记（九）：用【Button()】功能按钮实现人机交互

Python图形界面(GUI)Tkinter笔记（九）：用【Button()】功能按钮实现人机交互

在Tkinter库中，功能按钮(Button)是实现人机交互的一个非常重要的组件: 【一】主要可实现功能及意义: (1)响应用户交互: Button组件允许用户通过点击来触发某个事件或动作。当用户点击按钮时,可以执行一个指定的函数或方法。 (2)提供用户输入: Button组件是图形用户界面(G…
阅读更多...
持续总结中！2024年面试必问 20 道 Rocket MQ面试题（三）

持续总结中！2024年面试必问 20 道 Rocket MQ面试题（三）

上一篇地址&#xff1a;持续总结中&#xff01;2024年面试必问 20 道 Rocket MQ面试题&#xff08;二&#xff09;-CSDN博客 五、什么是生产者&#xff08;Producer&#xff09;和消费者&#xff08;Consumer&#xff09;在RocketMQ中&#xff1f; RocketMQ是一个高性能、高吞…
阅读更多...
最新文章

Copyright @ 2022~2023