java基础语知识（8）

王磊鑫2025-02-21 8:02

类之间的关系

在类之间，最常见的关系有：

  • 依赖（"uses-a"）;
  • 聚合（"has-a"）;
  • 继承（"is-a"）。
  1. 依赖 ：一种使用关系，即一个类的实现需要另一个类的协助，使用关系具有偶然性、临时性、非常弱，被使用类的变化会影响到使用类。在 Java 中表现为局部变量、方法的参数或者对静态方法的调用。例如class Driver中方法drive1(Car car)、drive2()、drive3()分别通过形参、局部变量、静态方法调用体现对Car类的依赖。
  2. 聚合 ：关联关系的特例，是强关联关系，体现整体与部分的关系，且部分可以离开整体而单独存在，它们有各自的生命周期，部分可属于多个整体对象，也可为多个整体对象共享。在 Java 中一般使用成员变量形式实现，一般用setter方法给成员变量赋值。例如class Driver中Car mycar，若赋予 "车是司机财产一部分" 语义，可表示聚合关系。
  3. 继承（泛化） ：是一种继承关系，表示一般与特殊的关系，指定子类如何获得父类的所有特征和行为。通过关键字extends明确标识。例如class Dog extends Animal，表示Dog类继承自Animal类，Dog类拥有Animal类的属性和方法，还可拥有自己特有的属性和方法。

对象与对象变量

想要使用对象，首先必须先构造对象，并且对其指定初始状态。然后对对象应用方法。

在java程序设计语言中，要使用**构造器（constructor, 或称构造函数）**构造新实例。构造器是一种特殊的方法，用来构造并初始化对象。

构造器的定义

构造器的名称必须与类名完全相同，并且没有返回类型（连 void 也不能有）。

基本语法如下：

java 复制代码 
[访问修饰符] 类名([参数列表]) {
    // 构造器的方法体
}

构造器的特点

  • 名称与类名相同：构造器的名称必须和所在类的名称一致，这是 Java 语言的规定，用于明确标识这是一个构造器。大小写也需要一致。
  • 没有返回类型：构造器不能声明返回类型，包括 void 也不可以。这是因为构造器的主要目的是创建并初始化对象，而不是返回一个值。
  • 在创建对象时自动调用：当使用 new 关键字创建一个对象时，会自动调用相应类的构造器来完成对象的初始化工作。

对象（Object）

定义

对象是类的一个实例。类是对一类事物的抽象描述，规定了这类事物所具有的属性和行为；而对象则是类在现实世界中的具体个体，它拥有类所定义的属性和行为的具体值。例如，"汽车" 可以看作一个类，而某一辆具体的红色宝马汽车就是 "汽车" 类的一个对象。

创建对象

在 Java 中，使用 new 关键字来创建对象，其一般步骤如下：

  1. 声明类类型的变量：指定要创建对象的类型。
  2. 使用 new 关键字创建对象：调用类的构造器来初始化对象。
java 复制代码 
class Car {
    String color;
    String brand;

    // 构造器
    public Car(String color, String brand) {
        this.color = color;
        this.brand = brand;
    }

    public void showInfo() {
        System.out.println("This is a " + color + " " + brand + " car.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建 Car 对象
        Car myCar = new Car("red", "BMW");
        myCar.showInfo();
    }
}

在上述代码中，Car 是一个类，myCar 是 Car 类的一个对象。通过 new Car("red", "BMW") 调用 Car 类的构造器创建了一个具体的汽车对象，并对其属性进行了初始化。

对象变量（Object Variable）

定义

对象变量是用来引用对象的变量，它存储的是对象在内存中的引用（地址），而不是对象本身。可以把对象变量看作是指向对象的一个 "指针"，通过这个变量可以访问和操作对象的属性和方法。

对象变量的声明和赋值

声明对象变量的语法与声明基本数据类型变量类似，需要指定变量的类型和名称。赋值时，将 new 关键字创建的对象的引用赋给对象变量。

示例代码如下：

java 复制代码 
class Dog {
    String name;

    public Dog(String name) {
        this.name = name;
    }

    public void bark() {
        System.out.println(name + " is barking!");
    }
}

public class Main {
    public static void main(String[] args) {
        // 声明对象变量
        Dog myDog;
        // 创建对象并将引用赋值给对象变量
        myDog = new Dog("Buddy");
        myDog.bark();
    }
}

在上述代码中，Dog myDog; 声明了一个 Dog 类型的对象变量 myDog，myDog = new Dog("Buddy"); 将创建的 Dog 对象的引用赋给了 myDog 变量，之后就可以通过 myDog 来调用 Dog 对象的方法。

对象和对象变量的区别

  1. 存储内容不同

