Java總結分享之反射、列舉、Lambda表示式

class Student{
    //私有屬性name
    private String name = "rong";
    //公有屬性age
    public int age = 18;
    //不帶引數的構造方法
    public Student(){
        System.out.println("Student()");
    }
    //帶兩個引數的構造方法
    private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
    }

    private void eat(){
        System.out.println("i am eating");
    }

    public void sleep(){
        System.out.println("i am sleeping");
    }

    private void function(String str) {
        System.out.println("私有方法function被呼叫:"+str);
    }

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

public static void main(String[] args) {
    //有3種方式可以獲取Class物件
    //1.通過物件的getClass()方法
    Student student1 = new Student();
    Class<?> c1 = student1.getClass();
    //2、通過類名.class獲取
    Class<?> c2 = Student.class;
    //3. forName(「路徑」)
    Class<?> c3 = null;
    try {
        c3 = Class.forName("Student");
    } catch (ClassNotFoundException e) {
        throw new RuntimeException(e);
    }
    System.out.println(c1.equals(c2));
    System.out.println(c1.equals(c3));
    System.out.println(c2.equals(c3));}

public static void main(String[] args) {
    //獲取相關類的Class物件
    Class<?> c = Student.class;
    //使用newInstance方法建立範例
    try {
        //需要進行強轉
        Student student = (Student) c.newInstance();
        System.out.println(student);
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }}

public static void main(String[] args) throws ClassNotFoundException {
    //1.獲取Clas物件
    Class<?> c = Class.forName("Student");
    //2.獲取指定參數列的構造器，演示獲取Student中的一個私有構造器,引數傳形參列表型別
    try {
        Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);
        //獲取的私有構造方法，需要開啟存取許可權,預設關閉
        constructor.setAccessible(true);
        //3.根據獲取到的構造器獲取範例物件,使用newInstance方法,需要傳入構造器需要的引數
        Student student = (Student) constructor.newInstance("張三", 20);
        System.out.println(student);
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }}

public static void main(String[] args) {
    //1.獲取Class物件
    Class<?> c = Student.class;
    try {
        //2.通過反射建立範例物件
        Student student = (Student) c.newInstance();
        //3.獲取私有屬性name
        Field field =  c.getDeclaredField("name");
        //4.給該私有屬性開許可權
        field.setAccessible(true);
        //5.修改該私有屬性
        field.set(student, "被反射修改的私有屬性");
        System.out.println(student);
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }}

public static void main(String[] args) {
    try {
        //1.獲取Class物件
        Class<?> c = Class.forName("Student");
        //2.獲取Student的一個範例物件
        Student student = (Student) c.newInstance();
        //3.通過class物件獲取範例的方法物件，引數為方法名，以及形參列表
        Method method =  c.getDeclaredMethod("function", String.class);
        //4.為私有方法開存取許可權
        method.setAccessible(true);
        //5.通過invork方法呼叫方法
        method.invoke(student, "傳入私有方法引數");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }}

public static int final RED = 1;public static int final GREEN = 2;public static int final BLACK = 3;

public enum Color {
    RED,BLUE,GREEN,YELLOW,BLACK;}

enum Color {
    BLACK,YELLOW,GREEN;}public class Test {
    public static void main(String[] args) {
        Color color = Color.YELLOW;
        switch (color) {
            case BLACK:
                System.out.println("BLACK");
                break;
            case YELLOW:
                System.out.println("YELLOW");
                break;
            case GREEN:
                System.out.println("GREEN");
                break;
            default:
                break;
        }
    }}

public enum Color {
    BLACK,YELLOW,GREEN;

    public static void main(String[] args) {
        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println(c);
        }
    }}

public enum Color {
    BLACK,YELLOW,GREEN;
    public static void main(String[] args) {
        Color color = Color.valueOf("BLACK");
        System.out.println(color);
    }}

public enum Color {
    BLACK,YELLOW,GREEN;
    public static void main(String[] args) {
        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println(c + "的索引:" + c.ordinal());
        }
    }}

public enum Color {
    BLACK,YELLOW,GREEN;
    public static void main(String[] args) {
        System.out.println(Color.GREEN.compareTo(Color.YELLOW));
        System.out.println(Color.BLACK.compareTo(Color.YELLOW));
    }}

public enum Color {
    BLACK("BLACK", 11, 1),
    YELLOW("YELLOW", 12, 2),
    GREEN("GREEN", 13, 3);
    public String colorName;
    public int colorId;
    public int ordonal;

    Color(String colorName, int colorId, int ordonal) {
        this.colorName = colorName;
        this.colorId = colorId;
        this.ordonal = ordonal;
    }

    @Override
    public String toString() {
        return "Color{" +
                "colorName='" + colorName + '\'' +
                ", colorId=" + colorId +
                ", ordonal=" + ordonal +
                '}';
    }

    public static void main(String[] args) {
        Color[] colors = Color.values();
        for (Color c : colors) {
            System.out.println(c);
        }
    }}

public class Test {
    public static void main(String[] args) {
        //嘗試獲取列舉物件
        Class<?> c = Color.class;
        try {
            //獲取構造方法物件
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class, int.class);
            //開許可權
            constructor.setAccessible(true);
            //通過構造方法構造物件
            Color color = (Color) constructor.newInstance("藍色", 88, 2);
            System.out.println(color);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }}

Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class, String.class, int.class, int.class);

