java初学者笔记26 —— 反射与注解

已于 2024-04-05 12:57:35 修改
阅读量30 收藏
点赞数
分类专栏： java 文章标签： java 笔记
于 2023-08-10 10:19:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62678419/article/details/132203657
版权

文章目录

反射与注解

反射

通过java反射机制，可以在程序中访问已经装载到JVM中的java对象的描述，实现访问、检测和修改描述java对象本身信息的功能。java反射机制的功能十分强大，在java.lang.reflect包中提供了对该功能的支持

访问构造函数

在通过下列一组方法访问构造方法时，将返回Constructor类型的对象或数组。每个Constructor对象代表一个构造方法，利用Constructor对象可以操纵相应的构造方法；

Constructor类的常用构造方法
方法说明
isVarArgs()查看该构造方法是否允许带有可变参数，如果允许则返回true，否则返回false
getParameterType()按照声明顺序以Class数组的形式获得该构造方法的各个类型参数
getExceptionType()以Class数组的形式获得该构造方法的各个参数类型
newInstance(Object…initargs)通过该构造方法利用指定参数创建一个该类的对象，如果未设置参数则表示采用默认无参的构造方法
setAccessible(boolean flag)如果该构造方法的权限为private，默认未不允许通过反射利用newInstance(Object…initargs)方法创建对象。那么，先执行该方法并将入口参数设为true，则允许创建
getModifiers()获得可以解析出该构造方法所采用修饰符的整数
Modifier类中的常用解析方法

通过java.lang.reflect.Modifier类可以解析出getModifiers()方法的返回值所表示的修饰符信息，在该类中提供了一系列用来解析的静态方法，既能查看是否被指定的修饰符修饰，又能以字符串的形式获得所有修饰符。Modifier类常用静态方法如下所示

静态方法说明
isPublic(int mod)查看是否被public修饰符修饰，如果是则返回true，否则返回false
isPratected(int mod)查看是否被protected修饰符修饰，如果是则返回true，否则返回false
isPrivate(int mod)查看是否被private修饰符修饰，如果是则返回true，否则返回false
isStatic(int mod)查看是否被static修饰符修饰，如果是则返回true，否则返回false
isFinal(int mod)查看是否被final修饰符修饰，如果是则返回true，否则返回false
isString(int mod)以字符串的形式返回所有修饰符
例子：反射一个类的所有构造方法
//Demo1.java
public class Demo1 {
    String s;
    int i, i2 ,i3;
    private Demo1(){
    }
    protected Demo1(String s,int i){
        this.s = s;
        this.i = i;
    }
    public Demo1(String ... strings) throws NumberFormatException {
        if(0 < strings.length)
                i = Integer.valueOf(strings[0]);
        if(1 < strings.length)
                i2 = Integer.valueOf(strings[1]);
        if(2 < strings.length)
                i3 = Integer.valueOf(strings[2]);
    }

    public void print() {
        System.out.println("s=" + s);
        System.out.println("i=" + i);
        System.out.println("i2=" + i2);
        System.out.println("i3=" + i3);
    }
}
//Constructor.java
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ConstructorDemo1 {
    public static void main(String[] args) {
        Demo1 d1 = new Demo1("10","20","30");
        Class<? extends Demo1> Demo1Class = d1.getClass();
        //获取所有构造方法
        Constructor[] declaredConstructors = Demo1Class.getDeclaredConstructors();
        for(int i = 0;i < declaredConstructors.length;i ++){   // 遍历构造方法
            Constructor<?>constructor = declaredConstructors[i];
            System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());
            System.out.println("该构造方法的入口参数类型依次为：");
            Class[] parameterType = constructor.getParameterTypes();
            for(int j = 0;j < parameterType.length;j ++){
                System.out.println(" " + parameterType[j]);
            }
            System.out.println("该构造方法可能抛出的异常类型为：");
            // 获得所有可能抛出的异常信息
            Class[] exceptionTypes = constructor.getExceptionTypes();
            for(int j = 0;j < exceptionTypes.length;j ++){
                System.out.println(" " + exceptionTypes[j]);
            }
            Demo1 d2 = null;
            while(d2 == null){
                try {
                    if(i == 2)
                        d2 = (Demo1)constructor.newInstance();
                    else if(i == 1)
                        d2 = (Demo1)constructor.newInstance("7",5);
                    else{
                        Object[] parameters = new Object[]{new String[]{"100","200","300"}};
                        d2 = (Demo1)constructor.newInstance(parameters);
                    }
                } catch (Exception e) {
                    System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");
                    constructor.setAccessible(true);
                }
            }
            if(d2 != null){
                d2.print();
                System.out.println();
            }
        }
    }
}

