漫漫Java学习路,第十八天

package cn.tedu.date;
import java.text.SimpleDateFormat;
import java.util.Date;
//本类用于日期类date的入门
public class TestDate {
    public static void main(String[] args) {
        //创建日期类对象,包含当前日期
        Date d1 = new Date();
        System.out.println(d1);

        //创建一个日期转换工具类对象,用来转换日期的格式
        SimpleDateFormat sdf = new SimpleDateFormat();
        //使用工具转换日期
        String s = sdf.format(d1);
        System.out.println(s);
        //可以自定义格式来转换日期
        SimpleDateFormat sdf2 = new SimpleDateFormat
                ("yyyy/MM/dd hh:mm:ss");
        String s1 = sdf2.format(d1);
        System.out.println(s1);
    }
}

package cn.tedu.design;
//本类用于实现单例设计模式方案2:懒汉式
/*关于单例设计模式的两种实现方式:
* 1.饿汉式:不管你用不用这个类的对象,都会直接先创建一个
* 2.懒汉式:先不给你创建这个类的对象,等你需要的时候再创建--延迟加载的思想
* 延迟加载思想:是指不会在第一时间就把对象创建好占用内存
*            而是什么时候用到,什么时候再去创建对象
* 3.线程完全问题:由于我们存在唯一的对象single2.并且多条语句都操作了这个变量
* 所有,如果将程序放在多线程的环境下,就容易出现数据安全问题
* 解决方案:
* 1)将3条语句都是要同步代码块包裹,保证同步排队的效果
* 2)由于getSingle()方法里也只有这3条语句,所以也可以将本方法修饰为同步方法
* 注意:被synchronized修饰的方法称作同步方法,到那时不推荐使用!.*/
public class Singleton2 {
    public static void main(String[] args) {
        Mysingle2 s1 = Mysingle2.getSingle();
        Mysingle2 s2 = Mysingle2.getSingle();
        System.out.println(s1==s2);
        System.out.println(s1);
        System.out.println(s2);
    }
}
class Mysingle2{
    private Mysingle2() {
        System.out.println("饱汉子不知饿汉子饥");
    }
    //创建的是本类对象对应类型的引用类型变量,用来保存对象的地址值
    //引用类型的成员变量,默认值为null
    private static Mysingle2 single;
    synchronized public static Mysingle2 getSingle(){
        System.out.println("柳树皮,观音土");
        synchronized (Mysingle2.class) {
            if (single == null) {
                single = new Mysingle2();
            }
        }
        return single;
    }
}

package cn.tedu.reflection;
//本类用于测试暴力反射的物料类
public class Person {
    private String name;
    private int age;
    private void save(int n,String s){
        System.out.println("存档");
    }
    private void add(String str){
        System.out.println("酒乃粮食精,"+str);
    }
    private void update(){
        System.out.println("修正");
    }
}

package cn.tedu.reflection;
//本类用于学习反射的物料类
public class Student {
    private String name;
    public int age;
    public int age2;

    public String getName() {
        return name;
    }

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

    public Student(String name, int age, int age2) {
        this.name = name;
        this.age = age;
        this.age2 = age2;
    }

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

