Java的第一遍学习笔记 面向对象编程补充

Object类

== 运算符

1. == 运算符既可以判断基本类型，又可以判断引用类型。

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

int i = 10;
double d = 10.0;
System.out.println(i==d)//true

3. 如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象，如果希望判断内容是否相同，则需要重写。

public class Test {
    public static void main(String[] args) {
        NotePad a = new NotePad();
        Computer b = a;  //向上转型，a和b都指向同一个NotePad对象
        System.out.println(a==b); //true 因为a和b地址相同
    } 
}

equals方法

1. 是Object类的方法，只能判断引用类型。

2. 默认判断的是地址是否相等，子类往往重写该方法，用于判断内容是否相等（比如String类）。

        String str1 = "shang";
        String str2 = "shang";
        System.out.println(str1 == str2);  //true，str1和str2地址相同
        System.out.println(str1.equals(str2)); //true
        String str3 = new String("shang");
        String str4 = new String("shang");
        System.out.println(str3 == str4);  //false
        System.out.println(str3.equals(str4));  //true
        System.out.println(str1 == str3);  //false
        System.out.println(str1.equals(str3));  //true

   需要注意一点，String类是否用new来初始化还是有区别的。比如str1和str2，实际上都指向同一块内容为"shang"的区域，因此str1和str2地址相同。而str3和str4，虽然指向的内容都是相同,但是由于用到了new，开辟了两个String对象，因此str3和str4指向两个内容相同但地址不同的String对象。 

查看JDK源码

1. 一般来说 IDEA 配置好JDK后，jdk的源码也就自动配置好了。

2. 如果没有的话点击 菜单File --> Project Stucture --> SDKs --> Sourcepath 然后点击加号 --> 找到jdk安装目录，把 src.zip 和 javafx-src.zip 加入即可。

3. 在需要查看某个方法源码时，将光标放在该方法上，输入 ctrl + b 即可。或者在方法上点击右键 --> go to --> Declarartion or Usages。 

hashCode方法

1. 提高具有哈希结构的容器的效率（如HashMap，HashTable等）。

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

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

4. 哈希值主要是根据地址号计算的（通过将该对象的内部地址转换成一个整数实现的），不能将哈希值等价于地址。

5. hashCode如果有需要的话，也会重写。

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) { //value就是把对象toString后的结果
            char val[] = value;  //将字符串转化为字符数组

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];  //哈希值计算方法
            }
            hash = h;
        }
        return h;
    }

toString方法

默认返回：全类名（包名+类名）+ @ + 哈希值的十六进制。

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

重写：子类往往重写toString方法，用于返回对象的属性信息。

      

自动调用：当输出对象时，toString方法会被自动调用（重写会影响）。

public class Test {
    public static void main(String[] args) {
        Person wang = new Person(10, "wang", 20);
        System.out.println(wang);    //com.shang.Person@1b6d3586
    }
}

finalize方法

1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，写自己的业务逻辑代码（数据库连接，打开文件等），如果不重写就会调用 Object类的finalize。 

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

    public static void main(String[] args) {
        Person p1 = new Person();
        p1 = null;   // 这时，p1对象就是一个垃圾，垃圾回收器会销毁对象 
    }                // 在销毁对象前，会调用该方法的finalize方法

输入一个 f 就可以重写 finalize方法了。 finlize的调用类似C++的析构函数。

3. 垃圾回收机制的调用，是由系统来决定（有自己的GC算法），也可以通过System.gc() 主动触发垃圾回收机制。（在实际开发中，几乎不会运用 finalize）

重写equals方法

public boolean equals(object obj){
        if(this == obj){
            return true;
        } //如果是地址相同那么就返回true
        if(!(obj instanceof  Doctor)){
            return false;
        }//如果obj不是Doctor类或其子类，那么返回false
        Doctor doctor = (Doctor)obj; //传入的参数向下转型
        return this.name.equals(doctor.name)&&this.age == doctor.age;
    }

断点调试（debug）

简介

