Java新特性

一 函数式接口--可以以极简的形式表达出来（要不然就要用匿名内部类写出来）

@FunctionalInterface
//证明是一个函数接口
public interface MyI {
    void show(int a);
}

//消费型接口
public class Demo2 {
    public static void main(String[] args) {
        MyI myI =(s)-> System.out.println(s);
        myI.show(2);
    }
}

//供给型接口
public class Demo3 {
    public static void main(String[] args) {
        MyI2 myI2 =(s)->{
            s+= 20;
            return s;
        };
        myI2.show(10);
    }
}

//断言 --->boolean类型
public class Demo4 {
    public static void main(String[] args) {
        MyI3 myI3 =(s)->{
            if(s>10){
                return true;
            }else {
                return false;
            }
        };
    }
}

二  反射 常考问题(在框架中经常使用) 

以User 类为例

public class User {
    public String name;
     int age;
     private String sex;

     public void show(){
         System.out.println("show...");
     }



    public void show(int a,String b){
        System.out.println("show...");
    }
    private void eat(){
        System.out.println("eat...");
    }

    private static void eat2(){
        System.out.println("eat...");
    }


    public User(){
        System.out.println("有参构造");
    }

    private User(int a){
        System.out.println("无参构造");
    }




}

反射首先要有一个具体的实例
有三种方法获取

public class Text2 {
    public static void main(String[] args) throws Exception {
        //  1.类名.class属性
        Class userClass =User.class;
        //2.
        User user =new User();
        Class< ? extends  User> aClass =user.getClass();
        //3 全限定类名
        Class<?> aClass1 =Class.forName("com.buka.day01.User");

        //4获取类的方法

        //5.获取私有方法

        Method[] methods =userClass.getMethods();
        for(Method method :methods){
            System.out.println(method);
        }

        //6 获取单个方法
        Method show =aClass.getMethod("show");


        //7 执行方法
        show.invoke(user);




        //底层问题 双亲委派类型
        //框架 反射



    }
}

分别获取类对象 方法 成员变量的方法（包括私有属性）


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Demo6 {
    public static void main(String[] args) throws Exception {

        //1.获取类对象
        Class<?> userClass = User.class;



        //2.获取所有方法(公开)
        Method[] methods = userClass.getMethods();



        //3.获取所有方法（有私有 ，无继承)
        Method[] methods1 =userClass.getDeclaredMethods();

        //4.获取指定方法
        Method show =userClass.getMethod("show",int.class,String.class);
        show.invoke(new User(),1,"2222");

        //5.获取私有方法
        Method eat =userClass.getDeclaredMethod("eat");


        eat.setAccessible(true);//暴力反射，可以将修饰符失效
        eat.invoke(new User());


        Field[] fields = userClass.getFields();
        for (Field  fi:fields
             ) {
            System.out.println(fields);
        }


        Field[] declaredFields = userClass.getDeclaredFields();
        for (Field decl:fields
             ) {
            System.out.println(decl);
        }


        User sss =new User();//一个实例
        Field name =userClass.getField("name");//一个模板
        name.set(sss,"张三");//指定那个实例进行赋值
        System.out.println(name.get(sss));


        System.out.println("----------------");
        Field sex1 = userClass.getDeclaredField("sex");
        sex1.setAccessible(true);//私有方法属性必须要暴力反射
        sex1.set(sss,"女");
        System.out.println(sex1.get(sss));

        //获取构造方法
        Constructor<?>[]constructor = userClass.getConstructors();




        //构造方法创建对象
        Constructor<?> constructor1 = userClass.getConstructor();
        Object o = constructor1.newInstance();


        Constructor<?> declaredConstructor = userClass.getDeclaredConstructor(int.class);
        declaredConstructor.setAccessible(true);
        User user =(User) declaredConstructor.newInstance(11111);

        System.out.println(user);


    }
}

三  枚举 枚举底层就是一个类

public enum MYEnum {
    //枚举项 规定范围    若有枚举项必须放在最前，
    one ,two;
    public void show(){

    }
    //枚举里的的构造方法必须是私有的（默认为private)

    MYEnum(){

    }

    //int long short char String 这五种放在switch中
    //枚举类型可以放在switch类型中


}

四 设计模式---单例模式

（1)饱汉式

public class DemoText {
   //1.私有构造方法
   private DemoText(){

   }
   //2。创建一个static （只加载一个） 创建一个本类的新对象
   private static DemoText DemoText =new DemoText();  
 //3.创建一个方法进行调用
    public static DemoText getDemoText(){
        return DemoText;
   }
    //1.创建私有构造方法
    private DemoText(){

    }
    //2.成员变量
    private static DemoText demoText=null;
    //3 静态方法,调用成员变量
    public static DemoText getDemoText(){
        if(demoText ==null){
            demoText =new DemoText();
        }
        return demoText;
    }
}

（2)饿汉式 --在不需要这个类之前就加载出来

public class DemoText {

    //饿汉式
    //1.创建私有构造器
   private DemoText(){

   }
   //2.创建 static 类型的私有属性
   private static DemoText demoText =new DemoText();
   //3.创建public 方法
    public static  DemoText getDemoText(){
        return demoText;
    }
   
}