[Java] 手把手教你类、对象和包

🔥一个人走得远了，就会忘记自己为了什么而出发，希望你可以不忘初心，不要随波逐流，一直走下去🎶
🦋 欢迎关注🖱点赞👍收藏🌟留言🐾
🦄 本文由 程序喵正在路上 原创，CSDN首发！
💖 系列专栏：Java入门
🌠首发时间：2022年5月7日
✅如果觉得博主的文章还不错的话，希望小伙伴们三连支持一下哦

1. 前言

Java 语言与其他面向对象语言一样，引入了类和对象的概念，类是用来创建对象的模板，它包含被创建的对象的状态描述和方法的定义。因此，要学习 Java 编程就必须学会编写类，即怎样用 Java 的语法去描述一类事物共有的属性和行为。属性通过变量来刻画，行为通过方法来体现。即方法操作属性形成一定的算法来实现一个具体的功能。类把数据和对数据的操作封装成一个整体。

2. 类

2.1 类的声明

在类声明中，需要定义类的名称、对该类的访问权限，以及该类与其他类的关系等
声明的格式如下。

[修饰符] class <类名> [extends 父类名] [implements 接口列表] {
}

修饰符：可选参数，用于指定类的访问权限，可选值为 public、abstract 和 final。

类名：必选参数，用于指定类的名称，类名必须是合法的 Java 标识符。一般情况下，要求首字母大写。

extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用 extends 关键字时，父类名为必选参数。

implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用 implements 关键字时，接口列表为必选参数。

下面我们主要介绍如何使用 public 关键字修饰的公共类，一个类被声明为 public，就表明该类可以被其他所有的类访问和引用，也就是说，程序的其他部分可以创建这个类的对象、访问这个类内部可见的成员变量、调用它的可见方法。

例如，定义一个 Fruit 类，该类拥有 public 访问权限，即该类可以被它所在包之外的其他类访问或引用，具体代码如下：

public class Fruit {

}

注意：Java 的类文件的扩展名为 .java，类文件的名称必须与类名相同，即类文件的名称为类名+ “.java"，例如，有一个 Java 类文件 Fruit.java，则其类名为 Fruit。

2.2 类体

在类声明部分的大括号中的内容为类体。类体主要由两部分构成，一部分是成员变量的定义，另一部分是成员方法的定义。类体的定义格式如下：

[ 修饰符 ] class < 类名 > [ extends 父类名 ] [ implements 接口列表 ] {
  定义的成员变量
  定义的成员方法
}

下面我们通过一个例子来更好地理解类体。本例主要实现定义一个水果类 Fruit，在该类中定义一个表示颜色的属性 color、一个表示种植的方法 plant()、一个表示生长的方法 grow() 和一个表示收获的方法 harvest()。

第一步：选择 Eclipse 主菜单中的 “文件” / “新建” / “项目” 命令，在打开的 “新建项目” 对话框中选中 “Java项目” 选项，单击 “下一步” 按钮，在打开的 “新建Java项目” 对话框中，输入项目名称 “Test”（这个项目名可以任意），单击 “完成” 按钮完成项目的创建。

第二步：在包资源管理器中刚刚创建的项目上单击鼠标右键，在弹出的快捷菜单中选择
“新建” / “类” 命令，在打开的 “新建Java类” 对话框的 “名称” 文本框中输入类名 “Fruit”，单击 “完成” 按钮。

第三步：在包资源管理器中打开刚刚创建的类 Fruit.java，在该类中定义相应的变量和方法。

Fruit 类的代码如下：

public class Fruit{
	//定义 color 成员变量
    public String color = "";

    //定义种植成员方法
    public void plant() {
        System.out.println("果树正在种植……");
    }
    
    //定义生长成员方法
    public void grow() {
        System.out.println("果树正在生在……");
    }
    
    //定义收获的成员方法
    public void harvest() {
        System.out.println("水果已经收获……");
    }
}

