Java程序基础错误

Posted 2023-02-15

下面是我的源程序，在eclipse环境下编写的，是在教材上抄写的程序，为什么会编译出错呢，我核对了没有书写错误：

public class Book

public static void main(String[] args)
// TODO 自动生成的方法存根
private String name;

public String getName()
int id = 0;
setName("Java");
return id + this.name;


private void setName(String name)
this.name = name;


public Book getName()
return this;






描述 资源 路径 位置 类型
参数 name 的修饰符不合法；只允许使用终态 Book.java /Book/src 第 6 行 Java 问题
语法错误，将“enum Identifier”插入到完整 EnumHeaderName 中 Book.java /Book/src 第 8 行 Java 问题
标记“String”上有语法错误，应为 @ Book.java /Book/src 第 8 行 Java 问题
语法错误，将“EnumBody”插入到完整 BlockStatement 中 Book.java /Book/src 第 18 行 Java 问题
不能实例化类型 UseCase3 UseCase3.java /10.11/src/com/lzw 第 6 行 Java 问题
标记“(”上有语法错误，应为 ; Book.java /Book/src 第 14 行 Java 问题
语法错误，将“EnumBody”插入到完整 BlockStatement 中 Book.java /Book/src 第 8 行 Java 问题
语法错误，将“enum Identifier”插入到完整 EnumHeaderName 中 Book.java /Book/src 第 18 行 Java 问题
条件操作数类型 Quadrangle 和 Anything 不兼容 Parallelogram.java /10.06/src 第 27 行 Java 问题
标记“Book”上有语法错误，应为 @ Book.java /Book/src 第 18 行 Java 问题
标记“)”上有语法错误，应为 ; Book.java /Book/src 第 14 行 Java 问题

我想是LZ你抄错了吧。。 不可能有一本书这么糟糕的。。。如果lz你的书的确是这样写。。估计也是盗版的或者别的啥原因。。

换本吧。。

 

LZ你的代码有很多错。。比如，方法里嵌套方法，方法名相同..... 

 

 

正确的代码应该是这样的

 

//定义一个Book类

class Book

    private String name;    //Book的名字
    static int id = 0;    //Book的id，id应该是静态的。因为你下面要输出每本书的id号

    public String getName()     //取得Book的名字
   
        id++;     //id号自加
        setName("Java");    //设置Book的名字为“Java”
        return id + " --" + this.name;    //返回id号和书本的名字（用一个+号，意思是把整数和字符串2个值进行拼接。。）
   

 

    private void setName(String name)    //设置Book的名字
   
        this.name = name;
   

 
    public Book getNames()    //返回调用这个方法的对象
   
        return this;
   

 

public class Test

    public static void main(String args[])
   
        Book book = new Book();    //实例化一个Book的对象
        System.out.println( book.getName() );    //用book这个对象去调用方法并打印出来getName()

   

 

 

运行结果：

 

如有不懂。。可以追问。。。

望采纳

参考技术A 1.将数组转化为列表
将数组转化为一个列表时，程序员们经常这样做：
List<String> list = Arrays.asList(arr);

Arrays.asList()会返回一个ArrayList对象，ArrayList类是Arrays的一个私有静态类，而不是java.util.ArrayList类，java.util.Arrays.ArrayList类有set()、get()、contains()方法，但是没有增加元素的方法，所以它的大小是固定的，想要创建一个真正的ArrayList类，你应该这样做:
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));

ArrayList的构造方法可以接受一个集合类型，刚好它也是java.util.Arrays.ArrayList的超类。
2.判断一个数组是否包含一个值
程序员们经常这样做:
Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);

这段代码起作用，但是没有必要把一个数组转化成列表，转化为列表需要额外的时间。它可以像下面那样简单:

Arrays.asList(arr).contains(targetValue);

或者是:
for(String s:arr)
if(s.equals(targetValue))
return true;


return false;

第一种方法比第二种更容易读
3.在一个循环中删除一个列表中的元素
思考下面这一段在循环中删除多个元素的的代码
ArrayList<String> list = new ArrayList<String>(Arrays.asList("a","b","c","d"));
for(int i=0;i<list.size();i++)
list.remove(i);

