JAVA基础类库--Object

最新推荐文章于 2021-10-02 13:24:12 发布
最新推荐文章于 2021-10-02 13:24:12 发布
阅读量217 收藏
点赞数
分类专栏： # Java基础 文章标签： Object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Loiterer_Y/article/details/103194485
版权

Object类用于统一对象、数组和接口。

Object类基本描述

1、Object类是所有类的父类，即任何一个类在没有定义继承某个类时，Object类就是其父类。

class Book{}	
class Book extends Object{}

上述两个类声明是等价的，Object类是唯一没有父类的类。Object类是所有类的父类，因此可以利用Object类通过向上转型，接收所有类型的对象。

class Book extends Object {
}

public class Demo {
    public static void main(String[] args) {
        Object objA = new Book(); // 向上转型
        Object objB = "Hello"; // 向上转型
        Book b = (Book) objA; // 向下转型
        String s = (String) objB; // 向下转型
    }
}

因此在不确定参数类型时，使用Object类型是最好的选择。
2、Object类中定义了一个无参构造方法，因为其是所有类的父类，所以实例化子类对象时必然会调用父类的无参构造方法。

一般而言，定义简单Java类时应覆写Object类中的如下方法：
· 取得对象信息：public String toString();
· 对象比较：public boolean equals(Object obj);
· 取得对象HASH码：public int hashCode();

toString()

class Book extends Object {
}

public class Demo {
    public static void main(String[] args) {
        Book b = new Book();
        String s = "Hello";
        System.out.println(b); // Book@1540e19d
        System.out.println(b.toString()); // Book@1540e19d
        System.out.println(s); // Hello
    }
}

上述代码中直接输出实例对象和使用toString()输出的结果是一样。因为输出对象时，会自动调用toString()将对象变为字符串后输出。Object类中的toString()为了适应对象的输出，仅输出对象的编码。
但是这和我们的想法不符，我们想输出的应该是实例化对象的属性信息，因此要覆写toString()。
范例：覆写toString()

class Book extends Object {
    private String title;
    private double price;

    // getter,setter,无参构造方法暂时略
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    public String toString() {
        return "书名：" + this.title + ",价格：" + this.price;
    }
}

public class Demo {
    public static void main(String[] args) {
        Book b = new Book("Java开发", 20.3);
        System.out.println(b); // 书名：Java开发,价格：20.3
    }
}

此时直接输出对象，调用的就是覆写后的方法。

equals()

范例：对象比较

class Book extends Object {
    private String title;
    private double price;

    // getter,setter,无参构造方法暂时略
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    public String toString() {
        return "书名：" + this.title + ",价格：" + this.price;
    }

    public boolean equals(Object obj) {
        if (this == obj) { // 地址相同
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Book)) { // 不是Book类对象
            return false;
        }
        Book book = (Book) obj;
        if (this.title.equals(book.title)
                && this.price == book.price) {
            return true;
        }
        return false;
    }
}

public class Demo {
    public static void main(String[] args) {
        Book bA = new Book("Java开发", 20.3);
        Book bB = new Book("Java开发", 20.3);
        System.out.println(bA.equals(bB)); // true
        System.out.println(bA.equals("Hello")); // false
    }
}

覆写后的equals()用于进行对象比较。

Object接收引用类型

1、Object类是所有类的父类，因此Object类对象可以接收所有类型的对象，包括数组和接口对象。
范例：接收数组数据

public class Demo {
    public static void main(String[] args) {
        Object obj = new int[]{1, 2, 3};
        System.out.println(obj); // [I@1540e19d表示数组
        if (obj instanceof int[]) { // 如果是数组，则输出
            int data[] = (int[]) obj; // 向下转型
            for (int x = 0; x < data.length; x++) {
                System.out.println(data[x]);
            }
        }
    }
}

范例：接收接口对象

interface A {
    public void fun();
}

class B implements A {
    public void fun() {
        System.out.println("Hello");
    }
}

public class Demo {
    public static void main(String[] args) {
        A a = new B();
        Object obj = a;
        A t = (A) obj;
        t.fun(); // Hello
    }
}

上述代码把参数类型统一为Object，有利于开发。

Object修改链表

此时我们可以利用Object类的特点解决之前开发的链表存在的问题：由于参数类型不统一，每次使用都要进行重新开发。
范例：修改链表

class Link { // 链表类，外部可见
    private class Node { // 节点类
        private Object data; // 保存数据
        private Node next; // 引用关系

