用java的Object转double

---

文章目录

• 一. Object superclass

• 1. Object 类的位置
• 2. Object 类的方法
• 3. 默认继承
• 4. Object 类的作用

• 二. super

• 1. super 的主要用途包括

• (1) 调用父类的构造方法
• (2)引用父类的成员

• 2. you can access overridden(or hidden) members of a superclass by using the super keyword to explicitly refer to the superclass

• (1)Overridden Members（方法覆盖）
• (2)Hidden Members（成员隐藏）

• 三. type casting类型转换

• 1. 隐式类型转换（自动类型转换）
• 2. 显式类型转换（强制类型转换）
• 3. 引用类型的类型转换

• 四. Equality

• 1. 基本数据类型（Primitive Data Types）
• 2. 引用类型（Reference Types）

• （1）引用相等性（Reference Equality）
• （2）对象相等性（Object Equality）

---

一. Object superclass

Object 是Java中的超类（Superclass）或根类（Root Class），它是所有类的直接或间接父类。在Java中，每个类都继承自 Object 类，即使你没有显式指定继承关系。
oracle

1. Object 类的位置

Object 类位于Java标准库的 java.lang 包中，这意味着你不需要导入它，它自动包含在每个Java程序中。

2. Object 类的方法

Object 类定义了一些通用的方法，这些方法可以被所有类继承和使用。其中一些常见的方法包括：

• equals(Object obj)：用于比较对象是否相等。
• hashCode()：返回对象的哈希码值。
• toString()：返回对象的字符串表示。
• getClass()：返回对象的运行时类。
• clone()：用于创建并返回对象的副本。returns (shallow) copy of object
• finalize()：用于垃圾回收前的清理操作。call by GC before reclaiming
  等等。

3. 默认继承

如果你不明确指定一个类的父类，那么该类将隐式继承自 Object 类。例如，以下两个类声明是等效的：

class MyClass { // 隐式继承自Object
    // 类定义
}

class MyClass extends Object { // 显式继承自Object
    // 类定义
}

4. Object 类的作用

• Object 类在Java中具有最广泛的应用。它为所有类提供了一组通用的方法，这些方法可以被继承和重写，以满足特定类的需求。
• 它也是多态性的基础，因为你可以使用 Object 引用来引用任何Java对象。
• Object 类的方法是所有其他类的备用实现，你可以自定义这些方法以满足特定类的需求。

---

二. super

在Java中，super 是一个关键字，用于引用父类（超类）的成员或调用父类的构造方法。
super_oracle

1. super 的主要用途包括

(1) 调用父类的构造方法

使用 super 可以在子类的构造方法中调用父类的构造方法。
这在子类需要执行父类构造方法的一部分时非常有用，以确保父类的初始化工作得以完成。

class Animal {
    Animal() {
        System.out.println("Animal类的构造方法");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // 调用父类的构造方法
        System.out.println("Dog类的构造方法");
    }
}

(2)引用父类的成员

使用 super 可以引用父类中的成员变量或方法，以区分与子类同名的成员。
这在子类覆盖（重写）父类方法时，需要在子类方法中访问父类的方法或成员时非常有用。

class Animal {
    void makeSound() {
        System.out.println("Animal发出声音");
    }
}

class Dog extends Animal {
    void makeSound() {
        super.makeSound(); // 调用父类的makeSound方法
        System.out.println("Dog叫：汪汪！");
    }
}

2. you can access overridden(or hidden) members of a superclass by using the super keyword to explicitly refer to the superclass

可以使用 super 关键字来访问在子类中被覆盖（overridden）或隐藏（hidden）的父类成员，以确保访问的是父类的版本，而不是子类中的版本。

(1)Overridden Members（方法覆盖）

当子类覆盖了父类的方法时，子类的版本会隐藏父类的版本，但你仍然可以使用 super 关键字来访问父类的被覆盖方法。
这在子类的方法中需要部分重用父类的行为时很有用。

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    void makeSound() {
        super.makeSound(); // 使用super关键字访问父类的被覆盖方法
        System.out.println("狗叫：汪汪！");
    }
}

可以传递参数

