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。
③根基类的构造方法被调用,依次向下调用。