Java的核心概念和技术

Xiao_die888

已于 2024-09-11 19:53:57 修改

阅读量1.2k

点赞数 18

文章标签： java

于 2024-09-11 16:33:38 首次发布

本文链接：https://blog.csdn.net/xiao_die888/article/details/142143658

版权

Java的核心概念和技术

1. Java特点

跨平台：
- Java虚拟机（JVM）：Java代码编译成字节码（.class文件），由JVM解释执行。JVM在不同平台上都有实现，因此Java程序可以在不同操作系统上运行。
- Java运行时环境（JRE）：包括JVM和Java类库，用于运行Java程序。
面向对象：
- 封装：通过访问修饰符控制数据访问，使用getter和setter方法保护数据。
- 继承：子类继承父类的属性和方法，避免代码重复。
- 多态：允许对象通过父类引用调用子类的方法，增强程序的灵活性和可扩展性。
强类型：
- 类型安全：编译器检查类型，避免了很多运行时错误。
- 自动类型转换：支持自动类型转换，如从int到double。
自动垃圾回收：
- 垃圾收集器：自动回收不再使用的对象，减少内存泄漏的风险。
- 主要算法：标记-清除、复制算法、标记-整理等。
多线程支持：
- Thread类：用于创建和管理线程。
- Runnable接口：实现接口的类可以被线程执行。
- 并发包：java.util.concurrent包提供了更高层次的并发工具，如ExecutorService。
安全性：
- Java沙箱：限制程序的权限，保护系统免受恶意代码的影响。
- 安全管理器：可以限制Java应用程序的操作权限。
丰富的API：
- 核心类库：包括java.lang, java.util, java.io等。
- 第三方库：如Apache Commons、Google Guava，提供了额外的功能和工具。

2. Java程序开发步骤、源文件编写与保存、编译、运行

编写源文件：
- 文件命名：类名和文件名必须相同，并且文件扩展名为.java。
- 包声明：建议在源文件的开头声明包名，如package com.example;。
保存文件：
- IDE：如IntelliJ IDEA、Eclipse可以自动保存和编译。
- 文本编辑器：确保保存文件时选择正确的编码格式（如UTF-8）。
编译：
- 命令行编译：
```
javac HelloWorld.java
```
- 编译选项：-d指定输出目录，-cp设置类路径。
运行：
- 命令行运行：
```
java HelloWorld
```
- 类路径：-cp指定运行时类路径，-classpath可以设置多个路径。

3. 访问控制权限修饰符的作用，可见范围的区分

public：
- 类：对所有类可见。
- 方法和属性：对所有类可见。
protected：
- 类：同一包中的类和子类可见。
- 方法和属性：同一包中的类和子类（包括不同包的子类）可见。
默认（包私有）：
- 类：同一包中的类可见。
- 方法和属性：同一包中的类可见。
private：
- 类：不能被其他类访问。
- 方法和属性：仅对定义它的类可见。

4. 基本数据类型与引用数据类型的区分

基本数据类型：
- 存储位置：栈中。
- 例子：int, float, boolean, char。
- 默认值：0（整型），0.0（浮点型），false（布尔型），'\u0000'（字符型）。
引用数据类型：
- 存储位置：堆中。
- 例子：String, Array, Class。
- 默认值：null。

5. 数据的声明、定义与使用

声明：
- 语法：类型变量名;
- 例子：
```
int age;
String name;
```
定义：
- 语法：类型变量名 = 初始值;
- 例子：
```
int age = 30;
String name = "Alice";
```

使用：

读取：

System.out.println(age);
System.out.println(name);

修改：
```
age = 31;
name = "Bob";
```

6. 类、抽象类、接口，概念与特性，联系与区别

类：

特性：可以实例化，包含属性和方法。

示例：

public class Person {
    String name;
    void sayHello() {
        System.out.println("Hello!");
    }
}

抽象类：
- 特性：不能实例化，至少有一个抽象方法，子类必须实现抽象方法。
- 示例：
```
abstract class Animal {
    abstract void makeSound();
}
```
接口：
- 特性：只定义方法签名，支持多重继承，可以实现多个接口。
- 示例：
```
interface Drawable {
    void draw();
}
```

7. `this`、`super`、`static`关键字的作用

this：

用法：区分实例变量和方法参数，调用当前对象的方法或构造函数。

示例：

public class Person {
    String name;
    Person(String name) {
        this.name = name;
    }
}

