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

包

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

包的命名规则：

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

包的命名规范：

                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();
            }
        }
    }
}

== 和 equals

                == 是一个比较运算符

1.既可以判断基本类型，也可以判断引用类型

2.如果是基本类型，判断的是值是否相等

3.如果是引用类型，判断的是地址是否相等，即判断是不是同一个对象。

                equals 是Object类中的方法

默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等

hashCode

        返回该对象的哈希码值，支持此方法是为了提高哈希表的性能。

1.提高具有哈希结构的容器的效率

2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的。

3.两个引用，如果指向的是不同对象，则哈希值是不一样的。

4.哈希值主要根据地址号来的，不能完全将哈希值等价于地址。

toString 方法

                基本介绍：

        默认返回：全类名(包名 + 类名) + @ + 哈希值的十六进制。子类往往重写toString方法，用于返回对象的属性信息。

        重写 toString 方法，打印对象或拼接对象时，都会自动调用该对象的toString形式。

        当直接输出一个对象时，toString 方法会被默认的调用，比如：

System.out.println(monster);        就会默认调用 monster.toString()

finalize方法

        当对象被回收时，系统自动调用该对象的 finalize 方法。子类可以重写该方法，做一些释放资源的操作。

        什么时候被回收：当某个对象没有任何引用时，则 jvm 就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象之前，就会调用 finalize 方法。

Ending： 

        OK，本篇文章就到此结束了，非常感谢你能看到这里，所以如果你觉得这篇文章对你有帮助的话，请点一个大大的赞，支持一下博主，若你觉得有什么问题或疑问，欢迎私信博主或在评论区指出~