3. 成员变量和局部变量

在类体中的变量定义部分所声明的变量为类的成员变量，而在方法体中声明的变量及方法的参数则称为局部变量。

3.1 声明成员变量

Java 用成员变量来表示类的状态和属性。声明成员变量的基本语法格式如下。

[ 修饰符 ] [ static ] [ final ] [transient ] [ volatile ] < 变量类型 > < 变量名 >;

修饰符：可选参数，用于指定变量的被访问权限，可选值为 public、protected 和 private。

static：可选，用于指定该成员变量为静态变量，可以直接通过类名访问。如果省略该关键字，则表示该成员变量为实例变量。

静态变量与实例变量的区别：
静态变量在内存中只有一个据贝，运行时 Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配，可以直接通过类名访问静态变量，而实例变量则可以在内存中存在多个考贝，互不影响，每创建一个实例,就会为实例变量分配一次内存。

final：可选，用于指定该成员变量为取值不会改变的常量。

transient：可选，用于指定该成员变量为暂时性变量，用于对象存盘。

volatile：可选，用于指定该成员变量为共享变量，用于并发线程的共享。

变量类型：必选参数，用于指定变量的数据类型，其值为 Java 中的任意一种数据类型。

变量名：必选参数，用于指定成员变量的名称，变量名必须是合法的 Java 标识符

例如，我们在前面声明的 Fruit 类中声明 3 个成员变量。

public String color;                    //声明公共变量 color
public static String flavor;            //声明静态变量 flavor
public final boolean STATE = true;      //声明常量 STATE 并赋值

3.2 声明局部变量

定义局部变量的基本语法格式同定义成员变量类似，所不同的是，不能使用 public、protected、private 和 static 关键字对局部变量进行修饰，但可以使用 final 关键字声明局部变量的基本语法格式如下。

[ final ] <变量类型> <变量名>;

final: 可选，用于指定该局部变量为常量。

变量类型：必选参数，用于指定变量的数据类型，其值为 Java 中的任意一种数据类型。

变量名: 必选参数，用于指定局部变量的名称，变量名必须是合法的 Java 标识符密【例

在成员方法 grow() 中声明两个局部变量如下：

public void grow() {
        final boolean STATE;        //声明变量 STATE
        int age;                    //声明局部变量 age
    }

4. 构造方法

在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，都会自动调用构造方法。

构造方法的特点如下：
(1) 构造方法没有返回值。
(2) 构造方法的名称要与本类的名称相同。

在定义构造方法时，构造方法没有返回值，但这与普通的没有返回值的方法不同，普通的没有返回值的方法使用 public void methodEx() 这种形式进行定义，但构造方法并
不需要 void 关键字进行修饰。

构造方法的语法定义格式如下。

public book() {
// . . . 构造方法体
}

public：构造方法修饰符。
book：构造方法的名称。

在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被初始化。

注意： 如果在类中没有明确地定义构造方法，则编译器会自动创建一个不带参数的默认构造方法。

如果在类中定义的构造方法都不是无参的构造方法，则编译器不会为类设置一个默认的无参构造方法，当试图调用无参构造方法实例化一个对象时，编译器会报错。所以，只有在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。

使用 this 关键字可以调用类的成员变量和成员方法，还可以调用类的构造方法。

下面我们通过一个例子来更好地理解构造方法。在项目中创建 AnyThting 类，在该类中分别定义一个没有参数的构造方法和一个包含 String 类型参数的构造方法，代码如下：

public class AnyThting {
    public AnyThting() {                     //定义无参构造方法
        this("this 调用有参构造方法");        //使用 this 调用有参构造方法
    	System.out.println("无参构造方法");
    }

	public AnyThting(String name) {			//定义有参构造方法
		System.out.println("有参构造方法");
	}
}

