16.Set、泛型、枚舉、反射、Class

Set

Set集合是Collection集合的子接口，元素不能重復，只能有一個null，元素存放無序。

常用子類

HashSet

TreeSet

LinkedHashSet

HashSet

其實底層就是HashMap，當我們構造一個HashSet對象，就是在 new HashSet();

當我們往HashSet中存放元素，其實在通過map調用Map的put方法，把Set添加的元素作為Map的鍵，值默認存放一個空對象。

所有的方法，都是通過底層的HashMap調用了HashMap中的方法。

特點：存放元素是無序的、可以存放null、元素不能重復、線程不安全。

package com.day16.set;import java.util.HashSet;
import java.util.Iterator;public class HashSetDemo {public static void main(String[] args) {//創建HashSet對象HashSet<String> hashSet = new HashSet<>();hashSet.add("hello");hashSet.add("world");hashSet.add("java");hashSet.add("hello");for (String s : hashSet) {System.out.println(s);}Iterator<String> iterator = hashSet.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
}

package com.day16.set;public class Student implements Comparable{private int sid;private String name;private String className;public Student(int sid, String name, String className) {this.sid = sid;this.name = name;this.className = className;}public Student() {}public int getSid() {return sid;}public void setSid(int sid) {this.sid = sid;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getClassName() {return className;}public void setClassName(String className) {this.className = className;}@Overridepublic String toString() {return "Student{" +"sid=" + sid +", name='" + name + '\'' +", className='" + className + '\'' +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (sid != student.sid) return false;if (name != null ? !name.equals(student.name) : student.name != null) return false;return className != null ? className.equals(student.className) : student.className == null;}@Overridepublic int hashCode() {int result = sid;result = 31 * result + (name != null ? name.hashCode() : 0);result = 31 * result + (className != null ? className.hashCode() : 0);return result;}@Overridepublic int compareTo(Object o) {Student s = (Student) o;if (this.getSid()>s.getSid()){return 1;}else if ((this.getSid()<s.getSid())){return -1;}return 0;}
}

package com.day16.set;import java.util.HashSet;public class HashSetDemo01 {public static void main(String[] args) {Student s1 = new Student(1001, "張三", "1班");Student s2 = new Student(1002, "李四", "2班");Student s3 = new Student(1003, "王五", "1班");Student s4 = new Student(1001, "張三", "1班");Student s5 = new Student(1002, "李四", "2班");HashSet<Student> students = new HashSet<>();students.add(s1);students.add(s2);students.add(s3);students.add(s4);students.add(s5);System.out.println(students);}
}

LinkedHashSet

底層其實是LinkedHashMap，所以它也具有LinkedHashMap的特點，有序性

這里的有序指的是存放有序，底層具有雙向鏈表的特點

所有的方法都是繼承自父類的HashSet，其它的方法都參考HashSet

特點：存放元素是有序的(存取有序)、可以存放null、元素不能重復、線程不安全。

package com.day16.set;import java.util.Iterator;
import java.util.LinkedHashSet;public class LinkedHashSetDemo {public static void main(String[] args) {LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();linkedHashSet.add("hello");linkedHashSet.add("world");linkedHashSet.add("linux");linkedHashSet.add("world");System.out.println(linkedHashSet);for (String s : linkedHashSet) {System.err.println(s);}Iterator<String> iterator = linkedHashSet.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
}

TreeSet

底層是TreeMap

特點：元素不能重復，存放的元素會實現自然排序，所以存放進來的對象必須要實現comparable接口，重寫compareTo方法，不能存放null元素。

package com.day16.set;import java.util.Iterator;
import java.util.TreeSet;public class TreeSetDemo {public static void main(String[] args) {TreeSet<Object> treeSet = new TreeSet<>();treeSet.add("hello");treeSet.add("java");treeSet.add("mysql");treeSet.add("linux");treeSet.add("hello");treeSet.add("a");treeSet.add("z");System.out.println(treeSet);for (Object o : treeSet) {System.out.println(o);}Iterator<Object> iterator = treeSet.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}}
}

package com.day16.set;import java.util.Comparator;
import java.util.TreeSet;public class TreeSetDemo01 {public static void main(String[] args) {//存入學生對象，按照學號自然排序Student s1 = new Student(1003, "張三", "1班");Student s2 = new Student(1002, "李四", "2班");Student s3 = new Student(1005, "王五", "1班");Student s4 = new Student(1004, "jack", "1班");Student s5 = new Student(1001, "tom", "2班");//        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {//            @Override//            public int compare(Student o1, Student o2) {//                if (o1.getSid() > o2.getSid()) {//                    return 1;//                } else if (o1.getSid() < o2.getSid()) {//                    return -1;//                }//                return 0;//            }//        });TreeSet<Student> treeSet = new TreeSet<>();treeSet.add(s1);treeSet.add(s2);treeSet.add(s3);treeSet.add(s4);treeSet.add(s5);System.out.println(treeSet);}
}

練習：寫個方法，可以生成1-20之間的不重復的10個隨機數，生成之后給他們做排序

package com.day16.prac;import java.util.Comparator;
import java.util.Random;
import java.util.TreeSet;/*
寫個方法，可以生成1-20之間的不重復的10個隨機數
生成之后給他們做排序*/
public class Demo {public static void main(String[] args) {TreeSet<Integer> treeSet = new TreeSet<>();while (treeSet.size() <10)  {Random random = new Random();int i = random.nextInt(20) + 1;treeSet.add(i);}System.out.println(treeSet);}
}

Collections工具類

package com.day16.set2;import java.util.ArrayList;
import java.util.Collections;public class ArrayListDemo {public static void main(String[] args) {//往集合中，存放元素，然后將集合的元素翻轉后輸出ArrayList<Integer> arrayList = new ArrayList<>();arrayList.add(1);arrayList.add(2);arrayList.add(3);arrayList.add(4);arrayList.add(5);arrayList.add(6);arrayList.add(7);System.out.println(arrayList);
//        ArrayList<Integer> list = new ArrayList<>();
//        for (int i = arrayList.size()-1; i >=0 ; i--) {
//            list.add(arrayList.get(i));
//        }
//
//        System.out.println(list);Collections.reverse(arrayList); //翻轉方法System.out.println(arrayList);Collections.sort(arrayList); //給list排序System.out.println(arrayList);}}

泛型

概念

在集合中，可以往集合中存放明確的數據類型的對象，這個時候，就需要在創建集合的時候，

就指定這個集合可以存放哪個具體的類型。

在創建集合對象的時候，可以在集合的后面，把類型當作參數的形式傳入到集合中，

比如List<String>這種寫法，可以看作是將String這個數據類型，以參數的形式傳入List集合中，

將來這個List集合中就只能存放String類型的數據

這種寫法，就稱為泛型。泛型本質上就是將數據類型參數化，將來自己可以類、接口、方法上面指定一個泛型，從而保證將來方法、類使用的廣泛性。

格式：<數據類型>

好處：

1.避免強制類型轉換，如果不指定，將來獲取的都是Object

2.優化了程序

3.把運行期間的問題，提前到了編譯期間

泛型用在哪些地方？

在類、接口后面看到<E> <T> ，就表示要使用泛型，一般都是在集合中。

ArrayList<String> arrayList = new ArrayList<>();

package com.day16.fanxing;public interface Inter<T> {void show(T t);
}

自己定義泛型的使用

package com.day16.fanxing;public class ObjectTool<E> {private E obj;public E getObj() {return obj;}public void setObj(E obj) {this.obj = obj;}
}

package com.day16.fanxing;public class TestObjectTool {public static void main(String[] args) {//創建一個沒有泛型的ObjectToolObjectTool tool = new ObjectTool();tool.setObj("java");Object obj = tool.getObj();System.out.println(obj);//指定泛型ObjectTool<Integer> tool1 = new ObjectTool<>();tool1.setObj(10);Integer i1 = tool1.getObj();System.out.println(i1);}
}

package com.day16.fanxing;public class ObjectTool1 {public <T> void show(T t){System.out.println(t);}public static void main(String[] args) {ObjectTool1 tool1 = new ObjectTool1();tool1.show("hello");tool1.show(100);tool1.show(true);// ObjetTool1<String> tool2 = new ObjetTool1<>();}
}

泛型的通配符

? 任意類型，都可以使用

? extends E 向下限定，E 和它的子類

? super E 向上限定，E和它的父類

package com.day16.fanxing;public class Animal {
}

package com.day16.fanxing;public class Cat extends Animal{
}

package com.day16.fanxing;public class Dog extends Animal{
}

package com.day16.fanxing;import java.util.ArrayList;
import java.util.Collection;public class AnimalDemo {public static void main(String[] args) {//泛型的通配符的使用//  ?Collection<Object> c1 = new ArrayList<Object>();//        Collection<Object> c2 = new ArrayList<Animal>();//        Collection<Object> c3 = new ArrayList<Dog>();//        Collection<Object> c4 = new ArrayList<Cat>();Collection<?> c5 = new ArrayList<Object>();Collection<?> c6 = new ArrayList<Animal>();Collection<?> c7 = new ArrayList<Dog>();Collection<?> c8 = new ArrayList<Cat>();//Collection<? extends Animal> c15 = new ArrayList<Object>();Collection<? extends Animal> c16 = new ArrayList<Animal>();Collection<? extends Animal> c17 = new ArrayList<Dog>();Collection<? extends Animal> c18 = new ArrayList<Cat>();Collection<? super Animal> c15 = new ArrayList<Object>();Collection<? super Animal> c26 = new ArrayList<Animal>();//        Collection<? super Animal> c27 = new ArrayList<Dog>();//        Collection<? super Animal> c28 = new ArrayList<Cat>();}
}

枚舉 Enum

枚舉類，是和Java中的類一個級別的類型

將來定義的每一個枚舉類，都是繼承自java.lang.Enum類，

每個枚舉類型的成員都可以看成是Enum類的實例，這些枚舉成員默認是final public static修飾的

當需要使用成員的時候，直接通過枚舉名稱調用就行了。

package com.day16.Enum1;public enum Color {RED,BLUE,WHITE,YELLOW;//就是Color的實例對象
}

所有的枚舉實例，都可以調用Enum中的方法

values()

T valueOf(類<T> enumType, String name) 返回具有指定名稱的指定枚舉類型的枚舉常量。

int ordinal() 返回此枚舉常數的序數（其枚舉聲明中的位置，其中初始常數的序數為零）。

package com.day16.Enum1;import java.util.Arrays;public class TestEnum {public static void main(String[] args) {System.out.println(Arrays.toString(Color.values()));for (int i = 0; i <Color.values().length ; i++) {System.out.println(Color.values()[i]);}String color="紅色";switch (color){case "紅色":System.out.println("紅色執行的內容");break;case "藍色":System.out.println("藍色執行的內容");break;case "黃色":System.out.println("黃色執行的內容");break;}}
}

反射：框架設計的靈魂

框架：半成品軟件，可以極大地簡化代碼編寫。

程序的編譯期和運行期

編譯期：將源代碼交給編譯器去編譯成計算機可以執行的文件的過程。

在Java中，就是把.Java文件編譯成.class文件的過程。

編譯可以看作是翻譯，這個期間，并沒有把代碼放入內存中運行起來，

只會把代碼當作文件進行操作，比如檢查是否存在錯誤。

運行期：將編譯后的文件交給計算機執行，直到程序執行結束。

其實就是把磁盤中的代碼放到內存中去執行。

Java反射機制

在程序運行狀態下，對于任意一個類，都可以去獲取這個類的所有屬性和方法，

對于任意一個對象，都能夠調用它的任意屬性和方法。

（以上的操作，并不是像以前學習的面向對象一樣，在創建對象之后，而是在沒有創建對象的情況下獲取的）

這種動態獲取信息以及動態調用對象方法的功能，稱為Java反射機制。

簡單說，反射機制就是指，程序運行時，能夠獲取自身的信息。

在Java中，只要知道類的名字，就能夠獲取這個類的所有信息。

Java中，聲明每個類都是class類的類對象。

通過class類的方法可以去獲取到每個類的屬性、方法，并且可以在沒有new對象的情況下，去執行這些屬性、方法。

Java代碼在計算機中執行的三個階段

1.source源代碼階段：這個階段代碼放在硬盤，沒進內存

2.class類對象階段

3.runtime運行階段

之前需要執行代碼，是從階段1，只能接通過new 進入到階段3的runtime，

反射就是研究在class類對象階段，獲取類的屬性、方法，并執行。

獲取Class類對象的方式

1.第一階段還沒加載的時候，通過要獲取類的全類名去獲取類對象【Class.forName("全類名");】

將來配置文件的時候，可以將類名配置在配置文件中，通過讀取配置文件，加載類

Class<?> personClass =

Class.forName("com.day16.reflect.Person");

2.加載進內存，還沒實例化，通過【類名.class】獲取這個類的Class類對象

常用于參數的傳遞

Class<Person> personClass1 = Person.class;

3.實例化對象后，通過對象，也能獲取到這個類的類對象【對象.getClass()方法】

一般用于對象獲取字節碼的方式

Class personClass2 = new Person().getClass();

package com.day16.reflect;public class Person {String name;int age;private String a;String b;protected String c;public String d;public Person(String name, int age) {this.name = name;this.age = age;}public Person() {}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void eat(){System.out.println("eat....");}public void eat(String food){System.out.println("eat"+food);}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", a='" + a + '\'' +", b='" + b + '\'' +", c='" + c + '\'' +", d='" + d + '\'' +'}';}
}

package com.day16.reflect;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;public class ReflectDemo {public static void main(String[] args) throws Exception {//1.第一階段還沒加載的時候，通過要獲取類的全類名去獲取類對象//Class.forName("全類名");//將來配置文件的時候，可以將類名配置在配置文件中，通過讀取配置文件，加載類Class<?> personClass =Class.forName("com.day16.reflect.Person");//2.加載進內存，還沒實例化//通過類名.class獲取這個類的Class類對象//常用于參數的傳遞Class<Person> personClass1 = Person.class;//3.實例化對象后，通過對象，也能獲取到這個類的類對象//對象.getClass()方法//一般用于對象獲取字節碼的方式Class personClass2 = new Person().getClass();System.out.println(personClass==personClass1);//trueSystem.out.println(personClass1==personClass2);//true//返回類名String name = personClass.getName();System.out.println(name);//獲取類對象屬性//Field getField(String name)  獲取指定名稱的成員屬性Field d = personClass.getField("d");System.out.println(d);//Field[] getFields()  獲取類對象中所有可以訪問的屬性Field[] fields = personClass.getFields();for (Field field1 : fields) {System.out.println(field1);}System.out.println("--------------------------");//Field getDeclaredField(String name) 返回一個指定的私有化的成員屬性Field name1 = personClass.getDeclaredField("name");System.out.println(name1);Field a = personClass.getDeclaredField("a");System.out.println(a);//Field[] getDeclaredFields() 返回所有的私有化的成員屬性Field[] declaredFields = personClass.getDeclaredFields();for (Field declaredField : declaredFields) {System.out.println(declaredField);}//獲取類對象構造方法,存入參數的Class類對象System.out.println("==============構造方法=================");//Constructor<T> getConstructor(類<?>... parameterTypes)//返回一個 Constructor對象，該對象反映 Constructor對象表示的類的指定的公共 類函數。Constructor<?> constructor2 = personClass.getConstructor();System.out.println(constructor2);System.out.println("-----------------");Constructor<?> constructor1 =personClass.getConstructor(String.class, int.class);System.out.println(constructor1);System.out.println("--------------------------");//Constructor<?>[] getConstructors()//返回包含一個數組 Constructor對象反射由此表示的類的所有公共構造 類對象。Constructor<?>[] constructors = personClass.getConstructors();for (Constructor<?> constructor : constructors) {System.out.println(constructor);}//T newInstance()//創建由此 類對象表示的類的新實例。Person p = (Person) constructor2.newInstance();p.eat();Person p1 = (Person) constructor1.newInstance("jack", 20);System.out.println(p1.getName());//也可以通過類對象直接調用newInstance()類創建對象//這里其實就是在調用Person的無參構造來創建對象Person p2 = (Person) personClass.newInstance();p2.eat();//使用Field對象去給屬性賦值//void set(Object obj, Object value)//將指定對象參數上的此 Field對象表示的字段設置為指定的新值。d.set(p2,"hello");System.out.println(p2);name1.set(p2,"tom");System.out.println(p2);a.setAccessible(true);//暴力反射，可以使私有化屬性賦值a.set(p2,"world");System.out.println(p2);//獲取對象的普通方法System.out.println("=============普通方法===============");//方法 getMethod(String name, 類<?>... parameterTypes)//返回一個 方法對象，它反映此表示的類或接口的指定公共成員方法 類對象。//方法[] getMethods()//返回包含一個方法對象數組，包括所有方法//方法 getDeclaredMethod(String name, 類<?>... parameterTypes)//返回一個 方法對象，它反映此表示的類或接口的指定聲明的方法 類對象。//方法[] getDeclaredMethods()//返回包含一個數組 方法對象反射的類或接口的所有聲明的方法，通過此表示 類對象，包括公共，保護，默認（包）訪問和私有方法，但不包括繼承的方法。//所有Method[] methods = personClass.getMethods();for (Method method : methods) {System.out.println(method);}//單個System.out.println("---------------------");Method method1 = personClass.getMethod("eat");System.out.println(method1);Method method2 = personClass.getMethod("eat", String.class);System.out.println(method2);//Method對象中，有invoke方法，可以通過調用這個方法，執行指定的方法，//Object invoke(Object obj, Object... args)//在具有指定參數的 方法對象上調用此 方法對象表示的底層方法。method1.invoke(p2);method2.invoke(p2,"冰激凌");}
}

Class類對象的方法

獲取類對象構造方法

Constructor<T> getConstructor(類<?>... parameterTypes)

返回一個 Constructor對象，該對象反映 Constructor對象表示的類的指定的公共類函數。

Constructor<?>[] getConstructors()

返回包含一個數組 Constructor對象反射由此表示的類的所有公共構造類對象。

獲取對象的普通方法

方法 getMethod(String name, 類<?>... parameterTypes)

返回一個方法對象，它反映此表示的類或接口的指定公共成員方法類對象。

方法[] getMethods()

返回包含一個方法對象數組，包括所有方法

方法 getDeclaredMethod(String name, 類<?>... parameterTypes)

返回一個方法對象，它反映此表示的類或接口的指定聲明的方法類對象。

方法[] getDeclaredMethods()

返回包含一個數組方法對象反射的類或接口的所有聲明的方法，通過此表示類對象，包括公共，保護，默認（包）訪問和私有方法，但不包括繼承的方法。

Method對象中，有invoke方法，可以通過調用這個方法，執行指定的方法，

Object invoke(Object obj, Object... args)

在具有指定參數的方法對象上調用此方法對象表示的底層方法。

method1.invoke(p2);

method2.invoke(p2,"冰激凌");

package com.day16.reflect;import java.lang.reflect.Constructor;
import java.lang.reflect.Method;public class ReflectDemo01 {public static void main(String[] args) throws Exception {//通過要獲取類的全類名去獲取類對象Class<?> personClass =Class.forName("com.day16.reflect.Person");//獲取類對象構造方法,存入參數的Class類對象System.out.println("==============構造方法=================");//Constructor<T> getConstructor(類<?>... parameterTypes)//返回一個 Constructor對象，該對象反映 Constructor對象表示的類的指定的公共 類函數。Constructor<?> constructor2 = personClass.getConstructor();System.out.println(constructor2);System.out.println("-----------------");Constructor<?> constructor1 =personClass.getConstructor(String.class, int.class);System.out.println(constructor1);System.out.println("--------------------------");//Constructor<?>[] getConstructors()//返回包含一個數組 Constructor對象反射由此表示的類的所有公共構造 類對象。Constructor<?>[] constructors = personClass.getConstructors();for (Constructor<?> constructor : constructors) {System.out.println(constructor);}//T newInstance()//創建由此 類對象表示的類的新實例。Person p = (Person) constructor2.newInstance();p.eat();Person p1 = (Person) constructor1.newInstance("jack", 20);System.out.println(p1.getName());//也可以通過類對象直接調用newInstance()類創建對象//這里其實就是在調用Person的無參構造來創建對象Person p2 = (Person) personClass.newInstance();p2.eat();//獲取對象的普通方法System.out.println("=============普通方法===============");//方法 getMethod(String name, 類<?>... parameterTypes)//返回一個 方法對象，它反映此表示的類或接口的指定公共成員方法 類對象。//方法[] getMethods()//返回包含一個方法對象數組，包括所有方法//方法 getDeclaredMethod(String name, 類<?>... parameterTypes)//返回一個 方法對象，它反映此表示的類或接口的指定聲明的方法 類對象。//方法[] getDeclaredMethods()//返回包含一個數組 方法對象反射的類或接口的所有聲明的方法，通過此表示 類對象，包括公共，保護，默認（包）訪問和私有方法，但不包括繼承的方法。//所有Method[] methods = personClass.getMethods();for (Method method : methods) {System.out.println(method);}//單個System.out.println("---------------------");Method method1 = personClass.getMethod("eat");System.out.println(method1);Method method2 = personClass.getMethod("eat", String.class);System.out.println(method2);//Method對象中，有invoke方法，可以通過調用這個方法，執行指定的方法，//Object invoke(Object obj, Object... args)//在具有指定參數的 方法對象上調用此 方法對象表示的底層方法。method1.invoke(p2);method2.invoke(p2,"冰激凌");}
}

Class類對象的功能總結

1.獲取Class類對象，可以通過以上3種方式

Class<Person> personClass = Person.class;

2.獲取到類對象之后可以做什么？

（1）可以通過類對象，直接調用newInstance()方法，創建這個類的實例對象

Person p2 = (Person) personClass.newInstance();

（2）也可以通過類對象，調用getConstructor(Class<?>... parameterTypes)

這個方法，返回 Constructor對象后，再調用newInstance(),根據參數創建這個

類的對象。

3.可以通過方法，獲取所有類的屬性，包括私有的

Field getDeclaredField(String name)

Field name = personClass.getDeclaredField("name");

獲取之后的返回值類型是Field，Field類型是所有類屬性抽取的類，然后可以使用Field類中的方法，去給屬性賦值，賦值的時候還是要結合要被賦值的具體對象，可以使用上面創建的對象。

如果屬性是私有的，賦值之前需要加上暴力反射。

void set(Object obj, Object value)

a.setAccessible(true);//暴力反射，可以使私有化屬性賦值

a.set(p2,"world");

4.可以通過方法，獲取到類的所有成員方法，包括私有的

Method getMethod(String name, 類<?>... parameterTypes)

Method method2 = personClass.getMethod("eat", String.class);

獲取到Method對象之后，可以通過Method對象中的方法，結合對象執行具體的某個方法

Object invoke(Object obj, Object... args)

method2.invoke(p2,"飯");

設計一個框架，實現，在不改變任何代碼的情況下，可以幫助我們創建任意類的對象，并且可以執行其中任意的方法

className=com.day16.kuangjia.Student;
methodName=study;

package com.day16.kuangjia;public class Person {public void eat(){System.out.println("eat...");}
}

package com.day16.kuangjia;public class Student {public void study(){System.out.println("study...");}
}

package com.day16.kuangjia;
//設計一個框架，實現，在不改變任何代碼的情況下，可以幫助我們創建任意類的對象，
//并且可以執行其中任意的方法
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;public class Test {public static void main(String[] args) throws Exception {//1、需要想辦法獲取到要執行的類的名稱和它類中的方法//通過將類名、方法名配置在配置文件中，然后獲取//在src目錄下，創建一個pro.properties//并且把要訪問的類的名稱和方法，配置好//className=com.day16.kuangjia.Student;//methodName=study;Properties properties = new Properties();//獲取到類加載器ClassloaderInputStream is = Test.class.getClassLoader().getResourceAsStream("pro.properties");properties.load(is);//2、加載配置文件，讀取到配置文件中類名和方法名String className = properties.getProperty("className");String methodName = properties.getProperty("methodName");//3.通過類名獲取到類對象，獲取方法對象，創建對象Class<?> cls = Class.forName(className);Object o = cls.newInstance();Method method = cls.getMethod(methodName);//4、執行方法method.invoke(o);}
}

結合泛型寫一個方法，將來可以根據傳入的SQL語句，查詢任意類的對象后，放入到list集合中，并且將這個List集合返回

package com.day16.kuangjia;import java.util.ArrayList;
import java.util.List;public class Test1 {//結合泛型寫一個方法，將來可以根據傳入的SQL語句，查詢任意類的對象后，//放入到list集合中，并且將這個List集合返回public List<Student> selectStudent(String sql){//ArrayList<Student> students = new ArrayList<>();//students.add();return students;}public List<Person> selectTeacher(String sql){//....ArrayList<Person> people = new ArrayList<>();// students.add()return people;}public <T> List<T> selectTeacher(Class<T> tClass,String sql){//....//        tClass.newInstance();ArrayList<T> people = new ArrayList<>();// students.add()return people;}
}