【Java】Object类、内部类

喜欢做梦

发布于 2024-11-25 18:04:57

10200

代码可运行

文章被收录于专栏：学习学习

运行总次数：0

代码可运行

Object类

Object类：Java默认提供的一种类。默认会继承Object父类。可以理解为Object是所有类的父类，其所有类的对象都可以继承Object类

示例：

//父类
public abstract class Animal {
    public String name;
    public int age;
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public abstract void eat();
}
//子类
public class Cat extends Animal implements IRun{
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void eat() {
        System.out.println(this.name+"吃猫粮");
    }
    public void run(){
        System.out.println(this.name+"会跑");
    }
}
//测试
 public static void main(String[] args) {
        Object obj1=new Cat("mimi",3);
    }

在Object中包含了许多方法，我们需要先要掌握hashCode（），equals（），toString（）这些方法

toString()方法

作用：获取对象信息

toString源码：

 public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

调用：

    public static void main(String[] args) {
        Dog dog1=new Dog("小白",2);
        System.out.println(dog1.toString());
    }

其获得的结果是这个对象在哪个包那个类下面的具体位置

如果你对这个结果并不满意，你想获得的是这个对象的具体内容，我们可以对其进行重写

    @Override
    public String toString() {
        return "Dog{" +
                "name=" + name +
                ", age=" + age +
                '}';
    }

equals方法

作用：对象的比较

在我们比较值的大小的时候，我们通常会使用==来看他们是否相等

    public static void main(String[] args) {
        int a=2;
        int b=2;
        System.out.println(a==b);
}

那如果我想要看对象的值是否相等呢？也可以用==吗？

 public static void main(String[] args) {
        Dog dog1=new Dog("小白",2);
        Dog dog2=new Dog("小白",2);
        System.out.println(dog1==dog2);
    }

显然是不可以的，==判断的是你当前变量中的值，而dog1和dog2其储存的是对象的地址，其对象不一样，其值也不一样。

在Java中，==进行比较时：

如果==左右两侧是基本类型变量，比较的是变量中的值是否相同
如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同

那应该怎么办呢？用 equals吗？

    public static void main(String[] args) {
        Dog dog1=new Dog("小白",2);
        Dog dog2=new Dog("小白",2);
        System.out.println(dog1==dog2);
        System.out.println(dog1.equals(dog2));
    }

也是不可以的，为什么？

equals方法默认也是按照地址比较的。

那应该怎么办？

如果要比较对象中的内容，必须重写Object中的equals方法 。Object是所有类的父类，Object有equals类，子类重写就好。

 @Override
    public boolean equals(Object obj) {
    if(obj == null){
            return false;
        }
        if(obj == this){
            return true;
        }
        //如果不是同一类型
        if(!(obj instanceof Dog)){
            return false;
        }
        Dog dog=(Dog)obj;
        return dog.name.equals(this.name)
        && dog.age==this.age;
    }

name是String类型要用equals来比较。

hashCode方法

作用：算一个具体的对象位置

我们一般认为内容都相同的变量应在同一个位置

 public static void main(String[] args) {
        Dog dog1=new Dog("小白",2);
        Dog dog2=new Dog("小白",2);
        System.out.println(dog1.hashCode());
        System.out.println(dog2.hashCode());
    }

但其值并不一样，于是我们要对其进行重写

这是一个native方法，底层有C/C++来写，我们看不到。

子类重写：

 @Override
    public int hashCode() {
        return Objects.hash();
    }

hashCode方法用来确定对象在内存中存储的位置是否相同

内部类

内部类：在外部类中，内部类定义位置与外部类成员所处的位置相同，因此称为内部类。

内部类的分类

实例内部类

实例内部类：未被static修饰的类

