java复习第三次

lambda 表达式

简介

lambda表达式是一个可传递的代码块，可在以后执行一次或多次。lambda表示参数。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

特性

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

书写格式

-> 操作符将lambda表达式分为两个部分左侧：lambda表达式的参数列表右侧：lambda表达式所执行的功能即lambda体

1.无参数，无返回值

无参数仍要提供空括号，就像无方法参数一样。

1	() -> System.out.println("Hello world");

2.一个参数，无返回值

当参数类型可推导得出时小括号可以省略

1 2	(x) -> System.out.println(x); x -> System.out.println(x);

3.多个参数，有返回值

当参数类型可推导得出时参数类型可省略

1 2	(x, y) -> x – y ; (int x, int y) -> x + y ;

4.只有一条语句

大括号和return都可以省略

1	(x, y) -> x – y ;

5.有多条语句

(x,y) -> {
	System.out.println("函数式接口");
	return x - y ;
}

函数式接口

只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口称为函数式接口。

是lambda表达式使用的前提

方法引用

只有当lambda表达式的体只调用一个方法而不做其他操作时，才能把lambda表达式重写为方法引用

对象::实例方法 objectName::instanceMethod 将lambda的参数当做方法的参数使用

Consumer<String> sc = System.out::println;
//等效
Consumer<String> sc2 = (x) -> System.out.println(x);
sc.accept("618, 狂欢happy");

类::静态方法 ClassName::staticMethod 将lambda的参数当做方法的参数使用

Function<Integer, String> sf = String::valueOf;
//等效
Function<Integer, String> sf2 = (x) -> String.valueOf(x);
String apply1 = sf.apply(61888);

类::实例方法 ClassName::instanceMethod 将lambda的第一个参数当做方法的调用者，其他的参数作为方法的参数。

BiPredicate<String, String> sbp = String::equals;
//等效
BiPredicate<String, String> sbp2 = (x, y) -> x.equals(y);
boolean test = sbp.test("a", "A");

构造器引用

与方法引用类似，不过方法名为new

1	int[] :: new//等价x -> new int[x]

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。

lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

内部类

简介

内部类： 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。广义上我们将内部类分为四种：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。

为什么使用？

在实际问题中我们会遇到一些接口无法解决或难以解决的问题，此时我们可以使用内部类继承某个具体的或抽象的类，间接解决类无法多继承引起的一系列问题。

例：

class Outer{
    private String str ="外部类中的字符串";
    //************************** 
    //定义一个内部类
    class Inner{
        private String inStr= "内部类中的字符串";
        //定义一个普通方法
        public void print(){
            //调用外部类的str属性
            System.out.println(str);
        }
    }
    //************************** 
    //在外部类中定义一个方法，该方法负责产生内部类对象并调用print()方法
    public void fun(){
        //内部类对象
        Inner in = new Inner();
        //内部类对象提供的print
        in.print();
    }
}
public class Test{
    public static void main(String[] args)
    {
        //创建外部类对象
        Outer out = new Outer();
        //外部类方法
        out.fun();
    }
}

特性

内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
内部类是另外一种封装，对外部的其他类隐藏。
内部类可以实现java的单继承局限。
内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独立。
内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
创建内部类对象的时刻并不依赖于外围类对象的创建。

class A {
    private String name = "A类的私有域";
    public String getName() {
        return name;
    }
}
class B {
    private int age = 20;
    public int getAge() {
        return age;
    }
}
class Outter {
    private class InnerClassA extends A {
        public String name() {
            return super.getName();
    }
}
    private class InnerClassB extends B {
        public int age() {
            return super.getAge();
    }
}
    public String name() {
        return new InnerClassA().name();
    }
    public int age() {
        return new InnerClassB().age();
    }
}
public class Test2 {
        public static void main(String[] args) {
            Outter outter = new Outter();
            System.out.println(outter.name());
            System.out.println(outter.age());
        }
}