首页手记 Java教程：新手入门到初级实战

Java教程：新手入门到初级实战

标签：

Java

概述

本文全面介绍了Java编程的基础知识，从环境搭建到基础语法，再到面向对象编程和异常处理，帮助读者快速入门。文章详细讲解了如何安装Java开发环境、配置IDE、声明变量、使用控制结构和操作数组与字符串。此外，还涉及了输入输出操作和实战项目，通过这些内容，读者可以系统地掌握Java编程技能。文中提供的Java教程涵盖了从入门到进阶的各个方面。

Java简介与环境搭建

Java语言简介

Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年推出。Java的设计目标之一是“编写一次，到处运行”，这意味着Java程序可以在任何支持Java虚拟机（Java Virtual Machine, JVM）的平台上运行。Java语言具备平台无关性、安全性和强大的网络功能，因此被广泛用于开发跨平台应用程序、Web应用、企业级应用等。

Java语言具有以下几个主要特点：

简单易学：Java语法简单，易于学习和使用。
面向对象：Java完全支持面向对象编程，使代码复用性更强。
跨平台：Java程序可以在任何安装了Java虚拟机的操作系统上运行。
自动内存管理：Java使用垃圾回收机制自动管理内存，减少了内存泄漏的风险。
丰富的库支持：Java拥有庞大的标准库，提供了广泛的函数和对象供开发者使用。
安全性高：Java内置的安全机制，特别适合用于网络环境和电子商务领域。
多线程支持：Java内置了多线程机制，支持并发执行。
动态性：Java支持动态加载类，可以根据需要动态加载和使用类。

Java的应用领域非常广泛，包括但不限于Web应用开发、企业级应用、Android应用开发、游戏开发等。

安装Java开发环境

安装Java开发环境包括安装Java开发工具包（Java Development Kit，JDK）和配置开发工具（如Eclipse或IntelliJ IDEA）。JDK是最基本的开发环境，包含编译、运行和调试Java程序所需的所有工具。以下是安装过程的详细步骤：

下载JDK
访问Oracle官方网站下载页面（https://www.oracle.com/java/technologies/javase/javase-jdk-archive-downloads.html）下载最新版本的JDK。
安装JDK
下载后运行安装文件，按照提示完成安装。默认情况下，JDK会被安装在以下目录：
- Windows: C:\Program Files\Java\jdk-<version>
- Linux: /usr/lib/jvm/java-<version>-openjdk
配置环境变量
安装完成后，需要配置环境变量才能使用Java命令。
- Windows:
  1. 右键点击“此电脑”或“计算机”，选择“属性”。
  2. 点击“高级系统设置”。
  3. 在“系统属性”窗口中，点击“环境变量”。
  4. 在“系统变量”区域点击“新建”，添加JAVA_HOME变量，值为JDK的安装路径，例如C:\Program Files\Java\jdk-<version>。
  5. 在“系统变量”区域找到Path变量，点击“编辑”，添加%JAVA_HOME%\bin。
- Linux:
  在终端中使用以下命令：
```
export JAVA_HOME=/usr/lib/jvm/java-<version>-openjdk
export PATH=$JAVA_HOME/bin:$PATH
```
验证安装
打开终端或命令行工具，输入以下命令来验证Java是否安装成功：
```
java -version
```
这将显示安装的Java版本信息。如果输出版本号，则表示安装成功。

配置IDE（如Eclipse, IntelliJ IDEA）

为了提高开发效率，通常会使用集成开发环境（Integrated Development Environment, IDE）。Eclipse和IntelliJ IDEA是两种常用的IDE。以下是配置步骤：

Eclipse配置

下载Eclipse
访问Eclipse官方网站（https://www.eclipse.org/downloads/）下载对应的版本。
安装Eclipse
下载安装包后，双击运行安装程序，按照提示完成安装。
配置Eclipse使用JDK
- 打开Eclipse，选择Window -> Preferences（或Eclipse -> Preferences）。
- 在左侧菜单中找到Java -> Installed JREs。
- 点击Add按钮，添加新的JRE，选择Standard VM，点击Next。
- 设置JRE home为之前安装的JDK目录，点击Finish。
- 在列表中选择新建的JRE，点击Apply，点击OK。
创建并运行简单程序
- 创建一个新的Java项目。
- 右键点击项目名，选择New -> Class。
- 输入类名为HelloWorld，点击Finish。
- 在HelloWorld.java中输入以下代码：
```
public class HelloWorld {
 public static void main(String[] args) {
     System.out.println("Hello, World!");
 }
}
```
- 右键点击HelloWorld.java，选择Run As -> Java Application，运行程序。

