java笔记8

继承、多态

多态，是一种编程语言行为，根据对象类型的不同，使用同样代码能调用不同方法。

关键字extends是java从已有类中得到一个新类的机制。

关键字super是将当前对象视为父类的一个实例的java机制。
super(); //调用父类的默认构造方法
super(2, 4); //调用父类的特定构造方法
super.equals(p); //子类ThreeDimensionalPoint调用父类的方法equals()
当子类没有重写父类的方法时，子类可以直接调用父类的方法。

有些人将方法重载视作句法的或者简单的多态。但它在编译时可以确定调用哪个方法，根据调用形式来做决定。
但，真正的多态，通常要求等到运行时才能做决定。
java中，根据变量所引用的对象类型决定调用。

继承
对象的构造总是一个两步的过程。第一步构造对象的父类部分，第二步才构造对象的子类部分。
public class B
{
public B(){System.out.println("B1");}
public B(int a){System.out.println("B2");}
}
public class C extends B
{
public C(){System.out.println("C1");}
public C(int a){System.out.println("C2");}
public C(int a, int b){ super(a+b); System.out.println("C3");}
public static void main(String[] args) { C c1 = new C(); C c2 = new C(3); C c3 = new C(3, 4);}
}
输出如下：
B1
C1
B1
C2
B2
C3

子类可以访问父类的public成员，不可以访问父类的private成员。
protected变量和成员除了可以在类内部被访问外，还可以被子类使用。
默认访问权限，只有当2个类在同一包中的时候，才可以互访对方的默认访问权限的成员。




数据域
public class D
{
protected int d;
public D(){d=0;}
public D(int v){ d=v;}
public void printD(){System.out.println("D's d: " + d);}

}
public class E extends D
{
public E(int v){d=v; super.d=v*100;} //两个d都是父类的d
public void printE(){System.out.println("D's d: " + super.d); System.out.println("E's d: " + this.d);}
}
public class F extends D
{
int d;
public F(int v){ d=v; super.d=v*100;}
public void printF(){System.out.println("D's d: " + super.d); System.out.println("F's d: " + this.d);}
public static void main(String[] args)
{
E e = new E(1);
F f = new F(2);
e.printE();
f.printF();
return ;
}
}
输出：
D's d: 100
E's d: 100
D's d: 200
F's d: 2

类型
public class X
{
public X(){}
public static boolean isX(Object v){ return (v instanceof X);}
public static bolean isObject(X v) { return (v instanceof object);}
}
public class Y extends X
{
public Y(){}
public static boolean ifY(Object v) { return (v instanceof Y);}
public static void main(String[] args)
{
X x = new X();
Y y = new Y();
X z = y;
System.out.println("x is an Object: " + X.isObject(x));
System.out.println("x is an X: " + X.isX(x));
System.out.println("x is a Y: " + Y.isY(x));
System.out.println();
System.out.println("y is an Object: " + X.isObject(y));
System.out.println("y is an X: " + X.isX(y));
System.out.println("y is a Y: " + Y.isY(y));
System.out.println();
System.out.println("z is an Object: " + X.isObject(z));
System.out.println("z is an X: " + X.isX(z));
System.out.println("z is a Y: " + Y.isY(z));
return ;
}
}
输出：
x is an Object: true
x is an X: true
x is a Y: false
y is an Object: true
y is an X: true
y is a Y: true
z is an Object: true
z is an X: true
z is a Y: true

后(动态)绑定
public class L
{
public L(){}
public void f()
{
System.out.println("Using L's f()");
g();
}
public void g(){ System.out.println("Using L's g()");}
}
public class M extends L
{
public M(){}
public void g(){System.out.println("Using M's g()");}
public static void main(String[] args)
{
L l = new L();
M m = new M();
l.f();
m.f();
return ;
}
}
输出：
Using L's f()
Using L's g()

Using L's f()
Using M's g()

一个final的类是不允许被扩展的，一个final的方法是不可以被重写的。

BufferedReader ImprovedReader

定义一个父类，其中某些方法没有有意义的定义；也就是说，有必要让某些方法成为父类的部分，使得其他代码可以利用java的多态能力。这种类被称之为抽象类。
abstract public class GeometricObject
{
Point position;
public Point getPosition(){ return position;}
abstract public void paint(Graphics g);
}

接口
接口不是一个类，而是一个部分模板，它必然存在于实现该接口的类中。
接口是java的类型。
public interface name
{
//常量
//方法的声明
}
//所有变量，不论显式指定与否，都是类常量（也就是public static final）
//所有列出的方法，不论显式与否，都是public的
接口与抽象类的三个重要区别：
(1)接口不能有任何方法实现；
(2)接口的所有方法都是public；
(3)接口中所有变量都是public，final以及static的

java允许一个类实现多个接口，而一个类只能扩展一个父类；
接口不是一个类，它也不属于类层次的一部分。

接口的使用
public interface Colorable
{
public Color getColor();
public void setColor(Color c);
}
public class ColorablePoint extends Point implements Colorable
{
Color color;
...
public Color getColor(){ return color;}
public void setColor(Color color){ color=c;}
}
public class Colorable3DPoint extends Point implements Colorable
{
...
public Color getColor(){...}
public void setColor(Color color){...}
}
ColorablePoint u = new ColorablePoint();
Colorable3DPoint v = new Colorable3DPoint();
Colorable w = u;
w.setColor(Color.BLACK);
w = v;
w.getColor(Color.RED);