Java类和对象

是大风呀～

已于 2023-12-28 10:54:50 修改

阅读量1k

点赞数 32

文章标签： java 开发语言

于 2023-12-18 14:16:10 首次发布

本文链接：https://blog.csdn.net/2201_75463924/article/details/135060141

版权

在Java中，“类”和“对象”是两个核心概念，它们是面向对象编程的基础。下面，我将解释这两个概念，并通过一个简单的例子来帮助你理解它们。

类（Class）

类是Java中用来描述具有相同属性和方法的对象的模板。它定义了对象的结构和行为。类是一个抽象的概念，它代表了一组对象的共性。

例如，我们有一个名为“汽车”的类。这个类可能包含一些属性（如颜色、型号、品牌等）和方法（如启动、停止、加速等）。

在类中，属性和方法有以下不同：

定义和作用：属性是类的成员变量，用于存储对象的状态信息。它们描述了对象的特征或属性。而方法是类的成员函数，用于定义对象的行为或操作。它们描述了对象可以执行的操作。
访问修饰符：属性通常具有访问修饰符，如public、private或protected，用于控制属性的可见性和访问权限。而方法也有访问修饰符，但通常与类访问修饰符相同，除非它们是私有的或受保护的。
初始值：属性可以有初始值，用于在创建对象时为其提供初始状态。而方法没有初始值，它们只是定义了行为或操作。
调用方式：属性可以直接通过对象来访问，例如obj.property，其中obj是对象名，property是属性名。而方法需要通过对象来调用，例如obj.method()，其中obj是对象名，method是方法名。
总的来说，属性和方法都是类的组成部分，它们各自有其特点和作用。属性用于存储对象的状态信息，方法用于定义对象的行为或操作。

类的定义：

[访问修饰符]class类名{
成员变量
成员方法
}
成员变量的定义：
[访问修饰符]数据类型变量名;
成员方法的定义：
[访问修饰符]返回值方法名([形参列表]){
方法体
}

对象的创建：

类名对象名；
对象名=new类名([实参列表])；

public > protected >默认>private
类可用的修饰符：public、默认
类成员可用的修饰符：public、protected、默认、private

类中有哪些方法可以被重写

在类中，有些方法是可以被重写的，即子类可以覆盖父类的方法。这些方法包括：

抽象方法：抽象方法是一种只有声明没有实现的方法，它存在于抽象类中。子类必须实现所有继承自抽象类的抽象方法。

什么是抽象方法

抽象方法是指没有方法体的方法，在声明方法时没有花括号“{}”以及其中的内容，而是直接在方法名后加上分号结束。只要一个类里面有一个方法是抽象方法，那么这个类就必须定义为抽象类，需要使用“abstract”关键字来修饰。

final方法：final方法是不能被重写的方法。如果一个方法是final的，那么子类不能覆盖它。

java`public final void myFinalMethod() { // ... }`

私有方法：私有方法只能在类内部访问，因此不能被子类重写。

java`private void myPrivateMethod() { // ... }`

静态方法：静态方法属于类而不是实例，因此也不能被子类重写。

java`public static void myStaticMethod() { // ... }`

现在，让我们将这些概念结合起来看一个简单的例子：

假设我们有一个父类Animal：

public class Animal {  
    public void makeSound() {  
        System.out.println("The animal makes a sound");  
    }  
      
    private void sleep() {  
        System.out.println("The animal sleeps");  
    }  
      
    public static void rest() {  
        System.out.println("The animal rests");  
    }  
}

在这个例子中：

makeSound() 是非final的公有方法，可以被其他子类重写（如果需要的话）。
sleep() 是私有方法，由于它是私有的，所以不能被子类重写。子类不会知道这个方法的存在。
rest() 是静态方法，它也不能被子类重写，因为它是属于Animal这个类而不是其任何实例的。

什么是私有方法和公有方法：

私有方法（Private Method）和公有方法（Public Method）是面向对象编程中的两种方法类型。

