我是一个java新手，写了一段代码，有关：摄氏度和华氏度之间的互相转化
package method;
import method.HuaShe;
public class TestCToFandFToC {
public static void main(String[] args){
System.out.println("摄氏 华氏 华氏 摄氏");
for(int i = 1;i <= 10;i++){
double she1 = 40.0;
double hua1 = cToF(she1);
double hua2 = 120.0;
double she2 = fToC(hua2);
System.out.println(she1 + " " + hua1 + " " + hua2 + " " + she2);
she1 -= 1;
hua2 -= 10;
}
}
}
//问题：为何出现错误？我import了啊！！
其中cToF和fToC是我另外写的函数，但是没有和上面代码段放在一起，而是新建了一个：package method;
public class HuaShe {
static double cToF(double c){
double ft = (9.0 / 5) * c + 32;
double f = (int)(ft * 100) / 100.0;
return f;
}
//--------------------------------------
static double fToC(double f){
double ct = (f - 32) / (9.0 / 5);
double c = (int)(ct * 100) / 100.0;
return c;
}
}
然后运行主函数时
cToF(she1);和fToC(hua2);报错：
The method cToF(double) is undefined for the type TestCToFandFToC
为什么会这样？？？
谢谢！

前言
方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。
当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式。
注意：方法引用是一个Lambda表达式，其中方法引用的操作符是双冒号"::"。
在Java8中，使用方法引用非常简单，如String::isEmpty，但无法使用它否定的方法引用。本文内容即如何解决此问题使得我们能够更加全面地使用方法引用。
首先看一个使用方法引用的例子：
Stream.of("A", "", "B").filter(String::isEmpty).count()
上面代码的输出为1，即空字符串的数目。如果我们想要获取非空字符串的数目，就不能直接使用方法引用了。
Stream.of("A", "", "B").filter(s -> !s.isEmpty()).count()
Java8中的Predicate，有predicate.negate()可以转换为断言的否定形式，但String::isEmpty却无法这么做(String::isEmpty.negate()或者!String::isEmpty )。因为方法引用并不是一个lambda或者函数接口，它能够被解析为一个或者多个函数接口。如，String::isEmpty至少可以被解析如下：
Predicate
Function
为了解决上述的问题，我们可以通过某种机制显式地将方法引用转换为一个函数接口：
public static  Predicate as(Predicate predicate) {
return predicate;
}
通过使用一个静态方法，接受方法引用参数，返回一个函数接口，即可实现方法引用到函数接口的转换。接着，我们就可以使用方法引用来实现上面例子中的获取非空字符串的数目。
Stream.of("A", "", "B").filter(as(String::isEmpty).negate()).count();
进一步还能使用各种组合的Predicate。
.filter(as(String::isEmpty).negate().and("A"::equals))
由于一个方法引用可能会被解析为多种函数接口，因此如果我们实现很多参数不同的as方法，那么很容易造成混淆。更好的方式则是在方法名中加入函数参数的类型来区分。
import java.util.function.*;
public class FunctionCastUtil {
public static  BiConsumer asBiConsumer(BiConsumer biConsumer) {
return biConsumer;
}
public static  BiFunction asBiFunction(BiFunction biFunction) {
return biFunction;
}
public static  BinaryOperator asBinaryOperator(BinaryOperator binaryOperator) {
return binaryOperator;
}
public static  BiPredicate asBiPredicate(BiPredicate biPredicate) {
return biPredicate;
}
public static BooleanSupplier asBooleanSupplier(BooleanSupplier booleanSupplier) {
return booleanSupplier;
}
public static  Consumer asConsumer(Consumer consumer) {
return consumer;
}
public static DoubleBinaryOperator asDoubleBinaryOperator(DoubleBinaryOperator doubleBinaryOperator) {
return doubleBinaryOperator;
}
public static DoubleConsumer asDoubleConsumer(DoubleConsumer doubleConsumer) {
return doubleConsumer;
}
public static  DoubleFunction asDoubleFunction(DoubleFunction doubleFunction) {
return doubleFunction;
}
public static DoublePredicate asDoublePredicate(DoublePredicate doublePredicate) {
return doublePredicate;
}
public static DoubleToIntFunction asDoubleToIntFunction(DoubleToIntFunction doubleToIntFunctiontem) {
return doubleToIntFunctiontem;
}
public static DoubleToLongFunction asDoubleToLongFunction(DoubleToLongFunction doubleToLongFunction) {
return doubleToLongFunction;
}
public static DoubleUnaryOperator asDoubleUnaryOperator(DoubleUnaryOperator doubleUnaryOperator) {
return doubleUnaryOperator;
}
public static  Function asFunction(Function function) {
return function;
}
public static IntBinaryOperator asIntBinaryOperator(IntBinaryOperator intBinaryOperator) {
return intBinaryOperator;
}
public static IntConsumer asIntConsumer(IntConsumer intConsumer) {
return intConsumer;
}
public static  IntFunction asIntFunction(IntFunction intFunction) {
return intFunction;
}
public static IntPredicate asIntPredicate(IntPredicate intPredicate) {
return intPredicate;
}
public static IntSupplier asIntSupplier(IntSupplier intSupplier) {
return intSupplier;
}
public static IntToDoubleFunction asIntToDoubleFunction(IntToDoubleFunction intToDoubleFunction) {
return intToDoubleFunction;
}
public static IntToLongFunction asIntToLongFunction(IntToLongFunction intToLongFunction) {
return intToLongFunction;
}
public static IntUnaryOperator asIntUnaryOperator(IntUnaryOperator intUnaryOperator) {
return intUnaryOperator;
}
public static LongBinaryOperator asLongBinaryOperator(LongBinaryOperator longBinaryOperator) {
return longBinaryOperator;
}
public static LongConsumer asLongConsumer(LongConsumer longConsumer) {
return longConsumer;
}
public static  LongFunction asLongFunction(LongFunction longFunction) {
return longFunction;
}
public static LongPredicate asLongPredicate(LongPredicate longPredicate) {
return longPredicate;
}
public static  LongSupplier asLongSupplier(LongSupplier longSupplier) {
return longSupplier;
}
public static LongToDoubleFunction asLongToDoubleFunction(LongToDoubleFunction longToDoubleFunction) {
return longToDoubleFunction;
}
public static LongToIntFunction asLongToIntFunction(LongToIntFunction longToIntFunction) {
return longToIntFunction;
}
public static LongUnaryOperator asLongUnaryOperator(LongUnaryOperator longUnaryOperator) {
return longUnaryOperator;
}
public static  ObjDoubleConsumer asObjDoubleConsumer(ObjDoubleConsumer objDoubleConsumer) {
return objDoubleConsumer;
}
public static  ObjIntConsumer asObjIntConsumer(ObjIntConsumer objIntConsumer) {
return objIntConsumer;
}
public static  ObjLongConsumer asObjLongConsumer(ObjLongConsumer objLongConsumer) {
return objLongConsumer;
}
public static  Predicate asPredicate(Predicate predicate) {
return predicate;
}
public static  Supplier asSupplier(Supplier supplier) {
return supplier;
}
public static  ToDoubleBiFunction asToDoubleBiFunction(ToDoubleBiFunction toDoubleBiFunction) {
return toDoubleBiFunction;
}
public static  ToDoubleFunction asToDoubleFunction(ToDoubleFunction toDoubleFunction) {
return toDoubleFunction;
}
public static  ToIntBiFunction asToIntBiFunction(ToIntBiFunction toIntBiFunction) {
return toIntBiFunction;
}
public static  ToIntFunction asToIntFunction(ToIntFunction ioIntFunction) {
return ioIntFunction;
}
public static  ToLongBiFunction asToLongBiFunction(ToLongBiFunction toLongBiFunction) {
return toLongBiFunction;
}
public static  ToLongFunction asToLongFunction(ToLongFunction toLongFunction) {
return toLongFunction;
}
public static  UnaryOperator asUnaryOperator(UnaryOperator unaryOperator) {
return unaryOperator;
}
private FunctionCastUtil() {
}
}
Stream.of("A", "", "B").filter(asPredicate(String::isEmpty).negate()).count();
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对脚本之家的支持。

