openHarmony中有关class的理解

最新推荐文章于 2024-08-01 15:05:06 发布

haoyou512

最新推荐文章于 2024-08-01 15:05:06 发布

阅读量591

点赞数 15

文章标签： java harmonyos

本文链接：https://blog.csdn.net/m0_49071631/article/details/137551121

版权

1、当你调用一个类的属性和方法时，通常需要一个实例对象。

原因归结为面向对象编程的基本概念和设计

封装

面向对象编程强调对象的封装性。一个对象封装了数据（属性）和操作这些数据的方法，这意味着每个对象都拥有自己的属性和方法的副本。因此，为了访问或修改对象的属性，或者调用对象的方法来执行特定操作，你需要一个该类的实例。这样，对象的状态和行为就封装在个体实例中，确保了数据安全性和方法操作的针对性。

状态和行为

状态（State）：对象通过属性持有状态。每个对象的状态可以独立于其他对象。例如，如果你有一个 Car 类，每个 Car 对象可以有不同的 color, brand 或 fuelLevel 等属性值。
行为（Behavior）：对象的方法定义了它可以执行的操作。这些操作可能会依赖于对象的当前状态，或影响对象的状态。调用特定实例的方法意味着操作该实例的状态。

静态成员

值得一提的是，类也可以有静态属性和静态方法，这些可以在没有类的实例时直接通过类调用。静态成员属于类本身，而非类的任何实例。它们用于存储类级别的数据，或提供不需要访问任何实例属性或方法的功能。

实际示例

考虑一个简单示例，一个Person类有name和age属性以及一个introduce方法：

public class Person {
    String name;
    int age;

    public void introduce() {
        System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
    }
}

要调用introduce方法并使其打印特定的name和age，你需要Person的一个实例：

Person person1 = new Person();
person1.name = "Alice";
person1.age = 30;
person1.introduce();  // 输出: Hello, my name is Alice and I am 30 years old.

在这里，introduce方法访问了this对象（在Java中隐式，其他一些语言则是显式）的name和age属性。没有对象实例，this（或等效的自引用）将没有意义，因为没有特定的状态（name和age）可供操作。

综上所述，需要一个实例对象来调用类的属性和方法，是因为只有通过实例化的对象，才能访问或者操作那个特定对象的状态和行为。这是面向对象设计的核心。

2、引用类型和实例的类型有什么异同点

在面向对象编程中，尤其是在使用诸如Java或C#这样的强类型语言时，引用类型和实例的类型是两个重要的概念，他们之间既有联系也有区别。

引用类型(Reference Type):

引用类型指的是变量声明时所指定的类型。这告诉编译器变量可用于引用哪种类型的对象。
在编译时期，编译器会使用引用类型来确定可以对变量执行哪些操作或调用哪些方法。
多态性是基于引用类型来实现的：引用类型可以指向任何兼容类型的对象，这意味着一个父类引用可以指向任何继承自这个父类的子类对象。

实例类型(Instance Type):

实例类型是在运行时确定的，它是实际创建在内存中的对象的类型。
当使用 new 关键字创建类的实例（对象）时，该对象的类型即为实例类型。
实例类型决定了对象在内存中的具体结构，包括对象的数据成员和可以调用的方法（包括继承自父类的方法以及自身类定义的方法）。

异同点:

相似点：引用类型和实例类型都与对象的类型相关，且都受到面向对象范畴内类和继承的规则影响。
不同点：
- 定义时机：引用类型在编译时期已定，实例类型在运行时定义。
- 作用范围：引用类型影响编译器对程序代码的理解和预检查，而实例类型影响对象在内存中的实际表现和行为。
- 多态性：通过引用类型实现多态性时，具体调用哪个方法是在运行时根据实例的实际类型来动态绑定的，对于非静态方法调用特别关键。

举个例子：

class Animal {
    void sound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 引用类型是Animal，实例类型是Dog

