/* 把泛型定义在类上，类型变量定义在类上,方法中也可以使用 */
public class ObjectTool<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

public static void main(String[] args) {
    // 创建对象并指定元素类型
    ObjectTool<String> tool = new ObjectTool<>();

    tool.setObj(new String("钟福成"));
    String s = tool.getObj();
    System.out.println(s);


    //创建对象并指定元素类型
    ObjectTool<Integer> objectTool = new ObjectTool<>();
    /**
      * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
      */
    objectTool.setObj(10);
    int i = objectTool.getObj();
    System.out.println(i);
}

// 定义泛型方法..
public <T> void show(T t) {
    System.out.println(t);
}

public static void main(String[] args) {
    //创建对象
    ObjectTool tool = new ObjectTool();

    //调用方法,传入的参数是什么类型,返回值就是什么类型
    tool.show("hello");
    tool.show(12);
    tool.show(12.5);
}

/** 浅拷贝函数 */
public static <T> T shallowCopy(Object source, Class<T> clazz) throws BeansException {
    // 判断源对象
    if (Objects.isNull(source)) {
        return null;
    }

    // 新建目标对象
    T target;
    try {
        target = clazz.newInstance();
    } catch (Exception e) {
        throw new BeansException("新建类实例异常", e);
    }

    // 拷贝对象属性
    BeanUtils.copyProperties(source, target);

    // 返回目标对象
    return target;
}

/*
    把泛型定义在接口上
 */
public interface Inter<T> {
  public abstract void show(T t);
}

/**
 * 子类明确泛型类的类型参数变量:
 */
public class InterImpl implements Inter<String> {

  @Override
  public void show(String s) {
    System.out.println(s);
  }
}

/**
 * 子类不明确泛型类的类型参数变量: 实现类也要定义出<T>类型的
 */
public class InterImpl<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public static void main(String[] args) {
    //测试第一种情况
    //Inter<String> i = new InterImpl();
    //i.show("hello");

    //第二种情况测试
    Inter<String> ii = new InterImpl<>();
    ii.show("100");
}