1. 断点调试是指在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后可以一步一步往下调试，调试过程中可以看各个变量当前的值，出错的话，调试到出错的代码行即显示错误，停下。进行分析从而找到这个Bug。

2. 断点调试是程序员必须掌握的技能。

3. 断点调试也能帮助我们查看Java底层源代码的执行过程，提高程序员的Java水平。

注：在断点调试的过程中，是运行状态，是以对象的运行状态来执行的。

快捷键

F7(跳入方法内)     F8(逐行执行代码)     shift + F8(跳出方法)     F9(resume，执行到下一个断点)    

调试异常

        int[] a = {1,2,3};
        for(int i = 0 ; i<4;i++ ){
            System.out.println(a[i]);  //在i=3时会报错
        }

查看源码 

方法1：使用 foce step into : 快捷键为 alt + shift +F7。

方法2：Settings --> Build,Execution,Deployment --> Debugger --> Stepping，把 Do not step into the classes 中的 java.* 和 javax.* 取消勾选。然后用Step into(F7)即可进入方法。

退出方法查看用Step out(shift + F8)。 

语句跳跃

用 Resume Program(F9)可以将Debug跳转到下一个断点，中间的语句直接执行。值得一提的是——1. 可以用Step into 进入方法后，在方法里设置断点。2. 在Debug过程中也可以设置断点。

对象断点的应用

1. 可以用Debug查看对象创建的过程。

 用Step into 进入该对象中查看具体初始化方法。

默认初始化：

显示初始化：

构造器：

 

2. 可以用断点调试一步步查找到调用的方法。

用Step into进入 println 方法。

再用Step into方法进入 valueOf 这个方法。

发现 valueOf 调用了 toString 方法，用Step into进入 toString 方法。

最终找到了在Person类中重写的 toString 方法。

 3. 还可以用断点调试验证动态绑定机制

public class Person {
    public void run(){
        System.out.println("人类跑步");
    }
} //父类

public class Student extends Person{
    public void run(){
        System.out.println("学生跑步");
    }
}//子类

public static void main(String[] args) {
         Person a = new Student();//向上转型
         a.run();  //Step into
    } 

     Step into后发现调用的是学生的方法。按照向上转型的理论，不能调用子类独有的成员。当调用run方法时，根据动态绑定机制先从子类查找，而调用属性时，没有动态绑定，根据编译类型。

instanceof比较操作符 

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

 语法是  实例对象  instanceof  类。

    public static void main(String[] args) {
        Computer c1 = new Computer();//运行类型为Computer
        Computer c2 = new PC(); //运行类型为PC
        System.out.println(c1 instanceof Computer);
        System.out.println(c1 instanceof PC);
        System.out.println(c2 instanceof Computer);
        System.out.println(c2 instanceof PC);
    }

多态数组 

    数组的定义类型为父类类型，里面保存的实际元素类型为子类类型，静态初始化可以直接写，动态初始化则需要new父类，然后对里面的元素单个向上转型。 

        Person[] a = new Student[3];  //不能这样写        

        // 第一种写法，静态初始化
        Preson p = new Person();
	    Person t = new Teacher();
	    Person s = new Student();
	    Person[] persons = {p,t,s};

        //第二种写法，动态初始化
        Person[] a = new Person[3]; //new父类
        a[0] = new Student();

  这里需要介绍一个问题：如何调用子类特有的方法（很明显，向上转型是不能调用的，因此需要用到向下转型） 

public class Person {
    private int age;
    private String name;
}

public class Student extends Person{
    public void Study(){
        System.out.println("学生正在学习");
    }
}

public class Test {
    public static void main(String[] args) {
        Person[] a = new Person[3];  
        Student stu = (Student)a[0];//向上转型
        a[0].Study();  //报错，因为Study是子类特有的方法，向上转型不能调用
    }
}

public class Test {
    public static void main(String[] args) {
        Person[] a = new Student[3];
        a[0] = new Student();
        Student stu = (Student)a[0];  //向下转型
        stu.Study();// 语义相同：((Student) a[0]).Study();
    }
}

房屋出租小项目的思路