super：

用法：访问父类的构造函数、方法和属性。

示例：

public class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

public class Dog extends Animal {
    @Override
    void eat() {
        super.eat();
        System.out.println("Dog eating...");
    }
}

static：

用法：定义类级别的成员，所有实例共享，静态方法不能访问实例变量。

示例：

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

8. 继承、重载、覆盖与多态，概念与用法

继承：

用法：使用extends关键字。

示例：

public class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

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

重载（Overloading）：

用法：同一类中方法名称相同但参数不同。

示例：

public class Printer {
    void print(int value) {
        System.out.println("Integer: " + value);
    }

    void print(String value) {
        System.out.println("String: " + value);
    }
}

覆盖（Overriding）：

用法：子类重写父类的方法。

示例：

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

public class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

多态：

用法：通过父类引用调用子类方法。

示例：

Animal myAnimal = new Dog();
myAnimal.makeSound(); // 输出 "Bark"

9. 面向对象的编码原则与应用

SOLID原则：
- 单一职责原则（SRP）：一个类应该只有一个原因引起变化。
- 开放封闭原则（OCP）：软件实体应该对扩展开放，对修改关闭。
- 里氏替换原则（LSP）：子类对象应该可以替换父类对象并正常工作。
- 接口隔离原则（ISP）：不应该强迫客户依赖它们不使用的方法。
- 依赖倒置原则（DIP）：高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

10. 面向过程和面向对象有什么特点

面向过程：
- 特点：通过函数和过程来处理数据，逻辑上关注算法和数据操作。
- 缺点：不够灵活，难以维护和扩展。
面向对象：
- 特点：通过对象来组织代码，数据和方法封装在对象内部。
- 优点：更易维护和扩展，符合人类思维方式，代码重用性强。

11. 集合基本概念与用法

List：
- ArrayList：动态数组，允许重复元素，提供快速随机访问。
- LinkedList：双向链表，适合频繁插入和删除操作。
Set：
- HashSet：基于哈希表的实现，不保证顺序，不允许重复元素。
- TreeSet：基于红黑树实现，元素有序，不允许重复元素。
Map：
- HashMap：基于哈希表的实现，允许空键和空值，不保证顺序。
- TreeMap：基于红黑树实现，键有序，不允许空键。

12. 泛型

泛型类：

定义：允许在类、接口和方法中使用类型参数。

示例：

public class Box<T> {
    private T content;
    public void set(T content) { this.content = content; }
    public T get() { return content; }
}

泛型方法：

定义：允许方法定义一个或多个类型参数。

示例：

public <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

13. 参数传递

值传递：
- 基本数据类型：传递的是变量的值。
- 引用数据类型：传递的是对象引用的值，即对象的内存地址。

示例：

public void modify(int num) {
    num = 10;
}

public void modifyArray(int[] arr) {
    arr[0] = 10;
}

int a = 5;
modify(a); // a仍然是5

int[] array = {5};
modifyArray(array); // array[0]变为10

14. 堆与栈的理解及其作用

堆：
- 用途：存储所有对象和数组。
- 内存管理：通过垃圾收集机制自动管理内存。
栈：
- 用途：存储方法的局部变量和调用信息。
- 特性：操作简单，存取速度快，方法调用时分配，方法结束时回收。

15. 位运算符、逻辑运算符的区别与应用

位运算符：
- 用途：直接操作整数的二进制位，适用于位标志、掩码等操作。
- 示例：
```
int a = 5; // 0101
int b = 3; // 0011
int result = a & b; // 0001
```
逻辑运算符：
- 用途：对布尔值进行逻辑运算，通常用于条件判断。
- 示例：
```
boolean a = true;
boolean b = false;
boolean result = a && b; // false
```

16. 经典运算符的使用

算术运算符：用于数学计算。

示例：

int a = 10;
int b = 5;
int sum = a + b; // 15

关系运算符：用于比较两个值。
- 示例：
```
boolean result = (a > b); // true
```
赋值运算符：用于给变量赋值。
- 示例：
```
int c = a;
c += 10; // c = 20
```

17. 类图的表示

类图：
- 表示：使用矩形表示类，矩形分为三个部分：类名、属性、方法。类之间的关系通过箭头和连线表示。
- 常见关系：
  - 继承：实线箭头（带空心箭头）。
  - 实现：虚线箭头（带空心箭头）。
  - 关联：实线（可能带有标注）。
  - 依赖：虚线（带箭头）。

