18.Java 反射，Constructor＜T＞对象，泛型，类型通配符，可变参数，对象的序列化和反序列化

//获取Class对象
//方式一：
Student stu = new Student();
Class<? extends Student> clazz1 = stu.getClass();
System.out.println(clazz1);   //输出  class Student

//方式二：
Class<Student> clazz2 = Student.class;
System.out.println(clazz2);   //输出  class Student

//方式三：
Class<?> clazz3 = Class.forName("cn.itcast.demo1.Student");
System.out.println(clazz3); //输出  class Student

//Student类：
public class Student {
	//成员变量
	public String name;
	private int age;
//公共的无参构造方法
	public Student() {
}
//公共的带参构造方法
public Student(String name) {
	System.out.println("您录入的name值："+name);
}
//私有的带参构造方法
public Student(int age) {
	System.out.println("您录入的age值是："+age);
}
//公共的空参方法
public void show1() {
	System.out.println("我是公共的空参方法");
}

//公共的带参构造方法
public void show2(int a) {
	System.out.println("我是公共的带参方法，您传入的 a值是:" + a);
}

//私有的带参构造方法
private int show3(int a, int b) {
System.out.println("我是私有的带参方法");
	return a + b;
}
}

//反射类
import java.lang.reflect.Constructor;
public class reflection {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//根据上面获取的字节码文件对象，获取指定的构造器对象

//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
System.out.println(con1);  //输出  public cn.itcast.demo2.Student()

//3.获取公共的有参构造getConstructor
Constructor con2 = clazz.getConstructor(String.class);
System.out.println(con2);  //输出 public cn.itcast.demo2.Student(java.lang.String)

//4.获取私有的有参构造,getDeclaredConstructor
Constructor con3 = clazz.getDeclaredConstructor(int.class);
System.out.println(con3);  //输出 public cn.itcast.demo2.Student(int)

//5.获取Student类所有的公共的构造函数getConstructors
Constructor[] cons = clazz.getConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
/**
*
* 输出：
* public cn.itcast.demo2.Student()
* public cn.itcast.demo2.Student(java.lang.String)
*/

//6.获取构造器的名字，看他是哪个类的构造
String name = con2.getName();
System.out.println(name);   //输出 cn.itcast.demo2.Student
//7.根据构造器对象和参数，创建对应的Student对象
Student stu = (Student)con2.newInstance("张三");  //将object类强制转换成Student类
System.out.println(stu);
/**
* 输出：
* 您录入的name值：张三
* cn.itcast.demo2.Student@2f4d3709
*/

//获取空参方法show1
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1);  //输出 cn.itcast.demo2.Student@7ef20235
//4.调用公共的空参方法
Method method1 = clazz.getMethod("show1");
//5.打印方法对象
System.out.println(method1);  //输出 public void cn.itcast.demo2.Student.show1()
//5.1打印方法名
System.out.println(method1.getName());  //输出  show1
//5.2调用此方法
method1.invoke(stu1);   //输出   我是公共的空参方法

//获取带参方法show2
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1);  //输出 cn.itcast.demo2.Student@7ef20235
//4.调用公共的有参方法
Method method1 = clazz.getMethod("show2",int.class);
//5.打印方法对象
System.out.println(method1);  //输出 public void cn.itcast.demo2.Student.show2(int)
//5.1打印方法名
System.out.println(method1.getName());  //输出  show2
//5.2调用此方法
method1.invoke(stu1,100);   //输出   我是公共的带参方法，您传入的 a值是:100

//获取私有的带参的方法show3
//获取带参方法show3
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取私有的有参构造
Constructor con1= clazz.getDeclaredConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
System.out.println(stu1);  //输出 cn.itcast.demo2.Student@7ef20235
//4.调用私有的有参方法
Method method3 =clazz.getDeclaredMethod("show3",int.class,int.class);
//4.1开启暴力反射，不管是不是私有的都拿过来
method3.setAccessible(true);
//5.打印方法对象
System.out.println(method3);  //输出 private int cn.itcast.demo2.Student.show3(int,int)
//5.1打印方法名
System.out.println(method3.getName());  //输出  show3
//5.2调用此方法
int sum = (int) method3.invoke(stu1, 100, 200);//输出   我是私有的带参方法
System.out.println("您录入的两个数和是："+sum);  //输出 您录入的两个数和是：300
}
}

//反射方式获取Student类getter,setter成员方法
	public class Student {
	//成员变量
	private String name;

//空参构造
public Student() {
}

//带参构造
public Student(String name) {

	this.name = name;
}

//getter和setter
public String getName() {
	return name;
}

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

//toString方法，用来打印对象的各属性值
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
'}';
}
}