        public Node(Object data) { // 有数据才有Node
            this.data = data;
        }

        // 设置关系
        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode;
            } else {
                this.next.addNode(newNode);
            }
        }

        // 数据查询
        public boolean containsNode(Object data) {
            if (data.equals(this.data)) { // 当前数据等于要目标数据
                return true; // 结束查询
            } else { // 当前数据不等于目标数据
                if (this.next != null) { // 有后续节点
                    return this.next.containsNode(data);
                } else { // 没有后续节点
                    return false;
                }
            }
        }


        public Object getNode(int index) {
            // 当前foot内容与要查询的索引比较
            // foot自增，目的是下次查询方便
            if (Link.this.foot++ == index) {
                return this.data;
            } else {
                return this.next.getNode(index);
            }
        }

        // 修改节点信息
        public void setNode(int index, Object data) {
            if (Link.this.foot++ == index) {
                this.data = data;
            } else {
                this.next.setNode(index, data);
            }
        }

        // 删除非根节点
        public void removeNode(Node previous, Object data) {
            // 参数中传递上一个节点和要删除的数据
            if (data.equals(this.data)) {
                previous.next = this.next;
            } else {
                this.next.removeNode(this, data);
            }
        }


        public void toArrayNode() {
            Link.this.retArray[Link.this.foot++] = this.data;
            if (this.next != null) {
                this.next.toArrayNode();
            }
        }
    }


    // ====================以上为内部类=====================
    private Node root; // 根节点
    private int count = 0; // 节点的个数
    private int foot = 0; // 索引
    private Object[] retArray; // 返回的数组

    public void add(Object data) {
        if (data == null) { // 输入数据为空
            return;
        }
        Node newNode = new Node(data); // 要保存的数据
        if (this.root == null) { // 根节点不存在
            this.root = newNode; // 设为根节点
        } else { //  根节点存在，交由Node处理
            this.root.addNode(newNode);
        }
        this.count++; // 每次增加节点，count+1
    }


    // 获取链表长度
    public int size() {
        return this.count;
    }

    // 判断是否为空链表
    public boolean isEmpty() {
        return this.count == 0;
    }


    // 判断数据是否存在
    public boolean contains(Object data) {
        if (data == null || root == null) {
            return false;
        }
        return this.root.containsNode(data);
    }

    // 根据索引获取信息
    public Object get(int index) {
        if (index > this.count) { // 超出查询范围
            return null;
        }
        this.foot = 0;
        return this.root.getNode(index); // 查询交给Node类
    }


    // 设置信息
    public void set(int index, Object data) {
        if (index > this.count) {
            return;
        }
        this.foot = 0; // 重置foot,作为索引
        this.root.setNode(index, data); // Node进行修改数据
    }

    // 判断删除节点是否为root
    public void remove(Object data) {
        if (this.contains(data)) { // 判断数据是否存在
            if (data.equals(this.root.data)) { // 判断数据是否是root数据
                this.root = this.root.next;
            } else {
                // root是Node对象，此处直接访问内部类私有操作
                this.root.next.removeNode(this.root, data);
            }
            this.count--; // 删除后数据个数减少
        }
    }

    public Object[] toArray() {
        if (this.root == null) {
            return null;
        }
        this.foot = 0; // 需要脚标控制
        this.retArray = new Object[this.count]; // 根据保存内容开辟数组
        this.root.toArrayNode();
        return this.retArray;
    }
}

范例: 测试程序

public class Demo {
    public static void main(String[] args) {
        Link all = new Link();
        all.add("A");
        all.add("B");
        all.add("C");
        System.out.println(all.size());
        all.remove("B");
        Object[] data = all.toArray();
        for (int x = 0; x < data.length; x++) {
            String str = (String) data[x];
            System.out.println(str);
        }
    }
}

综合实战: 宠物商店

要求: 以程序结构为主,实现一个宠物商店的模型,具有保存多个宠物的信息(名字,年龄),宠物上架、下架、模糊查询功能。
思路图：
在这里插入图片描述

宠物商店的商品（宠物）要符合宠物这一标准（接口），宠物商店借助链表实现上架、下架和模糊查询功能。
范例：定义宠物的标准

interface Pet { // 定义宠物的标准
    public String getName();

    public int getAge();
}

宠物商店与具体的宠物无关，只和宠物这一接口有联系。
范例：定义宠物商店

class PetShop {
    private Link pets = new Link(); // 要保存的宠物信息