        myAnimal.sound(); // 输出：Bark，因为实际类型是Dog
    }
}

在这个例子中，myAnimal 是 Animal 类型的引用，但它指向的实例类型是 Dog。这意味着在编译时，编译器允许对 myAnimal 调用 Animal 类中定义的所有方法。但在运行时，因为实际的对象是 Dog 类型的，所以执行的是 Dog 类中的 sound 方法实现。

这种区别对编程非常重要，它允许编码时使用更通用的代码，同时运行时保有对象的具体实现细节，这也是面向对象编程中封装和多态两个核心原则的体现。

3、对于一段代码，为什么在编译时通过，在运行时出错呢

即使代码在编译时通过了编译器的检查，它仍然可能在运行时出错。编译时检查和运行时行为是由不同的机制和状态管理的。编译器主要关注语法的正确性、类型的匹配、函数调用的合法性等，它并不执行代码，因此无法预见所有的运行时情况。以下是一些可能导致运行时出错的原因：

1. 空指针或空引用异常

如果代码在编译时无法确定某个引用是否会被赋予一个非空的值，那么当这段代码试图访问一个实际上是空的引用时，就会在运行时抛出异常。

2. 数组或集合越界

数组或集合的访问可能超过它们的有效索引范围，此类错误通常在运行时检测到，因为相关的索引值可能取决于程序的输入或其他运行时状态。

3. 类型转换错误

编译器可能允许不安全的类型转换，如果在编译时无法确定具体的实例类型。运行时尝试将对象转换为不兼容的类型时会引发异常。

4. 资源限制和外部条件

诸如文件不存在、网络问题、数据库连接失败、内存耗尽或其他系统资源问题，通常只在程序运行时出现，并且程序必须适当地处理这些情况。

5. 并发错误

多线程和并发编程可能引入死锁、竞争条件和其他并发问题。这些情况很难通过静态编译时分析预测，通常都需要在运行时动态地管理。

6. 逻辑错误

程序代码可能逻辑正确、语法正确，但算法可能由于逻辑错误而未能给出预期的结果。例如，错误的条件判断或错误的循环逻辑。

7. 运行时环境与编译时环境不符

程序可能在开发环境中编译并测试，但由于运行环境中的差异（比如不同的操作系统、不同版本的依赖库等），程序可能无法在生产或其他运行环境中正确执行。

8. 异常处理不当

即使对于可预见的错误情况，比如I/O操作，如果程序员没有正确处理潜在的异常，那么在运行时出现这些问题时程序也可能失败。

编译器尽力确保你的代码在语法上和类型上符合规则，但它不负责逻辑上的正确性以及一些运行时环境的问题。因此，编写健壮的代码不仅需要通过编译，还必须经过充分的测试，以确保程序能正确地处理各种运行时情况。

4、编译时主要检查什么

语法和类型上符合规则是编程语言正确性的基础要求之一。以下是一些具体方面：

语法正确性

编程语言的语法是一组规则，用于定义程序结构和组成元素的排列方式。语法正确性主要包括：

正确的关键字使用：编程语言中的关键字（如 if, for, class, return 等）必须按照规定的用法使用。
合理的符号布局：例如，圆括号、花括号、方括号、分号等符号必须正确地配对和放置。
正确的语句结构：语句必须按照语言的语法构造，比如赋值语句、控制流语句、函数定义等。
代码缩进和格式：虽然不是所有的编程语言都强制缩进（如Python），但良好的缩进和格式有助于代码的可读性。

类型系统的合规性

类型系统规定了值和表达式的不同类型，以及它们之间如何互动。类型上的正确性通常包括：