私有方法是一种只能在类内部访问的方法，无法从类的外部直接调用。私有方法的名字通常以两个下划线开头，例如__method_name。

公有方法则相反，可以从类的外部直接访问。公有方法的名字通常不以两个下划线开头。

这两种方法的主要区别在于其可见性和访问权限。私有方法只能被类的内部代码访问，而公有方法可以被类的外部代码访问。这种特性使得私有方法可以用于实现类的内部逻辑，而公有方法则用于与外部交互和提供接口。

需要注意的是，子类可以覆盖父类中的非抽象、非final、非私有、非静态的方法。

异常处理：

异常处理是程序设计中一种重要的错误处理机制。在编程中，异常是程序运行时发生的问题，如尝试除以零、数组越界等。通过异常处理，程序可以在遇到问题时采取适当的措施，而不是直接崩溃或产生不可预测的行为。

异常处理通常包括以下步骤：

抛出异常：当程序遇到问题时，它会抛出一个异常。这通常是因为某个条件没有得到满足，例如一个函数接收到错误的输入。

throw new Exception()

捕获异常：程序中特定的部分会负责捕获异常。这通常是在try块中完成的。如果try块中的代码抛出了异常，控制权将转移到相应的catch块。

try:  
    # 尝试执行可能会引发异常的代码  
    number = int(input("请输入一个数字: "))  
    result = number / 0  
except ZeroDivisionError:  
    # 当发生ZeroDivisionError时执行的代码  
    print("错误：除数不能为零！")  
except ValueError:  
    # 当发生ValueError时执行的代码  
    print("错误：输入的不是一个数字！")  
else:  
    # 如果try块中的代码没有抛出任何异常，则执行此代码块  
    print("计算结果为:", result)

在这个示例中，我们尝试从用户那里获取一个数字，并将其除以零。由于这是一个不可能的操作，所以会抛出ZeroDivisionError异常。我们还尝试将非数字输入转换为整数，这会引发ValueError异常。通过使用except块，我们可以捕获这些异常并采取适当的措施来处理它们。如果try块中的代码没有抛出任何异常，那么将执行else块中的代码。

处理异常：在catch块中，程序可以采取适当的措施来处理异常。这可能包括记录错误、显示错误消息、或者尝试恢复程序的正常状态。

处理异常的方法取决于具体的情境和需求。以下是一些常见的处理异常的方法：

记录异常信息：当发生异常时，记录异常的信息是很有用的。这可以帮助你了解发生了什么，以及如何解决它。你可以使用日志库或自定义的错误处理机制来记录异常信息。
尝试恢复或回滚操作：在某些情况下，可能存在一些操作可以恢复到正常状态或回滚到之前的状态。例如，如果一个网络请求失败，你可以尝试重新发送请求。
提供用户反馈：在处理异常时，为用户提供反馈也是非常重要的。例如，如果一个网络请求失败，你可以向用户显示一个错误消息，告诉他们发生了什么，并提供可能的解决方案。
优雅地失败：在某些情况下，你可能无法完全恢复到一个正常状态。在这种情况下，优雅地失败可能是最好的选择。这意味着在出现异常时，你的应用程序应该尽可能地保持稳定，并避免崩溃或产生不可预测的行为。
学习和改进：最后，处理异常的一个关键方面是学习和改进。通过分析异常的信息和原因，你可以了解你的应用程序的弱点和不足之处，并采取措施来改进它们。

以上是一些常见的处理异常的方法，但具体的方法取决于你的应用程序的需求和情况。

下面是一个简单的Python示例，展示了异常处理的基本结构：

try:  
    # 尝试执行可能会引发异常的代码  
    x = 1 / 0  # 这将引发一个ZeroDivisionError  
except ZeroDivisionError:  
    # 当发生ZeroDivisionError时执行的代码  
    print("除数不能为零！")