System.out.println(list);

输出结果是:
[b,d]

在这个方法中有一个严重的错误。当一个元素被删除时，列表的大小缩小并且下标变化，所以当你想要在一个循环中用下标删除多个元素的时候，它并不会正常的生效。
你也许知道在循环中正确的删除多个元素的方法是使用迭代，并且你知道java中的foreach循环看起来像一个迭代器，但实际上并不是。考虑一下下面的代码:
ArrayList<String> list = new ArrayList<String>(Arrays.asList("a","b","c","d"));
for(String s:list)
if(s.equals("a"))
list.remove(s);



它会抛出一个ConcurrentModificationException异常。
相反下面的显示正常：
String> list = new ArrayList<String>(Arrays.asList("a","b","c","d"));
Iterator<String> iter = list.iterator();
while(iter.hasNext())
String s = iter.next();
if(s.equals("a"))
iter.remove();



.next()必须在.remove()之前调用。在一个foreach循环中，编译器会使.next()在删除元素之后被调用，因此就会抛出ConcurrentModificationException异常，你也许希望看一下ArrayList.iterator()的源代码。
4.Hashtable与HashMap的对比
就算法而言，哈希表是数据结构的一个名字。但是在java中，这个数据结构的名字是HashMap。Hashtable与HashMap的一个重要不同点是Hashtable是同步的。所以你经常不需要Hashtable,相反HashMap经常会用到。
HashMap vs. TreeMap vs. Hashtable vs. LinkedHashMap
Top 10 questions about Map
5.在集合中使用原始类型
在Java中原始类型与无界通配符类型很容易混合在一起，拿Set来说，Set是一个原始类型，而Set<?>是无界的通配符类型。
考虑下面使用原始类型List作为参数的代码:
public static void add(List list,Object o)
list.add(o);

pulbic static void main(String[] args)
List<String> list = new ArrayList<String>();
add(list,10);
String s = list.get(0);

这段代码会抛出一个异常：
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at ...

使用原生类型集合是危险的，这是因为原生类型集合跳过了泛型类型检查，并且不是安全的，在Set、Set<?>和Set<Object>中有很大的不同，具体请看Raw type vs. Unbounded wildcard和Type Erasure。
6.访问级别
程序员们经常使用public作为类字段的修饰符，可以很简单的通过引用得到值，但这是一个坏的设计，按照经验，分配给成员变量的访问级别应该尽可能的低。
public, default, protected, and private
7.ArrayList与LinkedList的对比
当程序员们不知道ArrayList与LinkedList的区别时，他们经常使用ArrayList，因为它看起来比较熟悉。然而，它们之前有巨大的性能差别。简而言之，如果有大量的增加删除操作并且没有很多的随机访问元素的操作，应该首先LinkedList。如果你刚接触它们，请查看 ArrayList vs. LinkedList来获得更多关于它们性能的信息。
8.可变与不可变
不可变对象有许多的优点，比如简单，安全等等。但是对于每一个不同的值都需要一个独立的对象，太多的对象可能会造成大量的垃圾回收。当选择可变与不可变时应该有一个平衡。
一般的，可变对象用来避免产生大量的中间对象。一个典型的例子是连接大量的字符串。如果你用一个不可变的字符串，你会产生很多需要进行垃圾回收的对象。这很浪费CPU的时间，使用可变对象是正确的解决方案(比如StringBuilder)。
String result="";
for(String s: arr)
result = result + s;


有时在某些情况下也是需要可变对象的，比如将可变对象作为参数传入方法，你不用使用很多语句便可以得到多个结果。另外一个例子是排序和过滤：当然，你可以写一个方法来接收原始的集合，并且返回一个排好序的集合，但是那样对于大的集合就太浪费了。(来自StackOverFlow的dasblinkenlight’s的答案)
Why String is Immutable?
9.父类与子类的构造函数

