java编程思想-复用类(2)

如果java的基类拥有某个已被多次重载的方法名称，那么在导出类中重新定义该方法名称并不会屏蔽其在基类中的任何版本(这一点与C++不同)

class Homer
{
    char doh(char c)
    {
        System.out.println("char");
        return c;
    }
    float doh(float f)
    {
        System.out.println("float");
        return f;
    }
}

class Milhouse{}

class Bart extends Homer
{
    void doh(Milhouse m)
    {
        System.out.println("Milhouse");
    }
}

public class test 
{
    public static void main(String[] args)
    {
        Bart b = new Bart();
        b.doh(1);
        b.doh('x');
        b.doh(1.0f);
        b.doh(new Milhouse());
    }
}
/*
float
char
float
Milhouse
*/

关键字protect:就类用户而言，这是private的，但对于任何继承于此类的导出类或其他任何位于同一个包内的类来说，它却是可以访问的

final数据：1）一个永不改变的编译时常量  2）一个在运行时被初始化的值，而你不希望它被改变

对于基本类型，final使数值恒定不变，而用于对象引用，final使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象，但是，对象自身却是可以被修改的。

空白final指被声明为final但又未给定初值的域，无论什么情况， 编译器都确保空白final在使用前必须被初始化，且初始化后就不再改变。

java允许在参数列表中以声明的方式将参数指明为final，这意味着你无法在方法中更改参数引用所指向的对象。

class test
{
    void cal(final String s)
    {
        s = new String();//出错
    }
}

使用final方法的原因：想要确保在继承中使方法行为保持不变，不会被覆盖。
当将某个类定义为final时（通过将final置于它的定义之前），该类不允许被继承。

首先初始化基类的static变量，然后初始化派生类的static变量。在基类构造器完成之后，实例变量按其次序被初始化，最后，构造器的其余部分被执行。

class insect
{
    private int i = 9;
    protected int j;
    insect()
    {
        System.out.println("i = " + i + ",j = " + j);
        j = 39;
    }
    private static int x1 = printInit("insect.x1");
    static int printInit(String s)
    {
        System.out.println(s);
        return 47;
    }
}

public class test extends insect
{
    private int k = printInit("test.k");
    public test()
    {
        System.out.println("k = " + k);
        System.out.println("j = " + j);
    }
    private static int x2 = printInit("test.x2");
    public static void main(String[] args)
    {
        System.out.println("test constructed");
        test t = new test();
    }
}
/*
insect.x1
test.x2
test constructed
i = 9,j = 0
test.k
k = 47
j = 39
*/