应用程序编程接口 ----API

最新推荐文章于 2024-10-16 16:30:53 发布

サUBLL� 尔~

最新推荐文章于 2024-10-16 16:30:53 发布

阅读量410

点赞数 1

分类专栏：面向对象

本文链接：https://blog.csdn.net/qq_59378215/article/details/119677081

版权

面向对象专栏收录该内容

21 篇文章 1 订阅

订阅专栏

API (Applrication Programming Interface)

Java的API的话，就是写Java应用程序，可以去使用的类、接口等，调用它们的方法来完成我们需要的功能。
这些类等是已经有人替我们写好的，我们直接用即可。

如何查看API？
（1）方式一：官网提供有API文档，可以在线查看，也可以下载。全英文。
（2）方式二：一些前辈给我们整理的API手册。

1、Object类是在java.lang包
2、类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
==>（1）如果一个类没有显式的用extends继承其他类，那么它的父类默认就是Object。
所有类最终都能追溯到Object类。

例如：TestObject这个类，没有写extends其他类，那么它的父类就是Object。
GrandSon这个类的父类是Father，Father的父类是GrandFather，GrandFather的父类是Object，所以GrandSon这个类也可以追溯到Object类。

==>（2）所有类都是Object类的子类，那么Object类型的变量可以接收任意类型的对象。
==>（3）Object类型的数组，元素可以是任意类型的对象
Object[] arr = new Object[长度];
arr[0] = 任意类型的对象;
==>（4）Java规定Object类型的数组，可以接收任意引用数据类型的对象数组
Object[] arr = new 任意引用数据类型[长度];

==>（5）Java规定Object类型的变量不能直接接收基本数据类型的值，除非是后面学习的包装类的对象（自动装箱）
（6）Java规定Object类型的数组类型不能直接接收基本数据类型的数组

3、所有对象（包括数组）都实现这个类的方法。
Object类中声明的11个方法，所有对象都能拥有。
因此我们需要好好学习这11个方法。

4、我们所有子类的构造器首行，都有一句调用父类构造器的代码。
要么是super()，要么是super(实参列表)。

当创建子类对象时，都会执行父类对应的实例初始化方法。
因此，任意对象的创建都会导致Object类的无参构造对应的实例初始化被执行。（知识里面没有什么代码，大家看不到效果而已）

public class TestObject {
    public TestObject(){
        super();//代表的就是Object类的无参构造对应的实例初始化，并且这句话就算省略了，也会去执行
    }

    public static void main(String[] args) {
        //以下三句代码，都是向上转型，都是多态引用
        Object obj1 = "hello";//左边是Object类型的变量，右边是字符串“hello”对象
        Object obj2 = new TestObject();//左边是Object类型的变量，右边是TestObject对象
        Object obj3 = new GrandSon();//左边是Object类型的变量，右边是GrandSon对象
        System.out.println("-----------------------------");
        String[] arr1 = {"hello","world"};
        method(arr1);//形参Object[] arr，可以接收 String[] 的实参arr1


        GrandSon[] arr2 = new GrandSon[3];
        method(arr2);//形参Object[] arr，可以接收 GrandSon[] 的实参arr2

        System.out.println("-----------------------------");
        Object obj4 = 1; //obj4变量中不是存储int类型的1，而是存储的是Integer包装类的对象


        System.out.println("-----------------------------");
        int[] arr3 = {1,2,3,4,5};
//        method(arr3);//报错，因为形参Object[] arr，不能接收基本数据类型的数组
    }

    public static void method(Object[] arr){
        //...省略代码
    }
}

class GrandFather{

}
class Father extends GrandFather{

}
class GrandSon extends Father{

}

5、Object类的方法（今天先学习5个）
（1）public String toString()：返回该对象的字符串表示。即用一个字符串来表示/反映/描述一个对象。
字符串结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。
Java规定，如果我们直接打印对象，即println(对象)，自动调用对象的toString方法，来代替输出对象的“首地址”。
另外，当对象与String进行拼接时，也会自动调用对象的toString方法

重写toString方法？
A：手动重写
B：Alt + Insert ，使用Idea的toString方法模板