class Outclass3 {
    public  int a=2;
    public static int b=3;
    public int c=1;
    public void eat(){
    }
     //实例化内部类
        public class InnerClass1{
        public int c=3;
        public void fun(){
            //实例化内部类中，可以直接访问成员，无论静态非静态
            System.out.println(a);//2
            System.out.println(b);//3
            eat();
            //如果实例内部类的变量与外部类中的相同，访问相同变量，
            // 优先访问实例内部类中的变量
            System.out.println(c);//3
            //如何在外部类和内部类相同变量的情况下访问外部变量？
            //1.实例化外部类，通过 类名. 访问
            Outclass3 out=new Outclass3();
            System.out.println(out.c);
            //2.直接 外部类.this. 访问
            System.out.println(Outclass3.this.c);
        }
    }
    }
public class Test {
    public static void main(String[] args) {
    //实例内部类的实例化：要先实例化外部类，再进行对内部类的实例化
        Outclass3 outclass=new  Outclass3();
        Outclass3.InnerClass1 inner2=outclass.new InnerClass1();
        inner2.fun();
    }
}

实例内部类中可以直接访问外部内部类中的任何成员（不限类型）；
在实例内部类与外部类中具有先相同变量名的情况下优先访问内部类直接的成员，

在相同变量的情况下，如果要访问外部类中的成员

1.实例化外部类：通过类名. 访问

            Outclass3 out=new Outclass3();
            System.out.println(out.c);

2.直接外部类名. this. 访问

         System.out.println(Outclass3.this.c);

实例内部类中，包含2个this，一个是实例内部类自己的this，一个是外部类名.this

实例内部类的实例化，要在对对外部类的实例化的前提下
外部类中不能直接访问内部类中的成员，要对内部类进行实例化

  public void fun1(){
        InnerClass1 inner1=new InnerClass1();
        System.out.println(inner1.h);
    }

静态内部类

静态内部类：被static修饰的成员内部类

public  class Outclass {
    public  int a=2;
     static int k;
    public void eat(){
        k=3;
        System.out.println("吃东西");
    }
    public static void fun2(){
        System.out.println("....");
    }
    //在外部类中
    //静态内部类
    static class InnerClass{
        public int b=1;
        private int c=2;
        final int f=5;
        static final int g=6;
        public void fun(){
            /*1.可以直接直接访问外部类的静态成员*/
            k=3;//直接访问成员变量
            Outclass.fun2();//直接访问成员方法
           /*2.不可以直接访问外部类的非静态成员*/
            //a=3; 报错，不可以直接访问外部类的非静态成员
            //3.但可以实例化外部类，在进行对非静态成员的访问
            Outclass outclass1 =new Outclass();
            System.out.println(outclass1.a);
            outclass1.eat();
            System.out.println("....");
        }
        //构造
        public InnerClass(){

        }
    }
}
public class Test {
    public static void main(String[] args) {
        //4.内部类的实例化
        Outclass.InnerClass inner=new Outclass.InnerClass();
       //调用静态内部类中的方法
        inner.fun();
}
}

在静态内部类中，可以直接访问外部类中的静态成员，但不可以访问外部类的非静态成员。如果要访问外部的非静态成员，要先对外部类进行实例化
实例化静态内部类对象的时候，要先进行外部类名.

局部内部类

局部内部类：在方法体中的类

public class Test {
    public void test(){
        //局部内部类
        class Inner{
            public int a=1;
            public void fun(){
                System.out.println("...");
            }
        }
        //局部内部类的实例化
        Inner inner=new Inner();
        inner.fun();
    }

不能被public、static等修饰符修饰；
局部内部类只能在所定义的方法体内部使用；
几乎不用；

匿名内部类

public class Test {
    public static void main(String[] args) {
        new Out(){

        }.test();
    }

}
class Out{
    public void test(){
        System.out.println(".....");
    }
}
==========================================
public class Test {
    interface IA{
        void test1();
    }
    public static void main(String[] args) {
        //实现接口并重写
        IA a=new IA(){
            @Override
            public void test1() {
                System.out.println("。");
            }
        };
        a.test1();
    }

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-08-13，如有侵权请联系 cloudcommunity@tencent.com 删除

变量