leftso 353 0 2019-04-12 09:39:06

文章位置:左搜> 编程技术> 正文

一.前言

java 初学者常见十大潜在错误讲解

主要是针对一些因习惯或者初心导致的问题进行汇总讲解。
 

二.错误举例

2.1赋值 还是 比较 (= 与 ==)

这是从头开始学习Java的学生的第一个错误之一。很容易混淆= =是赋值运算符而==是关系运算符。这是自然的错误,因为在数学中“=”更接近Java的“ == ”,而不是Java的“=”。通常编译器会捕获这样的错误,但是它们可能会被隐藏起来。例如:
boolean myBoolean; 
if (myBoolean = true) {
doSomething; 
} 
看到没?无论如何,这个块都是真的,因为你将它指定为真...并且IED工具不会报红色的编译错误,这个容易给跪吧。哈哈

2.2使用==运算符比较字符串

在您完成第一个Java任务(通常有一些控制台输出和算术问题)之后的一段时间,您将学习String类。然而,初学者经常忘记特定字符串不是像char或int这样的基本类型的代表,它是一个对象。您无法使用==运算符比较对象。请记住使用string.equals(Object object)函数来比较字符串(或其他对象),而不是==运算符。Equals检查字符串的内容,而==操作符检查对象的引用是否相等。
老实说,字符串常量通常是“实习”。这意味着可以实际比较具有相同值的两个常量==,但实际上并不依赖于它。使用.equals。

2.3Class 的名称与Java文件不同名

这个错误在几年前非常受欢迎(甚至可能是所有人的领导者)。现在即使是初学者也使用现代IDE,它已经濒临灭绝。无论如何,记住在Java文件名和类名应该是相同的是有用的。如果你命名你的文件,例如,Test.java并在那里写一些CodeGymTest类代码:
$title(Test.java)
//File name: Test.java 
 
public class CodeGymTest { 
   public static void main(String[] args) { 
        System.out.println("Hello world"); 
   } 
}
你会得到下一个输出:
Test.java:9: error: class CodeGymTest is public, should be
                    declared in a file named CodeGymTest.java
public class CodeGymTest 
^
1 error
顺便说一句,如果 从类名中删除public修饰符,程序将运行。 

2.4从main方法或其他静态方法访问非静态成员

初学者通常不知道如何使用静态上下文。静态变量是类的所有实例之间共享的变量。因此,只有一个副本由所有对象共享。所以我们不能以“静态方式”使用非静态变量。这个错误通常发生在main()method (which is static!), when novice programmer attempts访问实例变量或方法中。如果您尝试这样的代码
public class MyExample {
    public String myString;  
 
public static void main(String[] args) {
        myString = “non static String”;    
}
  }
我们有编译错误:
on-static variable number cannot be referenced from a static context
我们该怎么做才能避免这种情况?首先,我们可以将变量设为静态,但它并不总是符合程序目的。其中一个解决方案是创建我们类的对象:
public class MyExample {
    public String myString;  
 
public static void main(String[] args) {
MyExample myExample = new myExample(); 
 
        myString = “non static String”;    
}
  }
请记住,您可以使用静态或非静态上下文中的静态变量或方法。您可以使用对象引用处理非静态元素。

2.5数组索引超出数组边界

这是初学者编程学生中非常流行的错误。这种普及的原因是,最初或多或少复杂的任务是关于阵列和周期。很简单的例子:
String[] name = { "Snoopy", "Woodstock", "Charlie Brown" };
for (int i = 0; i <= name.length; i++) {
    System.out.println(name[i]);
}
循环从零元素“史努比”开始,然后转到第一个“伍德斯托克”和第二个“查理布朗”......并尝试打印第三个元素,但我们没有它(我们的“第三个”是一个“第二”如“第一”是数字零)。这里的错误非常明显,但并不总是这样。 
 

2.6在循环或条件中输出“;”错误

在下面的块中,您不打印阵列的任何成员。首先,循环以“;”结束,所以没有任何反应。更重要的是:程序无法工作,因为你的int只能在循环内部工作,并以“;”结束。 

public static void main(String[] args)  {
 
            int [] myArray = {2,5,7};
            for (int i=0; i<3; i++);
            {
                System.out.println(myArray[i]);
            }
        }   
如果您尝试这样的事情:
public static void main(String[] args)  {
 
            int [] myArray = {2,5,7};
            int i = 0;
 
            for (i=0; i<3; i++);
            {
                System.out.println(myArray[i]);
            }
        } 
