Java编程思想(四) —— 复用类

看了老罗罗升阳的专訪，不由自主地佩服，非常年轻，我之前以为和罗永浩一个级别的年龄。也是见过的不是初高中编程的一位大牛之中的一个，专訪之后。发现老罗也是一步一个脚印的人。

别说什么难做，做不了。你根本就没去尝试。也没有去坚持。

If you can't fly then run,if you can't run then walk, if you can't walk then crawl,but

whatever you do,you have to keep moving forward——Martin Luther King.

复用类这标题刚開始非常难懂。后面专门去看了书的英文原版。事实上标题是reusing classes,又一次使用类，事实上复用就是“利用现成的东西”的意思。事实上实现的两种方法就是java中常常听到的——组合和继承。

(1)组合

has-a的作用。

public class TV {
   Show show;
   public String toString(){
     return "showgirl";
   }
}
 
class Show{
}

提一下toString方法，当你须要String而你是一个对象的时候，编译器会调用对象的toString方法。

TV里有Show，如今的show没有初始化。为null，不能调用show的方法。

组合的作用强大，以面向对象看，假如你在造一个Car类，那么你能够用组合轻易的将Glass，Light，Engine等等的Car这些部件组合起来。

(2)继承

is-a

package com.myown.iaiti;
 
public class Father {
     public int i;
     void get(){
         System.out.println("father");
     }
}
 
package son;
import com.myown.iaiti.*;
 
public class Son extends Father{
        Father f = new Father();
        int j = f.i;
        Son son = new Son();
        son.get();
    }
    
    public void get(){
        super.get();
        System.out.println("son");
    }
}
 

这里有个包訪问权限的问题，假如没有加public的时候。默认是包内成员訪问。不同包訪问，即Son中的Father成员訪问get方法是不可见的。而public的话是可见的，所以i訪问得到。

private部分是不能继承，属于父类私有，而public的部分。将继承，须要改动的方法，能够进行重写。要加入的属性能够单独加入。

并且继承的方法。假设原本的father的public方法重写之后没将public加上，会有Cannot reduce the visibility of the inherited method from Father，也就是不能降低父类中继承方法的可见性。

super指的是父类，即Father。

另一点是，事实上java中全部的类都隐式地继承了Object类。Object是父类，其它类是子类

老外喜欢讲为基类。子类也叫导出类或者派生类。

(3)代理

设计模式里面有个比較难懂的——代理模式，作者讲的非常有趣。代理是组合和继承的中庸之道。

package son;
class Father{
    public void get(){
        System.out.println("father");
    }
}
public class Son extends Father{
    public static void main(String[] args) {
        Father f = new Father();
        f.get();
    }
}
 
class FatherProxy{
    private Father f = new Father();
    public void get(){
        f.get();
    }
}

像直接把Father当做成员，那么father的方法就暴露给这个类了，那我们能够使用FatherProxy这种代理类。我自定义好get方法是怎么拿的，我自己知道是调用father的get方法。可是使用我这个代理的人不知道，我仅仅告诉他你要用就用代理的get的方法就能够了。封装性就体现出来了。上面仅仅是随便敲的一个简单样例。

(4)重写和重载

class Father{
    public void get(String s){
        System.out.println("father");
    }
 
    public void get(boolean b){
        System.out.println("boolean");
    }
}
public class Son extends Father{
    @Override
    public void get(String s){
        System.out.println("father");
    }
 
   // @Override //会有错误提示 由于父类没有该方法，不是重写
    public void get(int i ){
        System.out.println("sonint");
    }
 
    public static void main(String[] args) {
        Son s = new Son();
        s.get("d");
        s.get(false);
        s.get(1);
    }
}

重写是又一次覆盖父类的方法，假设没有重写或者重载。那么子类调用一个子类没有的方法时，事实上是调用父类。

重载是相同的方法名，但參数名称不同，为了防止你错误的进行重载能够加上@Override标签，那样会提示你并没有重写方法。

(5)protected

Java编程思想(三) —— 訪问权限的控制

在前面一篇提前写了，由于之前没讲继承的东西。

能够简单将protected看成父类给儿子继承的遗产，其它非继承类不能訪问。

(6)finalkeyword

加上finalkeyword的基本类型，表示这个变量初始化后不会改变。类似c的define。你希望一个变量在这个程序里就是这个值不须要改变。就能够用final。

public class Son{
    int  age = 2;
    public static void main(String[] args) {
 
        final int i = 1;
        // i = 2;  值不能再改变
        final Son son = new Son();
        //  son = new Son();
        //The final local variable son cannot be assigned.
        //It must be blank and not using a compound assignment
        //final修饰的局部变量son不能被分配，必须为空或者不要再次分配
 
        son.age = 4;
        //尽管引用恒定不变。可是，对象本身却能够改变。
    }
 
    void  change(final int c){
        // c= this.age; 无法赋予新值 由于值仅仅有在方法传參决定   对象引用和这个相似
        //age ++;       无法改变
    }
}

static本来是静态初始化，和final一起用就是占领了一块不能改变的存储空间。

static final即编译期常量。常量名依照c的常量命名传统。所实用大写字母。单词之间用下划线分开。

static final VALUE_ONE = 1。

final修饰方法时

public class Print {
    final void cannotprint(){
        System.out.println(1);
    }
}
 
public class PrintSon extends Print{
    //void cannotprint(){}
    //无法重写 由于被final修饰了
 
    public static void main(String[] args) {
        PrintSon ps = new PrintSon();
        ps.cannotprint();
    }
}

能够看成父类要求子类必须继承的不可改动財产（祖传）。private隐式地指定为final。由于private根本就不给你继承。这比给你继承但不能改动还更私有。

顺便将权限理清。

public，公共財产，不止是子类，其它类也能够用。

final，祖传珍宝，留给子类，但不同意改动。

private，父类私有財产，不会给子类继承。

protected。父类专门留给子类的財产，其它人不能用它。

当final修饰的是类的时候。是为了让这个类不会被继承。

(7)继承和初始化

这里的顺序问题是一个非常有趣的问题。

看样例。

class GrandFather{
    private static int i = print();
    private static int print(){
        System.out.println("g");
        return 1;
    }
}
class Father extends GrandFather{
    private static int i = print();
    private static int print(){
        System.out.println("f");
        return 1;
    }
}
public class Son extends Father{
    private static int i = print();
    private static int print(){
        System.out.println("s");
        return 1;
    }
    public static void main(String[] args) {
        System.out.println("first");
    }
}

打印的结果是first吗？错了。

尽管运行的是main方法。可是看到son这个须要静态初始化的i没有，结果是s。first吗？

这还有初始化的问题，son是继承father。那么编译器会载入father。并初始化i。那father继承grandfather。那么编译器会去载入grandfather，类似递归。

那最后最先初始化的是grandfather的i。

所以最后的结果是：g,f,s,first。

至于这章提到的向上转型。是和多态联系着的，所以放到下一篇来讲。

面向对象的三大基本特性之中的一个 —— Java编程思想(五) —— 多态。