@FunctionalInterfaceinterface NoParameterNoReturn {
	//注意：只能有一個方法
	void test();}

@FunctionalInterfaceinterface NoParameterNoReturn {
	void test();
	default void test2() {
		System.out.println("JDK1.8新特性，default預設方法可以有具體的實現");
	}}

 (parameters) -> expression 或 (parameters) ->{ statements; }

// 1. 不需要引數,返回值為 2() -> 2
    // 2. 接收一個引數(數位型別),返回其2倍的值x -> 2 * x    
// 3. 接受2個引數(數位),並返回他們的和(x, y) -> x + y    
// 4. 接收2個int型整數,返回他們的乘積(int x, int y) -> x * y    
// 5. 接受一個 string 物件,並在控制檯列印,不返回任何值(看起來像是返回void)(String s) -> System.out.print(s)

//無返回值無引數@FunctionalInterfaceinterface NoParameterNoReturn {
    void test();}//無返回值一個引數@FunctionalInterfaceinterface OneParameterNoReturn {
    void test(int a);}//無返回值多個引數@FunctionalInterfaceinterface MoreParameterNoReturn {
    void test(int a,int b);}//有返回值無引數@FunctionalInterfaceinterface NoParameterReturn {
    int test();}//有返回值一個引數@FunctionalInterfaceinterface OneParameterReturn {
    int test(int a);}//有返回值多引數@FunctionalInterfaceinterface MoreParameterReturn {
    int test(int a,int b);}

public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
            @Override
            public void test() {
                System.out.println("hello");
            }
        };
        noParameterNoReturn.test();
    }}

public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()->{
            System.out.println("無引數無返回值");
        };
        noParameterNoReturn.test();
        
        OneParameterNoReturn oneParameterNoReturn = (int a)->{
            System.out.println("一個引數無返回值："+ a);
        };
        oneParameterNoReturn.test(10);
        
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
            System.out.println("多個引數無返回值："+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        
        NoParameterReturn noParameterReturn = ()->{
            System.out.println("有返回值無引數！");
            return 40;
        };
        //接收函數的返回值
        int ret = noParameterReturn.test();
        System.out.println(ret);
        
        OneParameterReturn oneParameterReturn = (int a)->{System.out.println("有返回值有一個引數！");
            return a;
        };
        ret = oneParameterReturn.test(50);
        System.out.println(ret);
        
        MoreParameterReturn moreParameterReturn = (int a,int b)->{
            System.out.println("有返回值多個引數！");
            return a+b;
        };
        ret = moreParameterReturn.test(60,70);
        System.out.println(ret);
    }}

public class TestDemo {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn                = ()->System.out.println("無引數無返回值");
        noParameterNoReturn.test();

        OneParameterNoReturn oneParameterNoReturn                = a-> System.out.println("一個引數無返回值："+ a);
        oneParameterNoReturn.test(10);

        MoreParameterNoReturn moreParameterNoReturn                = (a,b)-> System.out.println("多個引數無返回值："+a+" "+b);
        moreParameterNoReturn.test(20,30);

        //有返回值無引數！
        NoParameterReturn noParameterReturn = ()->40;
        int ret = noParameterReturn.test();
        System.out.println(ret);

        //有返回值有一個引數！
        OneParameterReturn oneParameterReturn = a->a;
        ret = oneParameterReturn.test(50);
        System.out.println(ret);

        //有返回值多個引數！
        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        ret = moreParameterReturn.test(60,70);
        System.out.println(ret);
    }}

OneParameterNoReturn oneParameterNoReturn = a-> System.out.println(a);

OneParameterNoReturn oneParameterNoReturn = System.out::println;

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("欣");
    list.add("欣");
    list.add("向");
    list.add("榮");
    list.forEach(new Consumer<String>(){
        @Override
        public void accept(String str){
            //簡單遍歷集合中的元素。
            System.out.print(str+" ");
        }
    });}

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("欣");
    list.add("欣");
    list.add("向");
    list.add("榮");
    list.forEach(s -> System.out.print(s + " "));}

public static void main(String[] args) {
    Map<Integer, String> map = new HashMap<>();
    map.put(1, "欣");
    map.put(2, "欣");
    map.put(3, "向");
    map.put(4, "榮");
    map.forEach(new BiConsumer<Integer, String>(){
        @Override
        public void accept(Integer k, String v){
            System.out.println(k + "=" + v);
        }
    });}

public static void main(String[] args) {
    Map<Integer, String> map = new HashMap<>();
    map.put(1, "欣");
    map.put(2, "欣");
    map.put(3, "向");
    map.put(4, "榮");
    map.forEach((k,v)-> System.out.println(k + "=" + v));}

public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("aaaa");
    list.add("bbb");
    list.add("cc");
    list.add("d");
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String str1, String str2){
            //注意這裡比較的是長度
            return str1.length()-str2.length();
        }
    });
    System.out.println(list);}

 public static void main(String[] args) {
    ArrayList<String> list = new ArrayList<>();
    list.add("aaaa");
    list.add("bbb");
    list.add("cc");
    list.add("d");
    //呼叫帶有2個引數的方法，且返回長度的差值
    list.sort((str1,str2)-> str1.length()-str2.length());
    System.out.println(list);}