很遗憾,因您的浏览器版本过低导致无法获得最佳浏览体验,推荐下载安装谷歌浏览器!

Java当中你可能不知道的10件事

2020-02-11  来自: Java培训 浏览次数:33

java

1、没有被检查的异常

那就对了!JVM不知道任何这样的事情,只有Java语言知道。

您是否想要证明JVM不知道这样的事情?尝试以下代码:

public class Test {

// No throws clause here

public static void main(String[] args) {

doThrow(new SQLException());

}

static void doThrow(Exception e) {

Test. doThrow0(e);

}

@SuppressWarnings("unchecked")

static

void doThrow0(Exception e) throws E {

throw (E) e;

}

}

2.您可以使方法重载仅在返回type上有所不同

那不会编译,对吗?

class Test {

Object x() { return "abc"; }

String x() { return "123"; }

}

对。Java语言不允许两个方法 在同一类中“覆盖等效”,无论它们的throws子句或returntype可能如何不同。

哇,是的,这很有意义。实际上,这几乎就是您编写以下内容时发生的情况:

abstract class Parent {

abstract T x();

}

class Child extends Parent {

@Override

String x() { return "abc"; }

}

在中检出生成的字节码Child:

// Method descriptor #15 ()Ljava/lang/String;

// Stack: 1, Locals: 1

java.lang.String x();

0 ldc [16]

2 areturn

Line numbers:

[pc: 0, line: 7]

Local variable table:

[pc: 0, pc: 3] local: this index: 0 type: Child

// Method descriptor #18 ()Ljava/lang/Object;

// Stack: 1, Locals: 1

bridge synthetic java.lang.Object x();

0 aload_0 [this]

1 invokevirtual Child.x() : java.lang.String [19]

4 areturn

Line numbers:

[pc: 0, line: 1]

java

因此,T实际上只是Object字节码。很好理解。

合成桥方法实际上是由编译器生成的,因为Parent.x()可能期望签名的返回typeObject在某些调用位置。如果没有此类桥接方法,则无法以二进制兼容的方式添加泛型。因此,更改JVM以使其具有此功能的痛苦就较小(这也使协变量重载成为副作用……)聪明吧?

您是否熟悉语言细节和内部知识?

3.所有这些都是二维数组!

class Test {

int[][] a() { return new int[0][]; }

int[] b() [] { return new int[0][]; }

int c() [][] { return new int[0][]; }

}

对,是真的。即使您的心理分析器可能无法立即理解上述方法的返回type,它们也是相同的!与以下代码段相似:

class Test {

int[][] a = {{}};

int[] b[] = {{}};

int c[][] = {{}};

}

你觉得这很疯狂吗?

@Target(ElementType.TYPE_USE)

@interface Crazy {}

class Test {

@Crazy int[][] a1 = {{}};

int @Crazy [][] a2 = {{}};

int[] @Crazy [] a3 = {{}};

@Crazy int[] b1[] = {{}};

int @Crazy [] b2[] = {{}};

int[] b3 @Crazy [] = {{}};

@Crazy int c1[][] = {{}};

int c2 @Crazy [][] = {{}};

int c3[] @Crazy [] = {{}};

}

输入注释。仅凭其力量超越神秘感的设备

换句话说:

当我这样做时,我的四周假期前的后一次提交

我将为您找到上述任何一个用例的实际练习。

4.您没有条件表达式

因此,您认为使用条件表达式时就知道这一切吗?我告诉你,你没有。你们大多数人会认为以下两个片段是等效的:

Object o1 = true ? new Integer(1) : new Double(2.0);

…一样吗?

Object o2;

if (true)

o2 = new Integer(1);

else

o2 = new Double(2.0);

不。让我们进行快速测试

System.out.println(o1);

System.out.println(o2);

该程序将打印:

1.0

1个

java

是的 有条件的运营商将实现数字式的推广,如果“被需要”,对一个非常非常非常强的引号的“需要”。因为,您希望该程序抛出一个NullPointerException

Integer i = new Integer(1);

if (i.equals(1))

i = null;

Double d = new Double(2.0);

Object o = true ? i : d; // NullPointerException!

System.out.println(o);

5.您也没有得到复合赋值运算符

够古怪吗?让我们考虑以下两段代码:

凭直觉,它们应该等效,对吗?但猜猜怎么了。他们不是!JLS指定:

形式为E1 op = E2的复合赋值表达式等效于E1 =(T)(((E1)op(E2))),其中T是E1的type,只是E1仅被评估一次。

这是如此的美丽,我想引用彼得Lawrey的回答这个堆栈溢出问题:

这种转换的一个很好的例子是使用* =或/ =

字节b = 10;

b * = 5.7;

System.out.println(b); //打印57

要么

字节b = 100;

b / = 2.5;

System.out.println(b); //打印40

要么

char ch ='0';

ch * = 1.1;

System.out.println(ch); //打印'4'

