lambda
数据类型
基本类型
引用类型
数组
类
lambda
枚举
接口
注解
作用：
简化书写 之前学过的匿名内部类。
接口在jdk1.8之后的新特性
方法引用：
简化书写 lambda。
函数式编程 ：
Runnable run
Stream
简化书写 之前学过的 集合操作。
lambda
格式：
(参数)->{方法体};
无参无返回值
有参无返回值
有参有返回值
前提条件：
1：接口
2：函数式 接口
3：上下文推导环境
匿名内部类： 可以是 类 抽象类 接口的子类
lambda 必须是 函数式接口的子类。
接口在 jdk1.8之后的新特性(☆☆☆)：
之前的接口的组成：
常量
抽象方法。
interface Inter {
//int a ; //编译报错 常量必须要赋值不能使用默认值。
int a = 10; // 前面有默认修饰符 public static final
//void show(){} //编译报错 抽象方法必须没有方法体
void show(); //前面有默认修饰符 public abstract
}
jdk1.8之后的新特性 接口的组成
常量
抽象方法 abstract 和哪三个关键字 冲突？？？ final static private
非抽象方法
静态方法
静态私有方法
非静态私有方法。
interface Inter {
//int a ; //编译报错 常量必须要赋值不能使用默认值。
int a = 10; // 前面有默认修饰符 public static final
//void show(){} //编译报错 抽象方法必须没有方法体
void show(); //前面有默认修饰符 public abstract
//非抽象方法 必须给出 default 关键字
public default void method1(){ // 你给了default 前面就不会再有 默认修饰符 public abstract
}
//静态方法
public static void method2(){// 你给了static 前面就不会再有 默认修饰符 public abstract
}
//静态私有方法
private static void method2(){// 你给了static 前面就不会再有 默认修饰符 public
}
//非静态私有方法。
private void method1(){ // 你给了private 前面就不会再有 默认修饰符 public abstract
}
}
非静态的非抽象方法：
作用： 解决接口升级问题。
1万个类 实现了一个接口， 这时候对接口进行了升级，按照jdk1.7的规则， 加方法的话，只能加
抽象方法， 当加完抽象方法之后 1万个类 瞬间编译报错。 因为必须要重写 抽象方法。
有的时候 我们希望 1万个类 如果有类想升级 那么重写，有类的不想升级 就别重写了。 这时候 default来了。
案例1：
interface Inter {
public default void show(){
System.out.println("show");
}
}
class Student implements Inter {
}
public class Test {
public static void main(String[] args){
//Inter i = new Inter(); //编译报错。 接口 就算是jdk1.8 也不能创建对象啊。
//i.show();
//Inter.show(); // 编译报错。 因为 default方法不是静态 不能用类名调用.
// default 就不是给你接口准备的，
Student s = new Student();
s.show();
Inter i = new Student();
i.show(); // 多态除了 重写的方法 是调用的子类之外， 其他的所有的东西 都是调用的父类 父类没有那就只能报错了。
}
}
案例2：
interface Inter {
default void show(){ // 前面不写public的话 默认有
System.out.println("show");
}
}
class Student implements Inter {
void show(){ // 编译报错 子类重写重写父类的方法 权限修饰符 必须大于等于父类的权限修饰符
System.out.println("zi show");
}
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.show(); //
}
}
案例3：
interface Inter1 {
void method();
public default void show(){
System.out.println("show1");
}
}
interface Inter2 {
void method();
public default void show(){
System.out.println("show2");
}
}
class Student implements Inter1,Inter2 { // 多实现的规则 继续沿用。 但是 规定了 当一个类实现了多个接口，而多个接口中出现了 一样的 default方法， 那么子类必须重写，谁都不用
public void method(){ // 这也是 接口可以多实现的原因
System.out.println("method");
}
public void show(){
System.out.println(" zi show");
}
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.method(); // method
s.show(); //zi show
}
}
静态方法：
作用：让接口具备了功能， 让接口来调用。
案例1：
interface Inter {
public static void show(){ //
System.out.println("show");
}
}
class Student implements Inter {
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.show(); // 编译报错。 接口的静态方法 不是给儿子准备的。 儿子用不了。
Inter.show();
}
}
案例2：
class Person {
public static void show(){ //
System.out.println("show");
}
}
class Student extends Person {
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.show(); // show 正确的， 类的静态方法， 子类是可以调用的。
}
}
案例3：
class Person {
public static void show(){ //
System.out.println("fu show");
}
}
class Student extends Person {
public static void show(){ //
System.out.println("zi show");
}
}
public class Test {
public static void main(String[] args){
Person p = new Student();
p.show(); // fu show 静态的方法 不存在重写， 是谁的 就是谁的。,,,,,如果不是静态的话,答案是Zi show...
}
}
案例4：
interface Inter1 {
void method();
public static void show(){
System.out.println("show1");
}
}
interface Inter2 {
void method();
public static void show(){
System.out.println("show2");
}
}
class Student implements Inter1,Inter2 {
public void method(){ // 这也是 接口可以多实现的原因
System.out.println("method");
}
// Student 作为接口的子类 是无法使用接口的静态方法的， 所以 多实现接口的时候 随便有多少个相同的静态方法。
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.method(); // method
s.show(); //编译报错
}
}
私有方法：
作用：可以把多个非静态的非抽象方法 或者 多个静态方法 的共性的内容 抽取成一些静态方法。
interface Inter {
public static void show1(){
show3();
}
public static void show2(){
show3();
}
private static void show3(){
System.out.println("show");
System.out.println("show");
}
public default void method1(){
method3();
show3();
}
public default void method2(){
method3();
show3();
}
//private default void method3(){ // 编译报错。 你只要写了default 前面绝对默认是 public的 改不了。 你却private 冲突了。
//void method3(){ // 编译报错。 啥都不写 前面默认是public abstract的
private void method3(){ // 你写了 private之后 就不再有 publica bstract了 也不再有default了
System.out.println("method");
System.out.println("method");
}
}
class Student implements Inter {
}
public class Test {
public static void main(String[] args){
Student s = new Student();
s.method3();// 编译报错。 私有的
Inter.show3(); // 编译报错。 私有的
}
}
方法引用：
匿名内部类 ：代码比较多。
lambda表达式： 用来简化 匿名内部类的书写：
前提条件：
1： 接口
2： 只有一个抽象方法的接口 （函数式接口）
3： 必须有上下文的推导，才能使用lambda 否则不能确定 你lambda 是实现的哪个接口。
方法引用： 用来简化 lambda表达式的
前提条件：
1：必须满足 lambda表达式 前提条件
2：重写的方法，必须只有一条语句
3：这一条语句 必须是调用方法的情况 (对象.方法());
interface Inter{
void show(String s);
}
new Inter(){
@Override
public void show(String s) {
String s1 = s+"abc"; // 这种可不是对象调用方法啊。 这种就不能使用方法引用来表示
}
};
4：你重写的那个方法。 方法的参数 必须是你 方法内容里面 对象调用方法的 实际参数。
interface Inter{
void show(String s);
}
new Inter(){
@Override
public void show(String s) {
//System.out.println("abc"); // 不能使用方法引用来表示。
System.out.println(s);
}
};
调用方法的情况：
对象 调用非静态方法
对象::方法名
类名 调用静态方法
类名::方法名
new 调用 构造方法
类名::new
类名 调用 非静态方法
// method(s::substring); 如果遇到这种情况 ，方法引用就比较乏力了。
// java 为了 应对这种情况， 当 第一个参数， 是 要调用方法的那个对象， 后面的参数 都传递到 此方法中参数中去。 这时候
// 就允许 类名 调用 非静态方法