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,"越喝越年轻");
}
}