Chap 3 Java OO

focus on :

        * 对象和类的概念  
        * 类 (对类) 之间的关系  
        * 面向对象设计思想  
        * class  
        * new  
            * 引用的概念  
            * constructor-method的概念  
        * method重载  
            * constructor-method重载  
        * this  
        * static  
        * package & import  
        * private default protected public  
        * extends  
        * override  
        * final  
        * Object  
            * toString  
            * equals  
        * upcasting downcasting  
        * polymophysm / dynamic binding
        * abstract class  
        * interface  
            * implements

3.1 OO 设计思想

为什么用 OO ?

OO 编程 -- 一组对象互相配合通过沟通完成特定功能
- 汇编是对机器语言的抽象
- 面向过程的语言是对汇编的抽象
- 对象更加符合对于现实问题的抽象
对象都有对外服务的接口
- 通过继承可以复用
对象隐藏内部服务的实现
- 通过聚合可以复用
向对象更加容易使我们达到这些年苦苦追求的境界
- Reusable, Extensibility
组件 -- 比对象更高层次上的抽象
- Web Service

3.2 Class 之间的关系

关联关系 -- 学院 - 研究生 - 教授
继承关系 -- 运动员 { 游泳运动员，球类运动员，射击运动员 }
聚合关系 -- 聚集 - 球队 {队长，队员} 组合 - 人-{ 头，身体，四肢 }
实现关系 -- implements

3.3 Class 和 Object

Java 中万事万物皆 Object (对象)
Object 可看成 静态属性 (成员变量) 和 动态属性 (method) 的封装体
Class 是用来创建同一类型的 Object 的 “模板”
成员变量 = 属性 & method = 函数
同一类的每个对象共享该 Class 的method
非static method 是针对每个对象进行调用
局部变量分配在 Stack内存
成员变量分配在 Heap内存

3.4 new & Constructor

new -- 引用的概念
Constructor

Constructor in class extends

如果调用 super 必须写在 Constructor-method 的第一行
如果没调用，系统自动调用 super(), 如果没调，parent-class 中又没写参数为空这个 Constructor-method 则出错。

3.5 this keyword

this 可处理 method 中 成员变量 和 参数重名 的情况。
this 可看作是一个变量，它的值是当前对象的引用

3.6 static keyword

static 声明的成员变量为 static 成员变量，它为该类的公用变量，在第一次使用时被初始化。
static 声明的 method 为 static-method 在调用该method时, 不会将对象的引用传递给它
static-method 中不可访问非static成员。
可通过对象引用 or 类名访问 static成员, static 成员属于 Class, 不属于对象

3.7 package / import

package named method ：公司域名倒过来！

class文件的最上层包的父目录位于classpath下。
执行一个 Class 需要写 all package name
J2SDK 中主要的包介绍
- java.lang - 包含一些 java 语言的核心类
- java.net
- java.io
- java.util
把自己的文件打成 jar文件method : jar -cvf test.jar *.*

3.8 Class extends

修饰符	类内部	same package	子类	Anywhere
private	Yes
default	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

3.9 method-override

override-method 不能使用比 被override-method 更严格的访问权限 -- 其实这和polymophysm有关

3.10 Object Class

Object Class 是所有Java类的根基类
toString() Object 类中定义有 public String toString() method，其返回值是 String 类型。
equals method Object 类中定义有 :
- public boolean equals(Object obj) method 提供对象是否 “相等” 的逻辑
- Object的 equals method定义为：x.equals(y) 当 x 和 y 是同一对象的应用时返回 true
- J2SDk 提供的一些类，如 String, Date等，重写了 Object 的 equals method.
```
属性内容相等时 (并不一定是相同对象), 返回 true 否则返回 false.  
```

3.11 Object casting

upcasting
downcasting

基类引用可以指向子类对象
基类引用不可访问子类对象新增加的成员
可以使用引用变量 instanceof 类名来判断该引用型变量所指向的对象是否属于该类或该类的子类
子类的对象可以当作基类的对象来使用称作 upcasting，反之 downcasting

内存分析 - 明白了内存你就明白了一切！

3.12 polymophysm / dynamic binding

继承
重写
父类引用指向子类对象

package com.bjsxt.chap03;  
  
class Lady {  
    private String name;  
    private Animal pet;  
    Lady(String name, Animal pet) {  
        this.name = name;  
        this.pet = pet;  
    }  
    public void myPetEnjoy() {  
        pet.enjoy();  
    }  
}  
public class TestPolymoph_01 {  
  
    public static void main(String[] args) {  
        Cat c = new Cat("catName", "blue");  
        Dog d = new Dog("dogName", "block");  
        Lady l1 = new Lady("L1", c);  
        Lady l2 = new Lady("L2", d);  
        l1.myPetEnjoy();  
        l2.myPetEnjoy();  
    }  
}

知道了内存, 就知道了一切

动态绑定, 池绑定, 多态

1. 动态绑定的机制 是 实际类型 new 的是  
2. 深一点 -- 是对象内部有一个指针。。。。。。  
3. 动态绑定的机制是 ： 是调用实际类型，不是引用类型。  
4. 实际地址才会绑定到那个 method 上。 method 在  code segment  
5. 只有在 runtime，才能判断调用哪一个 method
    