    • 对象：对象是在堆内存中实际分配的一块内存区域，包含了对象的属性值等具体数据。
    • 对象变量：对象变量存储的是对象在堆内存中的引用（地址），它位于栈内存中。

  2. 生命周期不同

    • 对象 ：对象的生命周期从使用 new 关键字创建开始，直到没有任何对象变量引用它，并且被 Java 的垃圾回收机制回收为止。
    • 对象变量：对象变量的生命周期取决于它的作用域。当对象变量超出其作用域时，它就会被销毁，但对象本身不一定被销毁，只要还有其他对象变量引用它。

  3. 操作方式不同

    • 对象：对象本身不能直接进行操作，需要通过对象变量来访问和操作对象的属性和方法。
    • 对象变量：可以通过对象变量来调用对象的方法、访问对象的属性等。
  • 需要注意的是，对象变量并没有实际包含一个对象，它只是引用一个对象。
  • 在java中，任何对象变量的值都是对存储在另一个地方的某个对象的引用。
    注：很多人误以为 Java 对象变量等同于 C++ 引用。实则不然，C++ 无 null 引用且引用不可赋值。Java 对象变量类似 C++ 对象指针，如 Java 的 Date birthday; 等同于 C++ 的 Date* birthday; ，且二者用 new 初始化语法相近。变量复制后，二者指向同一对象指针，Java 的 null 引用对应 C++ 的 NULL 指针。

this关键字

在 Java 中，this关键字是一个引用，指向当前对象的实例，主要有以下几种用法：

引用当前对象的成员变量

当类中方法的局部变量和成员变量同名时，根据就近原则，方法会优先使用局部变量。若想访问被覆盖的成员变量，则需使用this前缀。例如：

java 复制代码 
public class Teacher { 
    private String name; 
    private double salary; 
    private int age; 
    public Teacher(String name,double salary,int age) { 
        this.name = name; 
        this.salary = salary; 
        this.age = age; 
    }
}

上述代码中，构造方法的参数与成员变量同名，通过this.name、this.salary、this.age明确操作的是成员变量。

调用当前对象的其他方法

this关键字可在方法内部调用当前对象的其他方法，能避免与方法参数或局部变量同名的方法名冲突，确保调用的是当前对象的方法。示例如下：

java 复制代码 
public class Dog { 
    public void jump() { 
        System.out.println("正在执行jump方法"); 
    } 
    public void run() { 
        this.jump(); 
        System.out.println("正在执行run方法"); 
    }
}
访问本类的构造方法

this()用于访问本类的构造方法，且必须是构造方法中的第一条语句。例如：

java 复制代码 
public class Student { 
    String name; 
    public Student() { 
        this("张三"); 
    } 
    public Student(String name) { 
        this.name = name; 
    } 
    public void print() { 
        System.out.println("姓名：" + name); 
    }
}

无参构造方法Student()中，this("张三")调用了有参构造方法Student(String name)。

实现链式调用

在方法返回this关键字，可实现链式调用，即能在同一个对象上连续调用多个方法。示例：

java 复制代码 
public class Calculator { 
    private int result; 
    public Calculator add(int number) { 
        this.result += number; 
        return this; 
    } 
    public Calculator subtract(int number) { 
        this.result -= number; 
        return this; 
    } 
    public int getResult() { 
        return this.result; 
    }
} 
// 链式调用示例 
Calculator calculator = new Calculator(); 
calculator.add(5).subtract(3); 
int result = calculator.getResult();

上述代码中，add和subtract方法都返回this，实现了链式调用。

此外，使用this关键字还有一些注意事项：

  • 不能在静态方法中使用，因为静态方法属于类本身，而非任何对象。
  • this关键字的值不能被赋值给另一个变量，因其只是一个引用，不是对象。
  • 应避免滥用，以免影响代码的可读性和可维护性。
  • this可以区分成员变量和局部变量。

构造方法

构造方法注意事项

  1. 构造方法的定义- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法。 - 如果定义了构造方法，系统将不再提供默认的构造方法。

  2. 构造方法的重载 - 带参构造方法和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载。

  3. 推荐的使用方式- 无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法。

无参数构造方法

如果类中没有定义任何构造方法，Java 编译器会自动提供一个默认的无参数构造方法。当然，也可以手动定义无参数构造方法。示例如下：

java 复制代码 
class Book {
    String title;
    int pageCount;

    // 无参数构造方法
    public Book() {
        title = "默认书名";
        pageCount = 0;
    }

