JAVA注解和反射

最新推荐文章于 2024-10-08 21:30:52 发布
最新推荐文章于 2024-10-08 21:30:52 发布
阅读量88 收藏 1
点赞数 2
分类专栏： javaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46266974/article/details/120589300
版权

JAVA注解和反射

一：注解

1.注解格式：@“注解名“
2.内置注解：@Override,@Deprecated,@SuppressWarnings
3.元注解: @Target,@Retention(RUNTIME>CLASS>SOURCE),@Document,@Inherited
4.自定义注解：a.@interface自动继承了Annotation接口了
             b.注解参数：参数类型+参数名（）

package annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
public class Main {
    @MyAnnatation01(name="张三")
    public void func01(){
        System.out.println();
    }
    @MyAnnatation02("张三")
    public void func02(){
        System.out.println();
    }
    @MyAnnatation03(age=22)
    public void func03(){
        System.out.println();
    }
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnatation01{
    //注解参数：参数类型+参数名（）
    String name();
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnatation02{
    String value();     //可用默认
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnatation03{
    String name() default "";
    int id()default -1;
    int[] score()default {85,75,60};
    int age();
}

二：反射

1.反射概述：

 1.java是静态语言，通过反射变为了准动态语言
 2.反射很强大，可以通过Refletion API任何类的内部信息，并能操作任意对象的内部属性及方法
 3.四种获取Class对象方式(类名):
                      （1. forname(“包名下的路径”)
                      （2. 对象名.getClass()
                      （3. 类名.class
                      （4. 基本类型包装类.Type
 5.一种获取其父类的Class对象方式: 对象名.getSuperClass()
 6.类被加载后，其该类的整体结构被封装到Class对象中，在内存中，一个类只有一个Class对象

package reflection;
import java.lang.annotation.ElementType;
public class Main {

    public static void main(String[] args) throws ClassNotFoundException {
        Person user = new Person();
        //1.通过forName("")获取
        Class c1 = Class.forName("reflection.Person");
        Class c2 = Class.forName("reflection.Person");
        System.out.println("c2 = " + c2);
        //2.通过对象获取
        Man man = new Man();
        Class c3 = man.getClass();
        System.out.println("c3 = " + c3);
        //3.通过类名获取
        Class c4 = Person.class;
        System.out.println("c4 = " + c4);
        Class c5 = Man.class;
        System.out.println("c5 = " + c5);
        Class c6 = Main.class;
        System.out.println("c6 = " + c6);
        //4.通过基本类型包装类的Type属性
        Class c7 = Integer.TYPE;
        System.out.println("c7 = " + c7);
        //5.获取父类的Class名
        System.out.println("c8 = " + c3.getSuperclass());
        //6.类被加载后，其该类的整体结构被封装到Class对象中，在内存中，一个类只有一个Class对象
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c6.hashCode());
        System.out.println("-------------");
        showAllClass();
    }
    //7.大部分类型的Class对象
    public static void showAllClass(){
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = int[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = Void.class;
        Class c9 = Class.class;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
        System.out.println("-----------");
        //同类型的数组其Class对象与数组的长度无光
        int[] a1 =new int[10];
        int[] a2=new int[100];
        System.out.println(a1.getClass());
        System.out.println(a2.getClass());
    }
}

class Person {
    String name;
    int age;
    public int id;

    public Person(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    public Person() {

    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public int getId() {
        return id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setId(int id) {
        this.id = id;
    }
    private void test(){}
}
class Man extends Person{
}

2.初识类加载内存机制：

1.类加载：将Class字节码文件加载到内存中，对应生成唯一的Class对象（方法区——>堆）
2.链接：为所有类变量（static）分配内存并为其设置默认初始值（方法区）
3.初始化：<clinit>()将所有赋值动作和静态代码块合并（栈）

package reflection;
public class ClassLoading01 {
    static{
        System.out.println("Main被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        ClassMemory();    //类加载内存机制

        //1.通过new来主动引用
        Son son=new Son();
        //2.通过forName()来主动引用
        //Class aClass = Class.forName("reflection.Son");

        //1.子类调用父类的静态方法不会触发自身类的主动引用
        //System.out.println(Son.mFather);
        //2.创建数组不会触发主动引用
        //Son[] vsSon=new Son[10];
    }

    //类内存加载机制
    public static void ClassMemory(){
        A a=new A();        //new操作在堆区
        System.out.println(a.m);
    }
}

//测试类加载的内存机制
class A{
    static{
        System.out.println("静态代码块初始化");
        m=300;
    }
    public static int m=100;
    A(){
        System.out.println("A的构造函数调用");
    }
}

class Father{
    static {
        System.out.println("父类被加载");
    }
    public static int mFather=1;
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
    }
    public static int mSon=1;
    public static final int nFinalSon=2;
}

3.初识类加载器：

一.类加载器：
   1.系统类加载器：ClassLoader.getSystemClassLoader()
   2.扩展类加载器：systemClassLoader.getParent()
   3.引导类(根)加载器(C/C++编写)：扩展类加载器.getParent()
   4.测试当前类和内置类的加载器
   5.获取系统加载器可以加载的路径：同4获取class对象.getClassLoader()
   6.双亲委派机制
二.获取类运行时结构：
   1.获取类名（全包名，只类名）:Class对象.getName()
   2.获取属性值（公有，所有，指定）:
           公有： Class对象.getFields()
           所有：Class对象.getDeclaredFields()
           指定：对应方法去掉s+属性名参数
   3.获取方法（公有，所有，指定）：
           公有：Class对象.getMethods()
           所有：Class对象.getDeclaredMethods()
           指定：对应方法去掉s+函数名参数
   4.获取构造方法（公有，指定）
           公有：Class对象.getConstructors()
           指定：对应函数去掉s+实际参数的class
三：反射动态创建对象并执行方法：
   1.无参创建对象和有参创建：
           无参：Class对象.newInstance()
           有参：Class对象..getConstructor(实际参数的Class对象)
   2.获取方法并调用：
           获取：Class对象.getMethod("方法名", 参数的Class对象)
           调用：方法名.invoke(创建的对象名, 参数)
   3.操作属性并调用
        权限检测：创建的对象名.setAccessible(true),ture为关闭
           调用：获取属性名后.set(创建的对象名,参数)
四：对象调用性能对比分析：
   1.普通对象调用(约3ms)
   2.通过反射调用(约3592ms)
   3.通过反射调用并关掉安全性权限检测(约1847ms)
   4.若频繁调用反射，可关闭安全检测提升性能

package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ClassLoading02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        //一：类加载器
        classLoadTest();
        //二：获取类运行时结构
        getClassRuning();
        //三：反射动态创建对象并执行
        createClassRuning();
        //四：对象调用性能分析
        performanceAnalyze();
    }

    //一：类加载器
    public static void classLoadTest() throws ClassNotFoundException {
        //获取系统加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取扩展类加载器
        ClassLoader parent1 = systemClassLoader.getParent();
        System.out.println(parent1);
        //获取根加载器(无法直接获取)
        ClassLoader parent2 = parent1.getParent();
        System.out.println(parent2);
        //获取当前类的加载器
        Class<?> aClass = Class.forName("reflection.ClassLoading02");
        System.out.println(aClass.getClassLoader());
        //获取内置类的加载器:Object类的加载器是根加载器
        ClassLoader classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
        //获取系统加载器可加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }

    //二：获取类运行时结构
    public static void getClassRuning() throws NoSuchFieldException, NoSuchMethodException {
        System.out.println("----------------");
        Person person = new Person();
        Class<? extends Person> aClass = person.getClass();
        //1.获取类名
        String name = aClass.getName();
        String simpleName = aClass.getSimpleName();
        System.out.println("全名：" + name);
        System.out.println("类名" + simpleName);
        System.out.println("----------------");
        //2.获取属性值
        Field[] declaredFields = aClass.getDeclaredFields();
        Field[] fields = aClass.getFields();
        Field field = aClass.getDeclaredField("name");
        Field id = aClass.getField("id");
        for (Field declaredField : declaredFields) {
            System.out.println("所有属性："+declaredField);
        }
        for (Field field1 : fields) {
            System.out.println("公有属性："+field);
        }
        System.out.println("指定私有属性：" + field);
        System.out.println("指定共有属性："+id);
        System.out.println("----------------------");
        //3.获取方法
        Method[] methods = aClass.getMethods();
        Method[] declaredMethods = aClass.getDeclaredMethods();
        Method getId = aClass.getMethod("setId", int.class);//重载，第二个参数是方法的参数类型
        Method test = aClass.getDeclaredMethod("test", null);
        for (Method method : methods) {
            System.out.println("共有方法："+method);
        }
        for (Method declaredMethod : declaredMethods) {
            System.out.println("所有方法："+declaredMethod);
        }
        System.out.println("指定共有方法：" + getId);
        System.out.println("指定私有方法："+test);
        System.out.println("-------------------");
        //4.获取构造器
        Constructor<?>[] constructors = aClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("获取构造器："+constructor);
        }
        Constructor<? extends Person> constructor = aClass.getConstructor(String.class, int.class, int.class);
        System.out.println("获取指定构造器："+constructor);
    }

    //三：反射动态创建对象并执行
    public static void createClassRuning() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        System.out.println("###################");
        Class<?> aClass = Class.forName("reflection.Person");
        //1.获取无参对象
        Object o = aClass.newInstance();
        System.out.println("反射创建无参对象："+o);
        //2.获取有参对象
        Constructor<?> constructor = aClass.getConstructor(String.class, int.class, int.class);
        Object person = constructor.newInstance("张三", 22, 101);
        System.out.println("反射创建有参对象："+person);
        //3.获取方法
        Method setName = aClass.getMethod("setName", String.class);
        setName.invoke(person, "李四");//invoke激活函数
        System.out.println("反射调用函数："+person);
        //4.操作属性
        Field personName = aClass.getDeclaredField("name");
        //关闭安全权限检测
        personName.setAccessible(true);
        personName.set(person,"王五");
        System.out.println("反射操作属性：name:"+personName.get(person));
    }

    //四：对象调用性能分析
    public static void performanceAnalyze() throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        System.out.println();
        System.out.println("---------------------");
        test01();//3ms
        test02();//3592ms
        test03();//1847ms
    }
    public static void test01(){
        Person person=new Person("zhangsan",18,28);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            person.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通对象调用："+(endTime-startTime)+"ms");
    }
    public static void test02() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class aClass = Class.forName("reflection.Person");
        Constructor constructor = aClass.getConstructor(String.class, int.class, int.class);
        Object person = constructor.newInstance("zhangsan", 18, 28);
        Method getName = aClass.getMethod("getName", null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(person,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("通过反射调用："+(endTime-startTime)+"ms");
    }
    public static void test03() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class aClass = Class.forName("reflection.Person");
        Constructor constructor = aClass.getConstructor(String.class, int.class, int.class);
        Object person = constructor.newInstance("zhangsan", 18, 28);
        Method getName = aClass.getMethod("getName", null);
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(person,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("通过反射并关闭安全检测调用："+(endTime-startTime)+"ms");
    }
}

4.反射获取泛型信息：

1.获取函数的泛型参数类型：
        泛型参数类型：方法名.getGenericParameterTypes()
        判断泛型参数为参数化类型:if(genericParameterType instanceof ParameterizedType)
        强转为参数化类型：((ParameterizedType) genericParameterType).getActualTypeArguments()
2.获取函数的返回泛型类型：
        返回泛型类型：方法名.getGenericReturnType()
        判断泛型参数为参数化类型：同上
        强转为参数化类型：同上

在这里插入代码片package reflection;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;

public class GetGenericityInformantion {
    public void test01(Map<String,Person> arg){

    }
    public Map<String,Person> test02(){
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        //1.获取函数的泛型参数类型
        Method test01 = GetGenericityInformantion.class.getMethod("test01", Map.class);
            //获取方法的泛型参数类型
        Type[] genericParameterTypes = test01.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            //打印泛型参数类型
            System.out.println("函数参数类型："+genericParameterType);
            //如果该泛型参数为参数化类型
            if (genericParameterType instanceof ParameterizedType){
            //将该泛型参数强转为参数化类型再获取实际的类型参数
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println("实际的类型参数："+actualTypeArgument);
                }
            }
        }
        System.out.println("-------------------");
        //2.获取函数的返回泛型类型
        Method test02 = GetGenericityInformantion.class.getMethod("test02");
        Type genericReturnType = test02.getGenericReturnType();
        System.out.println("函数返回的泛型类型："+genericReturnType);
        if (genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("函数返回的泛型信息："+actualTypeArgument);
            }
        }
    }
}

