Java学习笔记（二）

妖狐艹你老母 2023-10-11 16:17 43阅读 0赞

## 注解 ##

> **内置注解 Annotation**

*  @Override 表示一个方法声明打算重写超类中的另一个方法声明
 *  @Deprecated 表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择
 *  @SuppressWarnings 用来抑制编译时的警告信息
    
     *  参数 all unchecked deprecation

> **元注解 meta-annotation**

*  解释其他注解的注解
    
     *  @Target：描述注解的使用范围
     *  @Retention：描述注解的生命周期（在什么地方有效）（RUNTIME>CLASS>SOURCE）
     *  @Documented：说明该注解将被包含在javadoc中
     *  @Inherited：说明子类可以继承父类中的该注解

//自定义注解
    @Target(value = {
        ElementType.METHOD,ElementType.TYPE})//可以只有一个参数可以省略value=
    //@Target({ElementType.METHOD,ElementType.TYPE})
    @Retention(value = RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @interface MyAnnotation{
        
        //注解的参数：参数类型 + 参数名 + ();
        String value() default "";//default 默认值 没有默认值使用时必须传参数 只有一个参数时用value命名 返回值类型只能是基本类型
    }

## 反射 ##

> **Java Reflection**

*  反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
 *  加载完类之后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息

> **Class类的常用方法**

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static ClassforName(String name)</td> 
   <td>返回指定类名name的Class对象</td> 
  </tr> 
  <tr> 
   <td>Object newInstance()</td> 
   <td>调用缺省（无参）构造函数，返回Class对象的一个实例</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>返回此Class对象所表示的实体（类，接口，数组类或void）的名称</td> 
  </tr> 
  <tr> 
   <td>Class getSuperClass()</td> 
   <td>返回当前Class对象的父类的Class对象</td> 
  </tr> 
  <tr> 
   <td>Class[] getInterfaces()</td> 
   <td>获取当前Class对象的接口</td> 
  </tr> 
  <tr> 
   <td>ClassLoader getClassLoader()</td> 
   <td>返回该类的类加载器</td> 
  </tr> 
  <tr> 
   <td>Constructor[] getConstructors()</td> 
   <td>返回一个包含某些Constructor对象的数组</td> 
  </tr> 
  <tr> 
   <td>Method getMethod(String name,Class… T)</td> 
   <td>返回一个Method对象，此对象的形参类型为param Type</td> 
  </tr> 
  <tr> 
   <td>Field[] getDeclaredFields()</td> 
   <td>返回Field对象的一个数组</td> 
  </tr> 
 </tbody> 
</table>

> **获取Class类的实例**

1.  若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高：
    
        Class clazz = Person.class;
2.  已知某个类的实例，调用该实例的getClass()方法获取Class对象：
    
        Class clazz = person.getClass();
3.  已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException异常
    
        Class clazz = Class.forName("demo01.Student");

> **获得类的信息**

package base;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class Demo06 {
        
    
        public static void main(String[] args) throws Exception {
        
            Class c1 = Class.forName("base.User");
            User user = new User();
    
            //获得类的名字
            System.out.println(c1.getName());//获得包名+类名
            System.out.println(c1.getSimpleName());//获得类名
    
            //获得类的属性
            Field[] fields = c1.getFields();//只能找到public属性
            for (Field field : fields) {
        
                System.out.println(field);
            }
            fields = c1.getDeclaredFields();//找到全部的属性
            for (Field field : fields) {
        
                System.out.println(field);
            }
    
            //获得指定属性的值
            Field name = c1.getDeclaredField("name");
            System.out.println(name);
    
            //获得类的方法
            Method[] methods = c1.getMethods();//获得本类及其父类的所有public方法
            for (Method method : methods) {
        
                System.out.println("getMethods: " + method);
            }
            methods = c1.getDeclaredMethods();//获得本类的所有方法（包括私有）
            for (Method method : methods) {
        
                System.out.println("getDeclaredMethods: " + method);
            }
    
            //获得指定方法
            Method getName = c1.getMethod("getName");
            System.out.println(getName);
            Method setName = c1.getMethod("setName", String.class);//方法有参数 需要传入类型
            System.out.println(setName);
    
            //获得指定的构造器
            Constructor[] constructors = c1.getConstructors();//获得本类的public构造方法
            for (Constructor constructor : constructors) {
        
                System.out.println(constructor);
            }
            constructors = c1.getDeclaredConstructors();//获得本类的全部构造方法
            for (Constructor constructor : constructors) {
        
                System.out.println(constructor);
            }
    
            //获得指定的构造器
            Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class);
            System.out.println("指定的构造器: " + declaredConstructor);
            
        }
    }
    
    class User {
        
        private String name;
        private int age;
    
        public User() {
        
        }
    
        public User(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

> **动态创建对象执行方法**

package base;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    public class Demo07 {
        
        public static void main(String[] args) throws Exception {
        
            //获得Class对象
            Class c1 = Class.forName("base.User");
    
            //构造一个对象
            User user = (User) c1.newInstance();//调用无参构造器
            System.out.println(user);
    
            //通过有参构造器创建对象
            Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class);
            User zs = (User) declaredConstructor.newInstance("zs", 18);
            System.out.println(zs);
    
            //通过反射调用方法
            User user2 = (User) c1.newInstance();
            //通过反射获取方法
            Method setName = c1.getDeclaredMethod("setName", String.class);
            //invoke 激活 参数（对象,"方法的值"） 对象：需要执行该方法的对象
            setName.invoke(user2, "zs");
            System.out.println(user2.getName());
    
            //通过反射操作属性
            User user3 = (User) c1.newInstance();
            Field name = c1.getDeclaredField("name");
            //不能直接操作私有属性，我们需要关掉程序的安全检测，属性或方法.setAccessible(true);
            name.setAccessible(true);
            name.set(user3, "zs");
            System.out.println(user3.getName());s
        }
    }

> 反射获取泛型信息

> 反射操作注解

> ORM

*  Object relationship Mapping --> 对象关系映射
    
     *  类和表结构对应
     *  属性和字段对应
     *  对象和记录对应
 *  可以利用注解和反射完成类和表结构的映射关系