Java8 中引入方法引用新特性，用于简化应用对象方法的调用， 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。 方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。
计算时，方法引用会创建函数式接口的一个实例。 当 Lambda 表达式中只是执行一个方法调用时，不用 Lambda 表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的 Lambda 表达式。
一、语法
目标引用：方法名称
目标引用：类名、实例对象
方法名称：实例方法名、静态方法名
等效 Lambda 的方法引用示例如下：
二、方法引用分类
Java8 中对于方法引用主要分为四大类：构造器引用
Class::new
静态方法引用
Class::static_method
实例对象方法引用
Instance::method
特定类型任意对象的实例方法引用
Class:: method
三、构造器引用
语法是Class::new，或者更一般的Class< T >::new实例如下：
/**
* Lambda 表达式 实例化User 对象
*/
Supplier s01 =()->new User();
Function  f01 = (id)->{
return new User(id);
};
f01.apply(2019);
BiFunction bf01 = (id,uname)->{
return new User(id,uname);
};
bf01.apply(2019,"admin");
//方法引用 等价写法
Supplier s02 = User::new;
Function f02 = User::new;
f02.apply(2019);
BiFunction bf02 = User::new;
bf02.apply(2019,"admin");
四、静态方法引用
语法是Class::static_method，实例如下：
// 判断字符串是否为空串
Function f03 = (str)-> StringUtils.isBlank(str);
System.out.println(f03.apply(""));
// Base64 对输入字符串执行编码操作
Supplier s01 = ()->Base64.getEncoder();
s01.get().encodeToString("java8 is so easy!!!".getBytes());
Function f04 = StringUtils::isBlank;
System.out.println(f04.apply(""));
Supplier s02 = Base64::getEncoder;
s02.get().encodeToString("java8 is so easy!!!".getBytes());
五、实例对象方法引用
语法是Instance::method ，此时引用方法时必须存在实例，示例如下：
//方法引用构造User 对象
BiFunction bf02 = User::new;
User u02 = bf02.apply(2019,"admin");
// 调用实例对象方法
Supplier s01 = ()->u02.getUserName();
System.out.println(s01.get());
// 方法引用 等价Lambda 写法
Supplier s02 = u02::getUserName;
System.out.println(s02.get());
六、特定类型任意对象的实例方法引用
语法是Class:: method，第四种类型比较特殊，这里特定类型指多个对象类型说的，对象类型属于同一类类型通常是一个集合，元素类型一致，此时可以对类方法实现引用。
/**
准备测试数据
**/
List list= Arrays.asList(10,2,30,5,8,10,60,99,101);
List emails = Arrays.asList("126@126.com"," ","","java8@163.com");
Goods g01=new Goods(1,"小米9",1789,200, BigDecimal.valueOf(2500));
Goods g02=new Goods(2,"华为Mate20",5000,3000, BigDecimal.valueOf(7000));
Goods g03=new Goods(3,"OPPO R17",2000,2827, BigDecimal.valueOf(1500));
Goods g04=new Goods(4,"魅族 Note9",2000,1600, BigDecimal.valueOf(1600));
Goods g05=new Goods(5,"一加6T",8000,5000, BigDecimal.valueOf(3500));
List goods= Arrays.asList(g01,g02,g03,g04,g05);
// Lambda 对集合list元素排序 list 存放整数元素
list.sort((a1,a2)->a1-a2);
// Lambda 对集合goods 按销量排序
goods.sort((g1,g2)->g1.getSale()-g2.getSale());
// 过滤邮箱集合空串
emails.stream().filter((e) -> StringUtils.isNoneBlank(e))
.collect(Collectors.toList());
// 任意对象的实例方法引用 对集合list元素排序
list.sort(Comparator.comparing(Integer::intValue));
// 任意对象的实例方法引用 对集合goods 按销量排序
goods.sort(Comparator.comparing(Goods::getSale));
// 过滤邮箱集合空串
emails.stream().filter(StringUtils::isNoneBlank).collect(Collectors.toList());
七、方法引用应用
方法引用简化了 Lambda 表达式书写方式，对于函数式接口实现可以使用方法引用来替换 Lambda，当对 Lambda 掌握后使用方法引用时代码会变得更加简洁、自然 。