访问成员变量

在通过下列一组方法访问成员变量时，将返回Field类型的对象或数组。每个Field对象代表一个成员变量，利用Field对象可以操纵相应的成员变量。

Field类中提供的常用方法

方法说明
getName()获取该成员变量的名称
getType()获得表示该成员变量类型的Class对象
get(Object obj)获得指定对象obj中成员变量的值，返回值为Object型
set(Object obj,Object value)将指定对象obj中成员变量的值设置为value
getInt(Object obj)获得指定对象obj中类型为int的成员变量的值
setInt(Object obj,int i)将指定对象obj中类型为int的成员变量设置为i
getFloat(Object obj)获得指定对象obj中类型为float的成员变量的值
setFloat(Object obj,float f)将指定对象obj中类型为float的成员变量设置为f
getBoolean(Object obj)获得指定对象obj中类型为Boolean的成员变量的值
setBoolean(Object obj,boolean z)将指定对象obj中类型为boolean的成员变量的值设置为z
setAccessible(boolean flag)此方法可以设置是否忽略权限限制访问private等私有权限的成员变量
getModifiers()获得可以解析出该成员变量所采用修饰符的整数
例子
//Demo.java
public class Demo2 {
	int i;
	public float f;
	protected boolean b;
	private String s;
}

//FieldDemo2.java
import java.lang.reflect.Field;
public class FieldDemo2 {
    public static void main(String[] args) {
        Demo2 example = new Demo2();
        Class exampleC = example.getClass();
        Field[] declaredFields = exampleC.getDeclaredFields(); // 获取所有成员变量
        for (int i = 0; i < declaredFields.length; i++) { // 遍历成员变量
            Field field = declaredFields[i];
            System.out.println("名称为" + field.getName()); // 获取成员变量名称并输出
            Class fieldType = field.getType(); // 获取成员变量的类型
            System.out.println("类型为" + fieldType);
            boolean isTurn = true;
            while (isTurn) {
                // 如果该成员变量的访问权限是private或者protected,则抛出异常，即不允许访问
                try {
                    isTurn = false;
                    // 获得成员变量值
                    System.out.println("修改前值为" + field.get(example));
                    if (fieldType.equals(int.class)) { // 判断成员变量的值是否为int型
                        System.out.println("利用方法setInt()修改成员变量的值");
                        field.setInt(example, 168); // 为int型成员变量赋值
                    } else if (fieldType.equals(float.class)) { // 判断成员变量的值是否为float类型
                        System.out.println("利用方法setFloat()修改成员变量的值");
                        field.setFloat(example, 99.9F); // 为float类型的成员变量赋值ֵ
                        // 判断成员变量的值是否为boolean类型
                    } else if (fieldType.equals(boolean.class)) {
                        System.out.println("利用方法setBoolean()修改成员变量的值");
                        field.setBoolean(example, true); // 为Boolean类型的成员变量赋值
                    } else {
                        System.out.println("利用方法set()修改成员变量的值");
                        field.set(example, "MWQ"); // 可以为各种类型的成员变量赋值
                    }
                    // 获得成员变量值
                    System.out.println("修改后的值为：" + field.get(example));
                } catch (Exception e) {
                    System.out.println("在设置成员变量值时抛出异常" + "下面执行setAccessible()方法");
                    field.setAccessible(true); // 设置为允许访问
                    isTurn = true;
                }
            }
            System.out.println();
        }
    }
}

