// 注意：wrf这个引用也是强引用，它是指向SoftReference这个对象的， 
// 这里的软引用指的是指向new String("str")的引用，也就是SoftReference类中T 

SoftReference<String> wrf = new SoftReference<String>(new String("str"));

Java方法四种引用_主方法

没人指向的就是软引用

1.3 弱引用

弱引用就是只要 JVM 垃圾回收器发现了它，就会将之回收，使用方式：

WeakReference<String> wrf=new WeakReference<String>(str);

可用场景： Java 源码中的 java.util.WeakHashMap 中的 key 就是使用弱引用，我的理解就是，一旦我不需要某个引用， JVM 会自动帮我处理它，这样我就不需要做其它操作。

1.4 虚引用

虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入 ReferenceQueue 中。注意哦，其它引用是被 JVM 回收后才被传入 ReferenceQueue 中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有 ReferenceQueue ，使用例子：

PhantomReference<String> prf=new PhantomReference<String>(new String("str"),new ReferenceQueue<>());

可用场景：对象销毁前的一些操作，比如说资源释放等。 ** Object.fifinalize() 虽然也可以做这类动作，但是这个方式即不安全又低效 上诉所说的几类引用，都是指对象本身的引用，而不是指 Reference 的四个子类的引用 ( SoftReference 等 ) 。

2 体验方法引用

方法引用的出现原因在使用 Lambda 表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作那么考虑一种情况：如果我们在 Lambda 中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要那我们又是如何使用已经存在的方案的呢？这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案代码演示

public interface Printable {
    void printString(String s);
}
public class PrintableDemo {
    public static void main(String[] args) {
//在主方法中调用usePrintable方法
// usePrintable((String s) -> {
// System.out.println(s);
// });
//Lambda简化写法
        usePrintable(s -> System.out.println(s));
//方法引用
        usePrintable(System.out::println);
    }
    private static void usePrintable(Printable p) {
        p.printString("爱生活爱Java");
    }
}

3 方法引用符

方法引用符 :: 该符号为引用运算符，而它所在的表达式被称为方法引用推导与省略如果使用 Lambda ，那么根据 “ 可推导就是可省略 ” 的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导如果使用方法引用，也是同样可以根据上下文进行推导方法引用是 Lambda 的孪生兄弟

4 引用类方法

引用类方法，其实就是引用类的静态方法格式类名 :: 静态方法范例 Integer::parseInt Integer 类的方法： public static int parseInt(String s) 将此 String 转换为 int 类型数据练习描述定义一个接口 (Converter) ，里面定义一个抽象方法 int convert(String s); 定义一个测试类 (ConverterDemo) ，在测试类中提供两个方法一个方法是： useConverter(Converter c) 一个方法是主方法，在主方法中调用 useConverter 方法代码演示

public interface Converter {
    int convert(String s);
}
public class ConverterDemo {
    public static void main(String[] args) {
//Lambda写法
        useConverter(s -> Integer.parseInt(s));
//引用类方法
        useConverter(Integer::parseInt);
    }
    private static void useConverter(Converter c) {
        int number = c.convert("666");
        System.out.println(number);
    }
}

使用说明

Lambda 表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

5 引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法格式对象 :: 成员方法范例 "HelloWorld"::toUpperCase String 类中的方法： public String toUpperCase() 将此 String 所有字符转换为大写练习描述定义一个类 (PrintString) ，里面定义一个方法 public void printUpper(String s) ：把字符串参数变成大写的数据，然后在控制台输出定义一个接口 (Printer) ，里面定义一个抽象方法 void printUpperCase(String s) 定义一个测试类 (PrinterDemo) ，在测试类中提供两个方法一个方法是： usePrinter(Printer p) 一个方法是主方法，在主方法中调用 usePrinter 方法代码演示

public class PrintString {
    //把字符串参数变成大写的数据，然后在控制台输出
    public void printUpper(String s) {
        String result = s.toUpperCase();
        System.out.println(result);
    }
}
public interface Printer {
    void printUpperCase(String s);
}
public class PrinterDemo {
    public static void main(String[] args) {
//Lambda简化写法
        usePrinter(s -> System.out.println(s.toUpperCase()));
//引用对象的实例方法
        PrintString ps = new PrintString();
        usePrinter(ps::printUpper);
    }
    private static void usePrinter(Printer p) {
        p.printUpperCase("HelloWorld");
    }
}

使用说明

Lambda 表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

6 引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法格式类名 :: 成员方法范例 String::substring public String substring(int beginIndex,int endIndex) 从 beginIndex 开始到 endIndex 结束，截取字符串。返回一个子串，子串的长度为 endIndex-beginIndex 练习描述定义一个接口 (MyString) ，里面定义一个抽象方法： String mySubString(String s,int x,int y); 定义一个测试类 (MyStringDemo) ，在测试类中提供两个方法一个方法是： useMyString(MyString my) 一个方法是主方法，在主方法中调用 useMyString 方法代码演示

public interface MyString {
    String mySubString(String s,int x,int y);
}
public class MyStringDemo {
    public static void main(String[] args) {
//Lambda简化写法
        useMyString((s,x,y) -> s.substring(x,y));
//引用类的实例方法
        useMyString(String::substring);
    }
    private static void useMyString(MyString my) {
        String s = my.mySubString("HelloWorld", 2, 5);
        System.out.println(s);
    }
}

使用说明

Lambda 表达式被类的实例方法替代的时候第一个参数作为调用者后面的参数全部传递给该方法作为参数

7 引用构造器

引用构造器，其实就是引用构造方法 l 格式类名 ::new 范例 Student::new 练习描述定义一个类 (Student) ，里面有两个成员变量 (name,age) 并提供无参构造方法和带参构造方法，以及成员变量对应的 get 和 set 方法定义一个接口 (StudentBuilder) ，里面定义一个抽象方法 Student build(String name,int age); 定义一个测试类 (StudentDemo) ，在测试类中提供两个方法一个方法是： useStudentBuilder(StudentBuilder s) 一个方法是主方法，在主方法中调用 useStudentBuilder 方法

代码演示

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;
    }
}
public interface StudentBuilder {
    Student build(String name,int age);
}
public class StudentDemo {
    public static void main(String[] args) {
//Lambda简化写法
        useStudentBuilder((name,age) -> new Student(name,age));
//引用构造器
        useStudentBuilder(Student::new);
    }
    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}