Java 基础学习总结-优快云博客

作者：yqc / 学号：202302151410

7.1 封装（Encapsulation）

Date 类与 SimpleDateFormat

Random 类

学习心得

总结

引言

Java 是一门广泛应用于企业开发、移动应用和大数据分析的编程语言。本文将从 Java 的基础知识开始，逐步深入到面向对象编程以及常用工具类的核心知识点。希望通过本文，能够帮助读者更好地掌握 Java 编程，并在学习中找到适合自己的方法。

1. 变量与常量

变量与常量是 Java 编程的基础，代表程序运行中的动态与静态数据。

变量： 是存储数据的基本单位，值可以改变。
常量： 使用final修饰，代表一旦赋值就不能再更改的量。

示例代码

int age = 25; // 定义变量 final double PI = 3.14159; // 定义常量

学习心得

在编写代码时，善于使用常量可以减少重复赋值带来的错误，同时提升代码的可读性和稳定性。

2. 运算符与表达式

运算符用于对变量或常量进行操作，表达式是运算符与操作数的组合。

常见运算符

算术运算符： +，-，*，/，%
关系运算符： ==，!=，>，<，>=，<=
逻辑运算符： &&，||，!

示例代码

int a = 10, b = 20; 
boolean result = (a < b) && (a > 5); 
System.out.println("运算结果：" + result);

学习心得

运算符优先级是学习中的一个难点，建议使用括号明确逻辑。熟练掌握关系与逻辑运算符有助于编写条件控制语句。

3. 条件控制语句与循环语句

条件控制语句和循环语句使程序具有决策能力与重复执行功能。

常见条件控制语句

if-else 语句
switch-case 语句

示例代码

if (age > 18) {
 System.out.println("成年"); 
} else { 
System.out.println("未成年"); 
}

}

常见循环语句

for 循环
while 循环
do-while 循环

for (int i = 1; i <= 5; i++) {
 System.out.println("循环次数：" + i);
 }

学习心得

在循环中善于使用break和continue可以更灵活地控制流程。使用调试工具分析代码执行顺序对掌握循环语句尤为重要。

4. 方法

方法是实现功能逻辑的基本单元，用于代码复用和逻辑组织。

定义与调用方法

public static int add(int a, int b) {
    return a + b;
}
System.out.println(add(5, 3));

学习心得

设计方法时应遵循单一职责原则，即每个方法只完成一个任务，这有助于代码的可维护性和可扩展性。

5. 数组

数组是一种存储相同数据类型的集合，具有固定长度。

示例代码

int[] numbers = {1, 2, 3, 4, 5};
System.out.println("数组第一个元素：" + numbers[0]);

学习心得

学习数组时，可以结合二维数组的表格结构进行实际应用，比如实现简单的矩阵运算。

6. JVM 的堆内存与栈内存

理解内存管理是高效编写 Java 程序的关键。

栈内存： 存储局部变量和方法调用。
堆内存： 存储对象和数组。

学习心得

通过学习 JVM 的内存模型，可以帮助解决程序中的内存溢出问题，例如StackOverflowError和OutOfMemoryError。

7. 面向对象的相关知识点（增加比重）

面向对象编程（OOP）有三个基本特征：封装、继承、多态。这三个特性是 Java 面向对象的核心内容，能够使代码更具可读性、可维护性和可扩展性。

7.1 封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）打包在一起，隐藏实现的细节，外部只能通过公开的方法来访问对象的状态。这有助于提高代码的安全性和可靠性。

示例代码：

class Person {
    private String name;  // 私有属性

    // 公共的 getter 和 setter 方法来访问属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        System.out.println("姓名: " + person.getName());
    }
}

7.2 继承（Inheritance）

继承是 OOP 的重要特性之一，它使得子类能够继承父类的属性和方法，从而实现代码的重用。继承有助于减少冗余代码，使代码更简洁。

示例代码：

