代码收藏家技术教程 2024-06-03

Java中类与对象的基础知识

类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

声明一个类就是创建一个新的数据类型，而类在
Java
中属于
引用类型
，
Java
使用关键字
class
来声明类。我们来看以下简单的声明一个类。

基本语法：

class
<
class_name
>
{

field
;
//
成员属性

method
;
//
成员方法

}

//
实例化对象

<
class_name
> <
对象名
> =
new
<
class_name
>
();

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

类中的元素称为：成员属性。类中的函数称为：成员方法。

代码示例:

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

    public void study(){
        System.out.println("学习");
}

    public void eat(){
        System.out.println("吃饭");
}
}

这里我们创建了一个 Student 类，其中有成员属性：name、sex、age。和成员方法：study、eat。

类的实例化

用类类型创建对象的过程，称为类的实例化

代码示例：

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

    public void study(){
        System.out.println("学习");
}

    public void eat(){
        System.out.println("吃饭");
}
}

public class TeatDemmo{
    public static void main(String[] args){
        Student stu1 = new Student();
        stu1.study();
        stu1.eat();
}
}

其中 stu1 就是类 Student 的一个实例，我们创建了实例后才能在另一个类中用到这个类里面的成员方法和成员属性。

new 关键字用于创建一个对象的实例

使用 . 来访问对象中的属性和方法

同一个类可以创建多个实例

类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等

字段

在类中
,
但是方法外部定义的变量
.
这样的变量我们称为
"
字段
"
或
"
属性
"
或
"
成员变量
"

使用 . 访问对象的字段

"访问" 既包含读, 也包含写

对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值

默认值规则

对于各种数字类型, 默认值为 0

对于 boolean 类型, 默认值为 false

对于引用类型(String, Array, 以及自定制类), 默认值为 null

方法

成员方法：用于描述一个对象的行为，就相比于C语言中的函数

构造方法

方法中还有一种特殊的方法称为
构造方法
在实例化对象的时候会被自动调用到的方法,
方法名字和类名相同
,
用于对象的初始化。

我们来举个例子描述构造方法：

class Student{
    public String name;
    public int age;
    public char sex;
    public Student(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

}

public class Data{
    public static void main(String[] args) {
        Student stu1 = new Student("张三",20,'男');
    }
}

此处 Student() 方法就是我们的构造方法，构造方法在实例化对象的时候就会被自动调用，一般用于对象的初始化。

调试结果截图：

这里我们可以看到，我们只使用了实例化对象，但是以经给成员变量赋值了。

构造方法是一种特殊方法
,
使用关键字
new
实例化新对象时会被自动调用
,
用于完成初始化操作。

new
执行过程

为对象分配内存空间

调用对象的构造方法

语法规则

1.方法名称必须与类名称相同

2.构造方法没有返回值类型声明

3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数

若类中定义了构造方法，则默认的无参构造将不再生成

构造方法支持重载. 规则和普通方法的重载一致

this关键字

this
表示当前对象引用，
可以借助
this
来访问对象的字段和方法

我们会发现在构造函数的内部，我们可以使用
this
关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this。

代码示例：

class Person { 
 private String name;
 private int age; 
 private String sex; 
 

 public Person() { 
 this("bit", 12, "man");//必须放在第一行进行显示
 } 
 
 //这两个构造函数之间的关系为重载。
 public Person(String name,int age,String sex) { 
 this.name = name; 
 this.age = age; 
 this.sex = sex; 
 } 
} 

public class Main{ 
 public static void main(String[] args) { 
 Person person = new Person();//调用不带参数的构造函数
 }
}

这里我们使用了构造方法的重载，我们在 main（）函数中实例化的时候没有传参，说明我们自动调用了不带参数的构造方法。在不带参数的构造方法中我们又使用了 this() 函数，这个函数的作用是调用其他的构造方法（根据传参来选择调用哪个构造方法）。

注意：this() 方法必须在该构造方法的第一行。

static 关键字

1、修饰属性

2、修饰方法

3、修饰代码块

4、修饰类

修饰属性
，
Java
静态属性和类相关
,
和具体的实例无关
.
换句话说
,
同一个类的不同实例共用同一个静态属性。

修饰方法

如果在任何方法上应用
static
关键字，此方法称为静态方法。

静态方法属于类，而不属于类的对象。

可以直接调用静态方法，而无需创建类的实例。

静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

注意事项
:
静态方法和实例无关
,
而是和类相关
.

静态方法不能直接使用非静态数据成员或调用非静态方法(非静态数据成员和方法都是和实例相关的)。

this和super两个关键字不能在静态上下文中使用。

代码示例：

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

    public static String classroom;
    public Student(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public static void func(){
        System.out.println("这是一个静态方法");
        System.out.println(classroom);
    }

}

public class Data{
    public static void main(String[] args) {
        Student stu1 = new Student("张三",20,'男');
        Student.classroom = "2022308";
        Student.func();
    }
}

通过上述代码我们可以看出，在我们使用被 static 修饰过的成员变量或方法的时候，并不需要对象实例化，我们只需要通过类来调用。而且在静态方法里面我们可以直接使用静态成员变量。

运行结果图：

上述代码数据属性的内存布局：

因此被 static 关键字修饰的变量并不存在类中，不需要用用实例化来调用。

代码块

字段的初始化方式有：

1. 就地初始化

2. 使用构造方法初始化

3. 使用代码块初始化

前两种方式前面已经学习过了
,
接下来我们介绍第三种方式
,
使用代码块初始化

什么是代码块

使用
{}
定义的一段代码就是代码块

根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块

静态块

同步代码块

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

构造块：定义在类中的代码块
(
不加修饰符
)
。也叫：
实例代码块
。构造代码块一般用于初始化实例成员变量

静态代码块：使用
static
定义的代码块。
一般用于初始化静态成员属性。

代码示例：

class Student{
    public String name;
    public String id;
    public int age;
    public char sex;
    public static String classroom;

    static{
        classroom = "2000123";
        System.out.println("这是一个静态代码块");
    }

    {
        this.name = "小明";
        this.id = "202258454";
        this.age = 20;
        this.sex = '男';
        System.out.println("这是一个构造代码块");
    }

    public Student(){
        System.out.println("这是一个构造方法");
    }
}

public class Data{
    public static void main(String[] args) {
        Student stu = new Student();
    }
}

我们在 Student 类中写了一个静态代码块一个构造代码块和一个构造方法。接下来我们来看当实例化对象的时候，它们三个的执行顺序。

我们可以看到静态代码块优先于构造代码块优先于构造方法。

注意事项

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。

toString 方法

class Person {
    private String name;
    private int age;
    public Person(String name,int age) {
        this.age = age;
        this.name = name;
    }
    public void show() {
        System.out.println("name:"+name+" " + "age:"+age);
    }
    //重写Object的toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Data {
    public static void main(String[] args) {
        Person person = new Person("小明",19);
        person.show();
        System.out.println(person);
    }
}

输出结果：