Java：基础语法

1. 基本结构

类和方法

Java程序的基本单位是类，每个类包含一个或多个方法。类是对象的蓝图，定义了对象的属性和行为。方法是执行特定任务的代码块。

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!");: 输出字符串到控制台。

2. 变量和数据类型

基本数据类型

Java有八种基本数据类型，每种类型都有固定的大小和范围。

• byte: 8位整数，范围-128到127。
• short: 16位整数，范围-32,768到32,767。
• int: 32位整数，范围-2^31到231-1。
• long: 64位整数，范围-2^63到263-1。
• float: 32位单精度浮点数。
• double: 64位双精度浮点数。
• char: 16位Unicode字符。
• boolean: 布尔类型，只有两个值：true和false。

int age = 25;
double price = 19.99;
char grade = 'A';
boolean isJavaFun = true;

引用数据类型

引用数据类型包括类、接口和数组。

• String: 代表字符串。

String name = "Alice";

3. 操作符

算术操作符

用于进行算术运算。

• +: 加法。
• -: 减法。
• *: 乘法。
• /: 除法。
• %: 取模（余数）。

int a = 10;
int b = 5;
int sum = a + b; // 15
int diff = a - b; // 5
int product = a * b; // 50
int quotient = a / b; // 2
int remainder = a % b; // 0

比较操作符

用于比较两个值。

• ==: 等于。
• !=: 不等于。
• >: 大于。
• <: 小于。
• >=: 大于等于。
• <=: 小于等于。

int x = 10;
int y = 20;
boolean isEqual = (x == y); // false
boolean isNotEqual = (x != y); // true
boolean isGreater = (x > y); // false
boolean isLesser = (x < y); // true
boolean isGreaterOrEqual = (x >= y); // false
boolean isLesserOrEqual = (x <= y); // true

逻辑操作符

用于进行逻辑运算。

• &&: 逻辑与。
• ||: 逻辑或。
• !: 逻辑非。

boolean a = true;
boolean b = false;
boolean andResult = (a && b); // false
boolean orResult = (a || b); // true
boolean notResult = !a; // false

4. 控制结构

条件语句

• if语句：根据条件执行不同的代码块。

if (age > 18) {
    System.out.println("Adult");
} else {
    System.out.println("Not Adult");
}

• switch语句：根据变量的值执行不同的代码块。

int day = 2;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    // 其他case
    default:
        System.out.println("Invalid day");
}

循环语句

• for循环：用于固定次数的循环。

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

• while循环：用于基于条件的循环。

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

• do-while循环：类似于while循环，但至少执行一次。

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 10);

5. 数组

数组是相同数据类型元素的集合。

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

6. 方法

方法是执行特定任务的代码块，可以传入参数并返回结果。

public int add(int a, int b) {
    return a + b;
}

public static void main(String[] args) {
    HelloWorld hw = new HelloWorld();
    int sum = hw.add(5, 3);
    System.out.println(sum); // 输出8
}

7. 面向对象编程

类和对象

类是对象的蓝图，对象是类的实例。

public class Dog {
    String breed;
    int age;
    
    void bark() {
        System.out.println("Woof");
    }
}

public class TestDog {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.breed = "Labrador";
        myDog.age = 3;
        myDog.bark();
    }
}

继承

通过继承，一个类可以继承另一个类的属性和方法。

public class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

public class Dog extends Animal {
    void bark() {
        System.out.println("Woof");
    }
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat(); // 输出"This animal eats food."
        myDog.bark(); // 输出"Woof"
    }
}

多态

多态允许不同类的对象通过相同的接口调用不同的方法实现。

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

public class Dog extends Animal {
    void sound() {
        System.out.println("Woof");
    }
}

public class Cat extends Animal {
    void sound() {
        System.out.println("Meow");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.sound(); // 输出"Woof"
        myCat.sound(); // 输出"Meow"
    }
}

8. 异常处理

Java通过异常处理机制来处理运行时错误，确保程序的健壮性。

try {
    int division = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
} finally {
    System.out.println("This block is always executed");
}

• try块：包含可能抛出异常的代码。
• catch块：捕获并处理异常。
• finally块：无论是否发生异常，始终执行的代码块。

9. 常用类库

Java标准库提供了许多实用的类和方法，例如java.util包中的ArrayList类：

import java.util.ArrayList;

public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        
        for (String fruit : list) {
            System.out.println(fruit);
        }
    }
}

• import java.util.ArrayList;: 导入ArrayList类。
• ArrayList<String> list = new ArrayList<>();: 创建ArrayList对象。
• list.add("Apple");: 向列表添加元素。
• for (String fruit : list): 使用增强的for循环遍历列表。