在这个例子中，当尝试除以零时，会抛出一个ZeroDivisionError异常。这个异常被except块捕获，并打印出一个错误消息。

注意，良好的错误和异常处理对于构建健壮和可维护的软件至关重要。通过合理地使用异常处理机制，程序员可以创建更稳定、更可预测的程序，从而提高用户满意度和软件的可靠性。

对象（Object）

对象是类的实例。类定义了一个对象可能有的属性和方法，但具体每个对象的属性值和方法调用的结果可能会有所不同。每个对象都是类的一个实例，具有类定义的属性和方法。

例如，我们可以根据“汽车”类创建一个“宝马”对象。这个对象具有“汽车”类的所有属性和方法，但它的颜色、型号和品牌可能与其他的“汽车”对象不同。

Car myBmw = new Car("Black", "M3", "BMW");  
myBmw.start(); // 启动宝马车

面向对象的三大特征：封装、继承、多态

什么是对象之间的依赖关系呢

对象之间的依赖关系是指一个对象在完成某个操作时，需要借助另一个对象的帮助。在依赖关系中，一个对象被另一个对象所依赖，被依赖的对象通常称为被依赖对象，而依赖的对象称为依赖对象。

类和对象的示例：

让我们通过一个简单的示例来进一步理解Java中的“类”和“对象”的概念。

示例： 创建一个表示“学生”的类，并创建几个学生对象。

定义“学生”类

首先，我们需要定义一个名为“Student”的类。这个类可以包含一些属性（例如姓名、年龄和性别）和方法（例如自我介绍）。

public class Student {  
    private String name;  
    private int age;  
    private String gender;  
  
    // 构造函数，用于创建学生对象时初始化属性  
    public Student(String name, int age, String gender) {  
        this.name = name;  
        this.age = age;  
        this.gender = gender;  
    }  
  
    // 一个方法，用于自我介绍  
    public void introduce() {  
        System.out.println("大家好，我叫" + this.name + "，我" + this.age + "岁了，我是" + this.gender + "生。");  
    }  
}

创建“学生”对象

接下来，我们可以使用这个“Student”类来创建几个学生对象，并调用它们的方法。

public class Main {  
    public static void main(String[] args) {  
        // 创建第一个学生对象 - 小明  
        Student xiaoming = new Student("小明", 18, "男");  
        xiaoming.introduce(); // 调用小明的自我介绍方法  
  
        // 创建第二个学生对象 - 小红  
        Student xiaohong = new Student("小红", 17, "女");  
        xiaohong.introduce(); // 调用小红的自我介绍方法  
    }  
}

运行上述代码，你会看到以下输出：

大家好，我叫小明，我18岁了，我是男生。

大家好，我叫小红，我17岁了，我是女生。

这个简单的示例展示了如何定义类、如何创建对象以及如何调用对象的方法。在这个示例中，“Student”是类，而“xiaoming”和“xiaohong”是这个类的实例或对象。

构造方法:

构造方法是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。

构造方法和其他方法一样也可以重载。构造方法是一种特殊的成员方法，它的特殊性反映在以下几个方面：

构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。
主要完成对象的初始化工作，构造方法的调用是在创建一个对象时使用new操作进行的。
类中必定有构造方法，若不写，系统自动添加无参构造方法。
构造方法分为两种：无参构造方法、有参构造方法

public 类名 (参数){ 方法体 }

public是访问修饰符，表示这个构造方法可以被其他类访问。类名是构造方法的名称，它必须与类名相同。参数是构造方法的参数列表，用于初始化对象的状态。方法体是构造方法的主体，用于执行一些初始化的操作。

需要注意的是，构造方法没有返回值类型，也没有void，它的返回值类型是自动推断的，也就是返回的是该类的实例对象。此外，如果类没有定义任何构造方法，编译器会自动添加一个无参构造方法。

getter与setter方法：

