javaSE类和对象进阶用法举例详解_Java

前言

在掌握了类和对象的基础概念后，我们需要进一步学习面向对象的核心特性及进阶用法。本文将深入探讨封装的实现、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 代码。下一阶段，我们将学习继承和多态，进一步完善面向对象的知识体系。

到此这篇关于javase类和对象进阶用法的文章就介绍到这了,更多相关javase类和对象内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

javaSE类和对象进阶用法举例详解

2025年08月05日 • Java •我要评论

前言