2020-2-19

通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

内部类

成员内部类

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象格式：

外部类名.内部类名对象名 = new 外部类型().new 内部类型()；

匿名内部类【重点】

格式:

new 父类名或者接口名(){
// 方法重写
@Override
public void method() {
// 执行语句
}
};

StringBuilder常用的方法有2个：

public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
public String toString()：将当前StringBuilder对象转换为String对象。

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

备注：SLF4J是应用非常广泛的日志框架，它在记录日志时为了解决这种性能浪费的问题，并不推荐首先进行字符串的拼接，而是将字符串的若干部分作为可变参数传入方法中，仅在日志级别满足要求的情况下才会进行字符串拼接。例如： LOGGER.debug("变量{}的取值为{}。", "os", "macOS") ，其中的大括号 {} 为占位符。如果满足日志级别要求，则会将“os”和“macOS”两个字符串依次拼接到大括号的位置；否则不会进行字符串拼接。这也是一种可行解决方案，但Lambda可以做到更好。

获取流

获取一个流非常简单，有以下几种常用的方式：

所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

根据Collection获取流

Stream stream1 = list.stream();

根据Map获取流

Stream keyStream = map.keySet().stream();

Stream valueStream = map.values().stream();

Stream<Map.Entry<String,String>> entryStream = map.entrySet().stream();

根据数组获取流

String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };

Stream stream = Stream.of(array);

常用方法

统计个数：count（）

Stream<String> result = original.filter(s ‐> s.startsWith("张"));
System.out.println(result.count()); // 2

取用前几个：limit

Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.limit(2);
System.out.println(result.count()); // 2

跳过前几个：skip

如果希望跳过前几个元素，可以使用 skip 方法获取一个截取之后的新流：

Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
Stream<String> result = original.skip(2);
System.out.println(result.count()); // 1

组合：concat

Stream<String> streamA = Stream.of("张无忌");
Stream<String> streamB = Stream.of("张翠山");
Stream<String> result = Stream.concat(streamA, streamB);

通过对象名引用成员方法

public class MethodRefObject {
    public void printUpperCase(String str) {
    System.out.println(str.toUpperCase());
    }
}

@FunctionalInterface
public interface Printable {
void print(String str);
}

public class Demo04MethodRef {
private static void printString(Printable lambda) {
lambda.print("Hello");
}
    
public static void main(String[] args) {
    MethodRefObject obj = new MethodRefObject();
    printString(obj::printUpperCase);
    }
}

通过类名称引用静态方法

@FunctionalInterface
public interface Calcable {
int calc(int num);
}

public class Demo05Lambda {
    private static void method(int num, Calcable lambda) {
    System.out.println(lambda.calc(num));
    }
    public static void main(String[] args) {
    method(‐10, n ‐> Math.abs(n));
    }
}

public class Demo06MethodRef {
    private static void method(int num, Calcable lambda) {
    System.out.println(lambda.calc(num));
    }
    public static void main(String[] args) {
    method(‐10, Math::abs);
    }
}

//在这个例子中，下面两种写法是等效的：
//Lambda表达式： n -> Math.abs(n)
//方法引用： Math::abs

通过super引用成员方法

@FunctionalInterface
public interface Greetable {
	void greet();
}
public class Human {
    public void sayHello() {
    System.out.println("Hello!");
    }
}
public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好,我是Man!");
        }
    //定义方法method,参数传递Greetable接口
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        //调用method方法,使用Lambda表达式
        method(()‐>{
        //创建Human对象,调用sayHello方法
        new Human().sayHello();
        });
        //简化Lambda
        method(()‐>new Human().sayHello());
        //使用super关键字代替父类对象
        method(()‐>super.sayHello());
        }
}

通过this引用成员方法

@FunctionalInterface
    public interface Richable {
    void buy();
}
public class Husband {
    private void marry(Richable lambda) {
    lambda.buy();
    }
    public void beHappy() {
    marry(() ‐> System.out.println("买套房子"));
    }
}
public class Husband {
    private void buyHouse() {
    System.out.println("买套房子");
    }
    private void marry(Richable lambda) {
    lambda.buy();
    }
    public void beHappy() {
    marry(this::buyHouse);
}
//在这个例子中，下面两种写法是等效的：
//Lambda表达式： () -> this.buyHouse()
//方法引用： this::buyHouse

类的构造器引用

public class Person {
    private String name;
    public Person(String name) {
    this.name = name;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
}

public interface PersonBuilder {
	Person buildPerson(String name);
}

/*public class Demo09Lambda {
public static void printName(String name, PersonBuilder builder) {
System.out.println(builder.buildPerson(name).getName());
}
public static void main(String[] args) {
printName("赵丽颖", name ‐> new Person(name));
}
}*/

public class Demo10ConstructorRef {
    public static void printName(String name, PersonBuilder builder) {
    System.out.println(builder.buildPerson(name).getName());
    }
    public static void main(String[] args) {
    printName("赵丽颖", Person::new);
    }
}
//在这个例子中，下面两种写法是等效的：
//Lambda表达式： name -> new Person(name)
//方法引用： Person::new

数组的构造器引用

@FunctionalInterface
public interface ArrayBuilder {
	int[] buildArray(int length);
}
public class Demo11ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
    return builder.buildArray(length);
    }
    public static void main(String[] args) {
    int[] array = initArray(10, length ‐> new int[length]);
    }
}

//更好的写法
public class Demo12ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) {
    return builder.buildArray(length);
    }
    public static void main(String[] args) {
    int[] array = initArray(10, int[]::new);
    }
}

//在这个例子中，下面两种写法是等效的：
//Lambda表达式： length -> new int[length]
//方法引用： int[]::new

posted @ 2020-02-23 22:39 一起学编程阅读(96) 评论(0) 编辑收藏举报

刷新页面返回顶部

一起学编程

2020-2-19

公告