反射

注解

内置注解

package Annotation;

public class test extends Object {
    //Override 重写的注解
    @Override
    public  String toString() {
        return super.toString();
    }
    //Deprecated:不推荐程序员使用，但是可以使用，存在更好的方式
    @Deprecated
    public static void test1(){
        System.out.println("Deprecated");
    }
    @SuppressWarnings("all")
    public static void test2(){
        System.out.println("SuppressWarings");
    }
    public static void main(String[] args) {
        test1();
    }
}

反射

静态语言与动态语言

静态语言

动态语言

一类再运行中可以改变删除其结构的语言，运行时可以根据某些条件改变自身结构：C# js，Python

静态语言

与动态语言相对应的，结构不可变：c，c++，java

得到class类的几种方法

package ClassTest;

public class test {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Student();
        System.out.println("这个人是"+p1.name);
        //通过对象获得
        Class  c1 = p1.getClass();
        System.out.println(c1.hashCode());
        //通过forName获得
        Class c2 = Class.forName("ClassTest.Student");
        System.out.println(c2.hashCode());
        //类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
        //基本内置类型都有的包装类都有一个Type的属性
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}
class Person{
    String name;

    public Person() {
    }

    public String getName() {
        return name;
    }

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

    public Person(String name) {
        this.name = name;
    }
}
 class Student extends Person{
     public Student() {
         this.name = "学生";
     }
 }
 class Teacher extends Person{
     public Teacher() {
         this.name = "老师";
     }
 }

所有类型的class

package ClassTest;
//所有类型的class
public class test2 {
    public static void main(String[] args) {
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//一维数组
        Class c4 = int[].class;//一维数组
        Class c5 = int[][].class;//二维数组
        Class c6 = Override.class;//注解
        Class c7 = Integer.class;//包装类
        Class c8 = void.class;//void
        Class c9 = Class.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);
        //只要元素类型和维度一样，他就是同一个class
         int []a = new int[10];
         int []b = new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

引用

主动引用以及反射

不会产生引用的方法

• 访问一个静态域的时候，只有真正被声明的类才会被初始化
• 通过数组定义类引用，不会除非此类初始化
• 引用常量不会触发此类的初始化

package ClassTest;

public class Test3 {
   static  {
       System.out.println("Main被加载");
   }
    public static void main(String[] args) throws ClassNotFoundException {
       //主动引用
//        Son s1 = new Son();
        //反射也会产生主动引用
//        Class c2 = Class.forName("ClassTest.Son");
        //不会产生引用的方法
        System.out.println(Son.a);
        Son[] array  = new Son[5];
        System.out.println(Son.m);
    }
}
class Father{
     static int a = 1;
    static {
        System.out.println("父类被加载");
        int b = 1;
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载");

    }
    static  int b = 2;
    static  final  int m = 10;
}

类加载器

Bootstap ClassLoader：引导类加载器，用c++写的，jvm自带的，装载核心库，无法直接获取

Extension ClassLoader：扩展类加载器，负责jre目录下的jar包。指定目录下的jar包装入工作库

System ClassLoader：系统类加载器，负责java.lang.Path所指目录下的类与jar包装入工作

package ClassTest;

public class test4 {
    public static void main(String[] args) {
        //类加载通过jvm加载的
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        ClassLoader systemClassLoader1 = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        System.out.println(systemClassLoader1);
    }
}

class获取类的成员

package ClassTest.test5;

import java.lang.reflect.Field;

public class Main {

    public static void main(String[] args) {
        Class<Person> p1 = Person.class;
        Field[] fields = p1.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }

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

反射获取私有属性

package ClassTest.Test6;

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

public class Main {
    public static void main(String[] args) throws Exception {
        Class<Person> personClass = Person.class;
        //实例化类的对象
        Person person = personClass.newInstance();
        //获取全类名(包名+类名)
        System.out.println(personClass.getName());
        //获取简单类名
        System.out.println(personClass.getSimpleName());
        //给属性赋值
        Field name = personClass.getField("name");
        name.set(person,"阿鬼大大");
        //获取属性的值
        Object nameValue = name.get(person);
        System.out.println(nameValue);
        //调用方法
        Method say = personClass.getMethod("say");
        //调用方法
        say.invoke(person);
        System.out.println("-----------------------");


        //---------------------反射访问私有成员------------------
        //getDeclaredField可以访问公有属性，也能访问私有属性
        Field age = personClass.getDeclaredField("age");
        System.out.println(age);
        //私有属性赋值
        age.setAccessible(true);
        age.set(person,20);
        say.invoke(person);
        Method talk = personClass.getDeclaredMethod("talk");
        talk.setAccessible(true);
        talk.invoke(person);
        System.out.println("-----------");
        //getDeclaredMethods只能获取本类的方法，getMethod可以获取父类的方法
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName());
        }


    }
}

class Person {
    public String name;
    private int age;
    public void say(){
        System.out.println("my name is"+this.name);
        System.out.println("my age is"+this.age);

    }
    private  void talk(){
        System.out.println("谈话中");
    }
}

工厂模式

简单工厂模式

工厂类

class BeanFactory {
    public Object CreateInstance(Class clazz) throws Exception {
        return clazz.newInstance();
    }
}

​ 创建工厂对象

public class FactoryDemo01 {
    public static void main(String[] args) throws Exception {
        BeanFactory beanFactory = new BeanFactory();
        person p1 = (person) beanFactory.CreateInstance(person.class);
        System.out.println(p1);
        Animal a1 =(Animal) beanFactory.CreateInstance(Animal.class);
        System.out.println(a1);


    }
}