    public void displayInfo() {
        System.out.println("书名: " + title);
        System.out.println("页数: " + pageCount);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Book对象时，调用无参数构造方法
        Book myBook = new Book();
        myBook.displayInfo();
    }
}

在上述代码中，Book类定义了一个无参数构造方法，在创建Book对象时，该构造方法会被调用，将title初始化为 "默认书名"，pageCount初始化为 0。

带全部参数构造方法

带参数的构造方法用于在创建对象时，为对象的成员变量赋初始值。示例如下：

java 复制代码 
class Person {
    String name;
    int age;
    String address;

    // 带全部参数构造方法
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void showInfo() {
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("地址: " + address);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建Person对象时，调用带全部参数构造方法
        Person person = new Person("张三", 25, "北京市");
        person.showInfo();
    }
}

这里Person类的构造方法接受name、age、address三个参数，在创建Person对象时，通过传递相应的参数来初始化对象的成员变量。

构造方法重载

一个类中可以有多个构造方法，只要它们的参数列表不同，这就是构造方法重载。示例如下：

java 复制代码 
class Circle {
    double radius;
    String color;

    // 无参数构造方法
    public Circle() {
        radius = 1.0;
        color = "红色";
    }

    // 带一个参数构造方法
    public Circle(double radius) {
        this.radius = radius;
        color = "蓝色";
    }

    // 带两个参数构造方法
    public Circle(double radius, String color) {
        this.radius = radius;
        this.color = color;
    }

    public void printInfo() {
        System.out.println("半径: " + radius);
        System.out.println("颜色: " + color);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用不同的构造方法创建对象
        Circle circle1 = new Circle();
        Circle circle2 = new Circle(2.5);
        Circle circle3 = new Circle(3.0, "绿色");

        circle1.printInfo();
        circle2.printInfo();
        circle3.printInfo();
    }
}

在Circle类中，定义了三个构造方法，分别是无参数、带一个参数、带两个参数的构造方法。通过构造方法重载，可以根据不同的需求，以不同的方式来创建Circle对象。

标准的javabean类

JavaBean 是一种符合特定编程规范的 Java 类，在 Java 开发中用于封装数据和提供访问数据的方法，方便在不同组件间传递数据等。

在java中：

  1. 类是公共的（public）：保证其他类能够访问该 JavaBean 类。
  2. 有一个公共的无参构造方法：便于在反射等机制以及框架（如 Spring）创建对象时使用，比如在框架初始化对象实例时，会首先调用这个无参构造方法。
  3. 属性私有（private）：对数据进行封装，保证数据的安全性，防止外部直接访问和修改。
  4. 通过公共的 getter 和 setter 方法访问属性：提供了受控的方式来访问和修改私有属性，同时也可以在这些方法中添加业务逻辑，比如数据验证等。
组成部分
  1. 私有属性：用于存储数据，例如：
java 复制代码 
private String name;
private int age;

上述代码中，name和age就是JavaBean类的私有属性。

  1. 无参构造方法：
java 复制代码 
public MyBean() {
}

无参构造方法在创建对象时若没有传入参数，会默认初始化对象的属性。

  1. getter 方法 ：用于获取私有属性的值，命名规范是get加上属性名，且首字母大写（对于布尔类型属性，若属性名是is开头，则 getter 方法为is属性名），例如：
java 复制代码 
public String getName() {
    return name;
}
public int getAge() {
    return age;
}

4.setter 方法 ：用于设置私有属性的值，命名规范是set加上属性名，且首字母大写，例如：

java 复制代码 
public void setName(String name) {
    this.name = name;
}
public void setAge(int age) {
    this.age = age;
}

一个完整的JavaBean示例如下：

java 复制代码 
public class Person {
    // 私有属性
    private String name;
    private int age;

    // 无参构造方法
    public Person() {
    }

    // getter方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // setter方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

在使用时，可以：

java 复制代码 
public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("Alice");
        person.setAge(25);
        System.out.println("姓名：" + person.getName() + "，年龄：" + person.getAge());
    }
}
注意事项
  • 类名需要见名知意。
  • 成员变量使用private修饰。
  • 提供至少两个构造方法： 无参构造方法。 带全部参数的构造方法。
  • 成员方法： 提供每一个成员变量对应的setXxx()/getXxx()。 如果还有其他行为，也需要写上。

Java 内存分配区域