变量声明：变量在使用之前必须被声明，并且通常指定了一个类型。
类型匹配：赋值、函数参数传递、返回值等情况下，数据类型必须匹配或者能够通过某种转换规则来匹配。
类型转换：某些语言允许或要求显式的类型转换（强制转换），这必须合乎语言的规则。
类型推导：现代编程语言往往有类型推导的特性，变量的类型可以根据上下文确定，但同样必须遵守类型系统的规则。
泛型或模板的使用：在使用泛型（Generics）或模板时，对类型参数的约束必须得到遵守。
操作符重载：对于重载操作符的正确使用，在类型之间必须明确定义了如何操作。

编译器在编译过程中会检查这些方面的正确性。如果代码违反了语法规则或类型系统的约束，编译器将报错，指出问题所在，并要求程序员纠正这些错误以通过编译提升代码的技术品质。

对语言的语法和类型系统有深刻理解是写出正确、可维护代码的关键。这也是编译器帮助程序员找出问题的方式，确保代码在这两个层面上是准确无误的。然而，如前所述，即使代码在这些方面没有问题，它也可能涉及逻辑错误或运行时错误，这些通常需要通过测试来发现和修复。

5、使用更通用的代码优势

使用更通用的代码（即通过接口或父类的引用来操作对象）在面向对象编程中具有多个重要的目的和优势。以下是一些主要的设计目的和好处：

1. 代码的可维护性和可读性

通过使用通用代码，您可以减少对特定实现的依赖，使代码更易于理解和维护。例如，如果您的方法（startJourney）接受接口或父类类型的参数，而不是具体的实现类，那么对该方法的理解和使用将不必涉及具体的实现细节。

这里使用 TypeScript 编写一个函数，该函数接受一个符合接口的参数而非具体的实现类。
首先定义一个接口，然后创建几个实现了该接口的类，最后编写一个接收接口类型参数的方法，
演示如何调用它而不关心具体的实现细节。

定义一个简单的接口 Transport，它具有一个方法 move：

// Transport 接口定义了一个 move 方法
interface Transport {
    move(): void;
}

// Car 类实现了 Transport 接口
class Car implements Transport {
    move() {
        console.log('Driving a car');
    }
}

// Bicycle 类实现了 Transport 接口
class Bicycle implements Transport {
    move() {
        console.log('Riding a bicycle');
    }
}

// Boat 类实现了 Transport 接口
class Boat implements Transport {
    move() {
        console.log('Sailing a boat');
    }
}
现在编写一个函数 startJourney，它接受一个 Transport 接口类型的参数，
并调用其 move 方法：

function startJourney(transport: Transport) {
    transport.move();
}

// 创建各种 Transport 的实例
const car = new Car();
const bicycle = new Bicycle();
const boat = new Boat();

// 使用不同的 Transport 实例调用 startJourney 函数
startJourney(car);      // 输出: Driving a car
startJourney(bicycle);  // 输出: Riding a bicycle
startJourney(boat);     // 输出: Sailing a boat
在这个例子中，startJourney 函数并不关心它接受什么类型的 Transport 实例，
它只是知道它可以调用 move 方法。
作为结果，无论传入一个 Car，Bicycle，还是 Boat 的实例，startJourney 都能正常工作。

这样的设计使得你可以添加更多实现了 Transport 接口的类，
并将它们的实例传递给 startJourney 函数，而无需修改 startJourney 函数本身，
它增强了代码的可扩展性和可维护性。

2. 松耦合

编程时使用更通用的代码有助于实现松耦合，这意味着不同的程序组件可以独立变化而不会互相影响。例如，您可以更改一个对象的具体实现，而不必更改使用该对象的代码，前提是这些更改仍然遵循原始的接口或父类合约。

3. 易于扩展

用通用的方式编写代码可以使得添加新的功能或组件变得更简单。因为新的实现仍然遵循同一接口或父类，所以它们可以很容易地集成到现有系统中，而无需修改使用这些接口或父类的代码。

4. 多态性

使用更通用的代码支持多态性，这是面向对象编程的一个关键特性。这允许程序在运行时选择正确的方法实现，基于对象的真实类型，从而使得同一段代码可以用于操作不同类型的对象，每种对象根据其具体类型以不同的方式响应相同的消息。