这个编译期错误的出现是父类默认的构造方法未定义，在java中，如果一个类没有定义构造方法，编译器会默认的为这个类添加一个无参的构造方法。如果在父类中定义了构造方法，在这个例子中是Super(String s),编译器就不会添加默认的无参构造方法，这就是上面这个父类的情形。
子类的构造器，不管是无参还有有参，都会调用父类的无参构造器。因为编译器试图在子类的两个构造方法中添加super()方法。但是父类默认的构造方法未定义，编译器就会报出这个错误信息。
想要修复这个问题，可以简单的通过1)在父类中添加一个Super()构造方法，像下面这样：
public Super()
System.out.println("Super");


或者2)移除父类自定义的构造方法，或者3)在子类的构造方法中调用父类的super(value)方法。
Constructor of Super and Stub
10.”"还是构造器
有两种方式可以创建字符串
//1.使用字符串
String x = "abc";
//2.使用构造器
String y = new String("abc");

有什么区别？
下面的例子会给出一个快速的答案:
String a = "abc";
String b = "abc";
System.out.println(a==b);//true
System.out.println(a.equals(b));//true

String c = new String("abc");
String d = new String("abc");
System.out.println(c==d);//false
System.out.println(c.equals(d));//true

关于它们内存分配的更多信息，请参考Create Java String Using ” ” or Constructor?. 参考技术B 1，isStupidName方法为抽象方法，没有方法体；
2，I的值无法确定
3，抽象方法必须被重写，不能是私有的
4，final修饰的变量只能被赋值一次，++x会出错
5，因为形参为引用类型，没错
6，没错
7，final修饰的变量不能默认初始化，必须显示初始化
8，doSomeing需要static修饰
9，虽然没错，但是类名和main函数所在的类名必须一致，此类和main方法需是public 参考技术C 你的思路有点乱，我帮你把程序调整了一下，还望采纳
public class Book

private String name;
public String getName1()
int id = 0;
setName("Java");
return id + this.name;

private void setName(String name)
this.name = name;

public Book getName()
return this;

public static void main(String[] args)
Book a=new Book();
System.out.println(a.getName());
System.out.println(a.getName1());


本回答被提问者采纳 参考技术D public class Book

public static void main(String[] args)


// TODO 自动生成的方法存根
private String name;
public String getName1()
int id = 0;
setName("Java");
return id + this.name;

private void setName(String name)
this.name = name;

public Book getName()
return this;


以上为修改后程序。源程序错误有二，第一main()方法右半边大括号所在位置不对，第二，有两个getName()方法

Java基础-异常断言

处理错误

如果Java程序运行期间出现了错误，并且由于出现错误导致某些操作没有完成，程序应该能够返回到一种安全状态，并能够让用户执行一些其他的命令；或者允许用户保存所有操作结果，并以妥善的方式终止程序。
其中错误的来源可能有以下几种：
1.用户输入错误
例如：程序定义输入为int，但是用户输入了String。
2.设备错误
例如：网络设备损坏。
3.物理限制
例如：存储空间占满。
4.代码错误
例如：程序方法返回了错误的结果。

异常

定义：Java代码在运行期间发生的问题就是异常。在Java程序设计语言中，Throwable类是所有错误和异常的超类，异常对象都是派生于Throwable类的一个实例。
Java异常层次的简化示意图：

所有的异常都是由Throwable继承而来，在下一层分解为两个分支：Error和Exception。
Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误，应用程序不应该抛出这种类型的对象。
Exception层析结构又分为两个分支：

• Runtime Exception：由程序错误导致的异常。
• 其他异常：程序本身没有问题，但是由于像I/O错误（IOException）这类问题导致的异常。

注意：
Error这种内部错误，编译时不会出现，一旦出现错误，除了通告用户，并尽量使程序安全地终止制外，无法针对处理，只能修正代码，使得程序符合系统资源要求等。
Exception这种异常，可以针对抛出的具体异常进行针对性处理。一般编写程序时，重点关注异常。
异常的创建和抛出过程：

• JVM创建异常对象。
• 将异常对象抛出给方法的调用者，一旦异常被抛出了，后面的所有程序都不再执行。