大家都知道一个java应用项目可以打包成一个jar，当然你必须指定一个拥有main函数的main class作为你这个jar包的程序入口。
具体的方法是修改jar包内目录META-INF下的MANIFEST.MF文件。
比如有个叫做test.jar的jar包，里面有一个拥有main函数的main class：test.someClassName
我们就只要在MANIFEST.MF里面添加如下一句话：
Main-Class: test.someClassName
然后我们可以在控制台里输入java -jar test.jar即可以运行这个jar。
但是我们这个项目需要引用其他第三方的jar包，在eclipse里面以项目jar包的形式引用了这个叫做some.jar的包，当时放在项目的lib子目录下，最后项目打包时把这个some.jar也打进来了，但是用java -jar执行这个test.jar的时候报找不到Class异常，原因就是jar引用不到放在自己内部的jar包。
那怎么办？
运行时将其加入classpath的方式行不行？就是在运行jar的同时加入classpath参数：
java -classpath some.jar -jar test.jar
这种方式应该能解决问题吧，试一下，还是不行。
查了下资料，原来使用java -jar 命令运行jar包时classpath参数将会失效，所以，这种方式也不行。
那该怎么引用其他的jar包呢，答案还是在这个目录META-INF下的MANIFEST.MF文件中。jar包引用其他jar包的信息必须在这个文件中声明。
我们在MANIFEST.MF中添加如下代码：
Class-Path: lib/some.jar
lib是和test.jar同目录的一个子目录，test.jar要引用的some.jar包就在这里面。
然后测试运行，一切正常！
如果有多个jar包需要引用的情况：
Class-Path: lib/some.jar lib/some2.jar
每个单独的jar用空格隔开就可以了。
总结：不管怎么样，只要想办法在执行test.jar之前把需要引用的jar导入classpath就可以。你甚至可以把需要引用的包都放到jre/lib/ext目录下，这样jvm一启动，这些包就加载了。