Java 中的类和对象（实现封装，static修饰成员以及代码块）

JANG1024

已于 2022-11-11 23:50:56 修改

阅读量261

点赞数 4

分类专栏： JAVA基础文章标签： java jvm 开发语言 intellij-idea

于 2022-11-09 18:48:04 首次发布

本文链接：https://blog.csdn.net/qq_55829345/article/details/127751432

版权

JAVA基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

类和对象-封装

类的定义
类的实例化：
this 引用
构造方法
封装
Java 包(package)
import
static 静态成员
- static 修饰成员变量
- static 修饰成员方法
代码块

类的定义

Java 是一门面向对象的程序设计语言，在 Java 中，一切都是对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成某一功能。
在面向对象的设计过程中有两个特别重要的概念：类和对象。

类：类是一个模板，描述一类对象的行为和状态。有了模板我们就可以根据这个模板创建具体的对象
对象： 对象是类的一个具体实例，有状态和行为。

Java 定义类的语法如下：

// 创建类
class ClassName{
    field; // 字段(属性) 或者 成员变量
    method; // 行为 或者 成员方法
}

其中 class 为定义类的关键字，ClassName 为类的名字，{ } 中为类的主体。

例如我们想要定义一个狗类：

class Dog{
	//成员变量
    public String name;    //狗的名字
    public int age;        //年龄
    public String color;   //颜色
    //成员方法
    public void run(){  //跑步
        System.out.println("跑步");
    }
    public void watch(){    //看门
        System.out.println("看门");
    }
}

在这个类中，定义了狗的属性（名字、年龄、颜色）也叫成员变量，还有狗的行为（跑步、看门）也叫成员方法。

类的实例化：

定义好一个类后，我们就可以使用自己自定义的类来定义实例（这里的实例就是对象）。
用类型创建对象的过程，称为类的实例化，java 采用 new 关键字和类名来实例化对象。这就是大家常看到或听到的 new 一个对象。

下面将实例化上面的 Dog 类：

new 对象

注意： 使用点 . 来访问对象的属性或方法，同一个类可以创建多个对象。

this 引用

我们先来看这样一段代码：

没有this

在 dog1 对象，我们使用了对象 . 属性赋值，并且也打印出了狗的信息，在 dog2 对象，使用了对象里的方法，通过方法给对象赋值，也成功打印了信息。

在上面这段代码中，我们看到 setName 方法中，都是一个个字母，并不能直观地感受到每个参数具体是什么，所以我们将它修改一下：

形参改变后

当我们将 setName 方法中的形参修改后，我们发现 dog2 对象并没有打印出信息来，这是因为在 setName 方法中，局部变量优先，只是形参自己给自己赋值了，并没有将值赋给成员变量，所以成员变量的值仍是默认的，也就打印出图中的结果了。

那如何解决这个问题？我们只需要加上 this. 即可。效果如下：

加上this后

注意：
this 的类型：哪个对象调用就是哪个对象的引用类型。
this 只能在 “成员方法” 中使用。
在 “成员方法” 中，this 只能引用当前对象，不能再引用其他对象。

构造方法

在上面的代码中，每次创建对象后，需要手动调用 setName 方法设置具体信息，比较麻烦，而使用构造方法就可以解决这个问题。

在下面这段代码，当我们手动添加一个无参构造方法后，程序就会使用我们设置的方法，如果没有定义任何的构造方法（包括带参数的构造方法），Java 编译器才会提供一个默认构造方法。

无参构造方法

通过这段代码，我们可以认为，当构造方法调用完成之后，对象才产生。
当然，有不带参的构造方法，那就会有带参的构造方法。

带参构造方法

注意： 这里添加了带参的构造方法，此时就不能把不带参的构造方法给注释或删除。

写了构造方法后，不能删除无参方法
构造方法特点：

名字必须与类名相同。
没有返回值类型，设置为 void 也不行。即不能写成 public void Dog( ){ }。
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次。
构造方法可以重载（可以根据自己的需求提供不同参数的构造方法）。
如果用户没有定义任何构造方法，编译器才会生成一份默认的构造方法，生成的默认构造方法一定是无参的。
构造方法中，可以通过 this 调用其他构造方法来简化代码。（这里的 this 只能放在构造方法里的第一行。如果无参构造方法使用了 this 调用带参构造方法，那么带参构造方法中就不能再使用 this 调用无参构造方法，如果两个都用 this 调用对方，就一直会循环调用）

封装

面向对象程序三大特性：封装、继承、多态。封装其实就是把具体的实现细节给隐藏起来，只提供一些公开的接口和对象进行交互。也就是把不想给别人看见的东西给封装起来，通过其他方式才能访问。

实现封装的步骤：

修改属性的可见性，也就是访问限定符，一般限制为 private 。

class Student{
    public String name;
    private String sex;
    private int age;
}

上面这段代码，将 sex 和 age 设置为私有的，只能在 Student 类里使用。 private
2. 限定访问后，我们可以提供对外的访问方法（创建一对赋值 setter 和取值 getter 的方法），用于对私有属性的访问。

class Student{
    public String name;
    private String sex;
    private int age;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

如果有多个成员变量需要设置方法供外部访问，我们并不需要一步一步手动创建。

在 eclipse 里创建 getter 和 setter：

eclipse 创建get和set
生成get和set

IDEA里：右键选择 Generate：

在这里插入图片描述
在创建好 getter 和 setter 方法后，我们就可以在其他类中间接访问成员变量：

class Student{
    public String name;
    private String sex;
    private int age;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

public class Demo5 {
    public static void main(String[] args) {
        Student student=new Student();
        student.name="张三";
        student.setSex("男");
        student.setAge(18);
        System.out.println(student.name+"-"+student.getSex()+"-"+student.getAge());
    }
}

输出结果：
get和set打印结果

Java 包(package)

为了更好地管理类，Java 提供了包机制，用于区别类名的命名空间。就像电脑里的文件夹一样，同一个文件夹中，文件名不能一样，所以在同一个包中，类名不能一样，但是在不同包里，是可以一样的。

如何创建包：

这里可以一次性创建多个包（包里面还有包），通常情况下，一个公司使用它互联网域名的颠倒形式来作为它的包名，例如百度（www.baidu.com）就是：com.baidu.www。

创建多级包

效果如下：

多级包

import

在使用 Java 提供现成的类时，我们就需要使用 import 语句来导入相应的包。例如：

import java.util.Date;		导入java.util.Date
import java.util.Arrays;

也可以使用通配符 * ：

import java.util.*;

上面这个语句会导入 util 下的类，但是并不会一次性全部导入，只有当用到相关类的时候才会加载。

static 静态成员

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

static 修饰成员变量

当对象的某个属性都相同时，我们就可以使用 static 修饰，例如，学生对象的班级：

static

当我们调试后，可以发现静态成员变量并没有存储到某个具体的对象中：

static成员不在对象中

静态成员变量属性：

不属于某个具体的对象，是类的属性，所有对象共享，不存储在某个对象的空间中。
可以通过对象访问，也可以通过类名访问，但更推荐后者。
类变量存储在方法区中。
生命周期随类的加载而创建，随类的销毁而销毁。

static 修饰成员方法

当类里面的成员被修饰成 private 时，我们就只能在这个类中访问，如果想在外部访问，我们就只能提供静态成员方法供外部访问：
static静态方法

静态方法特性：

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