public class TestObjectMethod {
    public static void main(String[] args) {
        TestObjectMethod obj = new TestObjectMethod();
        System.out.println(obj.toString());//com.atguigu.api.TestObjectMethod@4554617c
        System.out.println(obj);//等价于 System.out.println(obj.toString());

        System.out.println("---------------------------");
        Student student = new Student("张三",99);
        System.out.println(student);//没有重写toString ==>com.atguigu.api.Student@74a14482
                                    //重写toString ==> Student{name='张三', score=99}

        System.out.println("---------------------------");
        System.out.println("学生的信息：" + student);
        String str = "结果：";
        str += student;//拼接
        System.out.println(str);

        System.out.println("----------------------");
        String string = "hello";
        System.out.println(string);//hello  而不是java.lang.String@hashCode值，因为String类重写了Object类的toString
    }
}
class Student{
    private String name;
    private int score;

    public Student() {
    }

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override  //可以去掉，表示下面的方法是重写的方法
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

（2）public final Class<?> getClass()：返回对象的运行时类型。

Class<?>：这个<?>先忽略，它是我们后面要学习的泛型部分的内容。
Class：是描述所有Java类型的一个类。首字母大写。Java虚拟机把每一个.class文件加载到方法区后都会用一个Class类型的对象来表示一个类型。
类的定义：一类具有相同特性的事物从抽象描述。
那么所有的 Java类型也有相同的特性，比如都有类名，都有构造器，都有包名等。
例如：String类型加载到方法区后，有一个Class对象来表示String类型。
Object类型加载到方法区后，也有另一个Class对象来表示Object类型。
Class对象的具体使用方式，在反射章节会详细讲解。现在只要知道它代表一个Java的数据类型即可。

public class TestObjectMethod2 {
    public static void main(String[] args) {
        Object obj = "hello";
//        obj的编译时类型是Object类型，运行时类型是String类型
        System.out.println(obj.getClass());//返回的是运行时类型      class java.lang.String

        Fu f = new Zi();
        //f的的编译时类型是Fu类型，运行时类型是Zi类型
        System.out.println(f.getClass());//返回的是运行时类型   class com.atguigu.api.Zi

        Object num = 1;//如果此时1按照int类型处理的话，会报错，只能按照引用数据类型处理，这里自动处理成Integer类型，Integer类型是我们后面会马上学到的包装类型。
        System.out.println(num.getClass());//返回的是运行时类型  class java.lang.Integer  不是int类型
    }
}
class Fu{

}
class Zi extends Fu{

}

3）protected void finalize()throws Throwable：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
子类重写 finalize 方法，以配置系统资源或执行其他清除。
A：throws Throwable：先不管它，它是表示该方法可能抛出异常的意思，后面异常部分讲完大家就懂了。

B：protected：要么在本类中，要么在本包中，要么在其他包的子类中访问，某个类的protected修饰的方法。
Object类在java.lang包，MyClass是在com.atguigu.api包中，是不同包。
MyClass是Object的子类，可以在MyClass类中的非静态方法中访问。

C：finalize()方法不是由程序员手动调用，而是有JVM中GC垃圾回收器调用，
在GC确定某个对象确实是“垃圾”（当垃圾回收器确定不存在对该对象的更多引用时）需要回收了，再调用。

D：一般的类不需要重写该方法，只有像系统资源类这些类才需要重写finalize方法。
例如：IO流类，数据库连接类，网络连接类等。
IO流类：FileInputStream 用于读取文件内容的IO流类

E：finalize方法调用的特点，是有GC来控制调用，我们没法确定它什么时候执行。
F：面试题的延伸
（1）final, finalize, finally的区别？
其中final是修饰符，上午讲过的
finalize是方法，就是上面的
finally是后面异常部分学习的关键字。

（2）finalize方法执行的特点（难）
finalize()方法不是由程序员手动调用，而是有JVM中GC垃圾回收器调用，有GC来控制调用，我们没法确定它什么时候执行。
每一个对象的finalize方法的只会执行一次。如果在finalize方法中，把对象“复活”了，那么这个对象下次称为垃圾之后，就不会调用finalize方法。

public class TestObjectMethod3 {
    public static void main(String[] args) throws InterruptedException {
        MyClass my = new MyClass();
//        my.finalize();//这里想要调用MyClass从Object继承的protected修饰的finalize()是不允许的。

        for(int i=0; i<10; i++){
            MyData myData = new MyData();//每一次循环后，上次循环中创建的MyData对象就成垃圾了，因为myData变量指向新的对象了
        }

        //为了让大家看到finalize方法被调用的过程，下面让main方法先不要着急退出，休息一会在退出
        //并且让GC尽快工作
        System.gc();//这句代码是呼叫GC来工作，它是不是立刻来也不一定。
        Thread.sleep(5000);//休息5秒，再继续，继续后面没有代码了，就表示main方法退出

        MyData.arr = null;//使得arr中所有对象称为垃圾
        System.gc();
        Thread.sleep(5000);

    }
}

class MyClass{

}

class MyData{
    public static MyData[] arr = new MyData[10];

