错误集锦

参考文档1

int类型溢出

PS D:\Document\Java20210111\code\day02> javac .\IdentifierTest.java
.\IdentifierTest.java:4: 错误: 整数太大
                int 学号 = 17180210019;
                         ^

从这两个报错中能看出，Java整型默认是int类型，如果超过int类型就要显示地在数的末尾加L或l表示这是一个long类型的整数

编码错误

命令行默认编码是GBK，而要编译的源文件编码格式为UTF-8，所以会出错

关于三元运算符

Object o1 = true ? new Integer(1) : new Double(2.0);
System.out.println(o1);//1.0 结果是1.0说明了三元运算符自动类型转换这件事。
/*
    三元运算符要求冒号前后两者类型能够统一，
    统一有两种情况：
        要么都是基本数据类型，能够进行自动类型转换
        要么都是引用数据类型，但必须满足子父类关系
    上述语句Integer和Double类显然不是子父类关系，就会进行自动拆箱变成基本数据类型再进行自动类型转换
    得到的结果再自动装箱赋给o1.
*/
Object o2;
if (true)
o2 = new Integer(1);
else
o2 = new Double(2.0);
System.out.println(o2);//1 这就毫无悬念

变量自增又赋给自己

结果i=1；为什么呢？ 先赋值，把i原来的值重新赋值给i，不变，然后i自增，但是这个自增后的值没有在放回变量i的位置

数组打印

这里字符型数组打印出了字符串，很神奇。 其实是方法重载的问题，除了char型外其他基本数据类型数组作为println的参数传进去都是调用println(Object[])方法，而char[]传进去调用的是println(char[])

包装类

public void method1() {
Integer i = new Integer(1);
Integer j = new Integer(1);
System.out.println(i == j);    //flase
Integer m = 1;
Integer n = 1;
System.out.println(m == n);//true
Integer x = 128;
Integer y = 128;
System.out.println(x == y);//false
}

同样的操作，第7行结果是true而第10行结果是false，为什么呢？ 因为Integer类内有个内部静态类IntegerCache，其中缓存了从-128至127的Integer类型数组，当自动装箱的int值在这个范围内时直接指向该数组中对应的包装类对象，而不是在堆中新开辟。 这有点类似于String类直接赋值，但又不太一样

父类与接口属性重名

问题如下：C类继承B实现A，A和B中都有名叫x的属性，问题来了，在C中用x会出现摸棱两可的情况。怎么解决呢？

interface A {
    int x = 0;
}
class B {
    int x = 1;
}
class C extends B implements A {
    public void pX() {
//        System.out.println(x);//The field x is ambiguous
    }

class C extends B implements A {
    public void pX() {
//        System.out.println(x);//The field x is ambiguous
        System.out.println(super.x);    //1
        System.out.println(A.x);        //0
    }

方法重载

package zdkk.test;
/**
 * @author: zdkk
 * @data: 2021/3/25
 * @time: 14:59
 * @package: zdkk.test
     1.8
 */
class MethodReloadDemo
{
    public static void print(int n)
    {
        System.out.println(n);
    }
    public static void print(short n)
    {
        System.out.println(n);
    }
    public static void print(Integer n)
    {
        System.out.println(n);
    }
    public static void print(String s)
    {
        System.out.println(s);
    }
    public static void main(String[] args)
    {
        MethodReloadDemo.print(1);
        MethodReloadDemo.print((byte)1);
        MethodReloadDemo.print("1");
//        MethodReloadDemo.print(null);   //error
    }
}

在第一种情况下，1 是 int。我们有个完全匹配的方法带 int。此时会调用第一个 void print(int n)。
在第二种情况下，我们没有带 byte 的方法。但有两个方法分别带 short 和 int。在类型拓宽规则基础上，byte 会首先拓宽为 short，然后拓宽为 int。因此，判定会调用 void print(short n)。
在第三种情况下，我们有一个完全匹配的方法带 String。此时会调用 void print(String s)。
第四种情况是模棱两可的。null 没有特定类型。编译程序将拒绝编译这个代码。在这种情况下，我们要编写 Cat.print((Integer)null) 来调用第三个方法，并且用 Cat.print((String)null) 来调用第四个方法。

package zdkk.test;
/**
 * @author: zdkk
 * @data: 2021/3/25
 * @time: 15:05
 * @package: zdkk.test
         1.8
 */
public class MethodReloadDemo2 {
    public static void print(Object o)
    {
        System.out.println(o);
    }
    public static void print(String s)
    {
        System.out.println(s);
    }
    public static void main(String[] args)
    {
        MethodReloadDemo2.print(1);                 //调用print(Object o)
        MethodReloadDemo2.print(null);              //调用print(String s)
        MethodReloadDemo2.print((Object) null);     //调用print(Object o)
    }
}