Java语言规范将派生于Error或RuntimeException类的所有异常称为非受查异常，所有其他的异常称为受查异常。编译器将核查是否为所有的受查异常提供了异常处理器。

抛出异常throw

在编写程序时，必须考虑程序出现问题的情况。
例如：在定义方法时，方法需要接受参数。那么，当调用方法使用接收到的参数时，首先需要先对参数数据进行合法的判断，参数若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。
在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。
throw用在方法内，用来创建并抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行，格式如下：

  1 throw new 异常类名(参数);

示例代码如下：

  1 public static void main(String[] args) throws Exception {
  2 
  3     int[] arr = null;
  4     int i = getArray(arr);
  5     System.out.println(i);
  6 }
  7 
  8 public static int getArray(int[] arr) throws Exception {
  9 
 10     if(arr == null){
 11         throw new Exception("数组为null");
 12     }else if(arr.length == 0){
 13         throw new Exception("数组中无元素");
 14     }else {
 15         int i = arr[arr.length - 1];
 16         return i;
 17     }
 18 
 19 }

在getArray方法中，当整型数组arr为null或为空时，使用throw关键字new一个异常对象。

throws子句

方法应该在其首部声明所有可能抛出的异常，如果方法内通过throw抛出了编译时的异常，而没有捕获并处理，那么必须通过throws关键字进行声明，让调用者去处理，声明格式武如下：

  1 修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2… {   }

throws用于方法进行异常类的声明上，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。
示例代码中getArray和main方法都在后面使用throws关键字，逐层往上抛给调用者去处理该异常。

  1 public static void main(String[] args) throws Exception {
  2     ......
  3 }
  4 
  5 
  6 public static int getArray(int[] arr) throws Exception {
  7     ......
  8 }

在编写方法时，不必将所有可能抛出的异常都进行声明，下面列举应该抛出异常的情况：

• 调用一个抛出受查异常的方法。
• 程序运行过程中发现错误，并且利用throw语句抛出一个受查异常。
• 程序出现错误。
• Java虚拟机和运行时库出现的内部错误。
  

捕获异常（try/catch）

当某个异常发生时，没有在任何位置进行捕获，程序就会终止执行，并在控制台上打印出异常信息，其中包括异常的类型和堆栈的内容。
要想捕获异常，必须设置try/catch语句块，格式如下：

  1 try {
  2     //被检测的代码
  3     //可能产生异常的代码
  4 }
  5 catch(异常类 变量) {
  6     //异常的处理代码语句
  7 }

 

• try：该代码块中编写可能产生异常的代码。
• catch：用来进行某种异常的捕获，编写异常处理代码，实现对捕获到的异常进行处理。

如果在try语句中的任何代码抛出了一个在catch子句中说明的异常类：
1. 程序将跳过try语句块的其余代码。
2. 程序将执行catch子句中的处理器代码。

捕获多个异常
在一个try语句块中可以捕获多个异常，并对不同类型的异常做出不同的处理。

  1 try {
  2     //被检测的代码
  3     //可能产生异常的代码
  4 }
  5 catch(异常类1 变量) {
  6     //异常的处理代码语句
  7 }
  8 catch(异常类2 变量) {
  9     //异常的处理代码语句
 10 }
 11 ......

捕获多个异常不仅会让代码看起来更简单，还会更高效。
多catch使用条件：

• 彼此之间不存在子类关系，多catch时没有顺序影响。
• 彼此之间存在子类关系，多catch时有顺序影响，应该先catch子类异常，再逐级catch超类异常（原因在于多态）。

