JavaSE：类与对象

一、前言

大家好鸭！通过上一篇博文的学习，相信你们都了解Java中的数据类型与变量、运算符。今天蜡笔小欣带大家一起走进Java的知识世界，去认识Java中的类与对象。

二、类与对象的介绍

这里的对象可不是我们现实中的对象，当然你们也可以自己new一个对象，哈哈哈哈小欣就不再开玩笑了。在计算机中，它不能像我们人一样去理解世界上的东西，为了更好的编辑，就抽象出了类和对象。类是用来对一个实体(对象)来进行描述的，通过把这个功能放在一起，然后由一个人去调用这个类的功能，接着编写相应的功能，而这个调用者就是对象的实现者。

1.类的定义格式

在java中定义类时需要用到class关键字，具体语法如下：

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体。类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。

Tips：

1.类名注意采用大驼峰定义。2.成员前写法统一为public。3.此处写的方法不带 static 关键字。

下面我们举个例子让大家熟悉熟悉，接下来我们定义一个学生类。

public class Student {//学生类
    public String name;
    public String gender;
    public short age;
    public double score;

    public void DoClass() {
        System.out.println("按时上课，不要迟到，如果请假，及时去补");
    }

    public void DoHomework() {
        System.out.println("教务系统，完成作业，一旦拖沓，神仙难救");
    }

    public void Exam() {
        System.out.println("考试目的，了解学情，人人必考，暴露问题");
    }
}

注意事项：

1. 一般一个文件当中只定义一个类，2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)，3. public修饰的类必须要和文件名相同，4. 不要轻易去修改public修饰的类的名称。

三、类的实例化

1.类的实例化介绍

定义了一个类，就相当于在计算机中定义了一种新的类型，有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)，用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

class Person {
    public String name;
    public int age;
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        Person person3 = null;
    }
}

这里Person 就是一个类，它里面的 name 和 int 就是类的成员，这里的 person1 就是引用，它指向后面 new 的对象，因为是引用，所以也可以指向 null 。而这里的person3就是指向空（null）引用。person1、person2、person3就是实例化的对象。

2.成员初始化

我们在创建类里的这些成员的时候就可以对它们进行初始化。

class Student {
    public String name = "张三";
    public int age = 18;
}

上面就是我们创建学生类的成员时，对它们进行初始化。但小欣不建议大家一开始救直接初始化，而是在类的调用者使用的时候再初始化。具体的代码如下：

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

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "张三";
        student.age = 18;
        System.out.println(student.name);
        System.out.println(student.age);

    }
}

运行结果如下：

我们在类的调用者里面对类的成员进行赋值，然后在 main 方法当中，通过引用来进行调用。

3.类中方法的实现

我们可以在类的里面写一个方法，调用这个方法后，直接返回名字和年龄。方法如下：

class Student {
    public String name;
    public int age;
    public void func() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "张三";
        student.age = 18;
        student.func();
    }
}

运行结果如下：

当我们要输出姓名和年龄的时候，就一个一个地去调用输出，直接调用类中的这个方法就可以。

四、封装

1.private实现封装

private是用来修饰成员变量或方法的关键字，被private修饰之后，就不能被类外的调用者访问了，这样就可以配合 public 来实现对外的接口。

我们可以这样理解：1.public：一个人的外貌特征，谁都可以看得到 2.default: 对于自己家族中(同一个包中)不是什么秘密，但对于其他人来说就是隐私了 3.private：只有自己知道，其他人都不知道。

下面我们通过一个例子来帮助我们更好的理解。

class Student {
    private String name = "张三";
    private int age = 18;
    public void func() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.func();
    }
}

运行结果：

上面我们通过利用private的封装属性，使其只能在类里面被访问到。后面的public方法让类的调用者在类外就可以访问到了。所以在类外直接调用func方法就可以输出结果。

2.getter和setter方法

我们把类里面的成员设置为private的属性时，就不能再类外面对它们进行初始化，但我们想在类外将这些成员赋其他的值，我们就可以使用getter和setter方法。

