JavaSE第九节————抽象类和接口（下）

已于 2024-08-16 09:45:14 修改
阅读量666 收藏 26
点赞数 24
分类专栏： JAVASE学习 文章标签： java 开发语言 学习
于 2024-08-16 09:39:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79418684/article/details/132817879
版权

系列文章目录

JavaSE第九节————抽象类和接口（下）

抽象类和接口

  1. 抽象类
  2. 接口
  3. Object类
  4. 内部类

文章目录

一、Object类

1.Object类的概念

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收
范例：使用Object接收所有类的对象

class Person{}
class Student{}
public class Test {
    public static void main(String[] args) {
        function(new Person());
        function(new Student());
    }
    public static void function(Object obj) {
        System.out.println(obj);
    }
} 
        //执行结果：
     //   Person@1b6d3586
     //   Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：
在这里插入图片描述
对于整个Object类中的方法需要实现全部掌握。
本小节当中，主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法

2.获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了，此处不再累赘

// Object类中的toString()方法实现：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

3.对象比较equals方法（ * * ）

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

  1. 如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同
  2. 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
  3. 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的
class Person{
    private String name ;
    private int age ;
    public Person(String name, int age) {this.age = age ;
        this.name = name ;
    }

    // Object类中的equals方法
    public boolean equals(Object obj) {
        return (this == obj); // 使用引用中的地址直接来进行比较
    }
}
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 20) ;
        Person p2 = new Person("李四", 20) ;
        int a = 10;
        int b = 10;
        System.out.println(a == b); // 输出true
        System.out.println(p1 == p2); // 输出false
        System.out.println(p1.equals(p2)); // 输出false
    }
}

在这里插入图片描述

Person类重写equals方法后，然后比较：

class Person{//重写equals方法
    private String name ;
    private int age ;
    public Person(String name, int age) {this.age = age ;
        this.name = name ;
    }
    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false ;
        } if(this == obj) {
            return true ;
        }
        // 不是Person类对象
        if (!(obj instanceof Person)) {
            return false ;
        }
        Person person = (Person) obj ; // 向下转型，比较属性值
        return this.name.equals(person.name) && this.age==person.age ;
    }
    // Object类中的equals方法

}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("张三", 20) ;
        Person p2 = new Person("李四", 20) ;
        int a = 10;
        int b = 10;
        System.out.println(a == b); // 输出true
        System.out.println(p1 == p2); // 输出false
        System.out.println(p1.equals(p2)); // 输出false
    }
}

在这里插入图片描述
结论：比较对象中内容是否相同的时候，一定要重写equals方法

4.hashcode方法

回忆刚刚的toString方法的源码：

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

我们看到了hashCode()这个方法，他帮我算了一个具体的对象位置，这里面涉及数据结构，但是我们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。

hashcode方法源码：

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到，我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例代码

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        Person per1 = new Person("gaobo", 20) ;
        Person per2 = new Person("gaobo", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
} 
 
        //执行结果
       // 460141958
       // 1163157884

在这里插入图片描述

注意事项：两个对象的hash值不一样。
像重写equals方法一样，我们也可以重写hashcode()方法。此时再来看看。

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    } @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class Test{
    public static void main(String[] args) {
        Person per1 = new Person("张三", 20) ;
        Person per2 = new Person("张三", 20) ;
        System.out.println(per1.hashCode());
        System.out.println(per2.hashCode());
    }
}

//执行结果
       // 460141958
           //    460141958

在这里插入图片描述
注意事项：哈希值一样。

结论：

1、hashcode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

二、内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内类，在Java中，可以将一个类定义在另一个类或者一个方法的内部前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

public class OutterClass {//外部类
	public int data = 1;
	public static int data2 = 5;
	private int data4 = 9;
    class lnnerClass{//内部类

    }
}

定义在class类名{}花括号外部的，即使在一个文件，都不能称为内部类

1.实例内部类（ * * ）

 class OutterClass {//外部类
    public int data = 1;
    public static int data2 = 5;
    private int data4 = 9;
    class InnerClass{//内部类
        public int  data = 9;
        public int  data5 = 4;
       // public static int data6 = 3;//1.内部类不能直接初始化静态成员变量
       public static final int data6 = 3; // 变成了常量，在编译的时候就确定了
        private int data7 = 7;

        public void test(){
            //System.out.println("InnerClass:test()" + data6);
            System.out.println("InnerClass:test()" );
            //3.在内部类中可以访问自己的成员，也可以访问外部类的成员
            System.out.println(data);//4.内部类成员与外部类成员重名时，优先使用内部类自己的成员
            System.out.println(OutterClass.this.data);//5.非要访问外部类与内部类重名的成员时，要用外部类名.this来访问
            System.out.println(data2);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
            System.out.println(data7);
        }

    }
    public void test(){
        System.out.println("OuterClass:test()");
    }
}
public class Test {
    public static void main(String[] args) {
      OutterClass outterClass= new OutterClass();
      OutterClass.InnerClass innerClass  = outterClass.new InnerClass();//2.要想实例内部类的对象
      innerClass.test();                                            // 先通过外部类生成一个外部类对象，然后通过对外部类对象的引用来实例化内部类
    }
}

在这里插入图片描述

注意事项：

  1. 外部类中的任何成员都可以在实例内部方法中直接访问
  2. 实例内部类所处的位置与外部类成员位置相同，因此也受public，private等访问限定符的约束。
  3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员来访问。
  4. 实例内部类对象必须在先有外部类对象的前提下才能创建
  5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
  6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先创建内部类的对象。

2.静态内部类（ * * * ）

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

//静态内部类
class OutClass{
    private int a;
    static  int b;
    public void methodA(){
        a = 11;
        System.out.println("OutClass:methodA" + a);
    }
    public static void methodB(){
        b = 23;
        System.out.println("OutClass:methodB" + b);
    }
    //静态内部类，被static修饰的成员内部类
    static class InnerClass{
        public void methodInner(){
            //在内部类中不能直接能访问外部类的非静态变量
        //a = 1000;//编译失败因为a不是类成员变量
            //间接访问
            OutClass outClass = new OutClass();
            outClass.a = 12;
            b = 90;
            //methodA();//编译失败，因为methodA不是类成员方法
            System.out.println("InnerClass:methodInner:" + b);
            System.out.println("InnerClass:methodInner:" + outClass.a);

        }
    }
}
public class Test {
    public static void main(String[] args) {
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.methodInner();
    }
}

在这里插入图片描述

注意事项：

  1. 在静态内部类中只能访问外部类中的静态成员。如果非要访问就要给它提供一个外部类的引用。
  2. 创建静态内部类对象时，不需要先创建外部类对象。

3.局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，一般使用的非常少。

public class Test {
    public static void func(){
        class A{
            public int a = 12;
        }
        A a = new A();
        System.out.println(a.a);
    }
    public static void main(String[] args) {
       func();
    }
}

在这里插入图片描述

注意事项：

  1. 局部内部类只能在所定义的方法体内部使用
  2. 不能被public，static等修饰符修饰
    编译器也有直自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
  3. 几乎不会使用

4.匿名内部类 

interface IA{
    void  test();
}
public class Test {

    public static void main(String[] args) {
//new IA();编译错误，IA不能实例化
        IA a = new IA() {//匿名内部对象
            @Override
            public void test() {
                System.out.println("这是重写了接口的方法");
            }
        };
        a.test();

        new IA() {//调用test方法的第二个方法
            @Override
            public void test() {
                System.out.println("这是重写了接口的方法");
            }
        }.test();
    }
}

在这里插入图片描述

莲雾flops
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值