从这个例子中可以看到定义的两个构造方法，在无参构造方法中可以使用 this 关键字调用有参的构造方法，但使用这种方式应当注意的是，只可以在无参构造方法中的第一句使用 this 调用有参构造方法。

5. 对象

在 Java 中，创建对象包括声明对象和为对象分配内存两部分，下面分别进行介绍。

5.1 声明对象

对象是类的实例，属于某个已经声明的类，因此，在对对象进行声明之前，一定要
先定义该对象的类。声明对象的语法格式如下。

类名 对象名;

类名：必选,用于指定一个已经定义的类。
对象名：必选，用于指定对象名称，对象名必须是合法的 Java 标识符。

例如，声明 Fruit 类的一个对象 fruit 的代码如下：

Fruit fruit;

在声明对象时，只是在内存中为其建立了一个引用并置初值为 null，表示不指向任何内存空间，因此，还需要为对象分配内存。

5.2 为对象分配内存

为对象分配内存也称为实例化对象。在 Java 中使用关键字 new 来实例化对象，具体语法格式如下。

对象名 = new 构造方法名([参数列表]);

对象名：必选,用于指定已经声明的对象名。
构造方法名：必选，用于指定构造方法名（即类名，因为构造方法与类名相同)。
参数列表：可选参数，用于为指定的构造方法提供入口参数，如果构造方法无参数，则可以省略。

例如，在声明 Fruit 类的一个对象 fruit 后，可以通过以下代码为对象 fruit 分配内存。

fruit = new Fruit();

在上面的代码中，由于 Fruit 类的构造方法无入口参数，所以省略了参数列表。

在声明对象时，也可以直接为其分配内存，例如，上面声明对象和为对象分配内存的功能也可以通过以下代码实现。

Fruit fruit = new Fruit();

5.3 使用对象

创建对象后，就可以通过对象来引用其成员变量并改变成员变量的值了，同时，也可以通过对象来调用其成员方法。通过使用运算符“”实现对成员变量的访问和成员方法的调用。下面通过具体的实例来介绍如何访问成员变量和调用成员方法。

本实例主要实现定义一个类并创建该类的对象的操作，同时通过创建的对象改变成员变量的值并调用该类中的成员方法。

第一步：创建一个名称为 Circ 的类，在该类中定义一个常量 PI、一个成员变量 r、一个不带参数的方法 getArea() 和一个带参数的方法 getCircumference()。

public class Circ {
    final float PI = 3.14159f;                  //定义一个用于表示圆周率的常量 PI
    public float r = 0.0f;

    //定义计算圆面积的方法
    public float getArea() {
        float area = PI * r * r;                //计算圆面积并赋值给变量 area
        return area;                            //返回计算后的圆面积
    }

    //定义计算圆周长的方法
    public float getCircumference(float r) {
        float circumference = 2 * PI * r;       //计算圆周长并赋值给变量 circumference
        return circumference;                   //返回计算后的圆周长
    }

    //定义主方法测试程序
    public static void main(String[] args) {
        Circ circ = new Circ();
        circ.r = 20;                            //改变成员变量的值
        float r = 20;
        float area = circ.getArea();             //调用成员方法
        System.out.println("圆的面积为：" + area);
        float circumference = circ.getCircumference(r); //调用带参数的成员方法
        System.out.println("圆的周长为：" + circumference);
    }
}

程序执行结果如下：

圆的面积为：1256.636
圆的周长为：125.663605

5.4 销毁对象

在许多程序设计语言中，需要手动释放对象所占用的内存，但是，在 Java 中就不需要手动完成这项工作。Java 提供的垃圾回收机制可以自动判断对象是否还在使用，并能够自动销毁不再使用的对象，收回对象所占用的资源。

Java 提供了一个名为 finalize() 的方法，用于在对象被垃圾回收机制销毁之前，由垃圾回收系统调用。但是垃圾回收系统的运行是不可预测的，因此，在 Java 程序中，也可以使用析构方法 finalize() 随时销毁一个对象。析构方法 finalize() 没有任何参数和返回值，每个类有且只有一个析构方法。