要么

char ch ='A';

ch * = 1.5;

System.out.println(ch); //打印'a'

现在,这有多么难以置信?我将在我的应用程序中将字符转换/乘法。因为,你知道...

6.随机整数

现在,这更像是一个难题。尚未阅读解决方案。看看您是否可以自己找到这个。

…然后“有时”,我得到以下输出:

92

221

45

48

236

183

39

193

33

84

7.转到

这是我的爱之一。Java有GOTO!输入...

int goto = 1;

这将导致:

Test.java:44:错误:预期

int goto = 1;

^

java

这是因为goto是一个未使用的关键字,以防万一...

但这不是令人兴奋的部分。令人兴奋的是,你可以真正实现与藤break,continue并标记块:

向前跳

label: {

// do stuff

if (check) break label;

// do more stuff

}

在字节码中:

2 iload_1 [检查]

3 ifeq 6 //向前跳

向后跳

label: do {

// do stuff

if (check) continue label;

// do more stuff

break label;

} while(true);

在字节码中:

2 iload_1 [检查]

3 ifeq 9

6 goto 2 //向后跳

8. Java具有type别名

在其他语言中(例如Ceylon),我们可以非常轻松地定义type别名:

interface People => Set;

People这样构造的type可以与Set以下项互换使用:

People? p1 = null;

Set? p2 = p1;

People? p3 = p2;

Java中,我们不能在顶级定义type别名。但是我们可以在类或方法的范围内这样做。假设我们对Integer,Long等的命名不满意,我们希望使用更短的名称:I和L。简单:

class Test {

void x(I i, L l) {

System.out.println(

i.intValue() + ", " +

l.longValue()

);

}

}

java

在上述程序中,Integer“别名” I用于Test类的范围,而Long“别名” L用于x()方法的范围。然后我们可以像上面这样调用上面的方法:

new Test().x(1, 2L);

当然,这种技术不应被认真对待。在这种情况下,Integer和Long都是终type,这意味着typeI和L是有效的别名(几乎,赋值兼容仅是一种方式)。如果我们使用了非终type(例如Object),那么我们真的会使用普通的泛型。

这些愚蠢的把戏足够了。现在换个真正了不起的东西!

9.一些type关系是不确定的!

好吧,现在这将变得非常时髦,因此可以喝杯咖啡并集中精力。请考虑以下两种type

// A helper type. You could also just use List

interface Type {}

class C implements Type> {}

class D

implements Type>>> {}

现在,做typeC和D甚至是什么意思?

它们有些递归,采用递归的相似(但略有不同)的方式java.lang.Enum。考虑:

public abstract class Enum> { ... }

使用以上规范,实际的enum实现仅仅是语法糖:

// This

enum MyEnum {}

// Is really just sugar for this

class MyEnum extends Enum { ... }

考虑到这一点,让我们回到两种type。以下内容可以编译吗?

class Test {

Type c = new C();

Type> d = new D();

}

C是Type <的子type吗?superC>?

步骤0)C

步骤1)Type >

步骤2)C(检查通配符?superC)

接着:

D是Type <的子type吗?superD >?

步骤0)D >

步骤1)Type >>> >

步骤2)D >>

步骤3)Type >> >

步骤4)D > >>

尝试在Eclipse中编译以上代码,它将崩溃!

10.类型交点

java

Java具有一个非常独特的功能,称为类型交集。您可以声明一个(通用)类型,它实际上是两种类型的交集。例如:

class Test {

}

泛型类型参数T,你绑定的类的实例Test必须实现两个Serializable和Cloneable。例如,String不是可能的界限,而是Date:

// Doesn't compile

Test s = null;

// Compiles

Test d = null;

Java 8中已重用了此功能,您现在可以在其中将类型转换为临时类型的交集。这有什么用?几乎没有,但是如果您想将lambda表达式强制为这种类型,则别无选择。假设您的方法受到这种疯狂的类型约束:

void execute(T t) {}

Runnable还Serializable希望这样做,以防万一您想在其他地方执行它并通过电线发送它。Lambda和序列化有点古怪。

Lambda可以序列化:

如果lambda表达式的目标类型和捕获的参数可序列化,则可以对其进行序列化

但是,即使这是真的,他们也不会自动实现Serializable标记器接口。要强制他们使用这种类型,必须强制转换。但是当你只投给Serializable……

execute((Serializable) (() -> {}));

…然后,lambda将不再可运行。

将其强制转换为两种类型:

execute((Runnable & Serializable) (() -> {}));

更多的java知识学习,请点击下方报名。

java

关键词: java           

Java培训,专营 JAVA培训 JAVA工程师 Java大数据 JAVA就业 JavaEE分布 JAVA框架 等业务,有意向的客户请咨询我们,联系电话:075526075552

CopyRight © 版权所有: Java培训 网站地图 XML


扫一扫访问移动端

在线客服