精华内容
下载资源
问答
  • Java实体类中的get/set方法,有无参构造器,toString方法的个人理解 写在前面:此文章为学习时编写,如有错误理解,希望各位不吝赐教,共同成长,谢谢  首先解释为什么需要实体类,当拥有多个属性的时候会不方便...

    Java实体类中的get/set方法,有无参构造器,toString方法的个人理解

    写在前面:此文章为学习时编写,如有错误理解,希望各位不吝赐教,共同成长,谢谢
      首先解释为什么需要实体类,当拥有多个属性的时候会不方便使用者的调用,所以创建一个罐子,把这些属性装进罐子,在使用的时候直接将整个罐子调用即可。方便使用者的调用;
      其次讲一下get/set的作用,本意是得到/设置,由于创建实体类的时候属性设置私有,别人无法直接得到它,如何才能得到这些属性呢,使用get;那如何设置这些属性的值呢?使用set;
      接下来讲一下有无参构造方法;当开发者没有在类中创建构造方法时,系统会创建一个空的无参构造方法,不然无法new一个类;当开发者创建带参构造方法时,系统就不会自动提供无参构造方法;
      toString方法是为了在idea的控制台输出打印的语句,如果实体类中未写toString方法,那么在deBug的时候控制台不会输出相关测试语句;
      代码展示:

    /**
     * 部门实体类
     */
    public class Department {
        private int deptno;//部门编号
        private String deptname;//部门名称
        private String location;//办公地点
    
        //无参构造方法
        public Department() {
        }
        //带全参构造方法
        public Department(int deptno, String deptname, String location) {
            this.deptno = deptno;
            this.deptname = deptname;
            this.location = location;
        }
    
        //get/set方法
        public int getDeptno() {
            return deptno;
        }
    
        public void setDeptno(int deptno) {
            this.deptno = deptno;
        }
    
        public String getDeptname() {
            return deptname;
        }
    
        public void setDeptname(String deptname) {
            this.deptname = deptname;
        }
    
        public String getLocation() {
            return location;
        }
    
        public void setLocation(String location) {
            this.location = location;
        }
        
        //tuString方法
        @Override
        public String toString() {
            return "Department{" +
                    "deptno=" + deptno +
                    ", deptname='" + deptname + '\'' +
                    ", location='" + location + '\'' +
                    '}';
        }
    }
    

    *小学生一枚,各位如有想法,还请不吝赐教

    展开全文
  • JAVA构造器排序

    千次阅读 2016-08-21 16:13:50
    二、比较排序:java.util.Comparator  上篇博客(自然排序)我提到了之所以提供比较排序接口,是因为有时需要对同一对象进行多种不同方式的排序,这点自然排序 Comparable 不能实现。另外, Comparator 接口的一...

    二、比较器排序:java.util.Comparator
      上篇博客(自然排序)我提到了之所以提供比较器排序接口,是因为有时需要对同一对象进行多种不同方式的排序,这点自然排序 Comparable 不能实现。另外, Comparator 接口的一个好处是将比较排序算法和具体的实体类分离了。
      翻翻 API 会发现, Arrays.sort 还有种重载形式:sort(T[] a, Comparator<? super T> c) ,这个方法参数的写法用到了泛型,我们还没讲到。我们可以把它理解成这样的形式: sort(Object[] a, Comparator c) ,这个方法的意思是按照比较器 c 给出的比较排序算法,对 Object 数组进行排序。Comparator 接口中定义了两个方法: compare(Object o1, Object o2) 和 equals 方法,由于 equals 方法所有对象都有的方法,因此当我们实现 Comparator 接口时,我们只需重写 compare 方法,而不需重写 equals 方法。Comparator 接口中对重写 equals 方法的描述是:“注意,不重写 Object.equals(Object) 方法总是安全的。然而,在某些情况下,重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序,从而提高性能。”。我们只需知道第一句话就OK了,也就是说,可以不用去想应该怎么实现 equals 方法,因为即使我们不显示实现 equals 方法,而是使用Object类的 equals 方法,代码依然是安全的。而对于第二句话,究竟是怎么提高比较器性能的,我也不了解,所以就不说了。
      那么我们来写个代码,来用一用比较器排序。还是用 Student 类来做,只是没有实现 Comparable 接口。由于比较器的实现类只用显示实现一个方法,因此,我们可以不用专门写一个类来实现它,当我们需要用到比较器时,可以写个匿名内部类来实现 Comparator 。下面是我们的按姓名排序的方法:
      

    public void sortByName () {  
        Student stu1 = new Student(1, "Little");  
        Student stu2 = new Student(2, "Cyntin");  
        Student stu3 = new Student(3, "Tony");  
        Student stu4 = new Student(4, "Gemini");  
    
        Student[] stus = new Student[4];  
        stus[0] = stu1;  
        stus[1] = stu4;  
        stus[2] = stu3;  
        stus[3] = stu2;  
        System.out.println("Array: " + Arrays.toString(stus));  
    
        Arrays.sort(stus, new Comparator() {  
    
            @Override  
            public int compare(Object o1, Object o2) {  
                if (o1 instanceof Student && o2 instanceof Student) {  
                    Student s1 = (Student) o1;  
                    Student s2 = (Student) o2;  
                    //return s1.getId() - s2.getId(); // 按Id排  
                    return s1.getName().compareTo(s2.getName()); // 按姓名排  
                }  
                return 0;  
            }  
    
        });  
    
        System.out.println("Sorted: " + Arrays.toString(stus));  
    }  

    当我们需要对Student按学号排序时,只需修改我们的排序方法中实现Comparator的内部类中的代码,而不用修改 Student 类。

    P.S. 当然,你也可以用 Student 类实现 Comparator 接口,这样Student就是(is a)比较器了(Comparator)。当需要使用这种排序的时候,将 Student 看作 Comparator 来使用就可以了,可以将 Student 作为参数传入 sort 方法,因为 Student is a Comparator 。但这样的代码不是个优秀的代码,因为我们之所以使用比较器(Comparator),其中有个重要的原因就是这样可以把比较算法和具体类分离,降低类之间的耦合。

    当Java构造器排序和自然排序同时出现时,默认选择比较器排序.
    

    下面,分别给出使用两种排序比较方式的 TreeSet 测试代码:

    
    /** 
     * 使用自然排序 
     * Student必须实现Comparable接口,否则会抛出ClassCastException 
     */  
    public void testSortedSet3() {  
        Student stu1 = new Student(1, "Little");  
        Student stu2 = new Student(2, "Cyntin");  
        Student stu3 = new Student(3, "Tony");  
        Student stu4 = new Student(4, "Gemini");  
    
        SortedSet set = new TreeSet();  
        set.add(stu1);  
        set.add(stu3); // 若Student没有实现Comparable接口,抛出ClassCastException  
        set.add(stu4);  
        set.add(stu2);  
        set.add(stu4);  
        set.add(new Student(12, "Little"));  
    
        System.out.println(set);  
    }  
    /** 
     * 使用比较器排序 
     * Student可以只是个简单的Java类,不用实现Comparable接口 
     */  
    public void testSortedSet3() {  
        Student stu1 = new Student(1, "Little");  
        Student stu2 = new Student(2, "Cyntin");  
        Student stu3 = new Student(3, "Tony");  
        Student stu4 = new Student(4, "Gemini");  
    
        SortedSet set = new TreeSet(new Comparator() {  
    
            @Override  
            public int compare(Object o1, Object o2) {  
                if (o1 instanceof Student  
                        && o2 instanceof Student) {  
                    Student s1 = (Student) o1;  
                    Student s2 = (Student) o2;  
                    return s1.getName().compareTo(s2.getName());  
                }  
                return 0;  
            }  
    
        });  
    
        set.add(stu1);  
        set.add(stu3);  
        set.add(stu4);  
        set.add(stu2);  
        set.add(stu4);  
        set.add(new Student(12, "Little"));  
    
        System.out.println(set);  
    }  

    最后,介绍个工具类,java.util.Collections。注意,这不是Collection接口。Collections很像Arrays类。Arrays提供了一系列用于对数组操作的静态方法,查找排序等等。Collections也提供了一系列这样的方法,只是它是用于处理集合的,虽然Collections类和Collection接口很像,但是不要被Collections的名字给欺骗了,它不是只能处理Collection接口以及子接口的实现类,同样也可以处理Map接口的实现类。

    展开全文
  • Java反射07 : 构造器Constructor学习示例

    千次阅读 2018-03-04 13:31:43
    java.lang.reflect.Constructor类提供了用于获取和操作构造器的静态方法。 1.通过Constructor可以做什么 通过Constructor可以做以下事情: 如何通过Class对象获取Constructor?如何通过Constructor对象获取...

    超级通道: Java泛型学习系列-绪论

    java.lang.reflect.Constructor类提供了用于获取和操作构造器的静态方法。

    1.通过Constructor可以做什么

    通过Constructor可以做以下事情:

    • 如何通过Class对象获取Constructor?如何通过Constructor对象获取Class?
    • 如何通过Constructor获取构造器的相关信息如:造器方法名、修饰符、参数个数、参数类型、参数化类型、异常类、可变参数、访问权限、注解?
    • 如何通过构造器Constructor进行对象实例化?

    2.代码实例

    实体类:

    /**
     * <p>用户表</p>
     *
     * @author hanchao 2018/2/14 22:30
     */
    @MyAnnotationA
    @MyAnnotationB
    public class User extends SuperUser implements InterfaceAAA,InterfaceBBB {
        @MyAnnotationA
        @MyAnnotationB
        public String username = "张三";
        private int password = 123456;
    
        public User() {
        }
    
        @MyAnnotationA
        @MyAnnotationB
        public User(@MyAnnotationA @MyAnnotationB String username,@MyAnnotationA int password) throws NullPointerException, ArrayStoreException {
            this.username = username;
            this.password = password;
        }
        //setter getter toString...
    }
    

    实例类:

    /**
     * java.lang.reflect.Constructor示例
     * Created by 韩超 on 2018/3/1.
     */
    public class ReflectConstructorDemo {
        private final static Logger LOGGER = Logger.getLogger(ReflectConstructorDemo.class);
    
        /**
         * <p>Title: java反射-构造器Constructor示例</p>
         *
         * @author 韩超 2018/3/1 11:48
         */
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            //首先获取Class对象
            Class userClass = User.class;
            //========================================= Class对象与Constructor对象相互获取 =============================
            LOGGER.info("========================================= Class对象与Constructor对象相互获取 =============================");
            //通过class.getConstructor()和class.getDeclaredConstructor获取默认构造函数
            Constructor defaultConstructor = userClass.getConstructor();
            Constructor defaultConstructor1 = userClass.getDeclaredConstructor();
            LOGGER.info("通过class.getConstructor()获取默认构造函数:" + defaultConstructor);
            LOGGER.info("通过class.getDeclaredConstructor()获取默认构造函数:" + defaultConstructor1 + "\n");
    
            //通过class.getConstructor(args...)和class.getDeclaredConstructor(args...)获取带参数的构造器
            Constructor paramConstructor = userClass.getConstructor(String.class, int.class);
            Constructor paramConstructor1 = userClass.getDeclaredConstructor(String.class, int.class);
            LOGGER.info("通过class.getConstructor(args...)获取带参数的构造器:" + paramConstructor);
            LOGGER.info("通过class.getDeclaredConstructor(args...)获取带参数的构造器:" + paramConstructor1 + "\n");
    
            //通过class.getConstructors()和class.getDeclaredConstructors获取所有构造器
            Constructor[] constructors = userClass.getConstructors();
            Constructor[] constructors1 = userClass.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                LOGGER.info("通过class.getConstructors()获取所有构造器:" + constructor);
            }
            for (Constructor constructor : constructors1) {
                LOGGER.info("通过class.getDeclaredConstructors()获取所有构造器:" + constructor);
            }
            System.out.println("");
    
            //通过constructor.getDeclaringClass()获取构造器所属的类
            Class userClass1 = defaultConstructor.getDeclaringClass();
            LOGGER.info("通过constructor.getDeclaringClass()获取构造器所属的类:" + userClass1 + "\n");
    
            //========================================= Constructor信息获取 =============================
            LOGGER.info("========================================= Constructor信息获取 =============================");
            //通过constructor.getName()获取构造器方法名
            LOGGER.info("通过constructor.getName()获取构造器方法名:" + defaultConstructor.getName() + "\n");
    
            //通过constructor.toGenericString()获取构造器的字符串描述(通用类型)
            LOGGER.info("通过constructor.toGenericString()获取构造器的字符串描述(通用类型):" + defaultConstructor.toGenericString() + "\n");
            //通过constructor.toString()获取构造器的字符串描述
            LOGGER.info("通过constructor.toString()获取构造器的字符串描述:" + defaultConstructor.toString() + "\n");
    
            //通过constructor.getModifiers()获取构造器的修饰符
            LOGGER.info("通过constructor.getModifiers()获取构造器的修饰符:" + Modifier.toString(defaultConstructor.getModifiers()) + "\n");
    
            //通过constructor.getParameterCount()获取参数个数
            LOGGER.info("通过constructor.getParameterCount()获取参数个数-defaultConstructor:" + defaultConstructor.getParameterCount());
            LOGGER.info("通过constructor.getParameterCount()获取参数个数-paramConstructor:" + paramConstructor.getParameterCount() + "\n");
            //通过constructor.getParameterTypes()获取参数类数组(Class)
            Class[] paramClasses = paramConstructor.getParameterTypes();
            for (Class paramClass : paramClasses) {
                LOGGER.info("通过constructor.getParameterTypes()获取参数类数组(Class):" + paramClass);
            }
            //通过constructor.getParameterTypes()获取参数类型数组(Type)
            Type[] paramTypes = paramConstructor.getGenericParameterTypes();
            for (Type paramType : paramTypes) {
                LOGGER.info("通过constructor.getGenericParameterTypes()获取参数类型数组(Type):" + paramType);
            }
            System.out.println("");
            //通过constructor.getParameters()获取构造器的参数(Parameter)数组
            Parameter[] parameters = paramConstructor.getParameters();
            for (Parameter parameter : parameters) {
                LOGGER.info("通过constructor.getParameters()获取构造器的参数数组:" + parameter);
            }
            System.out.println("");
            //通过constructor.getTypeParameters()获取参数化类型(泛型)
            TypeVariable[] typeVariables = paramConstructor.getTypeParameters();
            LOGGER.info("通过constructor.getTypeParameters()获取参数化类型(泛型)-paramConstructor参数化类型个数:" + typeVariables.length + "\n");
    
            //通过constructor.getExceptionTypes()获取异常类(Class)
            Class[] exceptionClasses = paramConstructor.getExceptionTypes();
            for (Class exceptionClass : exceptionClasses) {
                LOGGER.info("通过const.getExceptionTypes()获取异常类(Class):" + exceptionClass);
            }
            //通过constructor.getGenericExceptionTypes()获取异常类(Type)
            Class[] exceptionTypes = (Class[]) paramConstructor.getGenericExceptionTypes();
            for (Class exceptionType : exceptionTypes) {
                LOGGER.info("通过const.getGenericExceptionTypes()获取异常类(Type):" + exceptionType);
            }
            System.out.println("");
    
            //通过equals比较两个构造器是否相同
            LOGGER.info("通过equals比较两个构造器是否相同:" + defaultConstructor.equals(paramConstructor));
            //通过constructor.isSynthetic()判断构造器是否是合成方法
            LOGGER.info("通过constructor.isSynthetic()判断构造器是否是合成方法:" + defaultConstructor.isSynthetic());
            //通过constructor.isVarArgs()判断构造器是否有可变参数
            LOGGER.info("通过constructor.isVarArgs()判断构造器是否有可变参数:" + defaultConstructor.isVarArgs());
            //通过constructor.isAccessible()判断构造器是否可以访问
            LOGGER.info("通过constructor.isAccessible()判断构造器是否可以访问:" + defaultConstructor.isAccessible() + "\n");
    
            //========================================= Constructor注解信息 =============================
            LOGGER.info("========================================= Constructor注解信息 =============================");
            //通过constructor.getAnnotatedParameterTypes()获取注解的参数类型(组合类型)
            AnnotatedType[] annotatedTypes = paramConstructor.getAnnotatedParameterTypes();
            for (AnnotatedType annotatedType : annotatedTypes) {
                LOGGER.info("通过constructor.getAnnotatedParameterTypes()获取注解的参数类型(组合类型)- 参数类型:" + annotatedType.getType());
            }
            System.out.println("");
    
            //通过constructor.getAnnotation(Annotation.class)和constructor.getDeclaredAnnotation(Annotation.class)获取指定的一个注解Class
            LOGGER.info("通过constructor.getAnnotation(Annotation.class)获取指定的注解Class:" + paramConstructor.getAnnotation(MyAnnotationA.class));
            LOGGER.info("通过constructor.getDeclaredAnnotation(Annotation.class)获取指定的注解Class:" + paramConstructor.getDeclaredAnnotation(MyAnnotationB.class) + "\n");
    
            //通过constructor.getAnnotationsByType(annotation.cass)和constructor.getDeclaredAnnotationsByType(annotation.cass)获取指定的一类注解Class
            Annotation[] oneTypeAnnotations = paramConstructor.getAnnotationsByType(MyAnnotationB.class);
            for (Annotation annotation : oneTypeAnnotations) {
                LOGGER.info("通过constructor.getAnnotationsByType(annotation.cass)获取指定的一类注解Class:" + annotation);
            }
            Annotation[] oneTypeAnnotations1 = paramConstructor.getDeclaredAnnotationsByType(MyAnnotationB.class);
            for (Annotation annotation : oneTypeAnnotations1) {
                LOGGER.info("通过constructor.getDeclaredAnnotationsByType(annotation.cass)获取指定的一类注解Class:" + annotation);
            }
            System.out.println("");
    
            //通过constructor.getAnnotations()和constructor.getDeclaredAnnotations()获取全部注解类
            Annotation[] annotations = paramConstructor.getAnnotations();
            for (Annotation annotation : annotations) {
                LOGGER.info("通过constructor.getAnnotations()获取全部的注解类:" + annotation);
            }
            Annotation[] annotations1 = paramConstructor.getDeclaredAnnotations();
            for (Annotation annotation : annotations1) {
                LOGGER.info("通过constructor.getDeclaredAnnotations()获取全部的注解类:" + annotation);
            }
            System.out.println("");
    
            //通过constructor.getParameterAnnotations获取参数和注解的二维矩阵
            Annotation[][] parameterAnnotations = paramConstructor.getParameterAnnotations();
            for (int i = 0; i < parameterAnnotations.length; i++) {
                //第一个维度标识的是第i个参数的所有注解
                for (int j = 0; j < parameterAnnotations[i].length; j++) {
                    //第二个维度标识的是第i个参数的第j个注解
                    LOGGER.info("第" + (i + 1) + "个参数的第" + (j + 1) + "个注解:" + parameterAnnotations[i][j]);
                }
            }
            System.out.println("");
    
            //========================================= Constructor创建对象实例 =============================
            LOGGER.info("========================================= Constructor创建对象实例 =============================");
            //通过new创建实例化对象
            User user = new User();
            LOGGER.info("通过new创建实例化对象" + user.toString());
    
            //通过constructor.newInstance()以默认构造器进行对象实例化
            User user1 = (User) defaultConstructor.newInstance();
            LOGGER.info("通过constructor.newInstance()以默认构造器进行对象实例化" + user1.toString());
            //通过constructor.newInstance(args...)以指定构造器进行对象实例化
            User user2 = (User) paramConstructor.newInstance("王文武", 19191);
            LOGGER.info("通过constructor.newInstance(args...)以指定构造器进行对象实例化:" + user2.toString());
        }
    }

    3.运行结果

    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:27 - ========================================= Class对象与Constructor对象相互获取 =============================
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:31 - 通过class.getConstructor()获取默认构造函数:public pers.hanchao.reflect.common.User()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:32 - 通过class.getDeclaredConstructor()获取默认构造函数:public pers.hanchao.reflect.common.User()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:37 - 通过class.getConstructor(args...)获取带参数的构造器:public pers.hanchao.reflect.common.User(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ArrayStoreException
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:38 - 通过class.getDeclaredConstructor(args...)获取带参数的构造器:public pers.hanchao.reflect.common.User(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ArrayStoreException
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:44 - 通过class.getConstructors()获取所有构造器:public pers.hanchao.reflect.common.User()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:44 - 通过class.getConstructors()获取所有构造器:public pers.hanchao.reflect.common.User(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ArrayStoreException
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:47 - 通过class.getDeclaredConstructors()获取所有构造器:public pers.hanchao.reflect.common.User()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:47 - 通过class.getDeclaredConstructors()获取所有构造器:public pers.hanchao.reflect.common.User(java.lang.String,int) throws java.lang.NullPointerException,java.lang.ArrayStoreException
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:53 - 通过constructor.getDeclaringClass()获取构造器所属的类:class pers.hanchao.reflect.common.User
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:56 - ========================================= Constructor信息获取 =============================
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:58 - 通过constructor.getName()获取构造器方法名:pers.hanchao.reflect.common.User
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:61 - 通过constructor.toGenericString()获取构造器的字符串描述(通用类型):public pers.hanchao.reflect.common.User()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:63 - 通过constructor.toString()获取构造器的字符串描述:public pers.hanchao.reflect.common.User()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:66 - 通过constructor.getModifiers()获取构造器的修饰符:public
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:69 - 通过constructor.getParameterCount()获取参数个数-defaultConstructor:0
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:70 - 通过constructor.getParameterCount()获取参数个数-paramConstructor:2
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:74 - 通过constructor.getParameterTypes()获取参数类数组(Class):class java.lang.String
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:74 - 通过constructor.getParameterTypes()获取参数类数组(Class):int
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:79 - 通过constructor.getGenericParameterTypes()获取参数类型数组(Type):class java.lang.String
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:79 - 通过constructor.getGenericParameterTypes()获取参数类型数组(Type):int
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:85 - 通过constructor.getParameters()获取构造器的参数数组:java.lang.String arg0
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:85 - 通过constructor.getParameters()获取构造器的参数数组:int arg1
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:90 - 通过constructor.getTypeParameters()获取参数化类型(泛型)-paramConstructor参数化类型个数:0
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:95 - 通过const.getExceptionTypes()获取异常类(Class):class java.lang.NullPointerException
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:95 - 通过const.getExceptionTypes()获取异常类(Class):class java.lang.ArrayStoreException
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:100 - 通过const.getGenericExceptionTypes()获取异常类(Type):class java.lang.NullPointerException
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:100 - 通过const.getGenericExceptionTypes()获取异常类(Type):class java.lang.ArrayStoreException
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:105 - 通过equals比较两个构造器是否相同:false
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:107 - 通过constructor.isSynthetic()判断构造器是否是合成方法:false
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:109 - 通过constructor.isVarArgs()判断构造器是否有可变参数:false
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:111 - 通过constructor.isAccessible()判断构造器是否可以访问:false
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:114 - ========================================= Constructor注解信息 =============================
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:118 - 通过constructor.getAnnotatedParameterTypes()获取注解的参数类型(组合类型)- 参数类型:class java.lang.String
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:118 - 通过constructor.getAnnotatedParameterTypes()获取注解的参数类型(组合类型)- 参数类型:int
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:123 - 通过constructor.getAnnotation(Annotation.class)获取指定的注解Class:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:124 - 通过constructor.getDeclaredAnnotation(Annotation.class)获取指定的注解Class:@pers.hanchao.reflect.common.MyAnnotationB()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:129 - 通过constructor.getAnnotationsByType(annotation.cass)获取指定的一类注解Class:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:133 - 通过constructor.getDeclaredAnnotationsByType(annotation.cass)获取指定的一类注解Class:@pers.hanchao.reflect.common.MyAnnotationB()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:140 - 通过constructor.getAnnotations()获取全部的注解类:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:140 - 通过constructor.getAnnotations()获取全部的注解类:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:144 - 通过constructor.getDeclaredAnnotations()获取全部的注解类:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:144 - 通过constructor.getDeclaredAnnotations()获取全部的注解类:@pers.hanchao.reflect.common.MyAnnotationB()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:154 - 第1个参数的第1个注解:@pers.hanchao.reflect.common.MyAnnotationA()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:154 - 第1个参数的第2个注解:@pers.hanchao.reflect.common.MyAnnotationB()
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:154 - 第2个参数的第1个注解:@pers.hanchao.reflect.common.MyAnnotationA()
    
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:160 - ========================================= Constructor创建对象实例 =============================
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:163 - 通过new创建实例化对象User{username='张三', password='123456'}
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:167 - 通过constructor.newInstance()以默认构造器进行对象实例化User{username='张三', password='123456'}
    2018-03-04 13:16:17 INFO  ReflectConstructorDemo:170 - 通过constructor.newInstance(args...)以指定构造器进行对象实例化:User{username='王文武', password='19191'}

    4.总结

    根据代码实例和运行结果,总结如下:

    • Class对象与Constructor对象相互获取
      1. 通过class.getConstructor()和class.getDeclaredConstructor获取默认构造函数
      2. 通过class.getConstructor(args…)和class.getDeclaredConstructor(args…)获取带参数的构造器
      3. 通过class.getConstructors()和class.getDeclaredConstructors获取所有构造器
      4. 通过constructor.getDeclaringClass()获取构造器所属的类
    • Constructor信息获取
      1. 通过constructor.getName()获取构造器方法名
      2. 通过constructor.toGenericString()和constructor.toString()获取构造器的字符串描述
      3. 通过constructor.getModifiers()获取构造器的修饰符
      4. 通过constructor.getParameterCount()获取参数个数
      5. 通过constructor.getParameterTypes()获取参数类数组(Class)
      6. 通过constructor.getGenericParameterTypes()获取参数类型数组(Type)
      7. 通过constructor.getParameters()获取构造器的参数对象(Parameter[])数组
      8. 通过constructor.getTypeParameters()获取参数化类型(泛型)
      9. 通过constructor.getExceptionTypes()获取异常类(Class)
      10. 通过constructor.getGenericExceptionTypes()获取异常类(Type)
      11. 通过equals比较两个构造器是否相同
      12. 通过constructor.isSynthetic()判断构造器是否是合成方法
      13. 通过constructor.isVarArgs()判断构造器是否有可变参数
      14. 通过constructor.isAccessible()判断构造器是否可以访问
      15. 通过constructor.getAnnotatedParameterTypes()获取注解的参数类型(组合类型)
      16. 通过constructor.getAnnotation(Annotation.class)和constructor.getDeclaredAnnotation(Annotation.class)获取指定的一个注解Class
      17. 通过constructor.getAnnotationsByType(annotation.cass)和constructor.getDeclaredAnnotationsByType(annotation.cass)获取指定的一组注解Class
      18. 通过constructor.getAnnotations()和constructor.getDeclaredAnnotations()获取全部注解类
      19. 通过constructor.getParameterAnnotations获取参数和注解的二维矩阵
    • 通过构造器Constructor进行对象实例化
      1. 通过constructor.newInstance()以默认构造器进行对象实例化
      2. 通过constructor.newInstance(args…)以指定构造器进行对象实例化

    备注:

    展开全文
  • Java中的构造器,一般来说是进行初始化。在运行时刻,可以通过调用方法或执行某些动作来确定初始值,例如: package practise; public class Practise2 {  int i;  Practise2(int j){  System.out.println(i); ...

    Java中的构造器,一般来说是进行初始化。在运行时刻,可以通过调用方法或执行某些动作来确定初始值,例如:

    package practise;

    public class Practise2 {
        int i;
        Practise2(int j){
            System.out.println(i);
            i=j+1;
            
        }

    package practise;

    public class Test2 {
        public static void main(String args[]) {
            Practise2 p=new Practise2(2);
            System.out.println(p.i);
        }
    }
    /* output:

    0

    3

    */

    可以明显看出,自动初始化的进行是先于构造器初始化的,此例中的i先被初始化为0,然后变成3。

    构造器可以传入参数,并且一个类可以有多个构造器,但是构造器没有返回值。如果你在构造器前加上一个返回值类型,那么这就不是构造器,而变成了一个方法,并且会有黄色的警告: This method has a constructor name (这个方法有一个构造器的名字)

    除了初始化以外,在构造器中能做的事情很多,比如在构造器中调用本类的方法,亦或是在构造器中调用构造器。

    在构造器中调用本类的方法:很简单直接写上方法名,有参数的传参数,加不加this并没有影响。但是不要在构造器中调用可覆写的方法,因为这在实例初始化产生的循环中是很致命的。

    在构造器中调用构造器:这里必须使用this关键字;例:this();,如果构造器中有参数就传入参数。并且最多能调用一个构造器,且必须写在构造器起始位置。

    构造器的访问权限:构造器也有访问权限,如果你将构造器私有化,那么此构造器就无法被访问。我在对构造器的访问权限进行测试的时候,发现如果你将默认构造器,也就是没有参数的构造器私有,那么这个类就无法被继承,你也无法创建此类的实例对象(除非你再创建一个带参的构造器,并使用此构造器创建对象,但即使这样此类也无法被继承),只能调用此类的方法和属性。

    展开全文
  • java基础】构造器是啥?有啥用?

    千次阅读 2019-06-08 16:08:57
    java类必须包含一个及以上的构造器构造器的名字必须与类名相同 默认构造器 不过即使在创建对象时没有写构造器也不用担心,因为系统会默认提供一个无参数的构造器。此构造器能对各种数据类型进行赋初值。 ...
  • Java中类的构造器

    千次阅读 2015-01-02 18:37:09
    Java中,构造器就好比是工具,而new关键字就是工人,通过new关键字和构造器结合来创建对象。在Java语言当中,构造器又称之为构造方法。 2、构造器的作用 (1) 创建(构造)对象 (2) 初始化实例对象(给创建的...
  • java bean为何需要一个无参构造器

    千次阅读 2019-02-13 17:39:37
    java bean有一个约定俗成的习惯,就是要有一个无参构造器。 当然也可以不写,但是一般还是建议写的,原因如下: 1、 java web开发中spring是很常用的,其IOC利用了java的反射,而spring的反射要求这个bean必须要有一...
  • Java初始化对象的工具 - 构造器

    千次阅读 多人点赞 2020-03-12 02:06:15
    本文关键字:对象、初始化、实例化、构造器、构造方法。明确了类与对象的关系后,我们知道:类只是一个定义的结构,用来表述我们想要描述的事物,即具备哪些属性(成员变量),可以产生哪些行为(方法)。那么具体...
  • Java构造方法

    千次阅读 2017-12-30 17:08:39
    关于构造器:变量优于方法执行,只要在方法外面(包括构造器)   此处我主要想说明,用构造器创建类和变量的初始化顺序,该程序输出: person(1) person(3) this is build's block! person(2) 说明:不论...
  • Java通过反射调用类中的指定方法、指定属性、指定构造器1.调用指定方法2. 调用指定属性3. 调用指定构造器 1.调用指定方法 通过反射,调用类中的方法,通过Method类完成。步骤: 通过Class类的getMethod(String ...
  • java_泛型(构造器)部分实例

    千次阅读 2013-08-22 00:02:55
    import java.util.ArrayList; import java.util.Collection; import java.util.List; class MyClass{ public MyClass(T t){ System.out.println("t value is "+t); } } public class Generic
  • MyBatis-Plus 条件构造器实体(Entity)查询 首先创建一个数据库表,如下图所示: 然后创建一个Spring Boot项目,pom.xml和配置如下: <?xml version="1.0" encoding="UTF-8"?> <project xmlns=...
  • Java的面向对象编程一、类和对象二、创建类和使用对象三、特殊的toString()方法四、Java数据类型小结五、包 package六、变量的作用域七、带参数方法调用八、构造器九、方法的重载 一、类和对象 1、对象 特征 — 即...
  • Effective Java 作者简介:Joshua Bloch是Sun公司的高级工程师,也是“Java平台核心组”的设计师。他设计并实现了获奖的Java Collections Framework和java.math软件包,并且对Java平台的其他部分也做出了贡献。...
  • 结论:(总的来说,get和set方法就是为了能以得到和设置实体类中的私有属性...)当你在学习Java的时候,可能会遇到这样的问题,老师在某节课上说:“来同学们,咱们今天来建一个实体类,首先声明私有属性,然后再调用ge
  • javaBean构造器

    千次阅读 2017-11-29 20:50:09
    往往我们会给这个类一个空的构造器,因为在用容器和框架(比如spring)的时候,很多这些容器或框架需要通过反射(reflect)来实现java bean对象的构造,这时候如果没有一个无参数的缺省构造器,那么无论配置还是使用...
  • 我的机器学习教程「美团」算法工程师带你入门机器学习 以及「三分钟系列」数据结构与算法已经开始更新了,欢迎大家订阅~这篇专栏整合了这几年的算法知识,简单易懂,也将是我实体书的BLOG版。 欢迎大家扫码关注微信...
  • 一个类有多个组成部分,例如:成员变量,方法,构造方法等。反射就是加载类,并解剖出类的各个组成部分。...下面就是该类中各种构造器解剖的方式如下: //第一:怎么知道 Student类中有哪些构造器呢?方法如下:@Test
  • java实体类生成工具

    千次阅读 2017-10-13 14:08:32
    原因是这样的,eclipse有那种生成实体类的插件,可是我感觉装来装去很麻烦,于是我想,干脆自己做一个生成实体类的工具吧,说做就做,然后就自己花了两个小时左右做出来了一个,以后应该能大大提高工作效率吧。...
  • java构造方法指的是:与类名相同,无返回类型的方法,参数可以为空,也可以带参数。比如一个 Dao 类,private Dao(){}这个就是无参数的构造方法。private Dao(String name){}这个就是带参数的构造方法。作用:用来...
  • Java构造函数与默认构造函数(深入版)

    千次阅读 多人点赞 2020-03-07 22:39:11
    Java的继承(深入版)有介绍到类加载过程中的验证阶段,会检查这个类的父类数据,但为什么要怎么做?构造函数在类初始化和实例化的过程中发挥什么作用? (若文章有不正之处,或难以理解的地方,请多多谅解,欢迎...
  • 注明:上篇文章介绍了springboot+mybatis-plus通用CRUD的用法,这篇文章我们来介绍一下mybatis-plus强大的条件构造器。mybatis-plus的版本为最新版3.0.3 。条件构造器咱们讲述queryWrapper和updateWrapper的用法、...
  • Java Web+GeoTools工具+自定义几何对象构造器+简单应用

    万次阅读 热门讨论 2017-12-08 11:12:01
    -- 使用Java8,嘗試使用新特新【stream和lambda】 --&gt; &lt;properties&gt; &lt;java.version&gt;1.8&lt;/java.version&gt; &lt;geotools.version&gt;17.0&lt;/geo...
  • 对于user对象创建实体类 @Entity public class User { @PrimaryKey public String id; ...@SecondaryKey(relate=MANY_TO_ONE...//即使这里有构造器了也要加入默认构造器() public User(String id,String name)...
  • Java实体类(entity)作用

    千次阅读 2018-10-22 16:42:37
    java实体类的众多理解: A .就是属性类,通常定义在model层里面  B. 一般的实体类对应一个数据表,其中的属性对应数据表中的字段。 好处: 1.对对象实体的封装,体现OO思想。 2.属性可以对字段定义和状态进行...
  • 因为实习公司项目生产需要,带我的师傅希望可以编写一个代码生成,实现代码自动化生产,即给出数据库及其库中的表,创建 : 1.基于表的pojo(model层) 2.基于mybatis的持久层的接口文件以及接口对应的xml文件 ...
  • 构造器

    2018-08-29 18:30:38
    实体类 栈:局部变量 、方法参数 、 返回地址 堆:new对象  方法区:常量词 、 编译过后的代码, 本地方法区:API ···系统方法 程序计数器:代码执行顺序 、方法栈 属性:代表了类产生的对象的值数据. 对象...
  • 构造器[构造函数]: 在java中如果用户编写类的时候没有提供构造函数,那么编译器会自动提供一个默认构造函数.它会把所有的实例字段设置为默认值:所有的数字变量初始化为0;所有的布尔变量设置为false;所有对象变量...
  • mybatis-plus Wrapper 条件构造器

    万次阅读 2019-07-28 21:34:56
    实体包装,用于处理 sql 拼接,排序,实体参数查询等! 补充说明: 使用的是数据库字段,不是Java属性! 实体包装 EntityWrapper 继承 Wrapper 简单示例 翻页查询 public Page<T> selectPage(Page<....
  • java实体

    2014-05-12 10:56:43
    实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口,在程序中仅作为数据容器用来持久化存储数据用的。 它的一般格式就是 public class A{ private String id; public String getId(){ return this.id; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,377
精华内容 38,950
关键字:

java实体构造器

java 订阅