try/catch示例代码如下：

  1 public static void main(String[] args) {
  2     int[] arr = {1,2,3};
  3     try {
  4         int i = getArray(arr);
  5         System.out.println(i);
  6     }catch (NullPointerException ex){
  7         System.out.println(ex + " ,捕获到空指针异常");
  8     }catch (ArrayIndexOutOfBoundsException ex){
  9         System.out.println((ex + " ,捕获到数组越界异常");
 10     }
 11     System.out.println("程序继续执行！");
 12 }
 13 
 14 public static int getArray(int[] arr) {
 15 
 16     int x = 5;
 17     if (arr == null) {
 18         throw new NullPointerException("数组为null");
 19     } else if (arr.length < x) {
 20         throw new ArrayIndexOutOfBoundsException("数组越界");
 21     } else {
 22         return arr[5] + 1;
 23     }
 24 
 25 }

finally代码块

当代码抛出一个异常时，就会终止方法中剩余代码处理，并退出这个方法的执行。如果方法获得了一些本地资源，并且只有该方法自己知道，当方法退出前这些资源必须被回收，就会产生资源回收问题。
解决方式有两种：

• 一种是捕获并重新抛出所有的异常。
• 另一种是使用finally子句。

finally
有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
上文示例代码的一部分：

  1 try {
  2     int i = getArray(arr);
  3     System.out.println(i);
  4 } catch (NullPointerException ex) {
  5     System.out.println(ex + " ,捕获到空指针异常");
  6 } catch (ArrayIndexOutOfBoundsException ex) {
  7     System.out.println(ex + " ,捕获到数组越界异常");
  8 } finally {
  9     System.out.println("必须执行的代码，用以释放资源！");
 10 }
 11 ......

运行时期异常

RuntimeException和他的所有子类异常,都属于运行时期异常。
运行时期异常的特点：

• 方法中抛出运行时期异常,方法定义中无需throws声明,调用者也无需处理此异常。
• 运行时期异常一旦发生,需要程序人员修改源代码。

特点一就是上文两段完整的示例代码不同的原因。
NullPointerException,ArrayIndexOutOfBoundsException等都属于运行时期异常，因此不需要throws声明。
Exception不属于运行时期异常，因此需要throws声明。

继承关系抛出异常

超类的方法如果抛出异常，子类覆盖超类方法时：

• 可以不抛出异常。
• 也可以抛出超类相同的异常，或着超类异常的子类异常。

超类的方法如果没有抛出异常，子类覆盖超类方法时：

• 不能抛出异常。
• 当子类方法调用了抛出异常的方法时，别无选择，只能try/catch。
  

自定义异常

通过阅读异常源代码：发现java中所有的异常类，都是继承Throwable，或者继承Throwable的子类。这样该异常才可以被throw抛出。
说明这个异常体系具备一个特有的特性：可抛性：即可以被throw关键字操作。
并且查阅异常子类源码，发现每个异常中都调用了超类的构造方法，把异常描述信息传递给了超类，让超类帮助进行异常信息的封装。
例如：NullPointerException异常类源代码：

  1 public class ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException {
  2      private static final long serialVersionUID = -5116101128118950844L;
  3 
  4     /**
  5      * Constructs an <code>ArrayIndexOutOfBoundsException</code> with no
  6      * detail message.
  7      */
  8      public ArrayIndexOutOfBoundsException() {
  9          super();
 10      }
 11 
 12     /**
 13      * Constructs a new <code>ArrayIndexOutOfBoundsException</code>
 14      * class with an argument indicating the illegal index.
 15      *
 16      * @param   index   the illegal index.
 17      */
 18     public ArrayIndexOutOfBoundsException(int index) {
 19        super("Array index out of range: " + index);
 20     }
 21 
 22     /**
 23      * Constructs an <code>ArrayIndexOutOfBoundsException</code> class
 24      * with the specified detail message.
 25      *
 26      * @param   s   the detail message.
 27      */
 28     public ArrayIndexOutOfBoundsException(String s) {
 29         super(s);
 30     }
 31 }

通过查询JDK API 1.8可以看到继承关系如下：

由此可知，自定义异常类的格式如下：

  1 Class 异常类名 extends RuntimeException{
  2     public 异常类名(){
  3     }
  4     public 异常类名(String s){
  5        super(s);
  6    }
  7 }

自定义异常类的超类通常是RuntimeException，也可以是Exception等。
定义Person类，如果年龄age小于0或者大于150岁，抛出AgeWrongException异常，示例代码如下：
Person类代码：

  1 public class Person {
  2     private String name;
  3     private int age;
  4 
  5     public Person(String name, int age) throws AgeWrongException {
  6 
  7         int maxAge = 150;
  8         if (age < 0 || age > maxAge) {
  9             throw new AgeWrongException("Age信息错误！");
 10         } else {
 11             System.out.println("Age :" + age);
 12         }
 13         this.name = name;
 14         this.age = age;
 15     }
 16 
 17     @Override
 18     public String toString() {
 19         return "Person{" +
 20                 "name=‘" + name + ‘\\‘‘ +
 21                 ", age=" + age +
 22                 ‘}‘;
 23     }
 24 }

