【Java】内部类&Object类

最新推荐文章于 2024-07-11 17:24:34 发布

爱敲代码的菜菜

最新推荐文章于 2024-07-11 17:24:34 发布

阅读量478

点赞数 1

分类专栏： Java 文章标签： java Object类内部类 hashCode 匿名内部类

本文链接：https://blog.csdn.net/qq_74455045/article/details/130474179

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.内部类

定义：一个类定义在另一个类或一个方法的内部，前者称为内部类，后者称为外部类。

分类：实例内部类，静态内部类，局部内部类，匿名内部类。

1.1实例内部类

注意：1> 外部类中的任何成员都可以在实力内部类中直接访问(private也可以)；

2> 实力内部类所处的位置与外部类成员位置相同，因此也受public，private等访问限定符的约束；

3> 访问成员时优先内部类，要想访问外部类同名的成员，必须通过外部类类名.this.同名成员来访问；

4> 实力内部类对象必须在先有外部类对象的前提下创建（这也是其缺点之一）；

5> 外部类若想访问内部类的成员必须创建内部类对象。

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    private static int data3 = 3;
    //实例内部类：类里面，方法外面
    class InnerClass {
        public int data1 = 10;
        public int data4 = 4;
        private int data5 = 5;
        //public static int data6 = 6;//实力内部类中不能定义静态变量
                                      //原因：此变量不依赖对象，但是InnerClass类依赖对象
        public static final int data7 = 7;//加上final即可，此时该变量为常量，在编译时就已确定
        public void testInner() {
            System.out.println("testInner");
            System.out.println(data1);//优先访问内部类成员
            System.out.println(OuterClass.this.data1);//利用外部类名和this访问外部类成员
            System.out.println(data5);                //说明实例内部类存在外部类的this
        }
    }
    public void testOut() {
        //外部类若想访问内部类的成员必须创建内部类对象
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data5);//5
    }
}
public class Main {
    public static void main(String[] args) {
        //实例化实例内部类对象
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        OuterClass.InnerClass innerClas2 = new OuterClass().new InnerClass();//将上面两行代码合二为一
        innerClas2.testInner();
    }

}

1.2静态内部类

注意：1> 创建内部类对象时不需要先创建外部类对象；

2> 在静态内部类中只能访问外部类中的静态成员。

class OuterClass {
    public int data1 = 1;
    private int data2 = 2;
    private static int data3 = 3;
    //静态内部类
    static class InnerClass {
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;//可定义静态成员变量
        public void testInner() {
            System.out.println("testInner");
            System.out.println(data3);//可以访问外部类的静态成员
            //System.out.println(data1);//无法访问外部类非静态成员
            //System.out.println(OuterClass.this.data2);//使用外部类名.this也不可以
            //解决方法：new一个外部类对象
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        //实例化静态内部类
        OuterClass.InnerClass innerClass = new OuterClass.InnerClass();//不需要创建外部类对象，注意和实例内部类的区别
        innerClass.testInner();
    }
}

1.3局部内部类

注意：1> 只能在所定义的方法体内部使用；

2> 不能被public、static等修饰符修饰；

class OuterClass {
    public void test() {
        //局部内部类：方法里面
        class InnerClass {
            public int data1 = 1;
        }
        //只能在所定义的方法体内部使用
        InnerClass innerClass = new InnerClass();
        System.out.println(innerClass.data1);
    }
}

1.4匿名内部类

语法奇奇怪怪QAQ……但是之后会很常用，只能死记啦 o.O

class Student implements Comparable<Student> {
    @Override
    public int compareTo(Student o) {
        return 0;
    }
}
interface Shape {
    void draw();
}
public class Test {
    public static void main(String[] args) {
        Comparable<Student> comparable = new Student();
        //匿名内部类：相当于这里有一个类实现了Comparable接口并重写了compareTo方法
        new Comparable<Student>() {
            @Override
            public int compareTo(Student o) {
                return 0;
            }
        }; //注意这里的分号
        int a = 10;
        new Shape() {
            @Override
            public void draw() {
                //a = 20;//在匿名内部类中，访问的变量不能改变
                System.out.println(a);
            }
        }.draw(); //调用draw方法
    }
}

2.Object类

定义：Object是Java默认提供的一个类，是参数的最高同一类型。除了Object类，所有的类都是存在继承关系的。默认所有类继承Object父类。

疑问：之前我们学过，一个类只能继承一个类，这里的意思是只能同时继承一个类。

例如：Dog类继承Animal类，而Animal类又默认继承Object类，所以Dog类间接继承了Object类，没有违背一个类只能继承一个类这一说明。

//使用Object类接收所有类的对象

class Student {
    public int age;
    public Student(int age) {
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Object object1 = new Student(1);//Object可接收所有类的对象
    }
}

2.1getClass方法

public class Test {
    public static void main(String[] args) {
        Student student = new Student(10);
        Class<?> c = student.getClass();//Class<?> 这里涉及到了泛型，在之后的数据结构中会讲解
        System.out.println(c);//class Demo2.Student —— 在Demo2包下的Student类中
    }
}

2.2equals方法

进入Object的equals方法后，我们发现代码仍是使用地址比较，所以若想比较数据大小，必须要重写equals方法：

import java.util.Objects;
class Student {
    public int age;
    public Student(int age) {
        this.age = age;
    }
    @Override //根据自身需求重写equals方法
    public boolean equals(Object obj) {
        Student student = (Student) obj;
        return age == student.age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student(10);
        Student student2 = new Student(10);
        System.out.println(student1==student2);//比较地址，false
        //System.out.println(student1.equals(student2));//父类Object中的equals仍是比较地址，false
        System.out.println(student1.equals(student2));//重写equals后比较年龄大小，true
    }
}

2.3hashcode方法

定义：此方法帮我们算了一个具体的对象位置，用来确定对象在内存中存储的位置是否相同。一般在散列表中才有用，其他情况下无用。

import java.util.Objects;

class Student {
    public int age;
    public Student(int age) {
        this.age = age;
    }
    @Override //使用Generate生成
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age;
    }
    @Override //使用Generate生成
    public int hashCode() {
        return Objects.hash(age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student(10);
        Student student2 = new Student(10);//没重写hashCode：不一样
        //System.out.println(student1.hashCode());//460141958
        //System.out.println(student2.hashCode());//1163157884
                                                //重写hashCode后：一样
        System.out.println(student1.hashCode());//41
        System.out.println(student2.hashCode());//41

    }
}

狂补ing……