class Parent {
    int value;

    Parent(int value) {
        this.value = value;
    }
}

class Child extends Parent {
    Child(int value) {
        super(value); // 使用super关键字调用父类构造函数，传递参数
    }
}

(2)Hidden Members（成员隐藏）

子类可以定义与父类相同名称的新成员（字段或方法），从而隐藏父类的成员。
使用 super 关键字可以访问父类的成员，即使子类定义了同名的成员。

class Parent {
    int value = 10;
}

class Child extends Parent {
    int value = 20;

    void display() {
        System.out.println(value);      // 访问子类的value
        System.out.println(super.value); // 使用super关键字访问父类的value
    }
}

总之，使用 super 关键字可以帮助你在子类中访问父类的被覆盖或隐藏的成员，以便在需要时使用或扩展父类的行为。这有助于更好地控制继承关系中的成员访问。

三. type casting类型转换

类型转换（Type Casting）是将一个数据类型的值转换为另一个数据类型的值的过程。

1. 隐式类型转换（自动类型转换）

隐式类型转换是自动执行的，无需程序员的干预。它发生在编译时，当一个小范围的数据类型的值被赋给一个大范围的数据类型时。
这是安全的，因为小范围的值可以容易地适应大范围的数据类型。

int numInt = 10;
double numDouble = numInt; // 隐式类型转换，int转为double

2. 显式类型转换（强制类型转换）

显式类型转换需要程序员明确指定要进行类型转换的操作。这通常发生在将一个大范围的数据类型的值赋给一个小范围的数据类型时。
这需要使用强制类型转换运算符（(type)）来明确指定要进行类型转换。

double numDouble = 10.5;
int numInt = (int) numDouble; // 显式类型转换，double转为int

需要注意的是，显式类型转换可能导致数据的丢失或溢出，因此在执行显式类型转换时应谨慎。另外，将无法容纳的大值转换为小数据类型可能导致不准确的结果。

3. 引用类型的类型转换

类型转换也适用于引用类型，例如将子类对象引用赋给父类对象引用（向上转型）或将父类对象引用赋给子类对象引用（向下转型）。
向上转型是隐式的，而向下转型需要显式类型转换。

class Animal { }
class Dog extends Animal { }

Animal animal = new Dog(); // 向上转型，隐式
Dog dog = (Dog) animal;   // 向下转型，显式

总之，类型转换是在Java中进行数据类型转换的重要概念。它允许你在不同数据类型之间进行转换，以满足程序的需求。隐式类型转换通常是安全的，而显式类型转换需要谨慎处理，以避免数据丢失或溢出。在引用类型的情况下，向上转型是隐式的，而向下转型需要显式类型转换。

四. Equality

1. 基本数据类型（Primitive Data Types）

当你比较两个基本数据类型的变量时，可以使用 == 运算符来判断它们的值是否相等。因为基本数据类型存储的是实际值，而不是引用。

int num1 = 5;
int num2 = 5;
boolean areEqual = (num1 == num2);  // 通过 == 比较值的相等性

2. 引用类型（Reference Types）

当你比较两个引用类型的变量时，需要区分两种情况：

（1）引用相等性（Reference Equality）

如果你想比较两个引用变量是否指向同一个对象（具有相同的内存地址），可以使用 == 运算符。

（2）对象相等性（Object Equality）

如果你想比较两个对象的内容是否相等，应该使用 equals() 方法。默认情况下，equals() 比较的是引用相等性，但某些类会重写 equals() 方法以比较内容相等性。

String str1 = new String("Hello");
String str2 = new String("Hello");

boolean refEquality = (str1 == str2);  // 通过 == 比较引用相等性，通常为 false
boolean objEquality = str1.equals(str2);  // 通过 equals 比较对象内容相等性，通常为 true

需要注意的是，对于自定义类，你可以根据需要重写 equals() 方法，以实现对象内容的比较，而不仅仅是引用相等性的比较。这允许你自定义相等性的定义。通常情况下，引用相等性（使用 ==）用于判断两个引用是否指向同一对象，而对象相等性（使用 equals()）用于判断两个对象的内容是否相等。

---