访问成员方法

在通过下列一组方法访问成员方法时，将返回Method类型的对象或数组。每个Method对象代表一个方法，利用Method对象可以操纵相应的方法。

Method类的常用方法

方法说明
getName()获得该方法的名称
getParameterType()按照声明顺序以Class数组的形式获得该方法的各个参数类型
getReturnType()以Class对象的形式获得该方法的返回值的类型
getExceptionTypes()以Class对数组的形式获得该方法可能抛出的异常类型
invake(Object obj,Object…args)利用指定参数args执行指定对象obj中的该方法，返回值为Object型
isVarArgs()查看该方法是否允许带有可变数量的参数，如果允许则返回true，否则返回false
getModifiers()获得可以解析出该方法所采用的修饰符的整数
// Demo3.java

package com.mr;

public class Demo3 {
	static void staticMethod() {
		System.out.println("执行staticMethod()方法");
	}

	public int publicMethod(int i) {
		System.out.println("执行publicMethod()方法");
		return i * 100;
	}

	protected int protectedMethod(String s, int i) throws NumberFormatException {
		System.out.println("执行protectedMethod()方法");
		return Integer.valueOf(s) + i;
	}

	private String privateMethod(String... strings) {
		System.out.println("执行privateMethod()方法");
		StringBuffer stringBuffer = new StringBuffer();
		for (int i = 0; i < strings.length; i++) {
			stringBuffer.append(strings[i]);
		}
		return stringBuffer.toString();
	}
}
// MethondDemo.java
import java.lang.reflect.*;

public class MethondDemo {
	public static void main(String[] args) {
		Demo3 demo = new Demo3();
		Class demoClass = demo.getClass();
		// 获得所有方法
		Method[] declaredMethods = demoClass.getDeclaredMethods();
		for (int i = 0; i < declaredMethods.length; i++) {
			Method method = declaredMethods[i]; // 遍历方法
			System.out.println("名称为：" + method.getName()); // 获得方法名称
			System.out.println("是否允许带有可变数量的参数：" + method.isVarArgs());
			System.out.println("入口参数类型依次为：");
			// 获得所有参数类型
			Class[] parameterTypes = method.getParameterTypes();
			for (int j = 0; j < parameterTypes.length; j++) {
				System.out.println(" " + parameterTypes[j]);
			}
			// 获得方法返回值类型
			System.out.println("返回值类型为：" + method.getReturnType());
			System.out.println("可能抛出的异常类型有：");
			// 获得方法可能抛出的所有异常类型
			Class[] exceptionTypes = method.getExceptionTypes();
			for (int j = 0; j < exceptionTypes.length; j++) {
				System.out.println(" " + exceptionTypes[j]);
			}
			boolean isTurn = true;
			while (isTurn) {
				try {// 如果该方法的访问权限为private，则抛出异常，即不允许访问
					isTurn = false;
					if ("staticMethod".equals(method.getName()))
						method.invoke(demo); // 执行没有入口参数的方法
					else if ("publicMethod".equals(method.getName()))
						System.out.println("返回值为：" + method.invoke(demo, 168)); // 执行方法
					else if ("protectedMethod".equals(method.getName()))
						System.out.println("返回值为：" + method.invoke(demo, "7", 5)); // 执行方法
					else if ("privateMethod".equals(method.getName())) {
						Object[] parameters = new Object[] { new String[] { "M", "W", "Q" } }; // 定义二维数组
						System.out.println("返回值为：" + method.invoke(demo, parameters));
					}
				} catch (Exception e) {
					System.out.println("在执行方法时抛出异常，" + "下面执行setAccessible()方法！");
					method.setAccessible(true); // 设置为允许访问
					isTurn = true;
				}
			}
			System.out.println();
		}
	}
}

注解

java中提供了Annotation注解功能，该功能可用于类、构造方法、成员变量、成员方法、参数等的声明中。该功能并不影响程序中的运行，但是会对编辑器警告等辅助工具产生影响。