6. 包

Java 要求文件名和类名相同，所以如果将多个类放在一起，就很有可能出现文件名冲突的情况。就像在同一个学校的同一个班级里，有两名同名的学生，为了将这两名学生区分开，学校会将这两名学生安排在不同的班级里。此时，这个 “班级” 就相当于 Java 中的包，在一个包中可以包含多个类。下面将对 Java 中的包进行详细介绍。

6.1 包的概念

包 ( Package）是 Java 提供的一种用于区别类的名字空间的机制，是类的组织方式，是一组相关类和接口的集合，它提供了访问权限和命名的管理机制。Java 中提供的包主要有以下 3 种用途：
(1) 将功能相近的类放在同一个包中，可以方便查找与使用。
(2) 由于在不同的包中可以存在同名类，所以使用包在一定程度上可以避免命名冲突。
(3) 在 Java 中，访问权限是以包为单位的。

6.2 创建包

创建包可以通过在类或接口的源文件中使用 package 语句实现。package 语句的语法格式如下。

  package 包名;

包名：必选，用于指定包的名称，包的名称为合法的 Java 标识符。当包中还有包时
可以使用 “包1.包2……,包n” 进行指定，其中，包1 为最外层的包，而 包n 为最内层的包。

package 语句通常位于类或接口源文件的第一行。

下面我们将上面定义的类 Circ 放入 com.test 包中，具体代码如下：

package com.test;

public class Circ {
    final float PI = 3.14159f;                  //定义一个用于表示圆周率的常量 PI
    public float r = 0.0f;

    //定义计算圆面积的方法
    public float getArea() {
        float area = PI * r * r;                //计算圆面积并赋值给变量 area
        return area;                            //返回计算后的圆面积
    }

    //定义计算圆周长的方法
    public float getCircumference(float r) {
        float circumference = 2 * PI * r;       //计算圆周长并赋值给变量 circumference
        return circumference;                   //返回计算后的圆周长
    }

    //定义主方法测试程序
    public static void main(String[] args) {
        Circ circ = new Circ();
        circ.r = 20;                            //改变成员变量的值
        float r = 20;
        float area = circ.getArea();             //调用成员方法
        System.out.println("圆的面积为：" + area);
        float circumference = circ.getCircumference(r); //调用带参数的成员方法
        System.out.println("圆的周长为：" + circumference);
    }
}

Java 中的包相当于系统中的文件夹。例如，上面代码中的 Circ 类如果保存到 C 盘根说明目录下，那么它的实际路径应该为 “C:\com.test\Circ.java"。

6.3 使用包中的类

类可以访问其所在包中的所有类，还可以使用其他包中的所有 public 类。访问其他包中的 public 类有以下两种方法。

(1) 使用长名引用包中的类
使用长名引用包中的类比较简单，只需要在每个类名前面加上完整的包名即可，例如，创建 Circ 类（保存在 com.test 包中) 的对象并实例化该对象的代码如下：

com.test.Circ circ = new com.test.Circ();

(2) 使用import语句引入包中的类
由于使用长名引用包中的类的方法比较繁琐，所以 Java 提供了 import 语句来引人包中的类。import 语句的基本语法格式如下：

  import 包名1[.包名 2. ……] . 类名 1*;

当存在多个包名时，各个包名之间使用 “.” 分隔，同时包名与类名之间也使用 “.” 分
隔。

*：表示包中所有的类。

例如，引入 com.test 包中的 Circ 类的代码如下：

import com.test.Circ;

如果 com.test 包中包含多个类，也可以使用以下语句引入该包下的全部类：

import com.test.*;

🧸这次的分享就到这里啦，继续加油哦^^
🍭有出错的地方欢迎在评论区指出来，共同进步，谢谢啦