目录
前言
二、类的封装性
三、类的继承性
四、类的多态性
总结
前言
Java 是一种广泛使用的面向对象编程语言，其最突出的特点就是“一切皆对象”。在 Java 中，我们可以通过定义类和对象来实现代码的复用和封装。本文将为您介绍 Java 中的类和对象的概念和使用方法，帮助您更好地理解和使用 Java 编程语言。
一、类和对象是什么？
Java 中的类是一种用于封装数据和功能的蓝图，它定义了一种新的数据类型，并通过实例化该类创建相应的对象。类是 Java 程序的核心组件，它结合了数据和操作数据的方法。在编写 Java 程序时，我们通常需要为每个对象定义一个单独的类，然后通过创建该类的对象来访问其属性和方法。
举个例子，假设我们要创建一个学生类，用于存储和管理学生的信息。这个类可能需要包含学生的姓名、年龄、性别、学号等信息，同时还需要提供一些方法，比如查询学生的信息、修改学生的信息等。通过定义一个学生类，我们可以创建多个学生对象，每个对象代表一个学生，可以分别存储和管理每个学生的信息。
Java 中的对象则是类的一个实例，它具有类所定义的属性和方法，并可以通过调用方法来操作属性。在创建对象时，需要先声明对象的类型（即类），然后通过 new 关键字来分配内存空间并创建对象。
下面是一个简单的 Java 类和对象的示例代码，用于实现学生信息的存储和查询：
public class Student {
private String name; // 学生姓名
private int age; // 学生年龄
private String gender; // 学生性别
private String id; // 学生学号
// 构造方法，用于创建学生对象
public Student(String name, int age, String gender, String id) {
this.name = name;
this.age = age;
this.gender = gender;
this.id = id;
}
// 获取学生姓名
public String getName() {
return name;
}
// 获取学生年龄
public int getAge() {
return age;
}
// 获取学生性别
public String getGender() {
return gender;
}
// 获取学生学号
public String getId() {
return id;
}
// 修改学生姓名
public void setName(String name) {
this.name = name;
}
// 修改学生年龄
public void setAge(int age) {
this.age = age;
}
// 修改学生性别
public void setGender(String gender) {
this.gender = gender;
}
// 修改学生学号
public void setId(String id) {
this.id = id;
}
// 查询学生信息
public void getInfo() {
System.out.println("姓名：" + name);
System.out.println("年龄：" + age);
System.out.println("性别：" + gender);
System.out.println("学号：" + id);
}
}
public class Main {
public static void main(String[] args) {
// 创建学生对象
Student student1 = new Student("张三", 20, "男", "20180001");
Student student2 = new Student("李四", 21, "女", "20180002");
// 查询学生信息
student1.getInfo();
student2.getInfo();
// 修改学生信息
student1.setAge(21);
student2.setGender("男");
// 再次查询学生信息
student1.getInfo();
student2.getInfo();
}
}在上面的示例代码中，我们定义了一个学生类 Student，并在 Main 类中创建了两个学生对象 student1 和 student2。我们通过调用对象的方法 getInfo()，实现了查询学生信息并输出的功能。同时也通过调用对象的方法 setName()、setAge()、setGender() 和 setId()，来修改学生的信息。同时在 getInfo() 中也可以加入更多的方法，例如查询学生的成绩等等。
二、类的封装性
Java 中的类和对象支持封装，也就是说可以将对象的属性和方法尽可能地保护起来，只有类的内部可以直接访问，外部无法直接访问。这样可以避免外部类直接修改对象的属性，让代码更加安全和可靠。
在前面的示例中，我们使用了 private 关键字将类的属性定义为私有的，这样外部类无法直接访问它们。同时为了让外部类能够调用这些属性的值，我们也提供了公共的 get 和 set 方法，让外部类能够通过这些方法修改和获取属性的值。
三、类的继承性
Java 中的类和对象支持继承，也就是说一个类可以继承另一个类的全部属性和方法。继承关系的实现方式是使用 extends 关键字，子类可以访问父类的公共属性和方法，在此基础上可以添加新的属性和方法。
例如，我们可以定义一个 Person 类，它包含人的基本属性和方法，然后定义一个 Student 类，它继承了 Person 类，并添加了学生的特有属性和方法，如下所示：
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = 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 sayHello() {
System.out.println("Hello, I am a person.");
}
}
public class Student extends Person {
private String id;
public Student(String name, int age, String id) {
super(name, age);
this.id = id;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public void study() {
System.out.println("I am studying.");
}
}在这个示例中，我们定义了一个 Person 类，它有两个属性 name 和 age，和两个方法 getName 和 getAge，以及一个 sayHello 方法。在之后定义的 Student 类中，使用 extends 关键字继承了 Person 类，同时添加了一个学号 id 和一个 study 方法。由于 Student 类继承了 Person 类的属性和方法，所以我们可以在 Student 类中访问 Person 类中的属性和方法，在此基础上实现学生独有的操作。
四、类的多态性
Java 中的类和对象支持多态，也就是说可以使用相同的方法名实现不同的效果。多态性的实现方式主要有两种，一种是重载（overload），即在同一个类中定义多个相同名字的方法，但它们的参数列表不同；另一种是覆盖（override），即在父类和子类中具有相同名字的方法，但它们的具体实现不同。
例如，我们可以在前面定义的 Student 类中添加一个 sayHello 方法，与 Person 类中的 sayHello 方法同名，但它们的具体实现不同，如下所示：
public class Person {
// ...
public void sayHello() {
System.out.println("Hello, I am a person.");
}
}
public class Student extends Person {
// ...
@Override
public void sayHello() {
System.out.println("Hello, I am a student.");
}
}在这个示例中，我们在 Student 类中覆盖了 Person 类中的 sayHello 方法，并实现了自己的版本，输出的内容是 "Hello, I am a student."。这样，在使用 Student 类的 sayHello 方法时，程序就会自动调用子类的方法，而不是父类的方法。
总结
Java 中的类和对象是实现面向对象编程的重要组件，用于封装数据和方法。类是对数据和方法的抽象，而对象则是类的一个实例，可以独立地操作类的属性和方法。通过定义类和创建对象，我们可以实现代码的复用和封装，提高代码的可维护性和可扩展性。
