【javaSE】类和对象进阶

那我掉的头发算什么

发布于 2026-01-12 18:28:42

910

在掌握了类和对象的基础概念后，我们需要进一步学习面向对象的核心特性及进阶用法。本文将深入探讨封装的实现、static 成员的特性、代码块的作用以及对象打印的技巧，帮助你构建更完善的面向对象编程知识体系。

一、封装

封装是面向对象的三大核心特性（封装、继承、多态）之一，其核心思想是将类的属性和实现细节隐藏起来，只对外暴露必要的接口供其他对象访问。通过封装，可以提高代码的安全性、可维护性和复用性。

1.访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

在涉及包之前，先用private和publlic来帮助大家理解一下访问限定符的使用。例：

class Student{
    private String name;
    private int age;
    private double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }
}
public class Test2 {
    public static void main(String[] args) {
        Student student = new Student("xiaoming",9,78);
        System.out.println(student.name);/*报错，在Test2类中
        调用Student类中的成员变量name,但是name
        被private限定符修饰，所以没法直接使用*/

        student.setName("zhangsan");
        System.out.println(student.getName());
        /*不会报错：getName和setName都用public作为限定符来修饰，
        在不同包不同类中也可以随意调用*/
    }




}

然而，如果想借助getName和setName来改变name的值过于麻烦还需要再写两个成员方法，所以java提供了一种一键生成方法的简便方法：

只需要按照图中所示方法可以直接生成方法。我使用的是汉化版的idea，没有汉化版的应该如下图所示：

2.包

2.1包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

2.2导入包

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类.

public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

但是这种写法比较麻烦一些, 可以使用 import语句导入包.

import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*；

import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

可以使用import static导入包中静态的方法和字段。

import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}

2.3自定义包

基本规则 1.在文件的最上方加上一个 package 语句指定该代码在哪个包中. 2.包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ). 3.包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码. 4.如果一个类没有 package 语句, 则该类被放到一个默认包中 操作步骤

在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

在弹出的对话框中输入包名, 例如 com.bit.demo1

在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

2.4常见的包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reﬂect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

二、static成员

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

1.static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。 【静态成员变量特性】

不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
类变量存储在方法区当中
生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static int classroom = 1;
}
public class One {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
        Student student3 = new Student();
        System.out.println(Student.classroom);
        System.out.println(student1.classroom);
        System.out.println(student2.classroom);
        System.out.println(student3.classroom);
    }
}

静态成员变量可以直接通过类名访问也可以通过对象访问：但是classRoom是三个对象共享的下面这个例子详细说明共享性：

class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static int classroom = 1;
}
public class One {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
        Student student3 = new Student();
        student1.classroom++;
        student2.classroom++;
        student3.classroom--;
        Student.classroom++;
        System.out.println(Student.classroom);
    }
}

你觉得输出结果是多少呢？答案是3。因为classroom不依赖于对象而存在，依赖于类而存在。

2.static修饰成员方法

【静态方法特性】

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
不能在静态方法中访问任何非静态成员变量
静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

三、代码块

1.代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种： 1.普通代码块 2.构造块 3.静态块 4.同步代码块

2.普通代码块

普通代码块：定义在方法中的代码块

public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100

3.构造代码块静态代码块实例代码块

如何定义：

 {
        this.classroom = 114;
        System.out.println("调用了实例化代码块");
    }

    static{
        classroom = 115;
        System.out.println("调用了静态代码块，一般用来初始化成员变量");
    }

    public Student1(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        System.out.println("构造函数生成了");
    }

静态代码块随类的生成而生成：

class Student1{
    public String name;
    public String gender;
    public int age;
    private static int classroom = 113;
    public static int getClassroom(){
        return classroom;
    }

    {
        this.classroom = 114;
        System.out.println("调用了实例化代码块");
    }

    static{
        classroom = 115;
        System.out.println("调用了静态代码块，一般用来初始化成员变量");
    }

    public Student1(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        System.out.println("构造函数生成了");
    }
}
public class Two {
    public static void main(String[] args) {
        System.out.println(Student1.getClassroom());
    }
}

这段代码中只有静态代码块生成了。

再来看下面这段代码：

class Student1{
    public String name;
    public String gender;
    public int age;
    private static int classroom = 113;
    public static int getClassroom(){
        return classroom;
    }

    {
        this.classroom = 114;
        System.out.println("调用了实例化代码块");
    }

    static{
        classroom = 115;
        System.out.println("调用了静态代码块，一般用来初始化成员变量");
    }

    public Student1(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        System.out.println("构造函数生成了");
    }
}
public class Two {
    public static void main(String[] args) {
        Student1 student = new Student1("zhangsan","男",5);
        System.out.println(student.getClassroom());
    }
}

静态代码块只会执行一次，实例代码块和构造代码块执行次数和定义的对象个数相同。即： 注意事项 静态代码块不管生成多少个对象，其只会执行一次静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并) 实例代码块只有在创建对象时才会执行

四、对象的打印

在开发中，我们经常需要打印对象信息来调试或展示，但直接打印对象会得到不理想的结果，这就需要重写toString()方法

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;

    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

这段代码打印的结果是person这个对象的地址信息如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可。

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;

    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

toString方法也可以按照之前学习的一键生成构造方法的方式来快速生成

总结

本文介绍了类和对象的四个进阶知识点：封装通过private隐藏数据，用getter/setter控制访问，保障数据安全和代码可维护性。 static 成员属于类而非对象，适用于共享数据和工具方法，通过类名.成员访问。代码块分为静态代码块（类加载时执行）和实例代码块（对象创建时执行），用于初始化操作。对象打印需重写toString()方法，自定义属性输出格式，提升调试效率。这些知识点是面向对象编程的核心，掌握它们能帮助你编写更规范、高效的 Java 代码。下一阶段，我们将学习继承和多态，进一步完善面向对象的知识体系。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2026-01-12，如有侵权请联系 cloudcommunity@tencent.com 删除

对象