Day26

news/2024/7/21 23:03:00/文章来源:https://blog.csdn.net/m0_67496588/article/details/139291663

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.ldbm.cn/p/430396.html

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

相关文章

平方回文数-第13届蓝桥杯选拔赛Python真题精选

[导读]&#xff1a;超平老师的Scratch蓝桥杯真题解读系列在推出之后&#xff0c;受到了广大老师和家长的好评&#xff0c;非常感谢各位的认可和厚爱。作为回馈&#xff0c;超平老师计划推出《Python蓝桥杯真题解析100讲》&#xff0c;这是解读系列的第73讲。 平方回文数&#…

Java基础:异常(三)

Java基础&#xff1a;异常&#xff08;三&#xff09; 文章目录 Java基础&#xff1a;异常&#xff08;三&#xff09;1. Java异常体系1.1 错误的分类1.2 异常的分类 2. 异常的捕获与处理2.1 try-catch2.2 finally 3. 异常的抛出4. 自定义异常 1. Java异常体系 Java的异常体系是…

【JavaScript】ECMAS6(ES6)新特性概览(二):解构赋值、扩展与收集、class类全面解析

&#x1f525; 个人主页&#xff1a;空白诗 &#x1f525; 热门专栏&#xff1a;【JavaScript】 文章目录 &#x1f33f; 引言五、 Destructuring Assignment - 解构赋值&#xff0c;数据提取的艺术 &#x1f3a8;&#x1f4cc; 数组解构&#x1f4cc; 对象解构&#x1f4cc; 特…

打造高可用系统:深入了解心跳检测机制

本文作者:小米,一个热爱技术分享的29岁程序员。如果你喜欢我的文章,欢迎关注我的微信公众号“软件求生”,获取更多技术干货! Hello,大家好!我是你们的技术小伙伴小米,今天咱们来聊聊分布式系统中的“心跳检测”机制。心跳检测是一种简单而又重要的机制,用来监控系统的…

JAVA系列:NIO

NIO学习 一、前言 先来看一下NIO的工作流程图&#xff1a; NIO三大核心组件&#xff0c;channel&#xff08;通道&#xff09;、Buffer&#xff08;缓冲区&#xff09;、selector&#xff08;选择器&#xff09;。NIO利用的是多路复用模型&#xff0c;一个线程处理多个IO的读…

线上自由DIY预约小程序源码系统 自由DIY你的界面 带完整的的安装代码包以及搭建教程

系统概述 在当今数字化时代&#xff0c;移动应用成为人们生活和工作中不可或缺的一部分。预约小程序作为一种便捷的工具&#xff0c;为用户提供了高效的预约服务体验。而线上自由 DIY 预约小程序源码系统则为开发者和企业提供了更大的自由度和创造力&#xff0c;让他们能够根据…

新品发布(仓库小助手)一机在手,轻松无忧

你是否曾为繁琐的货物管理而烦恼&#xff1f; 你是否为了记录货物信息忙前忙后&#xff1f; 近几年&#xff0c;陆续有收到客户在运营跨境代购中的一些反馈&#xff0c;特别是仓库管理这块&#xff0c;比如包裹的出入库、移库、修改包裹信息等&#xff0c;都需要在电脑上完成&…

【做一道算一道】力扣332.重新安排行程

332.重新安排行程 给定一个机票的字符串二维数组 [from, to]&#xff0c;子数组中的两个成员分别表示飞机出发和降落的机场地点&#xff0c;对该行程进行重新规划排序。所有这些机票都属于一个从 JFK&#xff08;肯尼迪国际机场&#xff09;出发的先生&#xff0c;所以该行程必…

时间|基于SprinBoot+vue的时间管理系统(源码+数据库+文档)

时间管理系统 目录 基于SprinBootvue的时间管理系统 一、前言 二、系统设计 三、系统功能设计 1管理员功能模块 2用户功能模块 四、数据库设计 五、核心代码 六、论文参考 七、最新计算机毕设选题推荐 八、源码获取&#xff1a; 博主介绍&#xff1a;✌️大厂码农…

Linux服务器安装与配置python环境 最新linux安装python 小白教程

