Java 是一种面向对象的编程语言，其基础语法简单易学，结构清晰。Java 程序通常由类（Class）组成，每个类包含方法和字段。以下是 Java 基础语法的详细介绍，涵盖了从最基本的语法结构到一些常见的编程概念。

1. Java 程序结构

Java 程序通常由类（Class）组成，类是 Java 中的基本结构单元。每个 Java 程序至少有一个类和一个 main 方法。

示例代码：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
  • public class HelloWorld：定义一个名为 HelloWorld 的类。
  • public static void main(String[] args)：main 方法是 Java 程序的入口点，所有程序从此方法开始执行。
  • System.out.println("Hello, World!");：输出 “Hello, World!” 到控制台。

2. 数据类型

Java 是强类型语言，所有变量在使用之前都必须声明其数据类型。Java 提供了多种数据类型：

  • 基本数据类型：
    • byte：1 字节，-128 到 127
    • short：2 字节，-32,768 到 32,767
    • int：4 字节，-2,147,483,648 到 2,147,483,647
    • long：8 字节，-2^63 到 2^63 – 1
    • float：4 字节，单精度浮点数
    • double：8 字节，双精度浮点数
    • char：2 字节，表示一个 Unicode 字符
    • boolean：1 位，表示真或假（true 或 false）

示例代码：

public class DataTypes {
    public static void main(String[] args) {
        int num = 100;  // 整数类型
        double price = 99.99;  // 浮动类型
        char grade = 'A';  // 字符类型
        boolean isActive = true;  // 布尔类型
        
        System.out.println("Integer: " + num);
        System.out.println("Double: " + price);
        System.out.println("Character: " + grade);
        System.out.println("Boolean: " + isActive);
    }
}

3. 变量和常量

  • 变量：变量在使用之前必须声明类型和名称。Java 支持局部变量和成员变量（字段）。
  • 常量：常量是不可修改的变量，在声明时需要使用 final 关键字。

示例代码：

public class Variables {
    public static void main(String[] args) {
        final double PI = 3.14159;  // 常量声明
        int x = 5;  // 整数变量
        
        System.out.println("Constant PI: " + PI);
        System.out.println("Variable x: " + x);
    }
}

4. 控制结构

Java 提供了多种控制结构来控制程序的执行流程，包括条件语句、循环语句等。

条件语句

  • if：用于判断一个条件是否为真。
  • if-else：在条件不成立时执行另一个代码块。
  • switch：用于根据多个条件值执行不同的代码块。

示例代码：

public class Conditionals {
    public static void main(String[] args) {
        int num = 10;
        
        if (num > 0) {
            System.out.println("Positive number");
        } else {
            System.out.println("Negative number or zero");
        }
        
        // switch case 示例
        switch (num) {
            case 10:
                System.out.println("The number is 10");
                break;
            case 20:
                System.out.println("The number is 20");
                break;
            default:
                System.out.println("Other number");
        }
    }
}

循环语句

  • for：用于重复执行一段代码，适用于已知循环次数的情况。
  • while：当某个条件满足时持续执行，适用于循环次数不确定的情况。
  • do-while：至少执行一次循环体，然后检查条件。

示例代码：

public class Loops {
    public static void main(String[] args) {
        // for 循环
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
        
        // while 循环
        int j = 0;
        while (j < 5) {
            System.out.println("j = " + j);
            j++;
        }
        
        // do-while 循环
        int k = 0;
        do {
            System.out.println("k = " + k);
            k++;
        } while (k < 5);
    }
}

5. 数组

Java 中的数组是用于存储固定大小的相同类型数据的容器。数组可以是基本数据类型，也可以是对象类型。

示例代码：

public class Arrays {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};  // 声明并初始化数组
        
        // 访问数组元素
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("Element at index " + i + ": " + numbers[i]);
        }
    }
}

6. 函数（方法）

方法是执行特定任务的代码块。在 Java 中，方法是类的一部分，具有返回类型、方法名和参数。

示例代码：

public class Methods {
    
    // 无返回值方法
    public static void greet() {
        System.out.println("Hello, welcome to Java!");
    }

    // 有返回值方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        greet();  // 调用无返回值方法
        
        int result = add(5, 3);  // 调用有返回值方法
        System.out.println("Sum: " + result);
    }
}

7. 类和对象

Java 是面向对象的语言，类是对象的模板。对象是类的实例，可以拥有状态（字段）和行为（方法）。

示例代码：

class Car {
    String brand;
    int speed;

    // 方法
    void drive() {
        System.out.println(brand + " is driving at " + speed + " km/h");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Car myCar = new Car();
        myCar.brand = "Toyota";
        myCar.speed = 120;
        
        // 调用对象的方法
        myCar.drive();
    }
}

8. 继承

继承是 Java 中的一种机制，通过继承，子类可以继承父类的属性和方法。子类可以对父类的方法进行重写。

示例代码：

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Inheritance {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.sound();  // 调用子类的方法，重写了父类方法
    }
}

9. 接口和抽象类

  • 接口：用于定义类的行为规范，接口中的方法没有实现，类必须实现接口中的方法。
  • 抽象类：不能实例化的类，可以包含抽象方法（没有实现的方法）和普通方法。

示例代码：

interface Animal {
    void sound();  // 接口中的方法
}

abstract class Bird implements Animal {
    // 抽象类实现接口中的方法
    public abstract void fly();
}

class Parrot extends Bird {
    @Override
    public void sound() {
        System.out.println("Parrot says hello");
    }

    @Override
    public void fly() {
        System.out.println("Parrot is flying");
    }
}

public class InterfaceAbstractClass {
    public static void main(String[] args) {
        Parrot parrot = new Parrot();
        parrot.sound();
        parrot.fly();
    }
}

10. 异常处理

Java 提供了强大的异常处理机制，允许程序在运行时捕捉并处理异常，防止程序崩溃。

示例代码：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;  // 会引发异常
        } catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("This block always executes");
        }
    }
}

总结

Java 的基础语法涵盖了数据类型、变量、控制结构、函数、类和对象、继承、接口与抽象类以及异常处理等多个方面。掌握这些基础内容后，你可以编写简单的 Java 应用程序，进一步深入学习更高级的 Java 特性，如多线程、集合框架、网络编程等。