IntelliJ IDEA配置

下载IntelliJ IDEA
访问JetBrains官方网站（https://www.jetbrains.com/idea/download/）下载社区版（Community Edition），这是免费版本。
安装IntelliJ IDEA
下载安装包后，运行安装程序，按照提示完成安装。
配置IntelliJ IDEA使用JDK
- 打开IntelliJ IDEA，选择File -> Project Structure。
- 在左侧菜单中找到SDKs，点击+按钮添加新的SDK。
- 选择JDK，点击New，设置Name为JDK，Version为11（或其他版本），Home path选择JDK的安装目录。
- 点击OK，然后在Project -> Project SDK中选择新添加的JDK。
创建并运行简单程序
- 创建一个新的Java项目。
- 右键点击项目名，选择New -> Java Class。
- 输入类名为HelloWorld，点击OK。
- 在HelloWorld.java中输入以下代码：
```
public class HelloWorld {
 public static void main(String[] args) {
     System.out.println("Hello, World!");
 }
}
```
- 右键点击HelloWorld.java，选择Run 'HelloWorld.main()'，运行程序。

至此，Java开发环境已成功搭建。接下来可以开始学习Java的基础语法。

Java基础语法

变量与数据类型

在Java中，变量用于存储程序运行时的数据。变量需要指定类型，类型决定了变量可以存储的数据种类。Java的数据类型分为两大类：基本类型（Primitive Types）和引用类型（Reference Types）。

基本类型

Java的基本类型包括整型、浮点型、字符型和布尔型。

整型：
- byte: 8位有符号整数，范围为-128到127。
- short: 16位有符号整数，范围为-32768到32767。
- int: 32位有符号整数，范围为-2147483648到2147483647。
- long: 64位有符号整数，范围为-9223372036854775808到9223372036854775807。
浮点型：
- float: 32位单精度浮点数。
- double: 64位双精度浮点数。
字符型：
- char: 16位Unicode字符。
布尔型：
- boolean: 布尔值，可以是true或false。

引用类型

引用类型用于存储对象的引用。对象是由类定义的实体，每个对象都有自己的状态和行为。引用类型包括类、接口和数组。

变量的声明与初始化

变量声明需要指定类型，并可以指定初始值。以下是变量声明的例子：

int age = 25;
float price = 19.99f;
char grade = 'A';
boolean isAdult = true;

变量也可以在声明时初始化为默认值。例如：

int count;
float balance;
char symbol;
boolean active = false;

// 打印变量值
System.out.println(count);  // 输出: 0
System.out.println(balance); // 输出: 0.0
System.out.println(symbol);  // 输出: \u0000
System.out.println(active);  // 输出: false

变量的作用域与生命周期

变量的作用域是指变量在程序中的可见范围。Java变量的作用域包括局部变量、成员变量和方法参数。

局部变量：在方法、代码块或语句中声明的变量。其作用域仅限于声明它的语句块。
成员变量：在类中声明的变量。它们可以被类的所有方法访问。
方法参数：在方法声明中作为参数传递的变量。它们的作用域仅限于方法内部。

变量的生命周期是指变量在程序中的存在时间。局部变量和方法参数在声明它们的代码块执行完毕后被销毁，而成员变量则在对象实例创建时初始化，在对象销毁时被销毁。下面是一个示例：

public class VariableExample {
    private int memberVariable = 10;

    public void exampleMethod() {
        int localVar = 20;
        System.out.println(localVar);  // 输出: 20
    }

    public static void main(String[] args) {
        VariableExample example = new VariableExample();
        example.exampleMethod();
        // localVar 在这里不能访问，因为它的作用域仅限于 exampleMethod 方法内部
    }
}

控制结构

if语句

if语句用于根据条件执行代码块。如果条件为真（true），则执行代码块。语法如下：

if (condition) {
    // 执行代码块
}

例如：