目录 一、下载官网的安装包 二、安装流程 三、配置软连接&#xff08;类似window系统的环境变量&#xff09; 四、可能会出现的问题&#xff1a; 1.ssl连接问题&#xff0c;下图所示&#xff1a; 一、下载官网的安装包 1.官网安装包地址&#xff1a;https://www.python.org/…

【深度 Q 学习-01】 Q学习概念和python实现

文章目录 一、说明二、深度 Q 学习概念三、python实现四、结论 关键词&#xff1a;Deep Q-Networks 一、说明 在强化学习 &#xff08;RL&#xff09; 中&#xff0c;Q 学习是一种基础算法&#xff0c;它通过学习策略来最大化累积奖励&#xff0c;从而帮助智能体导航其环境。它…

nss刷题(3)

1、[SWPUCTF 2021 新生赛]include 根据提示传入一个file后显示了关于flag的代码 这是一个文件包含&#xff0c;考虑php伪协议&#xff0c;构造payload&#xff1a; ?filephp://filter/readconvert.base64-encode/resourceflag.php 2、[SWPUCTF 2021 新生赛]Do_you_know_http …

JAVA学习路线图

计算机网课资料分享群&#xff1a;710895979

Redis分布式存储方案

一、Redis分布式存储方案 1、哈希取余分区 ①、原理 哈希计算&#xff1a;首先&#xff0c;对每个键&#xff08;key&#xff09;进行哈希计算&#xff0c;得到一个整数哈希值&#xff08;hash value&#xff09;。取余操作&#xff1a;将这个哈希值对服务器数量进行取余操作…

新时代病毒侵染了全世界!自律的自我认知,无聊才是根本——早读(逆天打工人爬取热门微信文章解读)

刷视频的动作是什么&#xff1f; 引言Python 代码第一篇 【夜读】为什么要自律&#xff1f;这是我听过最走心的答案第二篇结尾 引言 文字阅读数量确实在缩减 虽然我觉得未来还是有一席之地 当下的人 普罗大众吧 你让他们看书 看文字 显然是不现实的 他们比起看书看文字 更喜欢…

项目成功的关键要素:进度管理

在项目管理中&#xff0c;进度管理是决定项目成败的关键因素之一。它关乎项目能否在预定的时间范围内高效、准确地完成既定目标。 一、进度管理的重要性 1、时间控制&#xff1a;项目的成功往往与时间的把握息息相关。进度管理能够确保项目在既定的时间框架内有序进行&#x…

红酒配餐中的酒杯选择与使用技巧

在红酒配餐中&#xff0c;酒杯的选择与使用技巧是影响品鉴体验的重要因素。合适的酒杯不仅能展现出红酒的优雅和风味&#xff0c;还能提升用餐的仪式感和愉悦感。云仓酒庄雷盛红酒以其卓着的品质和丰富的口感&#xff0c;成为了红酒爱好者们的首要选择品牌。下面将介绍在红酒配…

基于分块贝叶斯非局部均值优化(OBNLM)的图像去噪算法matlab仿真

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 4.1 块定义与相似度计算 ​4.2 贝叶斯框架下的加权融合 4.3 加权最小均方误差估计 5.完整程序 1.程序功能描述 基于分块贝叶斯非局部均值优化(OBNLM)的图像去噪算法matlab仿真&#xff0c…

这些趣味科学小故事,让孩子从小爱上数理化,快收藏!

在我们的日常生活中,无论是洗碗时看到的泡沫,还是在公园里看到的彩虹,背后都隐藏着无数的科学奥秘。这些现象虽然看似平常,却都深深扎根于数理化的基本原理中。生活中一些常见的问题,也能通过转化成数理化的问题来解决。那么在现实生活中,数理化是如何帮助我们解决问题的…

专家解读 | NIST网络安全框架(2):核心功能

NIST CSF是一个关键的网络安全指南&#xff0c;不仅适用于组织内部&#xff0c;还可帮助管理第三方网络安全风险。CSF核心包含了六个关键功能——治理、识别、保护、检测、响应和恢复&#xff0c;以及与这些功能相关的类别和子类别。本文将深入探讨CSF核心的主要内容&#xff0…