5.反射调用注解：

1.反射调用类的注解的value
2.反射调用类属性的注解value

package reflection;

import com.sun.jdi.Value;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class ReflectionCallAnnotation {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.获取类的注解信息
        Class<?> c1 = Class.forName("reflection.Student");
        Annotation[] annotations = c1.getAnnotations();//直接通过Class对象获取注解
        for (Annotation annotation : annotations) {
            System.out.println("获取类注解信息："+annotation);
        }

        //2.获取类注解的value()
        ClassAnnotation annotation = (ClassAnnotation)c1.getAnnotation(ClassAnnotation.class);
        System.out.println("获取类注解的value():"+annotation.value());//传递注解class参数获取

        //2.获取类属性的注解信息
        Field[] declaredFields = c1.getDeclaredFields();
        for (Field declaredField : declaredFields) {//传递注解class参数获取
            FieldAnnotation annotation1 = declaredField.getAnnotation(FieldAnnotation.class);
            System.out.println("获取类属性的直接信息："+"<"+declaredField.getName()+">"+annotation1.name()+" "+annotation1.type()+" "+annotation1.length());
        }
    }
}
@ClassAnnotation("db_student")
class Student{
    @FieldAnnotation(name="sName",type ="varchar",length = 5)
    private String sName;
    @FieldAnnotation(name="nIage",type = "int",length = 6)
    private int nIge;
    @FieldAnnotation(name = "sId",type = "varchar",length = 12)
    private String sId;