public class IfExample {
    public static void main(String[] args) {
        int age = 20;
        if (age >= 18) {
            System.out.println("成年人");
        } else {
            System.out.println("未成年人");
        }
    }
}

switch语句

switch语句用于根据一个表达式的值，选择执行一组代码块中的一个代码块。语法如下：

switch (expression) {
    case value1:
        // 执行代码块
        break;
    case value2:
        // 执行代码块
        break;
    default:
        // 默认执行代码块
}

例如：

public class SwitchExample {
    public static void main(String[] args) {
        int dayOfWeek = 2;
        switch (dayOfWeek) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("其他");
        }
    }
}

循环结构

循环结构用于重复执行一段代码，直到满足特定条件为止。Java中的循环结构包括for、while和do-while循环。

for循环：用于已知迭代次数的循环。

语法：

for (初始化; 条件; 更新) {
// 循环体
}

示例：

public class ForExample {
public static void main(String[] args) {
    for (int i = 1; i <= 5; i++) {
        System.out.println("i 的值是: " + i);
    }
}
}

while循环：用于在循环条件为真时执行循环体。

语法：
```
while (条件) {
// 循环体
}
```

示例：

public class WhileExample {
public static void main(String[] args) {
    int count = 1;
    while (count <= 5) {
        System.out.println("count 的值是: " + count);
        count++;
    }
}
}

do-while循环：与while循环类似，不同之处在于do-while循环至少执行一次循环体。

语法：
```
do {
// 循环体
} while (条件);
```

示例：

public class DoWhileExample {
public static void main(String[] args) {
    int count = 1;
    do {
        System.out.println("count 的值是: " + count);
        count++;
    } while (count <= 5);
}
}

这些基本的控制结构是Java编程中最常用的控制流机制，用于根据条件执行代码或重复执行代码块。掌握这些控制结构是编程的基础。

数组与字符串操作

数组

数组是一种存储一组相同类型元素的数据结构。Java中的数组类型包括基本类型数组和引用类型数组。数组在声明时需要指定长度，数组中的每个元素可以通过索引访问。

基本类型数组的声明和初始化：

int[] intArray = new int[5];
intArray[0] = 10;
intArray[1] = 20;
intArray[2] = 30;
intArray[3] = 40;
intArray[4] = 50;

// 初始化时直接赋值
int[] anotherArray = {1, 2, 3, 4, 5};

多维数组

多维数组是数组的数组，可以创建二维数组、三维数组等。例如，二维数组的声明和初始化：

int[][] matrix = new int[3][3];
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
matrix[2][0] = 7;
matrix[2][1] = 8;
matrix[2][2] = 9;

字符串

字符串是一个特殊的类String，用于存储和操作不可变的字符序列。字符串操作是最常见的任务之一，Java提供了丰富的API来操作字符串。

创建字符串：

直接赋值：
```
String name = "张三";
```
使用构造函数：
```
String name = new String("张三");
```

从原始字符数组生成：

char[] characters = {'H', 'e', 'l', 'l', 'o'};
String str = new String(characters);

字符串操作：

拼接字符串：

String str1 = "Hello";
String str2 = "World";
String result = str1 + " " + str2;
System.out.println(result);  // 输出: Hello World

字符串长度：

String str = "Hello";
int length = str.length();
System.out.println(length);  // 输出: 5

字符串切片：

String str = "HelloWorld";
String subStr = str.substring(0, 5);
System.out.println(subStr);  // 输出: Hello

查找子串：

String str = "HelloWorld";
int index = str.indexOf("W");
System.out.println(index);  // 输出: 6

替换子串：

String str = "HelloWorld";
String result = str.replace("World", "Java");
System.out.println(result);  // 输出: HelloJava

字符串比较：

相等比较：

String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2);
System.out.println(isEqual);  // 输出: true

不区分大小写比较：

String str1 = "Hello";
String str2 = "hello";
boolean isEqualIgnoreCase = str1.equalsIgnoreCase(str2);
System.out.println(isEqualIgnoreCase);  // 输出: true

字符串操作是Java编程中常见的任务，掌握这些操作有助于编写高效的程序。

面向对象编程

面向对象编程（Object-Oriented Programming, OOP）是Java语言的核心思想。OOP的主要概念包括类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）和抽象（Abstraction）。

类与对象

