黑马程序员技术交流社区
标题: day13学习总结 [打印本页]
作者: 段孟钊 时间: 2019-5-19 10:11
标题: day13学习总结
本帖最后由 段孟钊 于 2019-5-19 10:17 编辑
个人笔记一、体验Lambda表达式
[Java] 纯文本查看 复制代码
package lambdatest;
public class MyThread implements Runnable {
@Override
public void run() {
System.out.println("多线程启动了");
}
}
package lambdatest;
public class ThreadTest {
public static void main(String[] args) {
//标准格式
MyThread mt = new MyThread();
Thread t1 = new Thread(mt);
t1.start();
//简写版
new Thread(new MyThread()).start();
//匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程启动了");
}
}).start();
//lambda表达式
new Thread(() -> {
System.out.println("多线程启动了");
}).start();
}
}
函数式编程思想概述函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现
二、Lambda表达式的标准格式三、Lambda表达式练习1（抽象方法无参无返回值）Lambda表达式的使用前提
练习描述
无参无返回值抽象方法的练习
操作步骤
[Java] 纯文本查看 复制代码
package lambdatest1;
public interface Eatable {
void eat();
}
package lambdatest1;
public class EatableImp implements Eatable {
@Override
public void eat() {
System.out.println("均衡饮食");
}
}
package lambdatest1;
public class EatableTest {
public static void main(String[] args) {
//用实现类的方式，来调用接口的方法
Eatable e = new EatableImp();
getEatable(e);
//用匿名内部类的方式，来调用接口的方法
getEatable(new Eatable() {
@Override
public void eat() {
System.out.println("均衡饮食");
}
});
//用Lambda表达式的方式，来调用接口方法，
// Lambda表达式只能调用接口，并且这个接口只能有一个抽象方法
getEatable(() -> {
System.out.println("均衡饮食");
});
}
public static void getEatable(Eatable e){
e.eat();
}
}
四、Lambda表达式练习2（抽象方法带参无返回值）
[Java] 纯文本查看 复制代码
package lambdaTest2;
public interface Flyable {
void fly(String s);
}
package lambdaTest2;
public class FlyTest {
public static void main(String[] args) {
//匿名内部类
useFly(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
}
},"哈哈");
System.out.println("========");
//lambda表达式
useFly((s) -> {
System.out.println(s);
},"哈哈");
}
public static void useFly(Flyable f,String s){
f.fly(s);
}
}
五、Lambda表达式练习2（抽象方法带参带返回值）
[HTML] 纯文本查看 复制代码
package lambdatest3;
public interface Addable {
int add(int x,int y);
}
package lambdatest3;
public class AddableTest {
public static void main(String[] args) {
useAddable((x,y) -> {
return x+y;
},2,3);
}
public static void useAddable(Addable a,int x,int y){
int sum = a.add(x, y);
System.out.println(sum);
}
}
六、Lambda表达式的省略模式省略的规则
[Java] 纯文本查看 复制代码
package lambdaTest4;
public interface Addable {
int add(int x,int y);
}
package lambdaTest4;
public interface Flyable {
void fly(String s);
}
package lambdaTest4;
public class LambdaTest {
public static void main(String[] args) {
//lambda表达式简写规则：
//()，里面可以省略数据类型
/*useFly((s) -> {
System.out.println(s);
},"哈哈");*/
//当()里只有一个参数时，()可以省略
/*useFly(s -> {
System.out.println(s);
},"哈哈");*/
//当{}方法体内只有一条代码语句，可以把{}省略，还可以省略;(代码语句的;)
// useFly(s -> System.out.println(s),"哈哈");
/*useAdd((x,y) -> {
return x+y;
},2,3);*/
//当{}方法体内只有一条代码语句，可以把{}省略，还可以省略;(代码语句的;)，还可以省略return。
useAdd((x,y) -> x+y,2,3);
}
public static void useAdd(Addable a,int x,int y){
int sum = a.add(x, y);
System.out.println(sum);
}
public static void useFly(Flyable f,String s){
f.fly(s);
}
}
七、Lambda表达式的注意事项八、Lambda表达式和匿名内部类的区别九、接口组成更改概述常量
public static final
抽象方法
public abstract
默认方法(Java 8)
静态方法(Java 8)
私有方法(Java 9)
十、接口中默认方法（被重写，需把default去掉）十一、接口中静态方法（只能用类名调用）十二、接口中私有方法（提取其它方法共有功能，只供本类调用）
[Java] 纯文本查看 复制代码
package interfacetest;
public interface MyInterface {
void show1();
default void show2(){
show();
method();
System.out.println("show2");
}
default void show3(){
show();
method();
System.out.println("show3");
}
public static void method1(){
method();
System.out.println("method1");
}
static void method2(){
method();
System.out.println("method2");
}
private void show(){
System.out.println("show");
}
private static void method(){
System.out.println("method");
}
}
package interfacetest;
public class MyInterfaceIml implements MyInterface {
@Override
public void show1() {
System.out.println("Iml show1");
}
@Override
public void show3() {
System.out.println("Iml show3");
}
}
package interfacetest;
public class MyInterfaceTest {
public static void main(String[] args) {
MyInterface mi = new MyInterfaceIml();
mi.show1();
mi.show2();
mi.show3();
MyInterface.method1();
MyInterface.method2();
}
}
十三、体验方法引用方法引用的出现原因
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作
那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要
那我们又是如何使用已经存在的方案的呢？
这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案
[Java] 纯文本查看 复制代码
package methodtrad;
public interface Printable {
void printString(String s);
}
package methodtrad;
//方法引用，调用引用类的普通方法：对象名::方法名
public class PrintableTest {
public static void main(String[] args) {
//lambda表达式简写
usePrintable((s)-> System.out.println(s),"哈哈");
//方法引用，
/*
System.out————表示一个字节流对象
::————System.out指向引用自己的方法
println————是System.out的一个方法，用来打印数据，
System.out::println————把自己的方法println复制给Printable p的printString方法并让printString方法重写
重写的内容是复制println的方法里面的内容
并且创建一个Printable接口的实现类对象
通过usePrintable(System.out::println,"哈哈");
把这个实现类对象传递到这个方法的第一个参数
*/
usePrintable(System.out::println,"哈哈");
}
public static void usePrintable(Printable p,String s){
p.printString(s);
}
}
十四、方法引用符十五、引用类方法引用类方法，其实就是引用类的静态方法
[Java] 纯文本查看 复制代码
package methodtrad1;
public interface Converter {
int convert(String s);
}
package methodtrad1;
//方法引用，调用引用类的静态方法
public class ConverterTest {
public static void main(String[] args) {
useConverter((s) -> Integer.parseInt(s),"100");
//通过方法引用，引用静态方法：类名::方法名
useConverter(Integer::parseInt,"100");
}
public static void useConverter(Converter c,String s){
int num = c.convert(s);
System.out.println(num);
}
}
十六、引用对象的实例方法
[Java] 纯文本查看 复制代码
package methodtrad2;
public class PrintString {
public void printUpper(String s){
String str = s.toUpperCase();
System.out.println(str);
}
}
package methodtrad2;
public interface Printable {
void print(String s);
}
package methodtrad2;
//方法引用，调用引用类的不同方法：对象名::方法名
public class PrintableTest {
public static void main(String[] args) {
PrintString ps = new PrintString();
usePrintable(s -> ps.printUpper(s),"哈哈");
usePrintable(ps::printUpper,"哈哈");
}
public static void usePrintable(Printable p,String s){
p.print(s);
}
}
十七、引用类的实例方法
[Java] 纯文本查看 复制代码
package methodtrad3;
public interface MyString {
String mySubString(String s,int start,int end);
}
package methodtrad3;
//方法引用，如果非要调用引用类的非静态方法，
/*
1、传入的第一个参数一定要是这个引用类的对象
2、例如 ：String::substring,"hello",1,3
*/
public class MyStringTest {
public static void main(String[] args) {
useMyString((s,start,end) -> s.substring(start,end),"hello",1,3);
useMyString(String::substring,"hello",1,3);
}
public static void useMyString(MyString ms,String s,int start,int end){
String s1 = ms.mySubString(s,start,end);
System.out.println(s1);
}
}
十八、引用构造器
[Java] 纯文本查看 复制代码
package methodtrad4;
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;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
} package methodtrad4;
public interface StudentBuilder {
Student build(String name,int age);
}
package methodtrad4;
//方法引用，调用引用类的构造方法（构造器）类名::new————表示调用构造方法(创建一个对象)
public class StudentbuilderTest {
public static void main(String[] args) {
useStudentBuilder((name, age) -> new Student(name,age),"张三",20);
useStudentBuilder(Student::new,"张三",20);
}
public static void useStudentBuilder(StudentBuilder sb,String name,int age){
Student s = sb.build(name, age);
System.out.println(s);
}
}
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |