JAVA之旅（九）——Object类，equals，toString，getClass，内部类访问规则，静态内部类,内部类原则，匿名内部类...

最新推荐文章于 2023-05-18 10:02:45 发布
最新推荐文章于 2023-05-18 10:02:45 发布
阅读量208 收藏
点赞数
文章标签： java
原文链接：https://yq.aliyun.com/articles/316149
版权

JAVA之旅（九）——Object类，equals，toString，getClass，内部类访问规则，静态内部类,内部类原则，匿名内部类

天天被一些琐事骚扰，学习还得继续

一.Object类

Object是什么呢？我们可以翻阅JAVA API文档看他的介绍

这里写图片描述

上面介绍说，object是类层次结构的根类，也就是超类

  • Object：是所有对象的直接后者间继承关系，传说中的老祖宗，你父亲还有父亲，你父亲的父亲还有父亲是爷爷，这是继承关系，但是你的祖宗却只有一位，该类中定义的肯定是所有对象都具备的功能
class Demo { // extends Object

}

1.equals

我们可以用equals去比较两个对象是否相同

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        // 比较
        Demo1 demo1 = new Demo1();
        Demo2 demo2 = new Demo2();
        System.out.println(demo1.equals(demo2));
    }
}

class Demo1 {

}

class Demo2 {

}

结果肯定返回的是false

这里写图片描述

这里我们要注意的是，他比较的是内存地址

假设我们需要定义一个比较内容

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        // 比较
        Demo demo1 = new Demo(5);
        Demo demo2 = new Demo(8);
        System.out.println(demo1.Comper(demo2));
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }

    public boolean Comper(Demo d) {
        return this.num == d.num;
    }
}

他返回的也是false，但是我们有必要这样去做吗？

  • object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有相同的功能，没有必要重新定义，只要沿袭父类的功能，简历自己的特有内容即可，这就是覆盖，所以我们已经复写
//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        // 比较
        Demo demo1 = new Demo(5);
        Demo demo2 = new Demo(5);
        System.out.println(demo1.equals(demo2));
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }

    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        return this.num == ((Demo)obj).num;
    }
}

这里运用了多态的向下转型

这里写图片描述

2.toString

转换成字符串

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        // 比较
        Demo demo = new Demo(5);
        System.out.println(demo.toString());
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }
}

转换的结果十什么呢？

这里写图片描述

这个是什么值呢？

  • 类名@哈希值

什么是哈希值？我们可以用toHexString来转换

System.out.println(demo.toString());
System.out.println(Integer.toHexString(demo.hashCode()));

这里写图片描述

3.getClass

这个就不用多说，返回当前运行的Class，所以

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        // 比较
        Demo demo = new Demo(5);
        /*
         * System.out.println(demo.toString());
         * System.out.println(Integer.toHexString(demo.hashCode()));
         */

        System.out.println(demo.getClass());
    }
}

class Demo {

    private int num;

    public Demo(int num) {
        this.num = num;
    }
}

我们这里就直接返回了Demo

这里写图片描述

方法还有很多，比如getName

System.out.println(demo.getClass().getName());

得到的就是Demo这个名称了

二.内部类

这是一个小知识点，我们先看一下概念

  • 将一个类定义在另一个类里面，对立面那个类就称为内部类（内置类，嵌套类）

  • 访问特点

    • 内部类可以直接访问外部类的成员，包括私有成员
    • 而外部类要访问内部类中的成员就必须建立内部类的对象

我们来写一个内部类

class Outer {
    int x = 3;

    void show() {
        System.out.println("x = " + x);
        new Inner().fini();
    }

    /**
     * 内部类
     * 
     * @author LGL
     *
     */
    class Inner {
        void fini() {
            System.out.println("内部类"+x);
        }
    }
}

内部类的访问规则上面已经体现了

  • 内部类可以直接访问外部类的成员，包括私有成员
  • 而外部类要访问内部类中的成员就必须建立内部类的对象

那我们可以不可以直接访问内部类中的成员呢？

Outer.Inner inner = new Outer().new Inner();
inner.fini();

这样就可以访问了，不过我们一般都不这样做，因为大多数的情况我们会将内部类私有

那你有没有想过？为什么匿名内部类可以访问外部的成员？我们可以做一个这样的小测试，在内部类里面定义一个x分别是成员变量和局部变量

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        Outer.Inner inner = new Outer().new Inner();
        inner.fini();
    }
}

class Outer {
    int x = 3;

    void show() {
        System.out.println("x = " + x);
        new Inner().fini();
    }

    /**
     * 内部类
     * 
     * @author LGL
     *
     */
    class Inner {
        int x = 5;

        void fini() {
            int x = 6;
            System.out.println("内部类" + x);
        }
    }
}

我们现在输出的这个x你知道是多少吗？结果显而易见，是6

这里写图片描述

那我现在想打印这个5怎么打？用this就行了

这里写图片描述

那我们想打印这个3呢？this是内部类的，那我们需要外面的this，就用Outer.this.x，输出的就是3了

这里写图片描述

之所以可以直接访问外部类中的成员是因为内部类中持有了一个外部类的引用，该引用写法是：外部类名.this

三.静态内部类

当内部类在成员位置上，就可以被成员修饰符所修饰，比如：

  • private,将内部类在外部类中进行封装
  • static,内部类就具备了static的特性，当内部类被static修饰后，只能直接访问外部类中的static的成员，出现了访问局限，但是静态内部类出现的不是很多，毕竟有访问局限

这里写图片描述

在外部类中，我们是如何访问静态内部类呢？

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        new Outer.Inner().fini();
    }
}

class Outer {
    private static int x = 3;

    /**
     * 内部类
     * 
     * @author LGL
     *
     */
    static class Inner {

        void fini() {
            System.out.println("内部类" + x);
        }
    }
}

这样就可以访问了

四.内部类原则

我们来分析下内部类是怎么来的，为什么这样用

  • 当描述事物时，事物的内部还有事物，该事物用内部类描述，因为内部事物在使用外部事物

内部类就是能直接访问外部类中的具体事物，一般都用于程序设计上

五.匿名内部类

一般内部类不会被公有实现，我们内部类可以定义在任意位置，也可以这样做

class Outer {

    int x = 3;

    void fini() {

        class fini {

            void show() {

                System.out.println("内部类");
            }
        }

    }
}

这段程序，内部类会运行吗？答案是不会，因为没有对象，我们就给他new一个对象呗

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        new Outer().fini();
    }
}

class Outer {

    int x = 3;

    void fini() {

        class fini {

            void show() {

                System.out.println("内部类");
            }
        }
        new fini().show();
    }
}

这样就可以访问了，内部类定义在局部

  • 1.不可以被成员修饰符修饰
  • 2.可以直接访问外部类中的成员，因为还持有类中的引用，但是不可以访问他所在的局部变量，只能访问被final修饰的局部变量

而我们的匿名内部类，是什么概念？我们顾名思义，匿名内部类，是没有名字的

  • 1.匿名内部类其实就是内部类的简写格式
  • 2.定义匿名内部类的前提，就是内部类必须继承一个类或者实现接口

正常的逻辑代码

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        new Outer().function();
    }
}

class Outer {

    int x = 3;

    class Inner extends AdsDemo {
        @Override
        void show() {
            System.out.println("method:" + x);
        }
    }

    public void function() {
        new Inner().show();
    }
}

abstract class AdsDemo {

    abstract void show();
}

而我们现在要使用匿名内部类，就简化了代码，具体怎么做？

//公共的   类   类名
public class HelloJJAVA {
    // 公共的 静态 无返回值 main方法 数组
    public static void main(String[] str) {
        new Outer().function();
    }
}

class Outer {

    int x = 3;

    // class Inner extends AdsDemo {
    // @Override
    // void show() {
    // System.out.println("method:" + x);
    // }
    // }

    public void function() {
        // new Inner().show();
        new AdsDemo() {
            @Override
            void show() {
                System.out.println("x:" + x);
            }
        };

    }
}

abstract class AdsDemo {

    abstract void show();
}

这个就是匿名内部类

  • 匿名内部类的格式：new 父类或者接口（）{定义子类的内容}
  • 其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，你也可以把他理解为带内容的对象
  • 匿名内部类中定义的方法最好不超过三个

OK,本篇幅就到这里，我们的JAVA之旅这个课程不知不觉已经讲了这么多了，从当初的不确定，想尝试一下写，现在已经积累到第九篇了，所以总结出来，我们想做的事情还是得去尝试一下，万一实现了呢？

有志同道合的人，欢迎加群：555974449

weixin_34218579
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【JavaSE】类与对象（static 代码块 内部类 toString）超详解，听不懂你来打我
qq_59877583的博客
04-04 697
章节索引1.static关键字1.1 static修饰成员变量1.2 static修饰成员方法1.3 static成员变量初始化2. 代码块2.1 代码块的概念2.2 普通代码块2.3 构造代码块/示例代码块2.4 静态代码块 1.static关键字 1.1 static修饰成员变量 我们前面写过Student类中，每个实例化的学生都有各自的姓名，成绩，年龄等，这些信息来对不同的对象进行描述，但对于一个班一个学校的同学来说，他们具有同样的学校，班级，每次创建对象都为这些成员分配内存未免有些做无用功，浪费空间
Java基础（内部类）
ToString的博客
10-01 172
Outer类： public class Outer { int a = 5; //普通内部类 class Inner{ int a=10; //内部类中只能定义final型static,不能定义static static final int m=10; void showB(){ System.out.println(this.a);//内部类的属性 System.out.println(Outer.this.a);//访问外部类属性 } } //静态内部类
Java第十一天（内部类、、访问权限修饰符、Object类包括toString和equals方法重写）...
weixin_33898876的博客
05-09 341
2019独角兽企业重金招聘Python工程师标准>>> ...
JAVA toString方法详解
qq_61897054的博客
02-21 4万+
JAVA toString方法 在Java中，我们经常会编写许多自定义类。在使用时，我们如何打印出这些类中实例变量？ class value { private int s; public void set(int i) { this.s = i; } public int get() { return this.s; } } 在上例中，我们编写了一个简单的类，该类中包含一个实例变量 s ，在使用时我们可以用方法set()、get
java类的tostring方法
0bug0warning的博客
09-29 4196
tosting方法重写 java类中的tostring来用来输出类的信息。 我们先直接调用tostring方法看看会输出什么。 test类： package csdn; public class Test { public static void main(String[] args) { // TODO Auto-generated method stub Student a = n...
Object,String类练习.doc
01-14
在Java编程语言中，`Object`和`String`类是非常基础且重要的概念。这里我们将针对提供的文件内容，详细解析和扩展相关知识点。 1. **重写`equals()`方法**： 在示例代码中，尝试重写了`equals()`方法来判断两个`...
java中的Object类[文].pdf
10-11
Java中的`Object`类是所有Java类的根类，无论是用户自定义的还是Java标准库中的类，它们最终都会继承自`Object`。这个类包含了所有对象通用的基本方法，例如`equals()`、`hashCode()`、`toString()`以及`clone()`等...
Java基础入门教程 第5章 Java基础类的应用（共42页）.ppt
12-04
Object类是所有Java类的父类，它包含了一些通用的方法，如`toString()`用于返回对象的字符串表示，`getClass()`获取对象的类信息，`equals()`比较对象是否相等，以及`hashCode()`用于对象的哈希计算。 在Java中，...
java对象类余接口的学习
03-13
所有Java类都隐式地继承自`java.lang.Object`类，它提供了所有对象共有的基本方法，如`toString()`、`equals()`和`hashCode()`。 12. **finalize(), clone(), getClass()方法** `finalize()`方法在对象被垃圾...
12.【Object类、常用API】_API_
10-04
Java中的`Object`类是所有类的根，无论是自定义的还是Java库中的类，它们都直接或间接地继承自`Object`。`Object`类提供了许多基础方法，这些方法对于理解和操作对象至关重要。在本知识块中，我们将深入探讨`Object`...
Java 实体类中的toString方法
u013750244的博客
01-14 2255
文章来源：https://blog.csdn.net/Sunny5319/article/details/83617545 1.在Java中每个类都默认继承Object类，除非声明继承某个类。而Object类中有一个叫做toString的方法。该方法返回的是该Java对象的内存地址经过哈希算法得出的int类型的值在转换成十六进制。这个输出的结果可以等同的看作Java对象在堆中的内存地址。 例如： package com.cal.toString; public class Test1 { public
彻底弄懂Java中的toString方法
最新发布
m0_71461928的博客
05-18 2476
需要注意的是，Object类的toString()方法的返回值并不总是对于对象的描述，它只是一个简单的用于标识该对象的字符串。如果你的类没有重写该方法，那么它就会默认继承父类Object的toString()方法。因此，当你调用一个未重写toString()方法的对象的toString()方法时，实际上就是调用了Object类中默认的toString()方法，将对象转换为字符串返回。而Object类本身有一个toString()方法，用于返回一个表示该对象的字符串，该方法返回的是一个字符串类型的值。
【JAVASE系列】09_toString和equals和内部类
07-01 182
1、源代码上toString（）方法的默认实现：2、toString方法的作用： 1、equals源代码，默认实现： 2、equals的作用：通过equals来判断两个对象是否相等。 上面的代码可以正常比较对象，null也行，但是效果过低，改进方法如下：修改之后的equals方法： 三、String对toString和equals的重写 比较两个字符串不能使用双等号，要使用equals方法。 总结：1、java中的基本数据类型使用“==”来判断是否相等。2、java中的引用数据类型使用equals方
详解 Java 内部类
热门推荐
指点
09-04 6万+
前言 内部类在 Java 里面算是非常常见的一个功能了，在日常开发中我们肯定多多少少都用过，这里总结一下关于 Java 中内部类的相关知识点和一些使用内部类时需要注意的点。 从种类上说，内部类可以分为四类：普通内部类、静态内部类、匿名内部类、局部内部类。我们来一个个看： 普通内部类 这个是最常见的内部类之一了，其定义也很简单，在一个类里面作为类的一个字段直接定义就可以了，例： pub...
内部类和String类常用方法
Java_HowTo的博客
10-07 320
1:内部类 1) 成员内部类: a) 可以被private修饰,可以被static修饰. b) 成员内部类可以访问外部类的private修饰的方法,外部类访问内部类的方法,需要创建内部类对象来进行访问. 外部类名.内部类名  变量名 = 外部类对象.内部类对象( ) ; c) 成员内部类被static修饰的时候: 它只能访问外部类的静态方法,    外部类名.内部类名 变量名 = 外部类名
一种通用的toString()方法的编写
znb769525443的专栏
07-30 1249
通用的toString()方法的编写
JAVA 匿名内部类面试题，要求:在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现
Qioooba的博客
04-01 5032
/* 分析以下需求，并用代码实现 要求:在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现 public class Test { public static void main(String[] args) { } } //定义接口 interface InterA { void showA(); } class A { pub...
在Java中怎么定义一个匿名内部类，定义匿名内部类的条件是什么？
Dangwenjie的博客
05-19 9199
一.匿名内部类:   1.匿名内部类其实就是内部类的简写格式。   2.定义匿名内部类的前提：内部类必须是继承一个抽象类或者实现接口。只要一个类是抽象的或是一个接口，那么其子类中的方    法都可以使用匿名内部类来实现   3.匿名内部类的格式：  new 父类或者接口(){定义子类的内容}   4.其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。   5

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值