18. 垃圾收集方法

标记-清除：标记不再使用的对象，然后清除它们。
复制算法：将活动对象复制到新区域，并清除旧区域。
标记-整理：标记不再使用的对象，整理存活对象以提高内存利用率。

19. `final`、`finally`、`finalize`的区别

final：
- 用途：防止修改或继承。
- 示例：
```
final int MAX = 100;
```
finally：
- 用途：在 try-catch 语句块中执行清理代码。
- 示例：
```
try {
    // code
} finally {
    // cleanup code
}
```
finalize：
- 用途：对象垃圾回收前的清理方法（不推荐使用）。
- 示例：
```
protected void finalize() throws Throwable {
    // cleanup code
}
```

20. `error`和`exception`的概念，他们之间的联系与区别

error：
- 描述：通常表示严重的错误，如JVM错误或资源耗尽。
- 示例：OutOfMemoryError, StackOverflowError。
exception：
- 描述：表示程序运行时的错误，通常需要程序处理。
- 分为：
  - 检查异常（Checked Exception）：必须处理的异常，如 IOException。
  - 运行时异常（Runtime Exception）：不强制处理的异常，如 NullPointerException、ArrayIndexOutOfBoundsException。

21. 典型设计模式的定义、原理与作用

单例模式：

定义：确保一个类只有一个实例，并提供全局访问点。

示例：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

工厂模式：

定义：定义一个创建对象的接口，让子类决定实例化哪个类。

示例：

public interface Product {
    void use();
}

public class ProductA implements Product {
    public void use() { /* ... */ }
}

public class ProductB implements Product {
    public void use() { /* ... */ }
}

public class ProductFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}

观察者模式：

定义：定义对象之间的一对多依赖，让多个观察者同时监听某一主题。

示例：

public interface Observer {
    void update(String message);
}

public class Subject {
    private List<Observer> observers = new ArrayList<>();
    void addObserver(Observer observer) { observers.add(observer); }
    void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

策略模式：
- 定义：定义一系列算法，将

每一个算法封装起来，使得它们可以互换。

示例：

public interface Strategy {
    int execute(int a, int b);
}

public class AddStrategy implements Strategy {
    public int execute(int a, int b) {
        return a + b;
    }
}

public class Context {
    private Strategy strategy;
    public Context(Strategy strategy) { this.strategy = strategy; }
    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}

22. 多线程的机制、实现方法与应用

机制：
- 线程调度：JVM的线程调度由操作系统负责，可能使用时间片轮转或优先级调度。
- 同步：使用 synchronized 关键字，或者 ReentrantLock 类来保证线程安全。

实现方法：

继承Thread类：

public class MyThread extends Thread {
    public void run() {
        // thread code
    }
}

实现Runnable接口：

public class MyRunnable implements Runnable {
    public void run() {
        // thread code
    }
}

Thread t = new Thread(new MyRunnable());
t.start();

应用：
- 并发任务处理：如并行计算、下载任务。
- 异步操作：如后台任务处理、UI线程的非阻塞操作。

23. AWT、Swing和事件处理模型概念与应用

AWT：

特点：原生组件，直接映射到操作系统的GUI组件。

示例：

Frame frame = new Frame("AWT Example");
Button button = new Button("Click Me");
frame.add(button);
frame.setSize(300, 200);
frame.setVisible(true);

Swing：

特点：提供了更丰富的组件，所有组件都是由Java实现的，不依赖操作系统的GUI。

示例：

JFrame frame = new JFrame("Swing Example");
JButton button = new JButton("Click Me");
frame.add(button);
frame.setSize(300, 200);
frame.setVisible(true);

事件处理模型：

事件源：生成事件的组件。
事件监听器：响应事件的代码，通过接口实现。

示例：

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }
});

24. 关系的种类、表示及其含义

继承（Inheritance）：
- 表示：父类与子类之间的关系，子类继承父类的属性和方法。
- 示例：class Dog extends Animal {}
实现（Implementation）：
- 表示：类与接口之间的关系，类实现接口中定义的方法。
- 示例：class Dog implements Animal {}
关联（Association）：
- 表示：类之间的关系，通常通过成员变量表示。
- 示例：class Person { Address address; }
依赖（Dependency）：
- 表示：类在运行时依赖于另一个类。
- 示例：class Person { void setAddress(Address address) { this.address = address; } }