定义Annotation类型

在定义Annotation类型时，也需要用到用力爱定义接口的interface关键字，但需要在interface关键前加一个“@”符号，即定义Annotation类型的关键字为@interface，这个关键字的隐含意思是继承了java.lang.annotation.Annotation接口。

枚举类ElementType中的枚举常量

枚举常量说明
ANNOTATION_TYPE表示用于Annotation类型
TYPE表示用于类、接口和枚举，以及Annotation类型
CONSTRUCTOR表示用于构造方法
FIELD表示用于成员变量和枚举常量
METHOD表示用于方法
PARAMETER表示用于参数
LOCAL_VARIABLE表示用于局部变量
PACKAGE表示用于包

枚举类RetentionPolicy中的枚举常量

枚举常量说明
SOURCE表示不编译Annotation到类文件中，有效范围最小
CLASS表示编译Annotation到类文件中，但是在运行不加载Annotation到JVM中
RUNTIME表示在运行时加载Annotation到JVM中，有效范围最大
例子
// 创建自定义注解
// Constructor_Annotation.java
import java.lang.annotation.*;

@Target(ElementType.CONSTRUCTOR)
// 用于构造方法
@Retention(RetentionPolicy.RUNTIME)
// 在运行时加载Annotation到JVM中
public @interface Constructor_Annotation {
	String value() default "默认构造方法"; // 定义一个具有默认值的String型成员
}
// Field_Method_Parameter_Annotation
import java.lang.annotation.*;

// 用于字段、方法和参数
@Target( { ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
// 在运行时加载Annotation到JVM中
public @interface Field_Method_Parameter_Annotation {
	String describe(); // 定义一个没有默认值的String型成员
	
	Class type() default void.class; // 定义一个具有默认值的Class型成员
}
// Record
public class Record {
	@Field_Method_Parameter_Annotation(describe = "编号", type = int.class)
	// 注释字段
	int id;
	@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class)
	String name;

	@Constructor_Annotation()
	// 采用默认值注释构造方法
	public Record() {
	}

	@Constructor_Annotation("立即初始化构造方法")
	// 注释构造方法
	public Record(@Field_Method_Parameter_Annotation(describe = "编号", type = int.class) int id,
			@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class) String name) {
		this.id = id;
		this.name = name;
	}

	@Field_Method_Parameter_Annotation(describe = "获得编号", type = int.class)
	// 注释方法
	public int getId() {
		return id;
	}

	@Field_Method_Parameter_Annotation(describe = "设置编号")
	// 成员type采用默认值注释方法
	public void setId(
			// 注释方法的参数
			@Field_Method_Parameter_Annotation(describe = "编号", type = int.class) int id) {
		this.id = id;
	}

	@Field_Method_Parameter_Annotation(describe = "获得姓名", type = String.class)
	public String getName() {
		return name;
	}

	@Field_Method_Parameter_Annotation(describe = "设置姓名")
	public void setName(@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class) String name) {
		this.name = name;
	}
}

访问Annotation信息

如果在定义Annotation类型时将@Retention设置为RetentionPolicy.RUNTIME，那么在运行程序时通过反射就可以获取相关的Annotation信息，如获取构造方法、字段和方法的Annotation信息。

例子
// 访问注释中的信息
// AnnotationTest.java
import java.lang.annotation.*;
import java.lang.reflect.*;

public class AnnotationTest {

