Java的基本语法

文章目录

- Java语言的一些基本语法要点：
- Java语言的一些进阶概念和特性：
- Java代码示例
- - 基础示例
  - - 1. Hello World
    - 2. 计算两个数的和
  - 进阶示例
  - - 1. 使用Lambda表达式过滤列表
    - 2. 实现一个简单的泛型类
    - 3. 使用多线程打印数字
  - 异常处理示例
  - - 捕获并处理异常
  - 接口使用示例
  - - 定义与实现接口
  - 集合框架示例：使用ArrayList
  - - 添加、遍历和删除元素

Java语言的一些基本语法要点：

Java是一种广泛使用的面向对象的编程语言，它的设计注重于提高程序的清晰度、可靠性和可维护性。以下是Java语言的一些基本语法要点：

源代码文件与类命名：
- Java程序的源代码保存在以.java为扩展名的文本文件中。
- 一个源文件中可以有多个类，但只有一个公开(public)类，并且源文件的名称必须与这个公开类的类名完全匹配（包括大小写）。
主函数（Main Method）：
- Java应用程序的入口点是public static void main(String[] args)方法。
- 这个方法必须定义在公开类中。
标识符：
- 用于给变量、类、方法等命名的字符序列称为标识符。它们可以由字母、数字、下划线 _ 和美元符号 $ 组成，但不能以数字开头，且不能是Java的关键字。
数据类型：
- Java有基本数据类型，如int, double, boolean, char等，以及引用类型，如类、接口和数组。
- Java是一种强类型语言，每个变量都必须先声明其类型。
变量声明与初始化：
- 变量在使用前必须声明其类型，如int age = 25;。
运算符与表达式：
- 包括算术运算符、关系运算符、逻辑运算符、位运算符等，用于构建复杂的表达式。
控制流语句：
- 包括条件判断语句（if-else）、循环语句（for, while, do-while）和跳转语句（break, continue）。
修饰符：
- 用于修改类、方法、变量等的访问权限或行为，如访问修饰符（public, private, protected, default）和非访问修饰符（final, static, abstract）。
方法：
- 方法是一段执行特定任务的代码块，可以有返回值也可以没有，通过return语句返回结果。
类与对象：
- 类是创建对象的蓝图，定义了属性（变量）和方法。
- 对象是类的实例，通过new关键字创建。
继承与接口：
- Java支持单一继承，即一个类只能直接继承一个父类，但可以实现多个接口来获得多重继承的效果。
异常处理：
- 使用try-catch或try-with-resources结构来捕获和处理运行时错误或异常。
注释：
- 单行注释以//开始。
- 多行注释用/* ... */包围。
分隔符与空白符：
- 分号;用于结束语句，大括号{}用于界定代码块，逗号,用于分隔列表项等。

掌握这些基本语法是编写Java程序的基础，随着学习深入，还需了解更高级的概念和最佳实践。

Java语言的一些进阶概念和特性：

封装：
- 封装是面向对象编程的一个基本原则，通过将数据（字段）和操作这些数据的方法（行为）封装在类中，并限制对内部状态的直接访问，只通过公共的getter和setter方法（访问器和修改器）进行交互。
多态：
- Java中的多态允许将子类的对象当作父类的对象来使用，从而表现出不同的行为。这通过方法重写(Override)和接口实现来实现。多态增强了代码的灵活性和可维护性。
抽象类与接口：
- 抽象类是不能被实例化的类，它包含抽象方法（只有声明没有实现的方法），强迫子类去实现这些方法。
- 接口定义了一组没有实现的方法，任何实现了该接口的类都需要提供这些方法的具体实现。Java 8以后，接口还可以包含默认方法和静态方法。
泛型：
- 泛型允许在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率和类型安全性。例如，List<String>就是一个持有String对象的列表。
集合框架：
- Java集合框架提供了一套设计良好的接口和实现类，用于操作对象集合，如List、Set、Map等。它是Java编程中处理数据集合的基石。
Lambda表达式与函数式接口：
- 自Java 8起，引入了Lambda表达式，它提供了一种更简洁的方式来表示匿名函数。与函数式接口（只有一个抽象方法的接口）结合，可以用来代替匿名内部类，简化事件监听、集合操作等场景的代码。
Stream API：
- Stream API是Java 8引入的一个用于处理集合的高级抽象，支持高效的函数式编程风格，如过滤、映射、归约等操作，能够以声明性方式处理数据集合。
模块系统（Java Platform Module System, JPMS）：
- 自Java 9起引入，模块系统增强了大型应用的可维护性和性能，通过模块化项目结构，提供了更好的封装和依赖管理。
并发编程：
- Java提供了丰富的API来支持多线程和并发编程，包括Thread类、Runnable接口、Executor框架、并发集合、同步工具（如Locks, Semaphores）以及原子类等。
反射：
- Java反射机制允许在运行时检查和修改程序的行为，如动态创建对象、调用方法、访问字段等，这对于开发一些框架和库非常有用。

掌握这些进阶内容能帮助你编写更加高效、灵活和易于维护的Java应用程序。不断实践和学习新的Java特性，将使你成为更加熟练的Java开发者。

Java代码示例

下面是一些实用的Java代码示例，涵盖了一些基础和进阶的概念：

基础示例

1. Hello World

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

2. 计算两个数的和

public class Sum {
    public static void main(String[] args) {
        int a = 5;
        int b = 3;
        int sum = a + b;
        System.out.println("Sum of " + a + " and " + b + " is " + sum);
    }
}

进阶示例

1. 使用Lambda表达式过滤列表

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
                                          .filter(n -> n % 2 == 0)
                                          .collect(Collectors.toList());
        System.out.println(evenNumbers); // 输出 [2, 4, 6]
    }
}

2. 实现一个简单的泛型类

public class GenericBox<T> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        GenericBox<String> box = new GenericBox<>();
        box.set("Hello");
        System.out.println(box.get()); // 输出 Hello
    }
}

3. 使用多线程打印数字

class PrintNumber implements Runnable {
    private int limit;
    
    public PrintNumber(int limit) {
        this.limit = limit;
    }
    
    @Override
    public void run() {
        for (int i = 1; i <= limit; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        PrintNumber printNumber = new PrintNumber(10);
        Thread t1 = new Thread(printNumber, "Thread 1");
        Thread t2 = new Thread(printNumber, "Thread 2");
        
        t1.start();
        t2.start();
    }
}

这些例子展示了Java中从基础到进阶的一些常见用法，包括基本输出、基本数学运算、Lambda表达式、泛型、以及多线程编程。希望这些示例对你有所帮助！

接下来我将为你展示一些更具体的Java实用示例，涵盖异常处理、接口的使用、以及如何使用集合框架处理数据。

异常处理示例

捕获并处理异常

public class ExceptionHandling {
    public static void divideNumbers(int a, int b) {
        try {
            int result = a / b;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Division by zero is not allowed.");
        }
    }

    public static void main(String[] args) {
        divideNumbers(10, 0); // 将触发ArithmeticException
    }
}

接口使用示例

定义与实现接口

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.makeSound(); // 输出 Woof!
        myCat.makeSound(); // 输出 Meow!
    }
}

集合框架示例：使用ArrayList

添加、遍历和删除元素

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();

        // 添加元素
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        // 遍历并打印
        for (String name : names) {
            System.out.println(name);
        }

        // 删除指定元素
        names.remove("Bob");

        // 使用增强型for循环再次遍历
        System.out.println("After removal:");
        for (String remainingName : names) {
            System.out.println(remainingName);
        }
    }
}