你有java.lang.ArrayIndexOutOfBoundsException,因为System.out.println试图打印元素#3而只有这个,但是我们没有这样的数组成员。最后一个是第二个,它是7。 
同样的故事和条件。例如:
public static void main(String[] args)  {
 
            int [] myArray = {2,5,7};
           if (myArray[0] > myArray[1]);
            System.out.println("it is");
        }
    }
这里的条件不满意,但是“它是”将被打印,因为“;”如果构造。 

2.7缺少Switch-Case结构中的'break'关键字

关于错过“break”关键字的尴尬之处在于没有编译器错误。但是,您的代码工作方式错误。
看下面的代码示例,我们忘了在“case 0”中放置一个中断。该程序将工作,但它打印“0”和“1”,因为开关构造结束其工作与休息。
public static void switchCasePrimer() {
        int counting = 0;
 
        switch (counting) {
            case 0:
                System.out.println("0");
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            default:
                System.out.println("Default");
        }
}
这条规则有例外。切换块可以使用返回运算符完成其工作
public class test {
    public static void main(String[] args) {
        System.out.println(showSwitch(1));
    }
 
    public static int showSwitch(int condition) {
        switch (condition) {
            case 1:
                System.out.println(1);
                return 1;
            case 2:
                System.out.println(2);
                return 4;
            case 3:
                System.out.println(3);
                return 8;
            default:
                System.out.println("default");
                return 256;
        }
    }
}
在这种情况下,交换机在案例1之后立即完成其工作。

2.8通过值传递并通过引用传递

如果将基本数据类型(例如char,int或double)传递给方法,则会传递值。这意味着数据类型的副本将被复制并传递给您的方法。如果在方法内修改了该数据,则对方法外的“原始”数据没有影响。
public class Main {
 
    public static void swap(int i, int j)
    {
        int temp = i;
        i = j;
        j = temp;
        System.out.println("from swap method i = " + i + ", j = " + j);
    }
 
 
    public static void main(String[] args) {
 
 
        int i1 = 1;
        int j1 = 2;
        swap(i1,j1);
        System.out.println("from main method i = " + i1 + ", j = " + j1);
 
    }
}

将Java对象(例如,数组或字符串)传递给方法时,这意味着您传递的是引用(数据的地址),而不是重复。因此,如果您更改方法中的数据,它也将在其外部更改。
public class Main {
 
    static int[] outer = new int[3];
 
    public static void swap(int[] array) {
        System.out.println("(swap) Before swap :" + Arrays.toString(array));
        int first = array[0];
        int last = array[array.length - 1];
        array[0] = last;
        array[array.length - 1] = first;
        System.out.println("(swap) After swap :" + Arrays.toString(array));
    }
 
 
    public static void main(String[] args) {
        outer[0] = 0;
        outer[1] = 1;
        outer[2] = 2;
 
        swap(outer);
 
        System.out.println("(main) After swap :" + Arrays.toString(outer));
    }

2.9尝试使用未初始化的字段或变量

在没有初始化的情况下使用对象类型非常危险。
类变量由默认值初始化(0表示int,0.0表示double,false表示布尔值,null表示非基本类型(对象)。
public class Test2 {
    static String test;
 
    public static void main(String[] args) {
      
     System.out.println(test);
    }
}
输出是:
Null
使用本地方法变量时,需要手动初始化它们,否则会出现编译错误。
public class Test2 {
 
    public static void main(String[] args) {
        String test2;
     System.out.println(test2);
    }
}
输出是:
Error:(6, 28) java: variable test2 might not have been initialized  

2.10忘记整数除法

如果将一个int除以另一个int,则会再次获得int。所以½= 0,在这种情况下不是0.5:
public static void main(String[] args) {
 
        int i = 1;
        int j = 2; 
  int k = i/j;  
  } 

2.11在Child对象中调用构造函数的顺序

当您尝试创建Child类的实例时,首先调用Child,然后调用Parent。父子关系中构造函数执行的顺序从基本(父)类到继承(子)构建。
public class Test3 {
    static class Parent {
        Parent() {
            System.out.println("a Parent is created");
        }
    }
    static class Child extends Parent {
        Child(){
            System.out.println("a Child is created");
        }
    }
 
    public static void main(String[] args) {
        Child child = new Child();
    }
}

输出
a Parent is created
a Child is created