// 父类
class Animal {
    void speak() {
        System.out.println("动物发出声音");
    }
}

// 子类继承父类
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("狗叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak();  // 输出 "狗叫"
    }
}

7.3 多态（Polymorphism）

多态是指同一个方法调用，产生不同的行为。它是继承和方法重写的基础，通常表现为方法的动态绑定。通过多态，Java 程序能够处理不同类型的对象。

示例代码：

// 父类
class Animal {
    void speak() {
        System.out.println("动物发出声音");
    }
}

// 子类继承父类并重写方法
class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("狗叫");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("猫叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();  // 多态
        Animal animal2 = new Cat();  // 多态

        animal1.speak();  // 输出 "狗叫"
        animal2.speak();  // 输出 "猫叫"
    }
}

7.4 `this` 关键字

this 关键字用于引用当前对象。它常用于方法或构造方法中，避免局部变量与实例变量的冲突，或者在构造方法中调用其他构造方法。

示例代码：

class Person {
    private String name;

    // 构造方法中使用 this
    public Person(String name) {
        this.name = name;  // 通过 this 区分实例变量与参数
    }

    public String getName() {
        return this.name;
    }
}

7.5 `static` 关键字

static 关键字表示类变量或类方法。通过static，可以不需要创建对象，直接通过类名访问类的成员。

示例代码：

class Counter {
    static int count = 0;  // 静态变量

    public static void increment() {  // 静态方法
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter.increment();
        System.out.println("计数器: " + Counter.count);
    }
}

7.6 `final` 关键字

final 用于定义常量、禁止方法重写和禁止类继承。

示例代码：

// 定义常量
final double PI = 3.14159;

// 禁止继承
final class FinalClass {
    // 代码
}

// 禁止方法重写
class Animal {
    public final void speak() {
        System.out.println("动物发出声音");
    }
}

7.7 `super` 关键字

super 用于访问父类的成员，尤其是当子类重写了父类方法或属性时，super 可用于调用父类的原始方法或属性。

示例代码：

class Animal {
    void speak() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        super.speak();  // 调用父类的 speak 方法
        System.out.println("狗叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.speak();  // 输出 "动物发出声音" 和 "狗叫"
    }
}

7.8 抽象类与接口

抽象类（Abstract Class）： 用于提供一个类的框架，子类可以继承并实现其中的方法。抽象类可以有方法的实现和声明。
接口（Interface）： 用于定义一组行为规范，接口中的方法只有声明，没有实现。

示例代码：

// 抽象类
abstract class Animal {
    abstract void speak();  // 抽象方法
}

// 接口
interface CanFly {
    void fly();  // 接口方法
}

// 实现抽象类与接口
class Bird extends Animal implements CanFly {
    @Override
    void speak() {
        System.out.println("鸟叫");
    }

    @Override
    public void fly() {
        System.out.println("鸟飞");
    }
}

7.9 内部类

内部类 是定义在另一个类内部的类，可以访问外部类的成员，且常用于构建复杂数据结构。

示例代码：

class Outer {
    private int outerValue = 10;

    class Inner {
        void display() {
            System.out.println("外部类的值: " + outerValue);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.display();  // 输出 "外部类的值: 10"
    }
}

学习心得

OOP 概念的学习需要结合实际项目，比如实现一个简单的动物管理系统，可以更好地理解继承、多态等知识点。

8. 常用类

String 类

不可变字符串，使用+进行拼接。

Date 类与 SimpleDateFormat

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(sdf.format(new Date()));

Random 类

Random random = new Random();
System.out.println("随机数：" + random.nextInt(100));

学习心得

善于使用常用类可以提升编程效率。建议通过项目中实践学习这些类的功能。

总结

学习 Java 的基础知识需要不断实践和总结，本文从变量、运算符到面向对象编程及常用工具类，全面覆盖了 Java 的核心内容。通过理论与实践相结合的方式，相信大家可以更深入地掌握 Java 编程。