JavaSE第八天

复习：

abstract
1.抽象方法：
2.特点：没有方法体
3.抽象类：
4.特点：不是创建对象
5.抽象类中可以没有抽象方法
6.抽象类要子类，由子类创建对象->实现所有的抽象方法
                没有实现所有的抽象方法，标识为抽象类

interface
1.定义接口
  interface 接口名{
      变量：int x = 10;  默认public  static final
      方法：抽象方法：默认访问修饰符：public abstract
            普通方法:jdk8开始 default或者static
  }
  使用：由实现实现接口implements-> 实现接口中的所有方法

2.函数式接口：接口中只有一个抽象方法->lambda表达式

3.抽象类和接口的区别

内部类：
1.类体：
    没有static修饰的内部类
        outclass.innerclass name = new outclass().new innerclass();
    有static修饰的内部类
        outclass.innerclass name = new outclass.innerclass();
2.方法：
    不可以有static修饰
    
3.匿名类：
     匿名类可以继续父类，也可以实现接口，可以创建对象

     父类类型（接口类型） 变量名 = new  父类类型（接口类型）(){

    匿名类的类体；

     }

----------------------------------------------------------------
lambda表达式
1.函数式接口编程：接口中只有一个抽象方法，把方法通过匿名类实现的方式
                  简化一个表达式的写法  lambda表达式
2.() -> {}
   ()表示形参列表
    ->符号 goes to
   {}表示方法体   

   //参数列表的数据类型可省,方法体有一条语句{}可以省略
   IA2 a2 = (x,y)->System.out.println(x+y);
   //如果参数列表是一个参数，()可以省略
   IA2 a2 = x->System.out.println(x);
   //如果方法体中有一条语句，return可以省略
   IA3 a = (x,y)-> x+y;        
   System.out.println(a.test(1, 2));
----------------------------------------------------------
 练习：

1. 给定一个厨师接口Cook，内含唯一的抽象方法makeFood，且无参数，
   无返回值.
    使用Lambda的标准格式调用invokeCook方法，打印"吃饭啦！"
    public class TestLambda {
       public static void main(String[] args) {
          //调用invokeCook方法，匿名内部类方法实现
       
          //使用lambda表达式
       
       }
      public static void invokeCook(Cook cook){
          cook.makeFood();
      }
    }



2.定义接口
   public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
       int calc(int a,int b);
   定义测试类
    public class Demo01Calculator {
    
       public static void main(String[] args) {
        
       //调用invokeCalc方法，方法的参数使用匿名内部类
实现        
              
       //使用Lambda表达式简化匿名内部类的书写
        
       }
       public static void invokeCalc(int a,int b,Calculator c){
             int sum = c.calc(a,b);
             System.out.println(sum);
       }

    }

-----------------------------------------------------
lambda表达式使用已定义方法

方法的归属者::方法名
       public static void main(String[] args) {
        Demo4 demo = new Demo4();
        IDemo4_1 demo1 = (x,y)->demo.test1(x, y);
        IDemo4_1 demo2 = demo::test1;
        System.out.println(demo1.f1(1, 2));
        System.out.println(demo2.f1(1, 2));
        
        IDemo4_2 demo3 = (x,y)->Demo4.test2(x,y);
        IDemo4_2 demo4 = Demo4::test2;
        System.out.println(demo3.f2(1, 2));
        System.out.println(demo4.f2(1, 2));
        

    }
        //方法的参数相同，返回类型相同
    public  int test1(int x,int y){
        return x+y;
    }
    public static int test2(int x,int y){
        return x+y;
    }

3.定义接口
     interface IDemo{
    
    //控制输出System.out.println()
    void showMessage(String msg);
     }
     interface IDemo2{    
    //返回两数的最大值：Math.max()
    int max11(int x,int y);    
     }

    public class Demo8 {

    public static void main(String[] args) {
        //实现接口中的方法
        //要求是::的形式实现
          IDemo demo = System.out::println;
        demo.showMessage("hello");
        IDemo2 demo2 = Math::max;
        System.out.println(demo2.max11(1,2));
    }
    }

-------------------------------------------------
lambda对构造方法的引用
interface Demo5_1{
    //用无参的构造方法 创建对象，返回
    Student getStudent();
}
interface Demo5_2{
    //用带参的构造方法 创建对象，返回
    Student getStudent(String name,int age);
}

    Demo5_1 demo1 = ()-> new Student();
    Demo5_1 demo2 = Student::new;
    //demo1.getStudent();
    //demo2.getStudent();
    
    Demo5_2 demo3 = (name,age)->new Student(name,age);
    Demo5_2 demo4 = Student::new;
    demo3.getStudent("张三", 18);
    demo4.getStudent("张三", 18);