传统的接口:
接口中的属性都是静态常量。staticfinal接口中的方法都是抽象方法。abstract
后的接口
默认方法。default返回类型方法名{}静态方法。static返回类型方法名{}
package demo01;
/**
* @program: JDK8
* @description:
* @author: 阿木
* @create: 2022-02-14 09:35
**/
public class Test05 {
public static void main(String[] args) {
A a=new A();
a.fun();
My.fun3();
}
}
/**
* 默认方法: 可以被子类继承 而且还可以被子类重写。调用该方法可以通过对象调用。
* 静态方法: 不能被子类继承。只能通过接口名直接调用。
*/
interface My{
public void show();
default void fun(){};
//为什么使用默认方法？ 如果没有默认方法，接口中新增一个方法，那么所有的子类都必须重写该方法。扩展性非常差。
static void fun3(){
//只能通过接口名调用
}
}
class A implements My{
@Override
public void fun() {
}
@Override
public void show() {
}
}
class B implements My{
@Override
public void show() {
}
}函数式接口---JDK8内置。
我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口。
package demo01;
/**
* @program: JDK8
* @description:
* @author: 阿木
* @create: 2022-02-14 09:47
**/
public class Test06 {
public static void main(String[] args) {
Integer[] arr={1,2,3,4};
//创建一个接口---里面有一个计算数组和的方法.
M m=(a)->{
int sum=0;
for (int b:a){
sum+=b;
}
return sum;
};
s(arr,m);
}
public static void s(Integer[] arr,M m){
int r=m.sum(arr);
System.out.println(r);
}
}
//每个人定义接口的名字可能不同.而且接口中的方法名每个人定义可能也不同.
//JDK中内置了一个函数式接口. 而这些接口包含了有参, 无参 有返回值 和无返回值的接口.
interface M{
public int sum(Integer[] arr);
}
jdk提供的函数式接口javutifunction包下。
Consumer消费型函数式接口有参无返回值
voidaccept(Tt);
Function函数型函数式接口有参有返回值
Rapply(Tt);
Supplier
Tget();
Predicate
Consumer消费型函数式接口
/***Performsthisoperationonthegivenargument.**@paramttheinputargument*/voidaccept(Tt);
//创建一个消费型函数式接口对象Consumer
传递一个数组给消费型接口对象，并求出数组中最大的元素并输出。
Function函数型函数式接口
/***有参有返回值的方法*/Rapply(Tt);
Function
传递一个数组给函数型接口对象，并求出数组中最大的元素并返回。
/**无参有返回值时*@returnaresult*/Tget();
//创建供给型函数式接口Tget();//返回一个集合对象.Supplier
通过供给型函数随机产生一个100内整形数组。并返回。
Predicate
booleantest(Tt);//有参返回结果为boolean类型。
//创建一个断言型函数式接口boolean test(T t);
// Predicate predicate=(t)->{
// return t>18;
// };
Predicate predicate=(t)->{
if(t.getSex().equals('男')&&t.getAge()>18){
return true;
}
return false;
};
boolean b = predicate.test(new Student2('女',19));
if(b){
System.out.println('你可以洗脚');
}else{
System.out.println('你未成年.');
}
class Student2{
private String sex;
private Integer age;
public Student2(String sex, Integer age) {
this.sex = sex;
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
把一个数组交于断言型函数并判断数组中所有元素的值是否都大于1如果都大于则返回true
package demo01;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* @program: JDK8
* @description:
* @author: 闫克起2
* @create: 2022-02-14 10:28
**/
public class Test08 {
//void accept(T t);
public static void main(String[] args) {
//创建一个消费型函数式接口对象
Consumer consumer=(t)->{
System.out.println('今天洗脚花费了:'+t);
};
consumer.accept(1000.0);
//创建函数型函数式接口R apply(T t);
Function function=(t)->{
return t.toUpperCase();
};
String result = function.apply('hello');
System.out.println(result);
//创建供给型函数式接口T get();
//返回一个集合对象.
Supplier> supplier=()->{
List list=new ArrayList<>();
for(int i=0;i<5;i++){
list.add(new Random().nextInt(50));
}
return list;
};
List list = supplier.get();
System.out.println(list);
//创建一个断言型函数式接口boolean test(T t);
// Predicate predicate=(t)->{
//return t>18;
// };
Predicate predicate=(t)->{
if(t.getSex().equals('男')&&t.getAge()>18){
return true;
}
return false;
};
boolean b = predicate.test(new Student2('女',19));
if(b){
System.out.println('你可以洗脚');
}else{
System.out.println('你未成年.');
}
}
}
class Student2{
private String sex;
private Integer age;
public Student2(String sex, Integer age) {
this.sex = sex;
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
} 方法引用
例子:
使用函数式接口求一个数组中所有元素的和。
publicstaticvoidmain(String[]args){Consumer
发现在lambda表达式中的内容也非常多。能不能抽取一个方法，然后lambda表达式调用该方法。
package demo01;
import java.util.function.Consumer;
/**
* @program: JDK8
* @description:
* @author: 阿木
* @create: 2022-02-14 11:28
**/
public class Test09 {
public static void main(String[] args) {
Consumer consumer=(t)->{
Test09.sum(t);
};
Integer[] arr={2,6,8,10,5};
consumer.accept(arr);
}
//抽取的求和方法
public static void sum(Integer[] t){
int sum=0;
for (Integer a:t){
sum+=a;
}
System.out.println('数组中所有元素的和:'+sum);
}
}
发现:lambda表达式中有且仅有一条代码，调用了已经存在的方法。可以使用方法引用使语法更加简洁。
package demo01;
import java.util.function.Consumer;
/**
* @program: JDK8
* @description:
* @author: 阿木
* @create: 2022-02-14 11:28
**/
public class Test09 {
public static void main(String[] args) {
// Consumer consumer=(t)->{
// Test09.sum(t);
// };
Consumer consumer=Test09::sum;
Integer[] arr={2,6,8,10,5};
consumer.accept(arr);
}
//抽取的求和方法
public static void sum(Integer[] t){
int sum=0;
for (Integer a:t){
sum+=a;
}
System.out.println('数组中所有元素的和:'+sum);
}
}
有那些可以使用方法引用。
静态方法引用
只要lambda表达式符合->类名.静态方法(参数)使用方法引用的方式:类名::静态方法。
例子:对整形数组排序.
package demo01;
import java.util.Arrays;
import java.util.Comparator;
/**
* @program: JDK8
* @description:
* @author: 阿木
* @create: 2022-02-14 11:41
**/
public class Test10 {
public static void main(String[] args) {
Integer[] arr={21,2,33,22,12,4};
System.out.println('排序前:'+Arrays.toString(arr));
// Comparator comparator=(o1,o2)->{return o2-o1;};
// Comparator comparator=(o1,o2)->Integer.compare(o1,o2); //在Integer类中存在一个比较方法静态方法
//lambda只有一条语句,
Comparator comparator=Integer::compare; //静态方法引用: 类名::静态方法
Arrays.sort(arr,comparator);//排序 默认由小到大
System.out.println('排序后:'+Arrays.toString(arr));
}
}
文章为作者独立观点，不代表 股票程序化软件自动交易接口观点
相关文章
股民评论