[敏捷JAVA读书笔记-java基础部分] 第五章
一、面向对象的三个主要特征
面向对象的三个基本特征：封装、继承、多态
java的世界中分两类人：创建类的人，以及使用别人创建的类写程序的人。
创建类的人应该尽可能的隐藏程序实现的细节。就像前面章节中所说：隐藏该隐藏的，暴露该暴露的。
封装就可以做到这些~~~
继承:
一种生产类的方式，通过继承我们可以很好的解决重复代码的问题，父类有的子类也有，子类有的父类不一定有，子类扩充了父类的属性和行为。
多态：
java中的方法绑定多是晚绑定，除了final和private关键字修饰的方法。
晚绑定就是在运行的时候才知道是执行的哪个对象的方法！这就带来了一个结果----多态性。
重载和覆盖：
同一类中如果有函数，函数名相同，参数表不同，则构成重载。
子类中有函数，与父类的函数同名，而且参数表也相同构成覆盖。
转载孙卫琴mm的文章：
方法重载
有时候，类的同一种功能有多种实现方式，到底采用哪种实现方式，取决于调用者给定的参数。例如杂技师能训练动物，对于不同的动物有不同的训练方式。
public void train(Dog dog){
//训练小狗站立、排队、做算术
…
}
public void train(Monkey monkey){
//训练小猴敬礼、翻筋斗、骑自行车
…
}
再例如某个类的一个功能是比较两个城市是否相同，一种方式是按两个城市的名字进行比较，另一种方式是按两个城市的名字，以及城市所在国家的名字进行比较。
public boolean isSameCity (String city1,String city2){
return city1.equals(city2);
}
public boolean isSameCity(String city1,String city2,String country1,String country2){
return isSameCity(city1, city2) && country1.equals(country2);
}
再例如java.lang.Math类的max()方法能够从两个数字中取出最大值，它有多种实现方式。
public static int max(int a,int b)
public static int max(long a,long b)
public static int max(float a,float b)
public static int max(double a,double b)
以下程序多次调用Math类的max()方法，运行时，Java虚拟机先判断给定参数的类型，然后决定到底执行哪个max()方法。
//参数均为int类型，因此执行max(int a,int b)方法
Math.max(1,2);
//参数均为float类型，因此执行max(float a,float b)方法
Math.max(1.0F, 2.0F);
//参数中有一个是double类型，自动把另一个参数2转换为double类型，
//执行max(double a,double b)方法
Math.max(1.0,2);
对于类的方法（包括从父类中继承的方法），如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。
重载方法必须满足以下条件：
l 方法名相同。
l 方法的参数类型、个数、顺序至少有一项不相同。
l 方法的返回类型可以不相同。
l 方法的修饰符可以不相同。
在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。
例如以下Sample类中已经定义了一个amethod()方法。
public class Sample{
public void amethod(int i, String s){}
//加入其他方法
}
下面哪些方法可以加入到Sample类中，并且保证编译正确呢？
A）public void amethod(String s, int i){} （可以）
B）public int amethod(int i, String s){return 0;} （不可以）
C）private void amethod(int i, String mystring){} （不可以）
D）public void Amethod(int i, String s) {} （可以）
E）abstract void amethod(int i); （不可以）
选项A的amethod()方法的参数顺序和已有的不一样，所以能作为重载方法加入到Sample类中。
选项B和选项C的amethod()方法的参数签名和已有的一样，所以不能加入到Sample类中。对于选项C，尽管String类型的参数的名字和已有的不一样，但比较参数签名无须考虑参数的具体名字。
选项D的方法名为Amethod，与已有的不一样，所以能加入到Sample类中。
选项E的方法的参数数目和已有的不一样，因此是一种重载方法。但由于此处的Sample类不是抽象类，所以不能包含这个抽象方法。假如把Sample类改为抽象类，就能把这个方法加入到Sample类中了。
再例如，以下Sample类中已经定义了一个作为程序入口的main()方法。
abstract public class Sample{
public static void main( String[] s){}
//加入其他方法
}
下面哪些方法可以加入到Sample类中，并且保证编译正确呢？
A）abstract public void main(String s, int i); （可以）
B）public final static int main( String[] s){} （不可以）
C）private void main(int i, String mystring){} （可以）
D）public void main( String s) throws Exception{} （可以）
作为程序入口的main()方法也可以被重载。以上选项A、C和D都可以被加入到Sample类中。选项B与已有的main()方法有相同的方法签名，因此不允许再加入到Sample类中。
方法覆盖
假如有100个类，分别为Sub1，Sub2…Sub100，它们的一个共同行为是写字，除了Sub1类用脚写字 外，其余的类都用手写字。可以抽象出一个父类Base，它有一个表示写字的方法write()，那么这个方法到底如何实现呢？从尽可能提高代码可重用性的 角度看，write()方法应该采用适用于大多数子类的实现方式，这样就可以避免在大多数子类中重复定义write()方法。因此Base类的write ()方法的定义如下：
public void write(){ //Base类的write()方法
//用手写字
…
}
由于Sub1类的写字的实现方式与Base类不一样，因此在Sub1类中必须重新定义write()方法。
public void write(){ //Sub1类的write()方法
//用脚写字
…
}
如果在子类中定义的一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
覆盖方法必须满足多种约束，下面分别介绍。
（1）子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致。例如以下代码将导致编译错误。
public class Base {
public void method() {…}
}
public class Sub extends Base{
public int method() { //编译错误，返回类型不一致
return 0;
}
}
Java编译器首先判断Sub类的method()方法与Base类的method()方法的参数签名，由于两者一 致，因此Java编译器认为Sub类的method()方法试图覆盖父类的方法，既然如此，Sub类的method()方法就必须和被覆盖的方法具有相同 的返回类型。
以下代码中子类覆盖了父类的一个方法，然后又定义了一个重载方法，这是合法的。
public class Base {
public void method() {…}
}
public class Sub extends Base {
public void method(){…} //覆盖Base类的method()方法
public int method(int a) { //重载method()方法
return 0;
}
}
（2）子类方法不能缩小父类方法的访问权限。例如以下代码中子类的method()方法是私有的，父类的method()方法是公共的，子类缩小了父类方法的访问权限，这是无效的方法覆盖，将导致编译错误。
public class Base {
public void method() {…}
}
public class Sub extends Base {
private void method() {…} //编译错误，子类方法缩小了父类方法的访问权限
}
为什么子类方法不允许缩小父类方法的访问权限呢？这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：
Base base=new Sub(); //base变量被定义为Base类型，但引用Sub类的实例
base.method();
Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的 Sub实例的method()方法，如果这个方法为private类型，Java虚拟机就无法访问它。所以为了避免这样的矛盾，Java语言不允许子类方 法缩小父类中被覆盖方法的访问权限。本章第6.6节（多态）对多态做了进一步的阐述。
（3）子类方法不能抛出比父类方法更多的异常，关于异常的概念参见第9章（异常处理）。子类方法抛出的异常必须和父类方法抛出的异常相同，或者子类方法抛出的异常类是父类方法抛出的异常类的子类。
例如，假设异常类ExceptionSub1和ExceptionSub2是ExceptionBase类的子类，则以下的代码是合法的：
public class Base {
void method()throws ExceptionBase{}
}
public class Sub1 extends Base {
void method()throws ExceptionSub1{}
}
public class Sub2 extends Base {
void method()throws ExceptionSub1,ExceptionSub2{}
}
public class Sub3 extends Base {
void method()throws ExceptionBase{}
}
以下代码不合法：
public class Base {
void method() throws ExceptionSub1{ }
}
public class Sub1 extends Base {
void method()throws ExceptionBase {} //编译出错
}
public class Sub2 extends Base {
void method()throws ExceptionSub1,ExceptionSub2 {} //编译出错
}
为什么子类方法不允许抛出比父类方法更多的异常呢？这是因为假如没有这个限制，将会与Java语言的多态机制发生冲突。例如对于以下代码：
Base base=new Sub2(); //base变量被定义为Base类型，但引用Sub2类的实例
try{
base.method();
}catch(ExceptionSub1 e){ … } //仅仅捕获ExceptionSub1异常
Java编译器认为以上是合法的代码。但在运行时，根据动态绑定规则，Java虚拟机会调用base变量所引用的 Sub2实例的method()方法。假如Sub2实例的method()方法抛出ExceptionSub2异常，由于该异常没有被捕获，将导致程序异 常终止。
（4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中方法只能被重载，不能被覆盖。
（5）父类的静态方法不能被子类覆盖为非静态方法。例如以下的代码将导致编译错误：
public class Base {
public static void method() { }
}
public class Sub extends Base {
public void method() { } //编译出错
}
（6）子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法。在编译时，子类定义的静态方法也必须满足与方法覆盖类似的约束：方法的参数签名一致，返回类型一致，不能缩小父类方法的访问权限，不能抛出更多的异常。例如以下代码是合法的：
public class Base {
static int method(int a) throws BaseException{ return 0; }
}
public class Sub extends Base{
public static int method(int a) throws SubException { return 0; }
}
子类隐藏父类的静态方法和子类覆盖父类的实例方法，这两者的区别在于：运行时，Java虚拟机把静态方法和所属的类 绑定，而把实例方法和所属的实例绑定。下面举例来解释这一区别。在例程6-1中，Base类和它的子类即Sub类中都定义了实例方法method()和静 态方法staticMethod()。
例程6-1 Sub.java
package hidestatic;
class Base{
void method(){ //实例方法
System.out.println("method of Base");
}
static void staticMethod(){ //静态方法
System.out.println("static method of Base");
}
}
public class Sub extends Base{
void method(){ //覆盖父类的实例方法method()
System.out.println("method of Sub");
}
static void staticMethod(){ //隐藏父类的静态方法staticMethod()
System.out.println("static method of Sub");
}
public static void main(String args[]){
Base sub1=new Sub(); //sub1变量被声明为Base类型，引用Sub实例
sub1.method(); //打印 method of Sub
sub1.staticMethod(); //打印 static method of Base
Sub sub2=new Sub(); //sub2变量被声明为Sub类型，引用Sub实例
sub2.method(); //打印 method of Sub
sub2.staticMethod(); //打印 static method of Sub
}
}
运行Sub类的main()方法，程序将输出：
method of Sub
static method of Base
method of Sub
static method of Sub
引用变量sub1和sub2都引用Sub类的实例，Java虚拟机在执行sub1.method()和sub2.method()时，都调用Sub实例的method()方法，此时父类Base的实例方法method()被子类覆盖。
引用变量sub1被声明为Base类型，Java虚拟机在执行sub1. staticMethod()时，调用Base类的staticMethod()方法，可见父类Base的静态方法staticMehtod()不能被子类覆盖。
引用变量sub2被声明为Sub类型，Java虚拟机在执行sub2. staticMethod()时，调用Sub类的staticMethod()方法，Base类的staticMehtod()方法被Sub类的staticMehtod()方法隐藏。
（7）父类的非静态方法不能被子类覆盖为静态方法。例如以下代码是不合法的：
public class Base {
void method() { }
}
public class Sub extends Base {
static void method() { } //编译出错
}
（8）父类的私有方法不能被子类覆盖。例如在例程6-2中，子类Sub中定义了一个和父类Base中的方法同名、参 数签名和返回类型一致，但访问权限不一致的方法showMe()，父类中showMe()的访问权限为private，而子类中showMe()的访问权 限为public。尽管这在形式上和覆盖很相似，但Java虚拟机对此有不同的处理机制。子类方法覆盖父类方法的前提是，子类必须能继承父类的特定方法， 由于Base类的private类型的showMe()方法不能被Sub类继承，因此Base类的showMe()方法和Sub类的showMe()方法 之间并没有覆盖关系。
例程6-2 Sub.java
package privatetest;
class Base {
private String showMe() {
return "Base";
}
public void print(){
System.out.println(showMe()); //到底调用Base类的showMe()还是Sub类的showMe()?
}
}
public class Sub extends Base {
public String showMe(){
return "Sub";
}
public static void main(String args[]){
Sub sub=new Sub();
sub.print();
}
}
执行以上Sub类的main()方法，会打印出结果“Base”，这是因为print()方法在Base类中定义，因此print()方法会调用在Base类中定义的private类型的showMe()方法。
但是如果把Base类的showMe()方法改为public类型，其他代码不变：
public class Base {
public String showMe() {
return "Base";
}
…
}
再执行以上Sub类的main()方法的代码，会打印出结果“Sub”，这是因为此时Sub类的showMe()方 法覆盖了Base类的showMe()方法。因此尽管print()方法在Base类中定义，Java虚拟机还是会调用当前Sub实例的showMe() 方法。
（9）父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法；二是子类重新声明父类的抽象方法。例如以下代码合法：
public abstract class Base {
abstract void method1();
abstract void method2();
}
public abstract class Sub extends Base {
public void method1(){…} //实现method1()方法，并且扩大访问权限
public abstract void method2(); //重新声明method2()方法，仅仅扩大访问权限，但不实现
Tips
狭义的理解，覆盖仅指子类覆盖父类的具体方法，即非抽象方法，在父类中提供了方法的默认实现方式，而子类采用不同的实现方式。在本书中，为了叙述方便，把子类实现父类的抽象方法也看做方法覆盖。例如以下代码不合法：
public abstract class Base {
abstract void method1();
abstract void method2();
}
public abstract class Sub extends Base {
private void method1(){…} //编译出错，不能缩小访问权限
private abstract void method2(); //编译出错，不能缩小访问权限
}
（10）父类的非抽象方法可以被覆盖为抽象方法。例如以下代码合法：
public class Base {
void method(){ }
}
public abstract class Sub extends Base {
public abstract void method(); //合法
}
图6-2 Sub类继承Base类
在本书提供的UML类框图中，在子类中只会显示子类特有的方法及覆盖父类的方法，而不会显示直接从父类中继承的方 法。例如，图6-2表明Base类是抽象类（Base名字用斜体字表示），method1()为抽象方法（method1名字用斜体字表示）， method2()和method3()为具体方法。Sub类是Base类的子类，Sub类实现了Base类的method1()方法，覆盖了Base类 的method2()方法，直接继承Base类的method3()方法，此外Sub类还有自己的method4()方法。
二、面向接口编程
万能的接口啊，伟大的接口啊！~~~慢慢补齐
三、java垃圾回收机制
其实应该根java的初始化放在一起的。1、何谓垃圾？
一句话：如果一个对象没有任何指向他的引用，那么他就变为一个垃圾，等待gc的回收
2、何时回收？
不定时的，当你的内存快用完的时候，gc启动......
3、回收之前干嘛？
调用对象的 finalize方法，如果有的话。
四、package and classpath
package：等于给类加了一个姓：class Hello{
......
}
这个类的名字叫Hello
package com
class Hello{
......
}
这个类的名字叫com.Hello
classpath:是一个坐标。jvm会从classpath设定的位置开始寻找要找的东西。
比如D:/ 下有一个com包，里面有个类叫Hello
package com
class Hello{
......
}
如果不设定任何classpath，则默认的classpath为 . 一个小点
如何执行这个Hello呢？ 在d：/下：java com.Hello
或者：在系统的任何地方 java -cp d:/;. com.Hello
-cp = -classpath
设定classpath为d:/，执行com.Hello的时候jvm会根据classpath先到d:/寻找com，找到了，所以执行了~~~：~