小编Nam*_*man的帖子

我正在尝试使用jshell,但找不到粘贴多行表达式的选项.甚至可以在jshell中粘贴多行.与scala提供的类似paste mode.

在Java 9的模块声明中有2个结构:

exports com.foo;

和

opens com.foo;

凡exports赠款编译时访问,同时opens允许运行时访问,如反射和资源.

opens有一个宽容exports,你可以将整个模块定义为open,结果与显式打开每个包相同:

open module com.mod {

但是没有相似的结构

exported module com.mod {

我的问题:为什么会这样; 有什么决定允许一次打开整个模块而不是出口？

java doc中的ModifierforExports表明了这一点

MANDATED 导出在模块声明的源中隐式声明.

SYNTHETIC 未在模块声明的源中显式或隐式声明导出.

看几个module-info.classes,我可以看到通常有两种类型的用法:

module java.base {
    ...
    exports java.util; // type 1
    exports java.util.concurrent;
    exports java.util.concurrent.atomic;
    exports jdk.internal to jdk.jfr; // type 2
    exports jdk.internal.jmod to
        jdk.compiler,
        jdk.jlink;
    ...
}

在合格的出口做介绍这两种,但没有对枚举类型没有提及.这些是文档中提到的不同类型吗？

Q1.一般来说SYNTHETIC和MANDATED作为在使用调节剂Exports,ModuleDescriptor,Opens和Requires.这两者之间的区别是什么,在实践中优于另一个？

Q2.Synthetic Modifier如果没有在模块的源代码中声明,那么无论如何都是一个例子？

我将Java 8中的maven项目迁移到Java 9项目而没有任何构建工具Eclipse OxyGen 1a.

所以我的module-info.java看起来像这样:

但java.xml.bind不可访问,虽然它在我的模块路径中:

那么这里有什么问题？

我有一个关于线程和回调的一般问题.比方说,我们有一个线程与主程序一起连续运行.

主程序已经在线程中注册了回调函数.所以线程可以随时调用回调函数.通常,我们通过将函数指针传递给线程来注册回调.我想知道线程调用该回调函数的时间,它是该线程的一部分,还是它将成为主程序的一部分.我想知道这个过程的机制,比如当线程调用回调时主程序执行是如何停止或中断的.另一件事是在调用回调时函数调用堆栈将如何表现.

使用IDEA-EAP进行JDK9开发实验.

我收到以下错误 -

Error:(3, 20) java: package jdk.internal.misc is not visible  
(package jdk.internal.misc is declared in module java.base, which does
not export it to module com.jigsaw.npe)

Run Code Online (Sandbox Code Playgroud)

类定义如下 -

package experiment;
import jdk.internal.misc.Unsafe;

public class CompareAndSwap {

    static Unsafe UNSAFE = Unsafe.getUnsafe();
    ...
}

我已经尝试module-info.java在使用IDE创建的模块中包含一个文件,其中包含以下语句 -

module com.jigsaw.npe {
    requires java.base;
}

目录结构现在看起来如图所示 -

IDE虽然反映了module-info.java未使用的,但可能这就是我无法定义module com.jigsaw.npe上面尝试过的原因.

寻求一些帮助,了解如何正确放置module-info.java和/或除了我错过的以外的任何东西.

在将我们的一个项目迁移到Java 9(build 9 + 181)时,我遇到了一个特殊的问题,在类型推断和java模块相关的某些库中看起来像是一个不正确的实现.我使用的是dropwizard-core(1.1.0)和guice(4.1.0)配置如下:

public class CustomService extends io.dropwizard.Application<CustomServiceConfig> {

    public static void main(String[] args) throws Exception {
        new CustomService().run(args);
    }

    // other initializations

    @Override
    public void run(CustomServiceConfig config, io.dropwizard.setup.Environment environment) throws Exception {
        com.google.inject.Injector injector = createInjector(config, environment);
        environment.jersey().register(injector.getInstance(SomeResource.class)); //line 45
        environment.healthChecks().register("DBHealth", injector.getInstance(HealthCheck.class)); 
        environment.servlets().addFilter("Filter-Name", SomeFilter.class)
                .addMappingForUrlPatterns(EnumSet.allOf(DispatcherType.class), true, "/*");
    }


    private com.google.inject.Injector createInjector(CustomServiceConfig config, Environment environment) {
        return com.google.inject.Guice.createInjector(new CustomServiceModule(config, environment));
    }

}

public class CustomServiceModule extends com.google.inject.AbstractModule { …

我正在尝试使用jre 10.0.1 64位启动服务器.Windows启动批处理文件中的JVM设置有明显变化.通过设置-XX:+UseParNewGC 作为错误的参考点,为了使JVM服务器从java 10开始,而不是我已经显示的java 8设置,需要将其更改为什么？

导致错误引用的代码行是:

set JAVA_PARAMETERS=-XX:+UseParNewGC -XX:+CMSIncrementalPacing -XX:+CMSClassUnloadingEnabled -XX:ParallelGCThreads=2 -XX:MinHeapFreeRatio=5 -XX:MaxHeapFreeRatio=10

我一般对Java-11感到好奇,但特别是JEP:323计划将var声明添加到Lambda操作变量.

这个功能背后的动机在这里很好地讨论.请考虑以下文章中的引用:

// #1 - Legal
ITest divide = (@ATest var x, final var y) ->  x / y;
/* #2 Modifiers on Old-Style implicit paramaters => Illegal */
ITest divide = (@ATest x, final y) ->  x / y;

最终修饰符的使用对我来说很清楚,并且符合不变性最佳实践.

但是,我不确定注释.能够注释lambda隐式参数有什么好处？

你能提供一个在lambda操作变量上使用注释的事实上的有益例子吗？这不是一个意见问题,而是作为使用此功能时更具可读性或效率的代码的实际示例.

这有什么目的吗 static @NotNull @Other My.@NotNull @Other Builder createBuilder()

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

public class A {
    static class My {
        static class Builder {
            public My build() {
                return new My(); } } }

    @Target({ElementType.METHOD, ElementType.TYPE_USE})
    public @interface NotNull { }

    @Target({ElementType.METHOD, ElementType.TYPE_USE})
    public @interface Other { }

    public static @NotNull @Other My.@NotNull @Other Builder createBuilder() {
        return new My.Builder();
    }
}