    public Student() {
    }
    public void play(){
        System.out.println("今天大结局,放学后我要吃遍两条街");
    }
    public void eat(int n){
        System.out.println("今天点"+n+"本菜谱");
    }

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

package cn.tedu.reflection;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
//本类用于测试反射
public class TestReflect {
    @Test
    public void getClazz() throws ClassNotFoundException {
        Class<?> clazz1 = Class.forName("cn.tedu.reflection.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();

        System.out.println(clazz1);
        //通过刚刚获取到的字节码对象,获取Student类的资源
        System.out.println(clazz1.getName());//获取字节码对象对应的全路径名
        System.out.println(clazz1.getSimpleName());//获取字节码对象对应的类名
        System.out.println(clazz1.getPackage());//获取字节码对象对应的包对象
        System.out.println(clazz1.getPackage().getName());//获取字节码对象对应包名
    }
    @Test
    public void getFie() throws ClassNotFoundException {
        Class<?> clazz = Class.forName("cn.tedu.reflection.Student");
        Field[] fs = clazz.getFields();
        System.out.println(Arrays.toString(fs));
        for(Field f:fs){
            /*注意!目前成员变量的修饰符需要是public才能获取到,其他修饰符可以通过暴力反射获取*/
            System.out.println(f);
            System.out.println(f.getName());
            System.out.println(f.getType());
            System.out.println(f.getAnnotatedType());
        }
    }
    @Test
    public void getFuction(){
        Class<?> clazz = Student.class;
        Method[] ms = clazz.getMethods();
        //System.out.println(Arrays.toString(ms));
        for(Method m:ms){
            System.out.println(m.getName());
            System.out.println(Arrays.toString(m.getExceptionTypes()));
        }
    }
    @Test
    public void getCons(){
        Class<?> clazz = Student.class;
        Constructor<?>[] cs = clazz.getConstructors();
        System.out.println(Arrays.toString(cs));
        for(Constructor c:cs){
            System.out.println(c.getName());
            System.out.println(Arrays.toString(c.getParameterTypes()));
        }
    }
    @Test
    public void getObject() throws Exception {
        Class<?> clazz = Student.class;
        /*反射创建对象方案1:通过触发目标类中的无参构造创建对象*/
        Object o = clazz.newInstance();
        System.out.println(o);

        /*反射创建对象方案2:通过触发目标类的全参构造创建对象
        * 1.先获取指定的构造函数对象
        * 注意需要指定构造函数的参数,并且传入的是.class字节码对象*/
        Constructor<?> c = clazz.getConstructor(String.class, int.class);
        System.out.println(c);
        Object o2 = c.newInstance("赵六", 24);
        System.out.println(o2);

        Constructor<?> c1 = clazz.getConstructor(String.class, int.class, int.class);
        System.out.println(c1);
        Object o1 = c1.newInstance("猴赛雷",2016,19);
        System.out.println(o1);
    }
}

package cn.tedu.reflection;
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//本类用于测试暴力反射
public class TestReflect2 {
    /*1.通过暴力反射获取与操作属性*/
    @Test
    public void getFie2() throws Exception {
        Class<?> clazz = Person.class;
        Field field = clazz.getDeclaredField("name");
        System.out.println(field);
        System.out.println(field.getType());
        System.out.println(field.getType().getName());
        //设置属性值
        //1.需要指定到底是给哪个对象的name属性设置值,没有对象就创建对象
        Object p1 = clazz.newInstance();//利用反射,触发无参构造创建对象
        /*暴力反射,需要设置私有可见的权限!!!*/
        field.setAccessible(true);
        //通过字段对象Field给刚刚创建好的对象p1设置属性值
        //field.set(o,n);o是指具体给哪个对象的属性设置值,n是指具体的值是什么
        field.set(p1,"海绵宝宝");
        //field.get(o);o是指具体查看哪个对象的name属性值
        System.out.println(field.get(p1));
    }
    @Test
    public void getFie3() throws Exception {
        Class<?> clazz = Person.class;
        Field field1 = clazz.getDeclaredField("age");
        System.out.println(field1);
        System.out.println(field1.getType());
        System.out.println(field1.getType().getName());
        Object p1 = clazz.newInstance();
        field1.setAccessible(true);
        field1.set(p1,66);
        System.out.println(field1.get(p1));
    }
    /*2.通过暴力反射获取与使用方法*/
    @Test
    public void getFunction2() throws Exception {
        Class<?> clazz = Person.class;
        /*getDeclaredMethod(n,x,y,z....)
        * n:要获取的指定方法的方法名
        * x,y,z....可变参数,是指指定方法的参数类型,注意传入的是字节码对象*/
        Method method = clazz.getDeclaredMethod
                ("save",int.class,String.class);
        //System.out.println(method);
        /*执行私有方法*/
        method.setAccessible(true);
        Object p3 = clazz.newInstance();
        /*invoke(o,x,y,z...)表示通过反射执行方法
        * o:要给哪个对象执行上面获取到的save()
        * x,yz...:执行save()时需要传入的参数*/
        method.invoke(p3,999,"感冒灵");
    }
    @Test
    public void getFunction3() throws Exception {
        Class<?> clazz = Person.class;
        Method method = clazz.getDeclaredMethod("update");
        //System.out.println(method);
        method.setAccessible(true);
        Object p4 = clazz.newInstance();
        method.invoke(p4);
    }
    @Test
    public void getFunction4() throws Exception {
        Class<?> clazz = Person.class;
        Method method = clazz.getDeclaredMethod("add",String.class);
        method.setAccessible(true);
        Object p5 = clazz.newInstance();
        method.invoke(p5,"越喝越年轻");
    }
}