Java面向对象- -day5

拉姆达表达式

Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，
直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。
Java 8 引入的 Lambda 表达式的主要作用就是简化部分匿名内部类的写法。
能够使用 Lambda 表达式的一个重要依据是必须有相应的函数接口。所谓函数接口，是指内部有且仅有
一个抽象方法的接口。
Lambda 表达式的另一个依据是类型推断机制。在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指名.

函数式编程思想

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。编程中的函数，也有类似的概念，你调用我的时候，给我实参为形参赋值，然后通过运行方法体，给你返回一个结果。对于调用者来做，关注这个方法具备什么样的功能。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。
 

拉姆达表达式的使用

先了解一定的语法规则，后期在使用的时候，在逐渐熟悉更多的使用方式。

class F{
  // 通过调用AInterface中的sum方法，求两个数的和。
  int k(AInterface a , int x, int y){
    return  a.sum(x,y);
 }
  boolean b(BInterface b , int age){
    return  b.isBigPeople(age);
 }
  void c(BInterface b , DInterface d){
    int r = d.randomInt();
    boolean b1 = b.isBigPeople(r);
    if(b1){
      System.out.println("成年人");
   }else{
      System.out.println("未成年");
   }
 }
}


public class TestLambda {
  public static void main(String[] args) {
    // lambda表达式的使用 ,对应的接口要符合函数式接口的特征。
// 函数的参数格式(可以省略函数名字 , 可以省略参数的类型) -> { // 函数体}
//   如果是无参的函数，那么就直接写()
//   如果是有参的函数 ， 就写(参数名)
    AInterface aInterface = (a,b) -> {
      // 内部把a,b当接口中方法定义的类型使用。
      //if(a){ -- a是int类型，参数接口中方法的参数的类型。
      //  return 0;
      //}
      return  a + b;
   };
    aInterface.sum(4,5);
    BInterface bInterface = (h) ->{
      boolean b = h >= 18;
      return b;
   };
    bInterface.isBigPeople(19);
    CInterface cInterface = (name ,word)->{
      System.out.println(name + "," + word);
   };
    cInterface.sayHi("alice" ,"欢迎光临");
    DInterface dInterface = () -> {
      Random random = new Random();
      return  random.nextInt();

};
    dInterface.randomInt();
    // EInterface 不符合函数式接口规则，所以使用匿名内部类。
    EInterface eInterface = new EInterface() {
      @Override
      public int randomInt() {
        return 0;
     }
      @Override
      public int randomInt(int bound) {
        return 0;
     }
   };
    // 计算两个数的和 ，输出和
    int he = ((AInterface)(x,y)->{
      return  x +y;}).sum(3,5);
    System.out.println( he);
    // *** 方法调用的时候： 参数的类型，参数的个数， 参数的返回值。
    // *** 方法的定义： 方法签名(方法的修饰符，返回值 ，方法名，参数)，
    //        方法体怎么写。
   // 调用F中的k方法。
    F f = new F();
    int he1 = f.k((a,b)->{return  a +b;} , 4, 5 );
    System.out.println("he1:" + he1);
    // 调用F中的b方法。
    boolean b1 = f.b((m) ->{return  m >=18;} , 20);
    // 调用F中的c方法
    f.c( (a) ->{
          return  a >=18;
       },
       ()->{
          Random r = new Random() ;
          return  r.nextInt();
       } );
 }
}

 

1 拷贝小括号，写死右箭头，落地大括号

​ 2 @FunctionalInterface //显示声明

​ 3 default 方法实现，可以声明+实现一起在接口出现，允许多个

​ 4 静态方法，同上。

Object类型:所有类的父类

Object类是Java中所有类的基类，它位于java.lang包中。它是一个特殊的类，没有显式的父类。Object类定义了一些基本操作，所有其他类都可以使用这些操作。

以下是Object类的一些主要方法和功能：

1. equals(Object obj)：判断当前对象和给定对象是否相等。默认情况下，equals方法比较的是对象的引用地址，可以在自定义类中重写该方法以根据需要进行比较。

2. hashCode()：返回对象的哈希码值。默认情况下，hashCode方法返回对象的内存地址，可以在自定义类中重写该方法以根据需要提供更好的散列值。

3. toString()：返回对象的字符串表示。默认情况下，toString方法返回的是类名、@符号和对象的哈希码值的十六进制表示。可以在自定义类中重写该方法以返回有意义的字符串表示。

4. getClass()：返回对象的运行时类(Class对象)。

5. clone()：创建并返回此对象的副本。要实现克隆功能，类必须实现Cloneable接口，并覆盖clone方法。

6. finalize()：在垃圾回收器回收对象之前调用。

7. notify()、notifyAll()、wait()：用于线程间的通信，用于对象的锁定和解锁。

Object类也提供了一些静态方法，如：

• static void wait(long timeout)：导致当前线程等待指定的毫秒数，或者其他线程调用该对象的notify()、notifyAll()方法，或者超过指定的时间。
• static void wait(long timeout, int nanos)：导致当前线程等待指定的毫秒数加上指定的纳秒数，或者其他线程调用该对象的notify()、notifyAll()方法，或者超过指定的时间。
• static void wait()：导致当前线程等待，直到其他线程调用该对象的notify()、notifyAll()方法。

重写equals方法

从Object类中基础的equals方法，不满足子类的使用的时候，可以重写该方法。
重写equals : equals的比较，一般是比较两个对象的成员变量的值是否相等。

public class Shape {
   int x;
  int y;
  // 构造函数
  public Shape(){
 }
  // 重写toString方法
  //public String toString(){
  //  // return  Shape.class + "(" + x +"," + y +")";
  //  return  this.getClass() + "(" + x +"," + y +")";
  //}
  @Override
  public String toString() {
    return "Shape{" +
        "x=" + x +
        ", y=" + y +
        '}';
 }
  // 重写equals : equals的比较，一般是比较两个对象的成员变量的值是否相等。
  // 如果两个对象的x相等并且y相等，那么equals结果为true ，否则为false.
  public boolean equals1(Object o){ // 向上造型
    // 如果是null， 说明不等
    if(o == null)
      return  false;
    // 如果类型不同， 说明不等
    if(this.getClass() != o.getClass())
      return  false;
    // 如果是自己，说明相等。
    if(this == o)  // ==判断的是引用地址是否相当，如果相等，说明是同一个对象。
      return  true;
    // 如果类型相同，不是自己， 判断属性值是否相等。
    if(o instanceof Shape){
      Shape shape = (Shape)o;
      if(shape.x == this.x && shape.y == this.y){
        return  true;
     }
   }
    return  false ;// 不符合上面的条件，说明不相等。
 }
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;// 判断是否为自己
    if (o == null || getClass() != o.getClass()) // 是null ,或者类型不匹配
      return false;
    Shape shape = (Shape) o; // 强制类型转换
    return x == shape.x && y == shape.y; // 比较规则
 }
  @Override
  public int hashCode() {
    return Objects.hash(x, y);
 }
}