getter方法
返回对象内部的成员变量的值
格式：
[访问修饰符] 成员变量类型getXxx(){
return 成员变量;
}
setter方法
用来设置成员变量，可以在方法里面过滤掉一些不合理的值
格式：
[访问修饰符] void setXxx(成员变量类型参数) {

成员变量=参数；
}

在面向对象编程中，getter和setter方法是一种常见的模式，用于访问和修改类的属性。

Getter方法是一个用于获取类的属性的值的方法。它通常被命名为get后接属性名，并且不接受任何参数。例如，如果我们有一个名为name的属性，getter方法可以被命名为getName。

以下是一个Python中的getter方法示例：

class Person:  
    def __init__(self, name):  
        self._name = name  
  
    def getName(self):  
        return self._name

在这个例子中，getName是一个getter方法，它返回_name属性的值。

Setter方法是一个用于设置类的属性的值的方法。它通常被命名为set后接属性名，并且接受一个参数，该参数是新值的值。例如，如果我们有一个名为name的属性，setter方法可以被命名为setName。

以下是一个Python中的setter方法示例：

class Person:  
    def __init__(self, name):  
        self._name = name  
  
    def getName(self):  
        return self._name  
  
    def setName(self, new_name):  
        self._name = new_name

在这个例子中，setName是一个setter方法，它设置_name属性的新值。

在这个例子中，Person类有两个私有属性：_name和_age。我们使用getter方法（get_name和get_age）来获取这些属性的值，使用setter方法（set_name和set_age）来设置这些属性的值。请注意，在setter方法中，我们可以加入一些验证逻辑来确保属性的值是合理的。例如，在set_age方法中，我们检查新年龄是否是非负数。

getter和setter方法之间的区别是什么

getter和setter方法之间的主要区别在于它们的作用和功能。

Getter方法：Getter方法用于获取类的属性的值。它通常被命名为“get”后接属性名，并且不接受任何参数。Getter方法允许外部代码访问类的私有属性，从而获取该属性的值。
Setter方法：Setter方法用于设置类的属性的值。它通常被命名为“set”后接属性名，并且接受一个参数，该参数是新值的值。Setter方法允许外部代码修改类的私有属性，从而设置该属性的新值。

总的来说，getter和setter方法的主要区别在于它们的作用和功能。Getter方法用于获取属性的值，而Setter方法用于设置属性的值。这些方法通常用于封装类的属性，以防止外部直接访问和修改属性，从而保护类的内部状态。

静态成员：

只能访问静态数据成员和其他静态成员函数，不能访问类的非静态成员。非静态成员必须依赖于具体的对象，而静态成员函数在没有对象的情况下就可以被调用。静态成员函数可以在没有类的实例的情况下被调用，可以通过类名和作用域解析运算符来调用。

静态成员在声明时需要加上static关键字

静态成员的格式如下：

class 类名 {  
public:  
    static 数据类型 静态成员变量名; // 声明静态成员变量  
    static 返回类型 静态成员函数名(参数列表); // 声明静态成员函数  
};

其中，类名是类的名称，数据类型是静态成员变量的数据类型，静态成员变量名是静态成员变量的名称，返回类型是静态成员函数的返回类型，静态成员函数名是静态成员函数的名称，参数列表是静态成员函数的参数列表。

需要注意的是，静态成员变量和静态成员函数都是属于类的，而不是属于类的实例。因此，它们可以在没有类的实例的情况下被调用。

总结

类是对象的蓝图：类是对象的模板，它定义了对象的属性和方法。类就像是一个建筑师的蓝图，描述了建筑的结构和功能。
对象是类的实例：对象是类的具体实例，它根据类的定义创建，并具有类定义的属性和行为。对象就像是建筑师的建筑，它是根据蓝图构建的实体。
面向对象的编程：面向对象的编程是一种设计方法，它通过类和对象来模拟现实世界。面向对象的编程鼓励程序员将问题分解为一系列的类和对象，每个类和对象都有自己的职责和行为。