    @Override
    protected void finalize() throws Throwable {
        arr[0] = this;//当前对象复活了，因为有引用重新指向它了
        System.out.println("轻轻的我走了，不带走一段代码！");
    }
}

（4）public boolean equals(Object obj)：指示其他某个对象（形参obj接收的实参对象）是否与此对象（this对象，即调用equals方法的对象）“相等”。
A：回顾之前的
String str1 = "hello";
String str2 = new String("hello");
str1.equals(str2) ==> true
其中 str1就是调用equals方法的当前对象，而str2就是形参obj接收的实参对象
B：如果子类没有重写equals方法，那么Object类的equals实现如下：
public boolean equals(Object obj) {
return (this == obj); //即默认也是比较两个对象的地址
}
C：如何重写equals方法
方式一：手动重写
必须遵循5个原则：
自反性：x.equals(x)必须返回true，即自己和自己比较返回true
对称性：x.equals(y)返回true，那么y.equals(x)也应该返回true
传递性：x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)返回true
一致性：x和y两个对象，只要参与equals比较的属性值，地址值等等没有修改过，在程序运行期间，无论什么时候调用的结果应该是一致。
非空对象与null比较一定返回false. x.equals(null)结果一定是false
如果x.equals(null)执行了，说明 x一定是非空的，否则就报NullPointerException空指针异常

方式二：用IDEA的模板，Alt + Insert

public class TestObjectMethod4 {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = new String("hello");
        System.out.println(str1 == str2);//false   比较两个对象的地址
        System.out.println(str1.equals(str2));//true  比较两个字符串对象的内容   String类重写了equals方法

        System.out.println("-------------------------");
        Employee e1 = new Employee(1,"张三",15000);
        Employee e2 = new Employee(1,"张三",15000);
        System.out.println(e1 == e2);//false  比较两个对象的地址
        System.out.println(e1.equals(e2));//重写之前false，重写之后true

        System.out.println("-------------------------");
        System.out.println(e1.equals(e1));//true

    }
}

class Employee{
    private int id;
    private String name;
    private double salary;

    public Employee() {
    }

    public Employee(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //打印对象，比较方便，直接看对象的信息
    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true; //比较this对象和o对象的地址，如果地址相同，直接返回true，

        if (o == null || getClass() != o.getClass()) return false;
        //如果o对象是null，直接返回false，因为this非空，和null比较一定false，如果this空的话，就报NullPointerException空指针异常，就进不来了
        //getClass() != o.getClass() 如果this对象的运行时类型和o对象的运行时类型不一样，直接返回false。类型都不同，就没有比较了

        Employee employee = (Employee) o; //如果上面都没问题，说明this和o是两个对象，它们都非空，它们的类型一样都是Employee类型
                                        //这里先对o向下转型。如果不向下转型，就无法访问o对象的name等属性了
                                        //equlas方法的形参是Object类型，实参对象传入时被向上转型为Object了，需要向下转型
        return id == employee.id &&
                Double.compare(employee.salary, salary) == 0 &&
                Objects.equals(name, employee.name); //比较id,name,salary都相等，返回true
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, salary);
    }
}

（5）public int hashCode()：返回该对象的哈希码值。支持此方法是为了提高哈希表（例如 java.util.Hashtable 提供的哈希表）的性能。
A：hashCode值，就像是对象的一个编码一样，
理论上，是每一个对象都有唯一的hashCode值。即希望只要对象不同，那么hashCode就不同。
实际中，因为hashCode值是根据“散列函数”计算出来的一个int值，那么就可能存在两个不同的对象，hashCode值一样的情况。
生活中，遇到两个情况，他们的身份证号码和另一个人的号码重复。

B：hashCode的作用后面在哈希表中使用，今天不讨论

C： hashCode()和equals方法一定要一起重写。
并且要遵循如下原则：
A：如果两个对象的equals方法调用结果是true，那么它俩的hashCode值一定要一样
B：如果两个对象的hashCode值不同，那么equals方法一定要返回false
C：如果两个对象的hashCode值相同，那么equals方法的结果可能是true，可能是false
例如："Aa"和"BB"字符串的hashCode值相同，但是equals却是false
例如："Aa"和"Aa"字符串的hashCode值相同，equals也是true

public class TestObjectMethod5 {
    public static void main(String[] args) {
        System.out.println("Aa".hashCode());//2112
        System.out.println("BB".hashCode());//2112
    }
}