    public void add(Pet pet) { // 上架
        this.pets.add(pet);
    }

    public void delete(Pet pet) { // 下架
        this.pets.remove(pet);
    }

    public Link search(String keyWord) { // 模糊查询，返回的内容个数不明
        Link result = new Link();
        // 将集合以数组的形式返回，
        // 真正要查询的数据是Pet接口对象的getName()的返回值
        Object obj[] = this.pets.toArray();
        for (int x = 0; x < obj.length; x++) {
            Pet p = (Pet) obj[x];
            if (p.getName().contains(keyWord)) {
                result.add(p);
            }
        }
        return result;
    }
}

范例： 定义猫类

class Cat implements Pet {
    private String name;
    private int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }

        if (!(obj instanceof Cat)) {
            return false;
        }
        Cat cat = (Cat) obj;
        if (this.name.equals(cat.name)
                && this.age == cat.age) {
            return true;
        }
        return false;
    }

    public String toString() {
        return "猫名：" + this.name + ", 年龄" + this.age;
    }
}

可参照上述结构，定义一个狗类。
范例：测试

public class Demo {
    public static void main(String[] args) {
        PetShop shop = new PetShop();
        shop.add(new Cat("阿猫", 9));
        shop.add(new Cat("猫咪", 19));
        shop.add(new Dog("阿狗", 10));
        shop.add(new Dog("狗子", 8));
        // 模糊查询
        Link all = shop.search("阿");
        Object obj[] = all.toArray();
        for (int x = 0; x < obj.length; x++) {
            System.out.println(obj[x]);
        }
        shop.delete(new Dog("狗子", 8));
    }
}
不会画画的画师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Json-lib 是一个 Java 类库
09-11
Json-lib 是一个 Java 类库（官网：http://json-lib.sourceforge.net/）可以实现如下功能： •转换 javabeans, maps, collections, java arrays 和 XML 成为 json 格式数据 •转换 json 格式数据成为 javabeans ...
Java中对象数组的使用
Denlee的一片天
03-23 3573
今天在用Java实现链表时，用到了对象数组，在运行程序时，程序抛出异常：java.lang.NullPointerException。如下的代码：public class StaticLinkList {  public static class LNode {  public Object data;  public int cursor;  public LNode(){  } }//静态
转换DataObject对象返回Json字符串
qq_36836224的博客
08-30 3581
因为业务需要记录具体操作日志，就将整个表DataObject数据保存为json字符串 代码如下： public class DataObjectConvertUtil { @Bizlet("转换一个DataObject返回Json字符串") public static String convertDataObjectToJsonString(DataObject dataO...
数据增加：public void add(Object data)
编程语言基础知识
05-06 2782
数据增加：public void add(Object data)如果要想在链表之中实现一个数据的增加操作，则应该首先在链表里面提供有一个追加方法，而这个追加方法的参数应该是Object类型.1.在Link类中追加新的方法定义。 class Link{//负责链表的操作 //将Node定义为内部类，表示Node类只为Link类服务 private class Node{//负责数据与节点关...
java public t t_关于泛型：如何在Java中解释“public < T > T readObjectData(… Class < T > type)”？...
weixin_39805720的博客
02-24 610
我有这个Java代码。public < T > T readObjectData(ByteBuffer buffer, Class< T > type) {...T retVal = (T) summaries;return retVal;如何解释这段代码？ 为什么我们需要public < T > T而不是public T？如何将参数赋给第二个参数(Class&...
linkedlist java 实现,数据结构(LinkedList的java实现)
weixin_32736623的博客
03-16 103
package day10;import java.util.*;public class MyLinkedList implements List{static class Node{public Object data;public Node next;public Node(Object data){this.data=data;}}private Node head;public MyL...
java源码包---java 源码 大量 实例
04-18
　Tcp服务端与客户端的JAVA实例源代码，一个简单的Java TCP服务器端程序，别外还有一个客户端的程序，两者互相配合可以开发出超多的网络程序，这是最基础的部分。 递归遍历矩阵 1个目标文件，简单！ 多人聊天室 3...
Java-Library:基于数组的容器类库的实现
03-27
Java库项目描述实现一个基于数组的容器类Library，并使用它来保存该图书馆拥有的书籍清单的信息。 Library类的一个实例是一个可扩展的bag数据结构，其初始容量为4，并在容量满时自动将其容量增加（增加）4。终极成绩...
Java -核心类库 Object类常方法 Math类常用方法 System类常用方法 基本类型包装类常用方法等
最新发布
05-05
Java核心类库中的典型例子
Delphi 的数据结构泛型类库 - DeCAL (含源码)
11-30
Decal 的全称是 Delphi Container and Algorithm Library，也就是 Delphi 数据容器和算法类库...他的思想是来自Stepanov 和 Lee 的 C++ STL(Standard Template Library) 和 ObjectSpace’s JGL (Java Generic Library)
object类
口耳戈是个生僻字
02-07 151
Object类的基本定义 Ø  Object类是所有类的父类，也就是说任何一个类在定义的时候如果没有明确的继承一个父类的话，那么它就是Object类的子类，也就是说以下两种类定义的最终效果是完全相同的： class Book { } 等价于 class Book extendsObject { }   Object类是所有类的父类，最大的好处在于利用object类可以接收所有类的对
Javascript中数据类型及其判别方法（typeof instanceof Object.prototype.toSting.call(obj)的区别）
liulangdeyue的专栏
08-31 967
今天总结了一下js中常见的shuj
数据结构(三):栈的实现以及应用
weixin_50600369的博客
10-02 849
栈及其实现栈的描述栈的接口实现顺序栈以及基本操作的实现链栈以及基本操作的实现栈的应用分配符匹配问题: 栈的描述 栈是一中特殊的线性表,栈中的数据元素与数据元素之间的逻辑关系与线性表相同,他们的差别在于:线性表的插入和删除可以在表中任意位置,而栈的插入和删除只允许在表的尾端操作,允许插入和删除的一端叫做栈顶(top),另一端称为栈底(bottom),插入的操作称为入栈(push),删除的操作称为出栈(pop)。 栈的接口实现 public interface IStack { void clean()
二叉树算法
sunhongjing的专栏
03-17 297
#region 二叉树算法//using System; public class Node  {      //成员变量      private object _data; //数据      private Node _left; //左孩子      private Node _right; //右孩子     ///      /// 数组对像
Java四种引用类型
weixin_30344795的博客
09-22 234
引用与对象 每种编程语言都有自己操作内存中元素的方式，例如在 C 和 C++ 里是通过指针，而在 Java 中则是通过“引用”。 在 Java 中一切都被视为了对象，但是我们操作的标识符实际上是对象的一个引用（reference）。 //创建一个引用，引用可以独立存在，并不一定需要与一个对象关联 String s; 通过将这个叫“引用”的标识符指向某个对象，之后便可以通过这个引用来实现操...
Java学习提要——浅谈Object类
临渊
08-25 1367
1.Object类的基本定义Object类是所有类的父类，也就是说任何一个类在定义的时候没有明确继承一个父类的话，那么它就是Object的子类 下面两个类是完全相同的概念： class Test{} 与 class Test extends Object {} 好处在于，可以利用Object类可以接收全部类的对象，因为可以向上自动转型
返回结果是一个对象obj，但是obj instanceOf Object返回false
这个昵称没有被占用吧的博客
03-04 2986
今天在使用koa的使用，为了判断传入参数中是否正确，使用了object的hasOwnPrototype，但是却发现代码报错了。 首先获取到参数：var params = ctx.query; 然后判断返回对象中是否存在指定参数，如user参数：params.hasOwnPrototype("user") 最后执行的时候，发现代码报错 执行params instanceOf Object，发现返回的...
Java基本类库（四）————Object类
monologuezjp的博客
10-15 151
Object类是所有类、数组、枚举类的父类，也就是说，java允许把任何类型的对象赋给Object类型的变量。因为所有的Java类都默认继承Object类，所以任何Java对象都可以调用Object类中的方法。 常用方法 boolean equals(Object obj):判断指定对象与该对象是否相等。这里相等的标准是两个对象是同一个对象（==）,因此这个方法实际上没什么用处，当我们创...
java public object_Java8基础学习之Object类
weixin_34357614的博客
02-24 1596
Object介绍Object类是所有Java类的祖先。每个类(包括数组)都使用Object作为超类。在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。可以使用类型为Object的变量指向任意类型的对象。Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。查看源码package java.lang;public cla...
java autocad类库
12-29
kabeja是一个Java类库，用于解析和处理CAD文件，特别是AutoCAD的DXF文件格式。它提供了一组API，可以读取和操作DXF文件中的图形元素。 kabeja类库的主要特点包括： - 支持读取和解析DXF文件中的图形元素，如线段、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值