自定义异常AgeWrongException类代码：

  1 public class AgeWrongException extends Exception{
  2     public AgeWrongException(){
  3         super();
  4     }
  5 
  6     public AgeWrongException(String message){
  7         super(message);
  8     }
  9 }

测试类代码：

  1 public class AgeWrongExceptionTest {
  2     public static void main(String[] args) {
  3         try {
  4             Person person = new Person("Dcl_Snow", 300);
  5             System.out.println(person);
  6         } catch (AgeWrongException e) {
  7             System.out.println(e + "Age数值非法！");
  8         }
  9     }
 10 }

如果自定义异常类继承的是RuntimeException，则throws子句和try/catch都可省略。

使用异常机制的技巧

1. 异常处理不能代替简单的测试。
2. 不要过分的细化异常。
3. 利用异常的层次结构，不要只抛出RuntimeException异常，应该寻找更加适当的子类或自定义的异常类。
4. 不要压制异常，不要强烈的倾向于关闭异常，如果认为异常非常重要，就应该进行处理。
5. 在检查错误时，“苛刻”要比放任更好。
6. 不要羞于传递异常，不要只倾向于捕获异常，有时候让高层次的方法通知用户发生了错误，或者放弃不成功的命令会更加适宜。

断言

断言机制允许再测试期间向代码中插入一些检查语句。当代码发布时，这些插入的检查语句将会被自动移走。Java语言的断言引入关键字assert，格式如下：

  1 assert 条件;

 

  1 assert 条件 : 表达式;

两种方式都会对条件进行检测，如果结果为false，则抛出一个AssertionError异常。在第二种形式中，表达式会被传入AssertionError的构造器中，并转换成一个消息字符串。
注意：
“表达式”部分唯一的目的就是产生一个消息字符串。AssertionError对象并不存储表达式的值，因此并不能在以后得到它。
例如：要想断言x时一个非负数值：

  1 assert x >= 0;

或者将x的实际值传递给AssertionError对象，从而可以在后面显示出来：

  1 assert x >= 0 : x;

启用和禁用断言

默认情况下，断言被禁用，可以在运行程序时用-enableassertions或-ea选项启动：

  1 java -enableassertions MyApp

也可以在某个类或整个包中使用断言：

  1 java -ea:MyClass -ea:com.xxx.yyy...

这条命令开启MyClass类和com.xxx.yyy包及其子包中所有的类的断言。
禁用断言，使用-disableassertions和-da选项。
-ea和-da选项不能应用于那些没有类加载器的“系统类”，对于系统类来说，使用-enablesystemassertions或-esa选项启用断言。
使用断言的时机：

• 断言失败时致命的、不可恢复的错误。
• 断言检查只用于开发和测试阶段。

因此不应该使用断言向程序的其他部分通告发生了可恢复性的错误，或者不应该作为程序向用户通告问题的手段。断言只应该用于在测试阶段确定程序内部的错误位置。

IntelliJ IDEA设置启用断言

打开IntelliJ IDEA，创建一个断言测试类：

  1 public class AssertTest {
  2     public static void main(String[] args) {
  3         int x = 1;
  4         int y = 2;
  5         assert x > y;
  6         System.out.println(x + y);
  7     }
  8 }

此时执行程序，打印输出结果3，不会报任何异常。
然后点击IntelliJ IDEA主界面右上角的下拉箭头，选择“Edit Configurations...”：

打开配置界面：

此时左侧时选择需要启用断言的类，默认是刚刚创建的AssertTest类在选项“VM oprions:”中填写“-ea”：

启用断言即完成，此时执行程序报出断言异常。