JDK 1.8 新特性_Lambda表达式(一)

2.1接口
• 方法五要素: 修饰符
• 返回值
• 方法名
• 参数
• 方法体

没有方法体
• 被abstract修饰

属性
• 方法

对属性没有要求
• 至少有0个抽象方法
• 如果此类有一个方法时抽象的,此类必须是抽象类
• 类被abstract修饰
• 不能new

接口里面的方法全部是抽象的
• 属性全部是:public static final;
• 标准

属性可以是不变,是标准
• 所有实现类的方法也是一样的

接口里面的方法可以有方法体:就不再是抽象的方法
• 如何调用普通的方法呢? new 对象,对象.方法();
• static 修饰的,直接使用类名.方法名();

完全是被js,scala,python 给逼出来的
• 没有lambda表达式,是如何做的;匿名类;
• java 的开发 创建一个类
• 继承父类和接口
• 定义属性和方法
• new对象
• 调用属性和方法

疑问:为啥方法的参数不能是方法呢 ?
• 参数的方法要执行,方法的本身也要执行;

方法的参数得是接口;调用接口中方法

• 接口的注解;@必须是:@FunctionalInterface; #(注解!=注释)

• 接口中方法只能有一个是抽象的

• 方法的五要素,方法的参数是方法

  /* 方法的定义 */
  Public void aa(IAnimal a)
  {
  Asdflka sflkda sjlfdk askdfj afd
  }

  /* 方法的调用
  参数是接口,目的也是执行接口中的方法,默认执行抽象的方法
  (只能有一个)
  */
  对象名/类名.aa((接口中抽象方法的实参列表--A) ->
  {
  /* 方法体 */
  Return 返回值的值(类型要匹配啊
  });

• 注意

  如果A的参数列表只有一个,类型可以省略,(自动推断)
• 如果方法体只有一行,大括号可以省略;
• 返回值,return 也可以省略;(new)

• new Thread(() -> System.out.println("===lambda测试====")).start();

接口的类型分类

所有分类的lambda都在java.util.function

• 3.实例

  3.1接口

• 动物接口:

  import java.util.function.Supplier;
  
  /**
  * 接口
  * 动物
  * @author Administrator
  */
  public interface IAnimal
  {
  /* public static final */
  /*public static final int headNum = 1 ; */
  int headNum = 1;
  
  /**
  * 跑方法
  */
  void run();
  
  /**
  * 可以写方法体,
  * 普通的方法
  * default:修饰符,依然是public,
  */
  default void def_eat()
  {
  System.out.println("IAnimal-def_eat-用嘴吃---");
  }
  
  /**
  * 可以写方法体,
  * 静态的方法
  * default:修饰符,依然是public,
  */
  static String static_eat()
  {
  System.out.println("IAnimal-static_eat-用嘴吃---");
  return "--hwhw--";
  }
  
  /**
  * 创建了一个对象
  * 调用者
  * @return
  */
  static IAnimal createObj(Supplier<IAnimal> supplier)
  {
  /* 返回此对象 */
  return supplier.get();
  }
  }

  

  人实现类

/**
* 人
* @author Administrator
*/
public class Person implements IAnimal
{
@Override
public void run()
{
System.out.println("=Person==run==");
}

@Override
public void def_eat()
{
System.out.println("=Person==def_eat==");
}
}

• 狗实现类

* ~实现;孝子
* ~不实现;不孝子
* @author Administrator
*
*/
public class Dog implements IAnimal
{

@Override
public void run()
{
System.out.println("===Dog=run===");
}
}

• 测试类

/**
* 测试类
*
* ~标准的多态;
* 		动物的接口
* 		人和狗的实现类
* 		写了一个多态;父类引用指向子类对象
* ~jdk1.8里面的方法可以写方法体
* 		普通的方法;在方法返回值的左边加上default
* 		静态的方法;在方法返回值的左边加上static
*
* ~如何重写
* 		普通方法和静态方法有方法体,但是不报错;所有的实现类,不用重写default和static方法
* 		普通方法可以被实现类重写;
* 		静态的方法不能被重写
*
* ~Supplier:提供者
* 		使用::new调用new方法;
* 		::调用某一个方法;返回值必须是function Interface;
* @author Administrator
*/
public class ClientMain
{
public static void main(String[] args)
{
System.out.println("====");
/* 父类引用指向子类对象 */
IAnimal animal = new Person();
/* 调用属性 */
System.out.println("=对象.属性===>" + animal.headNum);
System.out.println("--类名(接口).属性名---" + IAnimal.headNum);
/* 调用方法 */
animal.run();
/* 调用普通的方法
* 对象名.方法
*  */
animal.def_eat();
/* 静态的方法 */
IAnimal.static_eat();

/* new一个Dog */
Dog dog = new Dog();
/*
* 当调用一个方法或者属性的时候,如何当前类里面有此方法或者属性,就执行;
* 如果当前类里面木有此类或者方法,往上找;
* */
dog.def_eat();

/*IAnimal animal2 = new Dog();*/
/* 提供了一个新特性
* 此写法和上面的写法一样,
* 下面的更装逼
* 调用了new方法 */
IAnimal animal2 = IAnimal.createObj(Dog::new);
System.out.println("---->" + animal2);

/* 返回值必须是@FunctionalInterface */
//String result = IAnimal::static_eat;
}
}

3.2 Lambda

3.2.1 匿名类
• 多线程实现

import java.util.Date;

/**
* 实现多线程的一种方式;
* ~多线程只要一启动,就会走一遍run方法
* @author Administrator
*/
public class MyRunnable implements Runnable
{
@Override
public void run()
{
for (int i = 0; i < 10; i++)
{
System.out.println(new Date().toLocaleString() +
"===" + i +"==>" + Thread.currentThread());
}
}
}

• 测试类

import java.util.Date;

/**
* ~多线程,写了一个类,实现了runnable接口
* ~匿名类
* 		缺点:只使用一次;(代码只调用一次)
* 		优点:在哪使用,在哪定义;方便
* ~多个人同时开发;
* @author Administrator
*/
public class AnnoMain
{
public static void main(String[] args)
{
/* 多线程;Runnable; */
/* 启动一个多线程;
* 不是调用MyRunnable中的main方法 */
Runnable myRunnable = new MyRunnable() ;
Thread t = new Thread(myRunnable);
/* 启动多线程 */
t.start();
/* -------匿名类-----
* new后面直接跟上接口名,只有在接口名后面直接写上类体才可以
* 类体:包含属性和方法
* public class 省略 implements Runnable
* {
* }
* */
Thread t1 = new Thread(new Runnable()
{
/**
* 匿名类里面的代码只能在此处使用一次
*/
@Override
public void run()
{
for (int i = 0; i < 10; i++)
{
System.out.println(new Date().toLocaleString() +
"=lambdaMain==" + i +"==>" + Thread.currentThread());
}
}
});
t1.start();
}
}

• 3.2.2 lambda表达式

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.function.Consumer;

import com.jinghangzz.news.inter.IAnimal;
import com.jinghangzz.news.inter.Person;

/**
* ~初识lambda
* 	方法的参数得是接口;调用接口中的方法
接口的注解;(注解!=注释);@必须是;@FunctionalInterface
接口中的方法只能有一个是抽象的
方法的五要素;方法的参数是方法
* @author Administrator
*/
public class LambdaMain
{
public static void main(String[] args)
{
/* 多线程
* 参数是:runnable;是接口
* 目的是想调用runnable中的run方法(抽象方法,只有一个)
* lambda语法就是诊对run来定义的
*  */
Thread t = new Thread( () ->
{
/* ():run方法的参数
* 方法体指的是run方法的方法体
* 返回值: */
/* 方法体 */
for (int i = 0; i < 10; i++)
{
System.out.println(new Date().toLocaleString() +
"==lambda=" + i +"==>" + Thread.currentThread());
}
});
t.start();

/* 简写为一行 */
new Thread(() -> System.out.println("===lambda测试====")).start();

/* lambda */
List<String> list = Arrays.asList("test1","test2","aaa","test4");
System.out.println("-asList-->" + list);
/* 循环List */
list.forEach(new Consumer<String>()
{
@Override
public void accept(String t)
{
System.out.println("==接口_low==>" + t);
}
});

/* 高大尚 */
list.forEach(e -> System.out.println("==lambda==" + e));
/* 全版:木有简写 */
list.forEach((String e) ->
{
System.out.println("==lambda=全版=" + e);
});

/* Person::new */
/*IAnimal ani = new Person();*/
Person person = (Person) IAnimal.createObj(Person::new);
/* 创建了 List */
List<Person> aniList = Arrays.asList(person);
/* 循环:参数是Consumer;它的注解就是funtionInterface */
aniList.forEach(Person::def_eat);
}
}