//反射获取
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
//4.获取指定的setName()方法,给Student对象设置值
Method method1 = clazz.getMethod("setName", String.class);
//4.1调用此方法
method1.invoke(stu1,"张无忌");
//5.打印学生对象
System.out.println(stu1);  //输出 Student{name='张无忌'}

//反射方式获取成员变量
public class Student {
//公有属性
public String name;
//私有属性
private int age;

//toString方法，用来打印对象的各属性值
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

public class reflection {
public static void main(String[] args) throws Exception {
//1.获取Class对象
Class clazz = Class.forName("cn.itcast.demo2.Student");
//2.获取公共的无参构造
Constructor con1= clazz.getConstructor();
//3.根据构造器对象和参数，创建对应的Student对象
Student stu1 = (Student)con1.newInstance();
//4.设置学生对象的各个属性值
//4.1设置姓名
Field field1 = clazz.getField("name");
field1.set(stu1, "张无忌");
//4.2设置私有年龄
Field field2 = clazz.getDeclaredField("age");
//需要开启暴力反射
field2.setAccessible(true);
field2.set(stu1, 36);
//5.打印学生对象
System.out.println(stu1);  //输出 Student{name='张无忌', age=36}
}
}

//1.创建泛型类Generic
public class Generic<T> {
private T t;
public T getT() {
   return t;
}
public void setT(T t) {
   this.t = t;
}

@Test
public void Test() {
//创建保存String类型数据的实例对象
Generic<String> str = new Generic<>();
str.setT("李刚");
System.out.println(str.getT()); //输出：李刚
//创建保存Integer类型数据的实例对象
Generic<Integer> in = new Generic<>();
in.setT(20);
System.out.println(in.getT());  //输出：20
}

//2.泛型类
public class Show<T> {
//创建泛型参数的方法
public void showname(T t){
	System.out.println(t);
}
}

@Test
public void test(){
//存入String对象
Show<String> str = new Show<String>();
str.showname("林青霞");  //输出：林青霞
//存入object对象爱
Show<Object> obj = new Show<Object>();
obj.showname("zhangsan");  //输出：zhangsan
}

//3.创建泛型接口
public interface Genetic<T> {
    void show(T t);
}


//创建泛型实现类继承泛型接口
public class GeniticImpl<T> implements Genetic<T>{
@Override
public void show(T t) {
	System.out.println(t);
}
}


@Test
public void test(){
//创建泛型实现类的对象
GeniticImpl<String> str = new GeniticImpl<String>();
str.show("林青霞");  //输出：林青霞
}

//类型通配符<?>
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<String>();
//类型通配符上限上限是Number类型
List<? extends  Number> list3 = new ArrayList<Number>();
List<? extends  Number> list4 = new ArrayList<Integer>();
//类型通配符下限是Number类型
List<? super   Number> list5 = new ArrayList<Object>();
List<? super   Number> list6 = new ArrayList<Number>();

public class NiHao {
//创建参数可变函数
public static int sum(int b,int...a){
int sum = 0;
//可变参数是一个素组，所以可以遍历获取数值
for (int i : a) {
    sum+=i;
}
//返回所有参数的和，可变参数必须要放在不变参数的后面才不会报错
return sum+b;
}
}

@Test
public void test1(){
int sum1 = NiHao.sum(5, 20, 30);
System.out.println(sum1);  //输出：55
int sum2 = NiHao.sum(5, 20, 30, 40, 50);
System.out.println(sum2); //输出：145

//这个被transient修饰的属性不可以被序列化：private transient int age;
@Data
@NoArgsConstructor
@AllArgsConstructor
//只有继承Serializable接口，对象才可以被序列化，且不需要重写任何方法
public class Student implements Serializable {
    //必须要加上这一句序列化就不会出错
    private static final  long serialVersionUID = 42L;
    private String name;
    private int age;
}

@Test
public void test1() throws IOException, ClassNotFoundException {
//1.下面执行对象序列化结果是一个读不懂的文件
//创建一个写入指定的outputstream的ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//创建Student对象
Student stu = new Student("林青霞",30);
//将指定的对象写入ObjectOutputStream
oos.writeObject(stu);
//释放资源
oos.close();

//2.下面执行对象反序列化来读取这个读不懂的文件
ObjectInputStream ois= new ObjectInputStream(new FileInputStream("D:\\project\\src\\test\\java\\com\\qy\\spring5\\testdemo\\1.txt"));
//读取反序列化对象
Object obj = ois.readObject();
//转换成Student对象
Student st = (Student) obj;
//获取属性
System.out.println(st.getName()+","+st.getAge());       //输出结果：林青霞,30