类是创建对象的蓝图或模板，它定义了对象的状态和行为。类通常包含属性（字段）和方法（函数）。

声明类：

public class Person {
   // 属性
   private String name;
   private int age;

   // 构造函数
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }

   // 方法
   public String getName() {
       return name;
   }

   public int getAge() {
       return age;
   }

   public void setName(String name) {
       this.name = name;
   }

   public void setAge(int age) {
       this.age = age;
   }
}

创建对象：

public class Main {
   public static void main(String[] args) {
       Person person = new Person("张三", 25);
       System.out.println(person.getName()); // 输出: 张三
       System.out.println(person.getAge());  // 输出: 25
   }
}

继承与多态

继承允许一个类（子类）继承另一个类（父类）的属性和方法。这减少了代码重复，并使代码更易于维护。

定义父类：

public class Animal {
   protected String name;

   public Animal(String name) {
       this.name = name;
   }

   public void speak() {
       System.out.println("动物发声");
   }
}

定义子类：

public class Dog extends Animal {
   public Dog(String name) {
       super(name);
   }

   @Override
   public void speak() {
       System.out.println("汪汪");
   }
}

使用继承：

public class Main {
   public static void main(String[] args) {
       Animal animal = new Animal("动物");
       animal.speak();  // 输出: 动物发声

       Dog dog = new Dog("小狗");
       dog.speak();     // 输出: 汪汪
   }
}

多态是指同一个行为可以有不同的表现形式。在Java中，多态是通过方法重写（方法覆盖）实现的。

接口与抽象类

接口定义了一组方法的集合，但不提供方法的实现。接口可以用于定义类的行为规范，实现多个接口可以实现多态。

定义接口：

public interface Flyable {
   void fly();
}

实现接口：

public class Bird implements Flyable {
   @Override
   public void fly() {
       System.out.println("鸟儿飞翔");
   }
}

使用接口：

public class Main {
   public static void main(String[] args) {
       Flyable bird = new Bird();
       bird.fly();  // 输出: 鸟儿飞翔
   }
}

抽象类是不能实例化的类，通常用于定义抽象方法和常量。抽象类可以继承其他抽象类或常规类。

定义抽象类：

public abstract class Animal {
   protected String name;

   public Animal(String name) {
       this.name = name;
   }

   public abstract void speak();
}

实现抽象类：

public class Dog extends Animal {
   public Dog(String name) {
       super(name);
   }

   @Override
   public void speak() {
       System.out.println("汪汪");
   }
}

使用抽象类：

public class Main {
   public static void main(String[] args) {
       Animal dog = new Dog("小狗");
       dog.speak();     // 输出: 汪汪
   }
}

面向对象编程是Java语言的核心特性，通过类和对象，可以更好地组织和管理代码，增强代码的可重用性和可维护性。

输入输出操作

Java提供了丰富的输入输出（I/O）类库，用于处理文件读写和标准输入输出。这些类库包括java.io包中的类和java.nio包中的类（新I/O）。

文件读写

文件读取可以通过FileInputStream和BufferedReader等类实现。