带来的莫大好处是 ... 可扩展性达到了极致好
    
OO核心中的核心

3.13 abstract Class

abstract关键字来修饰一个 Class 时，这个类叫做abstract-class。abstract 修饰 method 时，该 method 叫做 abstract-method
abstract-class 必须被 extends，abstract-method 必须被 override
abstract-class 不能被实例化
abstract-method 只需声明，而不需要实现。

3.14 Final 关键字

final 的变量的值不能够被改变
- final 的成员变量
- final 的局部变量(形参)
final method 不能被 override
final Class 不能被 extends
System final Class 如 : String, Math, Boolean etc..

3.15 interface

概述

interface 是 abstract-method 和常量值的定义的集合
从本质上讲，接口是一种特殊的 abstract-class，这种 abstract-class只包含常量和 method definition，而没有 var 和 method 的实现。只包含常量和 method 的定义，而没有var 和 method 的实现。

public interface Runner {  
    //public static final int id = 1;  
    int id = 1;  
    public void start();  
    public void run();  
    void stop(); // public void stop();  
}

interface特性

interface 可以多重实现
interface 中声明的属性默认为 public static final 的; 也只能是 public static final的;
interface 中只能定义 abstract-method, 而且这些 method 默认为public的，也只能是public的。
interface 可以继承其他的接口，并添加新的属性和 abstract-method。
多个 Class 可 implements 同一 interface
一个 Class 可 implements 多个 interface
与继承关系类似，接口与实现类之间存在多态性

其中的变量全部都是 public static final int id = 1;
java.lang - Comparable 我看就像 cmp 一样！(个人认为)  
Interface Comparable<T> 可以扩展  
接口与接口之间也可以相互继承  
类与接口只能 是 实现关系

Example Program

public interface Valuable {  
    public double getMoney();  
}  
  
interface Protectable {  
    public void beProtected();  
}  
  
interface A extends Protectable {  
    void m();  
    // void getMoney();  
}  
  
abstract class Animals {  
    private String name;  
      
    abstract void enjoy();  
}  
  
class GoldenMonkey extends Animals implements Valuable, Protectable {  
    public double getMoney() {  
        return 10000;  
    }  
      
    public void beProtected() {  
        System.out.println("live in the room");  
    }  
      
    public void enjoy() {  
          
    }  
      
    public void test() {  
        Valuable v = new GoldenMonkey();  
        v.getMoney();  
        Protectable p = (Protectable)v;  
        p.beProtected();  
    }  
}  
  
class Hen implements A  {  
    public void m() {}  
    public void beProtected() {}  
    public double getMoney() {  
        return 1.0;  
    }  
    // public void getMoney() {} // 不常见，怪异的问题  
  
}

Chap 4 异常处理

4.1 写程序有友好界面

  1, 鼻腔内感觉异常  
  2, 体温持续升高  
  3, 分泌乳白色液体  

  直接说感冒不就得了么?
 
 e.printStackTrace(); 非常好！给程序员读。堆栈信息都打印出来!

 java.lang.Throwable { 开车在上山走，  
   1, Error         山爆发 JVM 出问题。  
   2, Exception {   你可以处理的 -- 刹车坏啦！修好再走。。。  
   1, ...  
   2, RuntimeException  (经常出，不用逮) 压路面上的小石子  
  }

4.2 Exception Deal

Java异常是Java提供的用于处理程序中错误的一种机制。
所谓错误是指在程序运行的过程中发生的一些异常事件(如：除0溢出，数组越界，文件不存在等)
设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。
Java程序的执行过程中如出现异常事件，可以生成一个 Exception-object，该异常类对象封装了异常事件的信息并将被提交给Java-runtime-system，这个过程称为 throw e (会被打印出来，默认的处理方式)
Java-runtime-system 接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为 catch e

4.3 Example Program

import java.io.FileInputStream;  
import java.io.FileNotFoundException;  
import java.io.IOException;  
  
import javax.imageio.IIOException;  
  
public class TestTx {  
    public static void main(String[] args) {  
        FileInputStream in = null;  
        try {  
            in = new FileInputStream("myfile.txt");  
            int b;  
            b = in.read();  
            while (b != -1) {  
                System.out.println((char)b);  
                b = in.read();  
            }  
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
              
        } catch (IOException e) {  
            System.out.println(e.getMessage());  
        } finally {  
            try {  
                in.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
    }
}

Java learn 02 OO & Exception

Chap 3 Java OO

3.1 OO 设计思想

3.2 Class 之间的关系

3.3 Class 和 Object

3.4 new & Constructor

3.5 this keyword

3.6 static keyword

3.7 package / import

3.8 Class extends

3.9 method-override

3.10 Object Class

3.11 Object casting

3.12 polymophysm / dynamic binding

3.13 abstract Class

3.14 Final 关键字

3.15 interface

Example Program

Chap 4 异常处理

4.1 写程序有友好界面

4.2 Exception Deal

4.3 Example Program