5. 促进测试和模拟

当您使用更抽象的引用（如接口）时，可以更容易地在测试环境中替换依赖项，比如使用模拟（Mock）对象。这对于单元测试和测试驱动开发（TDD）至关重要，因为您可以测试特定的组件而无须依赖于它们的具体实现。

总结

通过以上方式，使用更通用的代码有助于创建更加模块化、灵活和可扩展的软件应用。这样的设计思想强调了编程的"开放/封闭原则"，即软件实体（类、模块、函数等）应该对扩展开放，对修改封闭，简化了未来的软件更新和维护工作。

6、重载和重写有什么异同点

重载（Overloading）和重写（Overriding）是Java中两种非常重要的概念。它们都是方法的多态性表现形式，但在功能和应用场景上有所区别。以下是它们的异同点：

重载（Overloading）

定义：重载发生在同一个类中或子类中，它允许存在多个同名的方法，只要它们的参数列表不同（不同的参数类型、数量或参数的顺序）。

目的：使得同一个方法名可用于不同的输入参数的场景，增加了方法的可用性。

编译时决定：哪个重载方法将被调用是在编译时就决定的，基于方法的签名。

访问权限：可以发生改变，与原方法相比，重载的方法可以具有不同的访问权限。

异常：可以声明新的检查异常，而不需要和原有的方法相匹配。

返回类型：可以改变，只要参数列表不同。

public class Example {
    public void print(String s) {
        System.out.println("Printing String: " + s);
    }

    public void print(int i) {
        System.out.println("Printing int: " + i);
    }
}

重写（Overriding）

定义：重写发生在继承关系的子类与父类之间，子类提供了一个具有相同方法签名（即相同的方法名和参数列表）的新版本。

目的：让子类可以提供针对父类方法的特定实现，允许子类修改或完全替换继承自父类的行为。

运行时决定：哪个方法将被调用是在运行时根据对象的实际类型决定的。

访问权限：子类重写的方法不能拥有比父类方法更加严格的访问权限。

异常：重写的方法不能抛出新的检查异常，或者比父类方法声明更宽泛的检查异常。

返回类型：如果返回类型是基本数据类型，则必须保持一致；如果返回类型是引用数据类型，那么子类可以返回在类层次结构中更具体的类型。

示例：

public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

异同点概括

相同点：

它们都是面向对象编程中的多态性的体现。
它们的名称相似。

不同点：

应用范围：重载通常针对同一个类中的方法；重写是指子类改变继承自父类的行为。
参数列表：重载的方法必须改变参数列表；重写的方法必须有相同的参数列表。
返回类型：重载的方法可以改变返回类型；重写的方法的返回类型在某些情况下可以是协变的。
访问权限：重载的方法可以有不同的访问权限；重写的方法不能有比父类更严格的访问权限。
异常声明：重载的方法可以声明新的或更广的异常；重写的方法只能抛出在父类中声明的异常或者其子集。
绑定时间：重载在编译时进行绑定；重写在运行时进行绑定。
关键字：重写通常与@Override注解一起使用；重载没有特殊关键字。

了解这些差异能够帮助开发者更好地在代码中应用这两种多态性的方式，并且避免潜在的错误和混淆。

7、重载和多态有什么异同点

重载（Overloading）和多态（Polymorphism）是Java中两个不同的概念，它们都属于面向对象编程的特性。我们先来看看它们的定义：

重载（Overloading）：是指在同一个类中可以存在多个同名方法，只要它们的参数列表不同（参数的数量、顺序或类型不同）。重载是编译时（静态）的多态性，这是因为哪个重载方法应该被调用是在编译时就已经决定的。
多态（Polymorphism）：是指允许不同类的对象对同一消息做出响应。简单来说，一个引用变量到底引用的是哪个类的实例对象，将在运行时动态决定。多态可以是接口多态性或继承多态性。在Java中，多态通常指的是一个父类类型的引用指向子类的实例对象，并且可以调用在父类中声明的方法。

