目录
- 引用类中的静态方法替换lambda
- 引用对象实例化方法替换lambda
- 引用类中的实例方法替换lambda
- 引用构造器替换lambda
引用类中的静态方法替换lambda
- 引用类方法：引用类的静态方法；`类名::静态方法名
==============================================`
demo: 将String类型数据转换成为Integer类型
创建一个接口名字为convers
package com.itxs.demo04;
/**
* @Classname : convers
* @Description : TODO 转换接口
* @Author : lin_refuel@qq.com
*/
public interface convers {
//数据转换方法
Integer conver(String str);
}
demo01:测试上面接口
package com.itxs.demo04;
/**
* @Classname : demo01
* @Description : TODO 转换接口测试类
* @Author : lin_refuel@qq.com
*/
public class demo01 {
public static void main(String[] args) {
// 匿名内部类方式
res(new convers() {
@Override
public Integer conver(String str) {
// 字符串转成Int类型数据
return Integer.parseInt(str);
}
});
// 完整的lambda
res((String str) ->{
return Integer.parseInt(str);
});
// 省略的lambda
res(str -> Integer.parseInt(str));
// 通过静态方法替换lambda
// 此时lambda的实参会作为静态方法的实参拿过来直接用
res(Integer::parseInt);
}
private static void res(convers c){
Integer ret = c.conver("9527");
System.out.println(ret+1);
}
}
个人理解：lambda就是针对接口，接口中只能有一个抽象方法，使用lambda时，就相当于直接重写了接口中的抽象方法，传递一个实际参数，直接写出你要做的事情
运行结果：
引用对象实例化方法替换lambda
- 引用对象的实例方法：引用对象中的成员方法；
对象::成员方法名
demo:小写的字符串转成大写
定义一个名字为printup的类
package com.itxs.demo05;
/**
* @Classname : printup
* @Description : TODO 输出大写字符串
* @Author : lin_refuel@qq.com
*/
public class printup {
public void printUp(String str){
// toUpperCase是可以将小写转大写
System.out.println("大写字母格式："+str.toUpperCase());
}
}
定义一个名字为printupp的接口
package com.itxs.demo05;
/**
* @Classname : printupp
* @Description : TODO 打印大写字符串
* @Author : lin_refuel@qq.com
*/
public interface printupp {
void printtup(String str);
}
测试类
package com.itxs.demo05;
import java.util.Locale;
/**
* @Classname : test
* @Description : TODO 引用实例化对象的方法
* @Author : lin_refuel@qq.com
*/
public class test {
public static void main(String[] args) {
// 小写字符串转大写字符串
// 匿名内部类的方式实现
print2(new printupp() {
@Override
public void printtup(String str) {
System.out.println(str.toUpperCase());
}
});
// 完整的lambda方式
print2((String str)->{
System.out.println(str.toUpperCase());
});
// lambda省略
print2(str -> System.out.println(str.toUpperCase()));
// 引用对象实例化方法 实例化对象 :: 方法名
// 个人感觉：形参 p中的方法printtup按照实例化对象printup中的printUp方法的样子进行重写
print2(new printup()::printUp);
}
private static void print2(printupp p){
p.printtup("abcdefg");
}
}
运行结果：
引用类中的实例方法替换lambda
- 引用类的实例方法：引用类中的成员方法；
类名::方法名
demo:字符串截取
定义一个名字为intercept的接口
package com.itxs.demo06;
/**
* @Classname : intercept
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public interface intercept {
String cept(String str,int begin,int end);
}
test测试类,测试上面接口
package com.itxs.demo06;
/**
* @Classname : test
* @Description : TODO 字符串截取
* @Author : lin_refuel@qq.com
*/
public class test {
public static void main(String[] args) {
//substring(),字符串截取方法
//匿名内部类的方式
res(new intercept() {
@Override
public String cept(String str, int begin, int end) {
return str.substring(begin,end);
}
});
// lambda完整的写法
res((String str,int begin,int end)->{
return str.substring(begin,end);
});
// lambda省略
res((str,begin,end)->str.substring(begin,end));
// 引用类中实例方法进行替换，第一个参数作为对象，其他实参作为实例方法的形参进行传递
res(String::substring);
}
private static void res(intercept i){
String s = i.cept("abcdefg", 1, 5);//从下标1截取到下标4
System.out.println(s);
}
}
运行结果：
引用构造器替换lambda
- 引用构造方器：引用构造方法；
类名::new
demo:通过接口获取学生类对象的几种方式
创建一个学生类
package com.itxs.demo07;
/**
* @Classname : Student
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
定义一个接口，创建一个返回Student类型的抽象方法
package com.itxs.demo07;
/**
* @Classname : student02
* @Description : TODO
* @Author : lin_refuel@qq.com
*/
public interface student02 {
Student getstu(String name,Integer age);
}
test测试类
package com.itxs.demo07;
/**
* @Classname : test
* @Description : TODO 引用构造器替换lambda测试
* @Author : lin_refuel@qq.com
*/
public class test {
public static void main(String[] args) {
// 匿名内部类获取一个学生类对象
res(new student02() {
@Override
public Student getstu(String name, Integer age) {
return new Student(name,age);
}
});
// lambda方式获取对象
res((String name,Integer age)->{
return new Student(name,age);
});
// 省略lambda
res((name,age)->new Student(name,age));
// 引用构造器
res(Student::new);
}
private static void res(student02 sb){
Student xs = sb.getstu("小肆", 18);
System.out.println("姓名："+xs.getName()+" 年龄："+xs.getAge());
}
}
