2018.10.7学习笔记

10.7学习笔记

今天学习了《Java编程思想》的第六、七章。下面对今日学习收获与疑惑作总结。

1.JAVA_HOME、PATH、CLASSPATH：

①JAVA_HOME：jdk的安装路径。
②PATH：作用是指定java命令的搜索路径，jdk安装目录下的bin目录下包含java的各种命令，如java、javac等命令。因此，将bin目录添加到PATH路径，使系统在PATH路径下搜索java命令执行。
③CLASSPATH：告诉java执行环境，在哪些目录下可以找到Java程序运行所需的类和包，通俗的说它的作用与import和package关键字有关。总之，系统会在CLASSPATH路径下寻找java运行所需的类和包。

2.怎么防止类被继承：
①将类的唯一定义的一个构造方法设置为private。
②将类用final关键字修饰。

3.类的访问权限：
只能使用public或者默认的包内访问这两种方式来定义类的访问权限控制。

4.Object类的方法：
clone(实现对象的浅复制)、getClass(final方法，获得运行时类型)、toString、finalize、equals(使用“==”来判断，一般会重写该方法)、hashCode、wait、notify、notifyAll。

5.浅复制与深复制：
①引用拷贝：
创建一个指向对象的引用变量的拷贝

Teacher teacher = new Teacher("Taylor",26);
Teacher otherteacher = teacher;
System.out.println(teacher);
System.out.println(otherteacher);
/**
blog.Teacher@355da254
blog.Teacher@355da254
*/

他们属于同一个对象，只是将引用赋给otherteacher并没有创建新的对象。

②对象拷贝(深复制与浅复制)
浅复制：
对一个对象进行复制，该对象的类中的基本类型数据域直接将值复制给另外一个对象，而对于对象数据域，复制的则是该对象数据域的引用(即没有创建新的该数据域对象)。
深复制：
深复制较浅复制的区别就是，对于对象数据域，其创建一个新的对象，并将原对象数据域的引用赋给该新的对象。因此，深复制实现了真正的创建一个对象的复制。

/**
 * description:深复制与浅复制，基础篇P443
 * 浅复制对对象数据域采用的是复制其引用
 * 深复制对对象数据域采用的是创建新的对象，将引用赋给对象
 * 但是无论是深复制还是浅复制，复制完之后==都返回flase
 *  */
package net.fuqian.learn.model;

import java.util.Date;

public class House implements Cloneable,Comparable<House> {
    private int id;
    private double area;
    private Date whenBuilt;

    public House(){
        whenBuilt = new Date();
    }

    public House(int id,double area){
        this.id = id;
        this.area = area;
        whenBuilt = new Date();
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getArea() {
        return area;
    }

    public void setArea(double area) {
        this.area = area;
    }

    public Date getWhenBuilt(){
        return whenBuilt;
    }

    /**
     * @description 深复制
     * @throws CloneNotSupportedException
     */
    @Override
    public Object clone() throws CloneNotSupportedException{
        House houseClone = (House)super.clone();
        houseClone.whenBuilt = (java.util.Date)(whenBuilt.clone());
        return houseClone;
    }

    /**
     *
     * @description 浅复制
     *  @Override
     *     public Object clone() throws CloneNotSupportedException{
     *         return super.clone();
     *     }
     */

    @Override
    public int compareTo(House house){
        if (area > house.area){
            return 1;
        }else if (area < house.area){
            return -1;
        }else
            return 0;
    }
}



package net.fuqian.learn.model;

public class client {
    public static void main(String args[]) throws CloneNotSupportedException{
        House house_1 = new House(1,100);
        House house_2 = (House) house_1.clone();
        System.out.print("两个house对象引用地址是否相等：");
        System.out.println(house_1 == house_2);
        System.out.print("两个house对象内容是否相等：");
        System.out.println(house_1.equals(house_2)); //object中的equals()方法采用的是判断 == ，因此这句代码没有意义，除非重写equals方法
        System.out.print("两个house对象的whenBuilt数据域对象引用地址是否相等：");
        System.out.println(house_1.getWhenBuilt() == house_2.getWhenBuilt());
        System.out.print("两个house对象的whenBuilt数据域对象内容是否相等：");
        System.out.println(house_1.getWhenBuilt().equals(house_2.getWhenBuilt()));
    }
}

6.main方法的调用不受访问控制权限：
即对于main方法来说类的访问控制权限都无效(相当于public)。

7.当创建了一个导出类的对象时，该对象包含了一个父类的子对象。

8.调用父类构造方法是你在创建子类构造方法的第一件事(带参数的构造方法)。

9.组合和继承的取舍以及结合：
问一问自己是否需要从子类向父类进行向上转型。

10.初始化与加载:
在java中，每个类的编译代码都存在于他自己的独立的文件中，该文件只在需要使用程序代码时才会被加载，即类的代码在初次使用时被加载。通常加载发生在创建第一个类的对象时候或者访问static域或static方法的时候。

继承与初始化：

public class Insect {
    private int i = 9;
    protected int j;
    Insect(){
        System.out.println("i = " + i + ",j = " + j);
        j = 39;
    }

    private static int x1 = printInit("static Insect.x1 initialized");

    public static int printInit(String s){
        System.out.println(s);
        return 47;
    }
}

public class Beetle extends Insect {
    private int k = printInit("Beetle.k initialized");
    public Beetle(){
        System.out.println("k = " + k);
        System.out.println("j = " + j);
    }

    private static int x2 = printInit("static Beetle.x2 initialized");

    public static void main(String args[]){
        System.out.println("Beetle constructor");
        Beetle beetle = new Beetle();
    }
}
/*
output：
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9,j = 0
Beetle.k initialized
k = 47
j = 39
 */

①第一步，先试图访问Beetle.main方法，于是加载器开始查找Beetle的编译代码，编译器发现他有一个父类，于是继续向上进行加载，直到加载完所有的父类。(不管你是否打算产生一个该父类的对象，都会加载)。
②根基类的static初始化，然后向下一个子类初始化。全部初始完毕之后，必要的类都已加载完毕，对象就可以创建了。首先，对象中所有基本类型被设置为默认值，对象引用设为null。
③根基类的构造方法被调用，依次向下调用。

10.7学习笔记

猜你喜欢