异同点

现在我们可以探讨它们的异同点：

相同点：

增加可读性：它们都可以使代码更加简洁和可读。对于重载，程序员可以为相似的功能使用相同的方法名；对于多态，不同的类可以使用相同的接口或父类方法，这样提高了代码的一致性。
提供灵活性：重载和多态都增加了程序的灵活性，方法重载允许同一个类的方法根据不同的参数类型和数量有不同的行为表现；而多态则允许不同的类对象通用同一接口，可以在不改变接口的前提下，增加新的实现类。

不同点：

功能目的：重载通常用于实现相似的功能，但是需要处理不同类型或不同数量的参数；而多态则是为了实现接口的不同实现，或继承关系中的方法重写，允许使用统一接口来处理不同的实现。
编译时机：方法的重载解析是在编译时完成的，因此也被称为静态多态。而多态是在运行时解析的，也就是说，调用哪个具体方法是在运行时才决定的，因此也被称为动态多态。
关键字的使用：在多态中，经常使用到关键字 extends（用于继承）和 implements（用于实现接口）。方法重载不需要使用特殊的关键字。

总结：
方法重载是函数层面的静态多态性，主要表现为同一个类中存在同名不同参的方法。多态则是对象层面的动态多态性，允许不同类的对象能共享同一接口，具体运行时绑定到哪个对象的方法取决于对象的实际类型。

8、继承和多态的相辅相成关系

继承（Inheritance）和多态（Polymorphism）是面向对象编程（OOP）中的两个核心概念，它们紧密相连，共同作用于程序设计中，使得软件可以更加灵活并易于扩展和维护。下面详细描述它们的相辅相成的关系：

继承

继承允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。继承的主要作用是代码复用和扩展。通过继承，子类拥有了父类的属性和方法，并可以根据需要添加新的属性和方法或者重写（Override）父类中的方法。

多态

多态是指不同的对象对同一操作作出不同的响应。在继承体系中，多态允许我们使用父类的引用类型来引用子类的对象。多态的实现通常依赖方法重写和运行时动态绑定功能。

它们如何相辅相成？

代码复用与扩展：继承允许子类继承父类的属性和方法，这意味着共通的逻辑可以放在父类中实现，而子类可以复用这些逻辑。同时，子类可以添加或重写父类的方法，实现功能的扩展，这也为多态的实现提供了基础。
接口替代实现：在继承中，子类的对象可以被看作是父类的实例。这样，父类类型的变量可以引用任何从该父类派生出的子类对象，这就实现了类型的一般化。在编程中，可以编写处理父类对象的代码，而实际运行时可以接受任意子类对象，从而体现多态行为。
动态方法调用：继承使得方法重写（Override）成为可能，而重写的方法将会在运行时根据对象的实际类型被动态地调用。这是多态表现得最明显的特性。方法重写强化了父类和子类间的行为差异，同时多态确保了正确行为的运行时调用。
简化和统一接口：利用继承，设计一个简洁的类层次结构，所有的子类都继承自共同的父类。然后，可以通过多态性使用父类类型的接口来操纵不同的子类对象，简化了客户端代码，并使得不同类对象之间可以互换使用而客户端代码无需修改。
易于扩展和维护：当系统需要新增一种子类时，只需要添加新的类并实现或重写适当的方法。现有的客户端代码通常不需要变动，因为它们操作的是父类接口，这体现了开闭原则（对扩展开放，对修改封闭）。

示例

假如我们有一个父类 Animal 以及几个子类 Dog、Cat 和 Bird：

public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Tweet");
    }
}
在多态的使用中，我们可以做到如下：

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal[] animals = new Animal[]{new Dog(), new Cat(), new Bird()};
        for (Animal animal : animals) {
            animal.makeSound(); // 根据实际对象类型调用相应的makeSound()方法
        }
    }
}

