Java--包，访问修饰符，多态数组，==和equals，hashcode，toString

news2025/11/4 11:48:04

包

同一个包里面不能有重复的类，不同的包可以有相同的类，包和包之间互不干涉。一个包下面有很多的类。

包的命名规则：

只能包含数字，字母，下划线，小圆点，但不能用数字开头，不能是关键字或保留字。

包的命名规范：

com.公司名.项目名.业务模块名

访问修饰符

Java共有四种访问修饰符，用于控制方法和属性（成员变量）的访问权限（范围）：

1.公开级别：public修饰，对外公开。

2.受保护级别：protected修饰，对子类和同一个包中的类公开。

3.默认级别：没有修饰符号，向同一个包的类公开。

4.私有级别：private修饰，只有类本身可以访问，不对外公开。

注意事项：

只有默认的和public才能修饰类，并且遵循上述访问权限的特点。

属性重写问题：

1.属性没有重写之说！属性的值看编译类型。

public class demo {
    public static void main(String[] args) {
        //生属性没有重写之说，属性的值看编译类型
        Base base = new Sub();      //向上转型
        System.out.println(base.count);     //10
        Sub sub = new Sub();
        System.out.println(sub.count);      //20
    }
}

class Base{
    int count = 10;
}

class Sub extends Base{
    int count = 20;
}

2.instanceof 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型

public class demo01 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB);   //true
        System.out.println(bb instanceof AA);   //true

        //aa是编译类型，BB是运行类型
        AA aa = new BB();
        System.out.println(aa instanceof AA);   //true
        System.out.println(aa instanceof BB);   //true

        Object object = new Object();
        System.out.println(object instanceof AA);   //false

        String str = "hello";
        System.out.println(str instanceof Object);  //true
    }
}

class AA {
}

class BB extends AA {
}

动态绑定机制

1.当调用对象方法时，该方法会和该对象的运行类型绑定。

2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。

多态数组

数组的定义类型是父类类型，里面保存的实际元素类型是子类类型。

案例如下：

public class Persion {

    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



    public String say() {
        return name + "\t" + age;
    }

}

public class Student extends Persion{
    private double score;

    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String say() {
        return super.say() + "\t" + "score=" + score;
    }

    public void study() {
        System.out.println("学生" + getName() + "在学习");
    }
}

public class Teacher extends Persion{
    private double salary;

    public Teacher(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //重写say方法
    @Override
    public String say(){
        return super.say() + "\t" + "salary=" + salary;
    }

    public void teach() {
        System.out.println("老师" + getName() + "在教书");
    }
}

public class Test {
    public static void main(String[] args) {
        Persion[] persion = new Persion[5];

        persion[0] = new Persion("z", 1);
        persion[1] = new Student("x", 2, 66);
        persion[2] = new Student("c", 3, 77);
        persion[3] = new Teacher("v", 4, 2500);
        persion[4] = new Teacher("b", 5, 25000);

        for (int i = 0; i < persion.length; i++) {
            System.out.println(persion[i].say());
            if (persion[i] instanceof Student) {
                Student student = (Student) persion[i];
                student.study();
            } else if (persion[i] instanceof Teacher) {
                Teacher teacher = (Teacher) persion[i];
                teacher.teach();
            }
        }
    }
}