	public static void main(String[] args) {
		Class recordC = null;
		try {
			recordC = Class.forName("Record");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}

		System.out.println("------ 构造方法的描述如下 ------");
		Constructor[] declaredConstructors = recordC.getDeclaredConstructors(); // 获得所有构造方法
		for (int i = 0; i < declaredConstructors.length; i++) {
			Constructor constructor = declaredConstructors[i]; // 遍历构造方法
			// 查看是否具有指定类型的注释
			if (constructor.isAnnotationPresent(Constructor_Annotation.class)) {
				// 获得指定类型的注释
				Constructor_Annotation ca = (Constructor_Annotation) constructor
						.getAnnotation(Constructor_Annotation.class);
				System.out.println(ca.value()); // 获得注释信息
			}
			Annotation[][] parameterAnnotations = constructor.getParameterAnnotations(); // 获得参数的注释
			for (int j = 0; j < parameterAnnotations.length; j++) {
				// 获得指定参数注释的长度
				int length = parameterAnnotations[j].length;
				if (length == 0) // 如果长度为0则表示没有为该参数添加注释
					System.out.println("    未添加Annotation的参数");
				else
					for (int k = 0; k < length; k++) {
						// 获得参数的注释
						Field_Method_Parameter_Annotation pa = (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
						System.out.print("    " + pa.describe()); // 获得参数描述
						System.out.println("    " + pa.type()); // 获得参数类型
					}
			}
			System.out.println();
		}

		System.out.println();

		System.out.println("-------- 字段的描述如下 --------");

		Field[] declaredFields = recordC.getDeclaredFields(); // 获得所有字段
		for (int i = 0; i < declaredFields.length; i++) {
			Field field = declaredFields[i]; // 遍历字段
			// 查看是否具有指定类型的注释
			if (field.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
				// 获得指定类型的注释
				Field_Method_Parameter_Annotation fa = field.getAnnotation(Field_Method_Parameter_Annotation.class);
				System.out.print("    " + fa.describe()); // 获得字段的描述
				System.out.println("    " + fa.type()); // 获得字段的类型
			}
		}

		System.out.println();

		System.out.println("-------- 方法的描述如下 --------");

		Method[] methods = recordC.getDeclaredMethods(); // 获得所有方法
		for (int i = 0; i < methods.length; i++) {
			Method method = methods[i]; // 遍历方法
			// 查看是否具有指定类型的注释
			if (method.isAnnotationPresent(Field_Method_Parameter_Annotation.class)) {
				// 获得指定类型的注释
				Field_Method_Parameter_Annotation ma = method.getAnnotation(Field_Method_Parameter_Annotation.class);
				System.out.println(ma.describe()); // 获得方法的描述
				System.out.println(ma.type()); // 获得方法的返回值类型
			}
			Annotation[][] parameterAnnotations = method.getParameterAnnotations(); // 获得参数的注释
			for (int j = 0; j < parameterAnnotations.length; j++) {
				int length = parameterAnnotations[j].length; // 获得指定参数注释的长度
				if (length == 0) // 如果长度为0表示没有为该参数添加注释
					System.out.println("    未添加Annotation的参数");
				else
					for (int k = 0; k < length; k++) {
						// 获得指定类型的注释
						Field_Method_Parameter_Annotation pa = (Field_Method_Parameter_Annotation) parameterAnnotations[j][k];
						System.out.print("    " + pa.describe()); // 获得参数的描述
						System.out.println("    " + pa.type()); // 获得参数的类型
					}
			}
			System.out.println();
		}
	}
}
// Constructor_Annotation.java
import java.lang.annotation.*;

@Target(ElementType.CONSTRUCTOR)
// 用于构造方法
@Retention(RetentionPolicy.RUNTIME)
// 在运行时加载Annotation到JVM中
public @interface Constructor_Annotation {
	String value() default "默认构造方法"; // 定义一个具有默认值的String型成员
}
// Field_Method_Parameter_Annotation.java
import java.lang.annotation.*;

// 用于字段、方法和参数
@Target( { ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER })
@Retention(RetentionPolicy.RUNTIME)
// 在运行时加载Annotation到JVM中
public @interface Field_Method_Parameter_Annotation {
	String describe(); // 定义一个没有默认值的String型成员
	
	Class type() default void.class; // 定义一个具有默认值的Class型成员
}
// Record.java
public class Record {
	@Field_Method_Parameter_Annotation(describe = "编号", type = int.class)
	int id;

	@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class)
	String name;

	@Constructor_Annotation()
	public Record() {
	}