读取文本文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReadExample {
   public static void main(String[] args) {
       try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
           String line;
           while ((line = reader.readLine()) != null) {
               System.out.println(line);
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

读取二进制文件：

import java.io.FileInputStream;
import java.io.IOException;

public class BinaryFileReadExample {
   public static void main(String[] args) {
       try (FileInputStream fis = new FileInputStream("example.bin")) {
           int content;
           while ((content = fis.read()) != -1) {
               System.out.print((char) content);
           }
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

文件写入可以通过FileOutputStream和BufferedWriter等类实现。

写入文本文件：

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class FileWriteExample {
   public static void main(String[] args) {
       try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
           writer.write("这是第一行");
           writer.newLine();
           writer.write("这是第二行");
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

写入二进制文件：

import java.io.FileOutputStream;
import java.io.IOException;

public class BinaryFileWriteExample {
   public static void main(String[] args) {
       try (FileOutputStream fos = new FileOutputStream("example.bin")) {
           String content = "Hello, World!";
           fos.write(content.getBytes());
       } catch (IOException e) {
           e.printStackTrace();
       }
   }
}

标准输入输出

标准输入可以通过System.in和BufferedReader等类实现。

读取标准输入：

import java.util.Scanner;

public class StandardInputExample {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);
       System.out.print("请输入一些文本：");
       String input = scanner.nextLine();
       System.out.println("你输入的是：" + input);
       scanner.close();
   }
}

标准输出可以通过System.out实现。

写入标准输出：

public class StandardOutputExample {
   public static void main(String[] args) {
       System.out.println("这是标准输出");
   }
}

Java IO类库简介

Java的java.io包提供了大量的类和接口用于文件输入输出，下面是常用的一些类：

FileInputStream：用于读取文件的字节输入流。
FileOutputStream：用于写入文件的字节输出流。
FileReader：用于读取文件的字符输入流。
FileWriter：用于写入文件的字符输出流。
BufferedReader：提供缓冲功能，用于从输入流中读取文本。
BufferedWriter：提供缓冲功能，用于写入文本到输出流。
InputStreamReader：用于将字节流转换为字符流。
OutputStreamWriter：用于将字符流转换为字节流。
PrintWriter：可以将数据输出为格式化的文本。

这些类提供了强大的文件操作功能，使文件输入输出变得简单且高效。掌握这些类及其用法，可以更好地处理文件相关的任务。

异常处理与调试技巧

异常处理是Java编程中非常重要的一个方面，它用于处理程序运行时可能出现的错误。Java的异常机制包括异常类、异常处理语句和异常层次结构。通过异常处理，可以提高程序的健壮性和可维护性。

异常处理机制

Java中的异常机制主要包括以下几个部分：

异常类（Exception Class）：
- Exception是所有异常类的超类，表示可以捕获到的异常。
- Error表示程序无法恢复的严重错误，通常由JVM或其他系统组件抛出。
- RuntimeException及其子类表示运行时异常，这类异常不需要在方法签名中声明，但需要在代码中处理。
异常处理语句：
- try块：用于放置可能发生异常的代码。
- catch块：用于捕获特定类型的异常。
- finally块：无论是否发生异常，都会执行的代码块。
- throw语句：用于手动抛出异常。
- throws子句：表示方法可能抛出的异常。
异常层次结构：
- Exception类下的子类分为RuntimeException和非RuntimeException。
- RuntimeException下的常见子类有ArithmeticException、NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException等。
- 其他常见的异常子类有IOException、FileNotFoundException、ClassNotFoundException等。

常见异常类型

以下是Java中的常见异常类型及其用途：

ArithmeticException：用于表示在算术运算中出现的问题，如除以零。

public class ArithmeticExceptionExample {
  public static void main(String[] args) {
      try {
          int result = 10 / 0;
      } catch (ArithmeticException e) {
          System.out.println("除以零异常");
      }
  }
}

NullPointerException：用于表示在调用对象的成员方法或访问成员变量时，对象引用为null。

public class NullPointerExceptionExample {
  public static void main(String[] args) {
      String str = null;
      try {
          int length = str.length();
      } catch (NullPointerException e) {
          System.out.println("空指针异常");
      }
  }
}

ArrayIndexOutOfBoundsException：用于表示数组索引超出范围。

public class ArrayIndexOutOfBoundsExceptionExample {
  public static void main(String[] args) {
      int[] array = new int[5];
      try {
          int value = array[10];
      } catch (ArrayIndexOutOfBoundsException e) {
          System.out.println("数组索引超出范围");
      }
  }
}

FileNotFoundException：用于表示文件不存在。

import java.io.File;
import java.io.IOException;

public class FileNotFoundExceptionExample {
  public static void main(String[] args) {
      File file = new File("不存在的文件.txt");
      try {
          if (file.exists()) {
              System.out.println("文件存在");
          } else {
              throw new FileNotFoundException("文件不存在");
          }
      } catch (FileNotFoundException e) {
          System.out.println("文件不存在异常");
      }
  }
}

IOException：用于表示与输入输出有关的异常。

import java.io.FileInputStream;
import java.io.IOException;

public class IOExceptionExample {
  public static void main(String[] args) {
      FileInputStream fis = null;
      try {
          fis = new FileInputStream("不存在的文件.txt");
      } catch (IOException e) {
          System.out.println("IO异常");
      } finally {
          if (fis != null) {
              try {
                  fis.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
      }
  }
}

调试工具介绍与使用

调试工具是开发过程中不可或缺的工具，用于跟踪程序执行并检查错误。Java提供了多种调试工具，包括JDB（Java Debugger）、IDE内置调试器（如Eclipse和IntelliJ IDEA）。

JDB是一个简单的命令行调试工具，主要用于调试Java应用程序。以下是使用JDB的基本步骤：

编译带调试信息的代码：
```
javac -g MyClass.java
```
启动JDB：
```
jdb MyClass
```
使用JDB命令进行调试：
- run：运行程序。
- list：列出当前行附近的源代码。
- step：单步执行。
- next：执行下一行代码。
- where：显示当前栈跟踪。
- print：打印指定表达式的值。

IDE内置调试器提供了更丰富的调试功能，如断点设置、变量查看、单步执行、方法调用栈查看等。

设置断点：
- 在代码中设置断点，可以通过点击行号左侧的空白区域或使用菜单选项。
- 断点设置后，程序会在指定行暂停执行。
单步执行：
- 使用Step Over（F6）、Step Into（F7）和Step Out（Shift + F7）进行单步执行。
查看变量值：
- 右键点击变量，选择Inspect或Variables窗口查看变量值。
- 使用Evaluate Expression窗口输入表达式并查看其值。
查看调用栈：
- 使用View Stack或类似选项查看当前调用栈信息。

调试是提高代码质量的重要手段，通过调试工具可以更好地理解和修复程序中的错误。

实战项目：简单的计算器应用

需求分析

计算器应用程序是一个简单的命令行程序，用户可以输入两个数字和一个运算符（如+、-、*、/），程序将根据输入执行相应的运算并输出结果。程序需要具备以下功能：

提示用户输入第一个数字。
提示用户输入运算符。
提示用户输入第二个数字。
根据用户输入执行相应的运算，并输出结果。
考虑输入错误的情况，如输入非数字或非运算符字符。

代码实现

根据需求分析，以下是计算器程序的实现代码：

输入处理：
- 使用Scanner类读取用户输入。
- 处理输入的数字和运算符。
运算处理：
- 根据运算符执行相应的运算。
- 处理除法中的除零异常。
异常处理：
- 捕获并处理非数字输入和非运算符输入。

下面是完整的代码实现：

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        try {
            // 输入第一个数字
            System.out.print("请输入第一个数字: ");
            double num1 = scanner.nextDouble();

            // 输入运算符
            System.out.print("请输入运算符 (+, -, *, /): ");
            String operator = scanner.next();

            // 输入第二个数字
            System.out.print("请输入第二个数字: ");
            double num2 = scanner.nextDouble();

            // 执行运算
            double result = 0.0;
            switch (operator) {
                case "+":
                    result = num1 + num2;
                    break;
                case "-":
                    result = num1 - num2;
                    break;
                case "*":
                    result = num1 * num2;
                    break;
                case "/":
                    if (num2 != 0) {
                        result = num1 / num2;
                    } else {
                        throw new ArithmeticException("除数不能为零");
                    }
                    break;
                default:
                    throw new IllegalArgumentException("无效的运算符");
            }

            // 输出结果
            System.out.println("结果是: " + result);

        } catch (Exception e) {
            System.out.println("错误: " + e.getMessage());
        } finally {
            scanner.close();
        }
    }
}

测试与调试

基本功能测试：
- 输入10 + 5，预期输出15。
- 输入10 - 5，预期输出5。
- 输入10 * 5，预期输出50。
- 输入10 / 5，预期输出2.0。
异常情况测试：
- 输入10 / 0，预期输出除数不能为零。
- 输入无效的运算符，如10 # 5，预期输出无效的运算符。
- 输入非数字字符，如abc + def，预期输出错误: 超出范围的扫描失败。

通过上述测试用例，确保程序能够正确处理各种输入情况，并输出预期的结果。调试过程中，可以使用IDE的调试工具逐步执行代码，检查每一步的变量值和程序流程。

总结，通过编写一个简单的计算器程序，可以系统地练习Java的基本语法、异常处理和输入输出操作。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕哥6287543

手记
篇

粉丝

2

获赞与收藏

1

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19278 315

Java 并发原理入门教程

26个小节 39003 568

Java 入门教程

50个小节 342046 3165

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空