    public Student() {
    }

    public Student(String sName, int nIge, String sId) {
        this.sName = sName;
        this.nIge = nIge;
        this.sId = sId;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sName='" + sName + '\'' +
                ", nIge=" + nIge +
                ", sId='" + sId + '\'' +
                '}';
    }

    public void setsName(String sName) {
        this.sName = sName;
    }

    public void setnIge(int nIge) {
        this.nIge = nIge;
    }

    public void setsId(String sId) {
        this.sId = sId;
    }

    public String getsName() {
        return sName;
    }

    public int getnIge() {
        return nIge;
    }

    public String getsId() {
        return sId;
    }
}
//对类的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface ClassAnnotation{
    String value();
}
//对属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotation{
    String name();
    String type();
    int length();
}
不羁的风zk
关注
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1265
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2502
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java注解和反射
qq_39565343的博客
03-02 2042
一、注解 注解（Annotation）： 从jdk5.0开始引进，可以对程序进行解释或被其他程序读取。 注解格式："@注释名"，并可以添加一些参数。 例：@MyAnnotation(value=‘value’) 1、内置注解 @override： 用于修饰方法，表示该方法声明是重写或实现一个父类的方法 @Deprecated： 用于修饰方法、属性、类，表示已过时不建议使用的 @SuppressWarnings： 用于抑制编译时的警告信息 2、元注解 作用：用于注解其他注解 @Target： 用于描述注解的适
java注解和反射
qq_39142743的博客
03-15 418
java注解和反射的笔记
java 反射和注解
weixin_41765786的博客
07-19 1474
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
Java注解与反射
weixin_64026220的博客
07-20 833
Java注解与反射的学习
Java 注解和反射详解
Woo_home的博客
09-15 3649
文章目录注解什么是注解？内置注解元注解@Target@Retention@Documented@Inherited自定义注解反射静态语言 VS 动态语言动态语言静态语言Java 反射机制概述Java 反射机制提供的功能Java 反射优点和缺点反射相关的主要 API理解 Class 类并获取 Class 实例Class 类Class 类的常用方法获取 Class 类的实例所有类型的 Class 对象Java 内存分析类的加载与 ClassLoader 的理解 注解 什么是注解？ Annotation 是从
java注解和反射的应用
KKALL1314的博客
07-19 2276
前言： 注解和反射经常结合在一起使用，在很多框架的代码中都能看到他们结合使用的影子 所以要想成为一个架构师，想要编写自己的框架，一定要能熟练的使用注解和反射。 注解的概念 注解在我看来就是一个标签，用来标记所修饰的东西，而在程序中，用到这个东西时，可以通过获取他的注解，也就是标签，来进行个性化操作。可以简化初始化时的工作，而把原本初始化做的工作放到业务处理中，借助注解去做，这样极大的提高了编程的...
Java注解和反射的学习笔记
xiao_huo_hua_的博客
06-12 1014
注解就是代码中的特殊标记，这些标记可以在编译、类加载、运行时被读取，从而做相对应的处理。注：注释时给人看的，注解是给程序看的，可以被编译器读取。
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
根据提供的文件信息，我们可以梳理出以下知识点： ...以上知识点详细阐述了文档中提到的方法和技术原理，为理解和应用Java注解和反射机制在Excel文件读写操作中的实际应用提供了理论基础和技术指导。
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
JAVA 注解和反射.7z
04-08
总结，Java注解和反射是Java开发中非常重要的技术，它们极大地增强了Java的灵活性和可扩展性。注解简化了代码，提供了元数据，而反射则允许程序在运行时探索和修改自身的结构，两者共同推动了Java的广泛应用。了解并...
一种基于Java注解和反射机制的Excel文件读写操作方法.zip
10-16
综上所述，基于Java注解和反射机制的Excel文件读写操作方法是一种将面向对象的编程理念应用于数据操作的有效方式。通过这种方式，我们能够以声明式的方式定义数据结构与Excel文件格式之间的映射，从而简化了代码，...
JDK1.0主要特性
FoolRabbit的专栏
10-06 658
JDK1.0主要特性。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1435
2024最新Java面试题，针对一些小厂，中厂
已解决-Sentinel控制台明明正常启动，扫描不到客户端应用
最新发布
qq_46248151的博客
10-08 591
经排查才发现，我在启动了Sentinel控制台之后，对SpringBoot应用做了配置的更新，于是重启了SpringBoot服务，这时SpringBoot是没有任何访问的。今天启动Sentinel控制台的时候，明明启动成功，无报错，浏览器能正常访问，但就是无论如何都刷新不出来应用。
Spring Boot新闻推荐系统设计与实现
2402_85758936的博客
10-04 1575
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。一旦输入系统的数据不正确，那么处理后的输出就会扩大这些错误，因此输入的数据的准确性对整个系统的性能起着决定性意义。输出是由电脑对输入的基本信息进行解决，生成高质量的有效信息，并使之具有一定的格式，提供给管理者使用，这是输出设计的主要责任和目标。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不羁的风zk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值