	@Constructor_Annotation("立即初始化构造方法")
	public Record(@Field_Method_Parameter_Annotation(describe = "编号", type = int.class) int id,
			@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class) String name) {
		this.id = id;
		this.name = name;
	}

	@Field_Method_Parameter_Annotation(describe = "获得编号", type = int.class)
	public int getId() {
		return id;
	}

	@Field_Method_Parameter_Annotation(describe = "设置编号")
	public void setId(@Field_Method_Parameter_Annotation(describe = "编号", type = int.class) int id) {
		this.id = id;
	}

	@Field_Method_Parameter_Annotation(describe = "获得姓名", type = String.class)
	public String getName() {
		return name;
	}

	@Field_Method_Parameter_Annotation(describe = "设置姓名")
	public void setName(@Field_Method_Parameter_Annotation(describe = "姓名", type = String.class) String name) {
		this.name = name;
	}
}
乐正龙牙lox
关注
专栏目录
【java反射】反射——包含你所想要了解的一切（初学者必看，超详细）
miles067的博客
07-23 64
反射：通俗来说就是没见过这个类，但是对这个类的内容做出分析。
《Java核心技术 卷I》笔记——（3）Java注解
娜娜米的博客
03-20 264
JAVA 注解 Annotation中文译过来就是注解、标释的意思，在Java中注解是一个很重要的知识点，但经常还是有点让新手不容易理解。 比如，大多数的文档对“注解”的解释——“Java 注解用于为 Java 代码提供元数据。作为元数据，注解不直接影响你的代码执行，但也有一些类型的注解实际上可以用于这一目的。Java 注解是从 Java5 开始添加到 Java 的。” 我个人认为，比较糟糕的技术文档主要特征之一就是：用专业名词来介绍专业名词。 注解？——标签！ 标签是一张便利纸，标签上的内容可以自
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（基础篇）
vincewm的博客
01-05 5149
从Java环境的搭建到实际代码的编写，从基本用法的讲解到底层原理的剖析，深度解析Java基础知识。本文是《Java学习路线》专栏的起始文章，旨在提供一套完整的Java学习路线，覆盖Java基础知识、数据库、SSM/SpringBoot等框架、Redis/MQ等中间件、设计模式、架构设计、性能调优、源码解读、核心面试题等全面的知识点，并在未来不断更新和完善，帮助Java从业者在更短的时间内成长为高级开发。
JAVA基础与高级学习笔记
llzqxl的博客
05-31 638
JAVA基础学习笔记 JAVA基础 java会出现内存溢出和泄露。 JDK与JRE的关系。 a. JDK（Java Development Kit Java开发工具包） JDK是提供给JAVA开发人员使用的，其中包含了Java的开发工具，也包含了JRE，所以安装装了JDK就不用再单独安装JRE了。其中的开发工具：编译工具（javac.exe）,打包工具（jar.exe）、javadoc等。 b. JRE（Java Runtime Enviroment Java运行环境） 包括Java虚拟机（Jav
【连载】Java笔记——又是被咖啡小可爱迷倒的一天呢
weixin_52777510的博客
01-25 318
我是灼灼，一只初学Java的大一金渐层。 向往余秀华和狄兰·托马斯的疯狂，时常沉溺于将情感以诗相寄；追逐过王尔德、王小波的文字，后陷于毛姆和斯蒂芬·金不可自拔；热爱文学的浪潮，白日梦到底却总在现实里清醒；艳羡平静又极度渴盼奔跑的力量。 欢迎与我交流鸭· QQ:1517526827； 个人博客：https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343 Java笔记——反射和注解 Java笔记正在连载中，欢迎来其他内容逛逛哟~ 相关内容如下.
Java基础知识笔记整理（零基础学Java）
热门推荐
风小风的博客
01-23 2万+
文章目录前言java语言特性java的编译与运行JDK、JRE、JVM字符编码数据类型标识符命名方法Java小知识数组一维数组二维数组逻辑运算符 前言 以下是一名java初学者在自学过程中所整理的笔记，欢迎大家浏览并留言，若有错误的地方请大家指正。 java语言特性 简单性：相对于其他编程语言而言，java较为简单，例如：java不再支持多继承，C++是支持多继承的，多继承比较复杂，C++中有指针，java中屏蔽了指针的概念等，这里说明一下，java语言低层是用C++实现的，并不是C语言。 面向对象：ja
个人Java开发初学笔记 2020.5.22更新
yaly.top的博客
02-23 766
java开发 编写java的步骤 写源文件，源文件的扩展名是.java 对源文件进行编译 不带包名的编译 rem 目录:>javac HelloWorld.java 带包名的编译 rem 目录:>javac -d . HelloWorld.java //.就是当前文件夹 对编译生成的.class文件做执行 不带包名的执行 目录:>java ...
【连载】Java笔记——了解Java先了解她的心呀
weixin_52777510的博客
01-24 679
我是灼灼，一只初学Java的大一金渐层。 向往余秀华和狄兰·托马斯的疯狂，时常沉溺于将情感以诗相寄；追逐过王尔德、王小波的文字，后陷于毛姆和斯蒂芬·金不可自拔；热爱文学的浪潮，白日梦到底却总在现实里清醒；艳羡平静又极度渴盼奔跑的力量。 欢迎与我交流鸭· QQ:1517526827； 个人博客：https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343 Java笔记——Java核心类 Java笔记正在连载中，欢迎来其他内容逛逛哟~ 相关内容如.
Java基础（六）——多线程的基本使用与原理
荆州拉人去编程
12-13 279
线程的创建 Thread类 通过继承Thread创建线程 通过实现Runnable接口创建线程 实现Callable接口 FutureTask 线程的生命周期 线程的编号和名称的管理 线程调度相关 线程的优先级 出生入死好兄dai——守护线程 线程同步机制 线程安全问题 synchronized关键字 Lock类 线程通信 干饭人与造饭人（生产者与消费者模型） 线程池的最最最最最最简单的使用 Executors类 ExecutorService接口
超详细的Java复习知识点2019——个人笔记.zip
06-24
这份名为"超详细的Java复习知识点2019——个人笔记"的文档，旨在为初学者提供一个全面且深入理解Java基础知识的指南。笔记内容可能涵盖了以下几个关键领域： 1. **Java语法基础**：包括变量、数据类型、运算符、...
java jdk5.0学习笔记——良葛格
11-28
良葛格的《Java JDK5.0学习笔记》是一本面向初学者的教程，旨在帮助读者掌握这个版本的核心概念和技术。以下是基于该书部分内容的知识点详解： 1. **泛型**：JDK 5.0引入了泛型，这是一种强大的类型系统增强，允许...
Java入门学习笔记
11-25
这份"Java入门学习笔记"涵盖了imooc网站上Java入门课程的三个赛季的内容，旨在为初学者提供一个全面的学习资源。 笔记的第一部分是"Java入门第一季学习笔记"，它可能包括Java的基础概念和语法。这部分可能会讲解...
李兴华java word版全部笔记
12-25
12. **注解**：介绍了Java注解的使用，包括自定义注解和元注解，以及如何通过反射机制处理注解信息。 13. **JDBC数据库编程**：详细阐述了如何使用Java进行数据库操作，包括连接数据库、执行SQL语句、处理结果集等...
Java编程思想笔记(全)
06-14
### Java编程思想笔记知识点概述 #### 第 1 章 对象导论 在这一章节中，主要介绍...以上内容概括了《Java编程思想笔记》中的核心知识点，涵盖了Java语言的基础到高级特性，适合初学者和有一定经验的开发者参考学习。
Java企业面试题3
最新发布
m0_74972727的博客
09-15 261
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 564
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Gradle
xiaocaij_icai的博客
09-15 110
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 882
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Java初学者笔记：基础语法、构造函数与面向对象
"Java笔记涵盖了Java语言的基础知识，专为初学者设计，内容详实且包含大量手打代码。笔记首先介绍了Java中的关键概念，如`continue`关键字，它仅适用于循环结构，用于结束当前循环周期并进入下一轮。对于条件判断，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值