Java 内存主要分为以下几个区域：

  • 栈（Stack） ：方法运行时所进入的内存，局部变量也是在这里存储。每个方法在执行时会创建一个栈帧用于存储局部变量表、操作数栈、动态链接、方法出口等信息。方法执行结束，栈帧就会被销毁。例如，在一个方法中定义的int num = 10;，num这个局部变量就存储在栈内存中。
  • 堆（Heap） ：new出来的对象和数组等都在堆内存中开辟空间并产生地址。堆是 Java 内存管理的核心区域，是被所有线程共享的一块内存区域，其生命周期从 JVM 启动开始，直到 JVM 停止。对象的实例化、内存分配等操作都在堆中进行，比如new Student();创建的学生对象就存放在堆内存中。
  • 方法区（Method Area） ：字节码文件加载时进入的内存，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。例如HelloWorld.class、Test.class等字节码文件在加载时就会进入方法区。另外，像static修饰的静态变量也存储在方法区。
  • 本地方法栈（Native Method Stack）：与虚拟机使用的本地方法相关，为 Native 方法服务。比如 Java 调用 C 或 C++ 的本地代码时，相关的内存操作就在本地方法栈进行。
  • 寄存器：用于存储指令、操作数等，是 CPU 内部的高速存储区域，与 Java 内存模型的关系相对间接，主要供 CPU 快速访问数据。

一个对象的内存分配过程（以Student s = new Student();为例）

  1. 加载 class 文件 ：JVM 首先会查找并加载Student类的字节码文件（.class文件）到方法区，解析类的元数据信息，如类的字段、方法等。
  2. 申明局部变量 ：在栈内存中声明一个名为s的局部变量，此时它还没有指向任何有效的对象。
  3. 在堆内存中开辟一个空间 ：使用new关键字在堆内存中为Student对象分配一块内存空间，这块空间用于存储对象的实例变量等数据。
  4. 默认初始化 ：堆内存中为对象分配的空间会进行默认初始化，比如对于基本数据类型的成员变量，int类型默认初始化为0，boolean类型默认初始化为false等；对于引用类型的成员变量，默认初始化为null。
  5. 显示初始化 ：按照类中成员变量定义时的赋值语句进行初始化，例如private int age = 18;，如果有这样的定义，此时age就会被初始化为18。
  6. 构造方法初始化 ：调用Student类的构造方法，对对象进行进一步的初始化操作，构造方法中可以对成员变量进行赋值等操作。
  7. 将堆内存中的地址值赋值给左边的局部变量 ：把在堆内存中创建的Student对象的地址赋值给栈内存中的局部变量s，此时s就指向了堆内存中的Student对象，后续就可以通过s来操作该对象。

多个对象引用指向同一个对象的内存情况

假设有以下代码：

java 复制代码 
Student s1 = new Student();
Student s2 = s1;
  • 首先按照上述单个对象创建过程，new Student();在堆内存中创建一个Student对象，同时在栈内存中创建局部变量s1并指向堆中的对象。
  • 执行Student s2 = s1;时，在栈内存中又创建了一个局部变量s2，并将s1中存储的对象地址赋值给s2，这样s1和s2都指向了堆内存中的同一个Student对象。此时，如果通过s1修改对象的属性，s2访问该对象时也会看到属性的变化，因为它们指向的是同一个对象。

不同对象的内存情况

当有多个不同对象创建时，比如：

java 复制代码 
Student s1 = new Student();
Student s3 = new Student();
  • 每次执行new Student();都会在 堆内存中开辟独立的空间创建新的Student对象。
  • 栈内存中分别有s1和s3两个局部变量，它们各自指向堆内存中不同的Student对象，这两个对象的属性相互独立，修改s1指向对象的属性不会影响s3指向的对象。
相关推荐
lsx2024068 分钟前
Perl 面向对象编程指南
开发语言
Allen Bright29 分钟前
【Java基础-46.3】Java泛型通配符详解：解锁类型安全的灵活编程
java·开发语言
柃歌32 分钟前
【UCB CS 61B SP24】Lecture 7 - Lists 4: Arrays and Lists学习笔记
java·数据结构·笔记·学习·算法
柃歌41 分钟前
【UCB CS 61B SP24】Lecture 4 - Lists 2: SLLists学习笔记
java·数据结构·笔记·学习·算法
画个逗号给明天"42 分钟前
C++STL容器之list
开发语言·c++
是姜姜啊！1 小时前
redis的应用,缓存,分布式锁
java·redis·spring
梨落秋溪、1 小时前
输入框元素覆盖冲突
java·服务器·前端
hrrrrb1 小时前
【Java】Java 常用核心类篇 —— 时间-日期API（上）
java·开发语言
小突突突1 小时前
模拟实现Java中的计时器
java·开发语言·后端·java-ee
七禾页话1 小时前
垃圾回收知识点
java·开发语言·jvm
热门推荐
01太炸裂了！清华大学deepseek从入门到精通使用手册又出第三版了，《普通人如何抓住DeepSeek红利》（无套路，直接下载）02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek本地部署详细指南04DeepSeek各版本说明与优缺点分析05本地部署DeepSeek教程（Mac版本）06DeepSeek r1本地安装全指南07本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09在Windows下安装Ollama并体验DeepSeek r1大模型10Page Assist - 本地Deepseek模型 Web UI 的安装和使用