JAVA从基础到高级的基础命令，类和对象，继承和多态等

Java是一种广泛使用的编程语言，尤其在企业级应用开发中。今天整理了一些常用的Java命令和概念，涵盖了从基础到高级的内容等。

1. 基础命令

1.1 编译Java文件

javac HelloWorld.java

这个命令用于编译Java源文件，生成字节码文件（.class文件）。

1.2 运行Java程序

java HelloWorld

这个命令用于运行已编译的Java程序。注意，不需要包含“.class”扩展名。

2. 包管理

2.1 创建包

package com.example.myapp;

在Java源文件的开头使用package关键字来定义包。

2.2 导入包

import java.util.*;

使用import关键字来导入其他包中的类。

3. 类和对象

3.1 定义类

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

使用class关键字定义一个类，类中可以包含字段、构造函数和方法。

3.2 创建对象

Person person = new Person("Alice", 30);
person.displayInfo();

使用new关键字创建对象，并调用对象的方法。

4. 继承和多态

4.1 继承

public class Student extends Person {
    private String studentId;

    public Student(String name, int age, String studentId) {
        super(name, age);
        this.studentId = studentId;
    }
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Student ID: " + studentId);
    }
}

使用extends关键字继承一个类，并使用super关键字调用父类的构造函数和方法。

4.2 多态

Person person = new Student("Bob", 20, "S12345");
person.displayInfo();

通过父类引用调用子类对象的方法，实现多态。

5. 接口和抽象类

5.1 定义接口

public interface Animal {
    void makeSound();
}

使用interface关键字定义接口，接口中的方法默认是公共抽象方法。

5.2 实现接口

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

使用implements关键字实现接口，并提供接口方法的具体实现。

5.3 抽象类

public abstract class Shape {
    abstract void draw();
}

使用abstract关键字定义抽象类，抽象类中可以包含抽象方法和具体方法。

6. 异常处理

6.1 抛出异常

public void checkAge(int age) throws IllegalArgumentException {
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative");
    }
}

使用throws关键字声明方法可能抛出的异常。

6.2 捕获异常

try {
    checkAge(-1);
} catch (IllegalArgumentException e) {
    System.out.println("Caught an exception: " + e.getMessage());
}

使用try-catch块捕获和处理异常。

7. 集合框架

7.1 List

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
for (String fruit : list) {
    System.out.println(fruit);
}

使用List接口和ArrayList类管理有序集合。

7.2 Set

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
for (String fruit : set) {
    System.out.println(fruit);
}

使用Set接口和HashSet类管理无序且不重复的集合。

7.3 Map

Map<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

使用Map接口和HashMap类管理键值对集合。

8. 多线程

8.1 创建线程

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

继承Thread类并重写run方法创建线程。

8.2 启动线程

MyThread thread = new MyThread();
thread.start();

使用start方法启动线程。

8.3 使用Runnable接口

public class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable is running");
    }
}

实现Runnable接口并重写run方法创建线程。

8.4 使用ExecutorService

ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(new MyRunnable());
executor.shutdown();

使用ExecutorService管理线程池，提高线程管理的灵活性和效率。

9. 文件I/O

9.1 读取文件

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

使用BufferedReader和FileReader读取文件内容。

9.2 写入文件

try (BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"))) {
    writer.write("Hello, World!");
}

使用BufferedWriter和FileWriter写入文件内容。

10. 网络编程

10.1 创建服务器

ServerSocket serverSocket = new ServerSocket(12345);
Socket socket = serverSocket.accept();

使用ServerSocket创建服务器，并等待客户端连接。

10.2 创建客户端

Socket socket = new Socket("localhost", 12345);

使用Socket创建客户端，并连接到服务器。

11. 数据库连接

11.1 加载驱动

Class.forName("com.mysql.cj.jdbc.Driver");

使用Class.forName方法加载数据库驱动。

11.2 建立连接

Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");

使用DriverManager.getConnection方法建立数据库连接。

11.3 执行查询

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
while (resultSet.next()) {
    System.out.println(resultSet.getString("name"));
}

使用Statement和ResultSet执行SQL查询并处理结果。

12. 注解

12.1 自定义注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    String value();
}

使用@Retention和@Target注解定义自定义注解。

12.2 使用注解

public class MyClass {
    @MyAnnotation(value = "Hello")
    public void myMethod() {
        System.out.println("Method with annotation");
    }
}

在方法上使用自定义注解。

13. Lambda表达式

13.1 简单Lambda表达式

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

使用Lambda表达式遍历集合。

13.2 复杂Lambda表达式

Predicate<String> isLongName = name -> name.length() > 5;
List<String> longNames = names.stream().filter(isLongName).collect(Collectors.toList());

使用Lambda表达式和Stream API过滤集合。

14. 函数式接口

14.1 定义函数式接口

@FunctionalInterface
public interface MyFunction {
    void apply();
}

使用@FunctionalInterface注解定义函数式接口。

14.2 使用函数式接口

MyFunction myFunction = () -> System.out.println("Functional interface");
myFunction.apply();

使用Lambda表达式实现函数式接口。

15. 流处理

15.1 创建流

Stream<String> stream = Stream.of("Alice", "Bob", "Charlie");

使用Stream.of方法创建流。

15.2 流操作

List<String> filteredNames = stream.filter(name -> name.startsWith("A"))
                                    .collect(Collectors.toList());

使用流操作过滤和收集数据。

16. 并行流

16.1 创建并行流

Stream<String> parallelStream = names.parallelStream();

使用parallelStream方法创建并行流。

16.2 并行流操作

List<String> parallelFilteredNames = parallelStream.filter(name -> name.startsWith("A"))
                                                    .collect(Collectors.toList());

使用并行流操作提高处理效率。

17. 反射

17.1 获取Class对象

Class<?> clazz = MyClass.class;

使用Class.forName或类名获取Class对象。

17.2 创建对象

MyClass obj = (MyClass) clazz.getDeclaredConstructor().newInstance();

使用反射创建对象。

17.3 调用方法

Method method = clazz.getMethod("myMethod");
method.invoke(obj);

使用反射调用方法。

18. 泛型

18.1 定义泛型类

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

使用泛型定义类，提高代码的通用性和类型安全性。

18.2 使用泛型类

Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
System.out.println(stringBox.getContent());

使用泛型类存储和操作数据。

19. 枚举

19.1 定义枚举

public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

使用enum关键字定义枚举类型。

19.2 使用枚举

Day day = Day.MONDAY;
switch (day) {
    case MONDAY:
        System.out.println("Monday");
        break;
    // other cases
}

使用枚举类型表示固定的常量集合。

20. 注解处理

20.1 定义注解处理器

public class MyAnnotationProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            MyAnnotation annotation = element.getAnnotation(MyAnnotation.class);
            System.out.println("Processing annotation: " + annotation.value());
        }
        return true;
    }
}

使用AbstractProcessor类定义注解处理器。

20.2 注册注解处理器

@SupportedAnnotationTypes("com.example.MyAnnotation")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class MyAnnotationProcessor extends AbstractProcessor {
    // process method
}

使用@SupportedAnnotationTypes和@SupportedSourceVersion注解注册注解处理器。

结论

Java提供了丰富的命令和概念，涵盖了从基础到高级的各个方面。通过掌握这些命令和概念，可以更高效地开发和维护Java应用程序。希望这些内容对你有所帮助。