在这个例子中，不同的 Animal 类型的对象（Dog、Cat 和 Bird）都是以 Animal 类型存储和处理的，但它们的 makeSound() 方法被动态地绑定到了具体的子类实现上。这样的设计使得我们可以轻松地增加更多的 Animal 子类而不影响现有代码。

9、按照继承和重写的规律，是不是只要了解父类方法的定义，就可以理解多个子类的方法功能

理解父类的方法可以提供对子类方法功能的基本了解，但这种理解是不完整的。虽然继承和重写规则确实为父类和子类之间的关系提供了一定的结构和约束，但不能假设仅通过了解父类或一个子类的方法，就能准确推测出所有其他子类的具体实现和功能。以下是几点需要考虑的原因：

方法的重写（Overriding）：子类可以重写父类的方法，并且重写的方法可能会有不同的行为。这个新的行为是基于子类的具体需求来设计的，可能会与父类同名方法的行为显著不同。
行为的多样性：子类的作用是扩展父类，并为特定场景提供特化的行为。一些子类可能会新增额外的逻辑，处理特殊情况，或者赋予方法全新的语义，这些都无法仅仅通过了解父类方法得知。
上下文的重要性：子类定义的上下文（它代表的实体的本质和目的）决定了方法的实现。即使方法名和参数列表相同，子类的方法可能会在不同的上下文下有完全不同的意义。

“上下文”指的并不是子类的实例对象本身（只是对当前类的一个承载和this紧密相关，是运行时创建的，只是一个副本），而是子类所代表的更广泛的概念和环境，即子类所处的环境、条件以及它在整个程序中的角色和职责。它涉及到以下几个方面：

领域模型：子类代表了领域模型中的一个具体实体或概念，它的功能和行为应当符合该实体在领域中的作用和特性。

业务逻辑：子类通常体现了特定的业务逻辑。根据业务需求的不同，相同名称和参数的方法可能在不同的子类中有不同的实现。

程序结构：子类在整个程序中所扮演的角色，例如它可能是基类的一个特化形式，也可能是实现某个特定接口或者满足某种设计模式的需求。

语境关联：子类的行为可能受到程序当前状态或者其他对象状态的影响，即方法的行为可能与外部条件或内部状态有关。

继承层次：子类在继承层次中的位置也会对其行为产生影响。例如，继承深度较深的子类可能会对继承自顶层基类的行为做出更细微的调整。

约束和限制：子类可能受到特定的约束，这些约束可能来自于其定义的业务规则、安全要求、性能考虑等。

总的来说，当我们谈论“上下文”的时候，我们是在讨论一个比单个实例对象更宽广的概念，它包括了程序设计的各个方面以及子类如何与这些方面相互作用。理解子类的上下文对于正确预期和实现其行为是非常重要的。

方法的隐藏和重载：除了重写，子类还可以隐藏父类的方法（在静态方法中出现），或重载父类的方法（提供与父类同名但参数不同的方法）。这些额外的变化也影响对子类行为的理解。
异常处理：子类实现的异常处理可能与父类不同，有时候子类可能会处理更多异常或更具体的异常而改变了方法的控制流。
访问级别的变化：重写方法时，子类可以改变方法的访问级别（通常是放宽限制），但是这不会改变方法的行为。

综上所述，尽管了解父类的方法提供了一个框架，能够帮助你预期子类可能的行为和约束，但它并不足以让你准确推测出所有子类的具体功能和实现。理解每个子类如何继承和扩展父类的功能是必要的，尤其是当你处理复杂的继承体系或者行为多样性很高的对象时。

在维护或使用第三方类库时，最好的做法是查看具体子类的文档或源代码，以确保对其行为有准确的理解。如果类库设计得当，子类的文档通常会指出它是如何扩展或改变父类行为的。