getter ：在类外面获取成员变量的值

setter ：在类外直接调用此方法，然后设置一个值。

class Student {
    private String name;
    private int age;

    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 void func() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
        student1.setName("张三");
        student1.setAge(10);
        student1.func();
        student2.setName("李四");
        student2.setAge(18);
        student2.func();
    }
}

输出结果：

上面因为private对name和age做了封装，所有我们调用setter方法，在类外进行访问。在Java中我们如果使用在类里使用privata对成员变量进行封装，可以鼠标右键点击Generate，选择Getter和Setter，然后选择哪些成员变量要生成Getter和Setter方法，最后点击OK就自动生成好了，这样让我们在写代码是更加方法。具体步骤如下：

五、构造方法的使用

1.构造方法的介绍

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

2.构造方法的特性

构造方法有以下这几种特性：

1.构造方法的名字必须与类名相同，2. 没有返回值类型，设置为void也不行，3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)，4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)，5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，6. 构造方法中，可以通过this调用其他构造方法来简化代码，7.绝大多数情况下使用public来修饰，特殊场景下会被private修饰。注意：一旦用户定义，编译器则不再生成。

下面实现一个不带参数的构造方法：

class Student {
    public Student() {
        System.out.println("这是不带参数的构造方法");
    }
}

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

输出结果如下：

我们在实例化类的对象的时候调用它的构造方法，因为上面我们自己写了构造方法，所以这里就调用我们写过的。但要注意：如果我们没有写构造方法，编译器会自己帮我们默认生成不带参数的构造方法。所以一个类，至少会有一个构造方法。

既然可以实现不带参数的构造方法，也就有带参数的构造方法，具体如下所示：

class Student {
    private String name;

    public Student(String name) {
        this.name = name;
        System.out.println("Studnet(Sting)带一个参数的构造方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("张三");
    }
}

输出结果：

在类初始化的时候，传入参数 “张三” 在类实例化的时候就可以调用带参数的构造方法。在Java中，如果想生成一个带参的构造方法，可以通过鼠标右键点击Generate，然后点击Constructor，再点击哪个成员要带参数，最后点OK就会自动生成一个带参数的构造方法。具体步骤如下：

六、this引用

1.this的介绍

在类当中this表示当前对象的引用（不是当前对象），我们可以通过this来访问类当中的成员变量和方法。通过使用this可以增加我们代码的可读性。当我们在使用getter和setter的时候，就会用 this。

class Student {
    private String name;
    private int age;

    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 void func() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        student1.setName("张三");
        student1.setAge(10);
        student1.func();
        
    }
}

2.this的特性

this的几个特性：

1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型，2. this只能在“成员方法“中使用，3. 在“成员方法“中，this只能引用当前对象，不能再引用其他对象，4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法，对象的引用传递给该成员方法，this负责来接收。

七、static静态关键字

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的，静态成员一般是通过静态方法来访问的。static可以修饰属性，方法。
划重点：static 修饰的变量通过类名访问。我们一起看看下面这个例子：

class Student {
    private String name;
    private int age;
    private static String classRoom="高三10班";

    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 static String getClassRoom() {
        return classRoom;
    }

    public void func() {
        System.out.println("姓名：" + name + " 年龄：" + age);
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("王五");
        student.setAge(18);
        student.func();
        System.out.println(Student.getClassRoom());

    }
}

运行结果如下：

所以我们在写代码时，当使用static来修饰方法的时候，不需要再创建对象，直接拿类名调用就可以。

八、总结

类与对象是JavaSE的基础之一，了解并掌握类与对象的概念和使用方法对于Java程序设计是非常重要的。我们写程序时合理的设计和使用类与对象，可以提高我们代码的可读性和可扩展性，进而实现更加灵活和高效的程序设计。今天对Java中的类与对象就分享到这里，感谢大家对蜡笔小欣的关注、鼓励与支持！我也会继续创作并跟大家分享，我们下次再见！！！

原文链接：https://blog.csdn.net/m0_74336101/article/details/136968224