java笔记8

1. 继承、多态

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

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

4. 关键字super是将当前对象视为父类的一个实例的java机制。

   super(); //调用父类的默认构造方法

   super(2, 4); //调用父类的特定构造方法

   super.equals(p); //子类ThreeDimensionalPoint调用父类的方法equals()

   当子类没有重写父类的方法时，子类可以直接调用父类的方法。

5. 有些人将方法重载视作句法的或者简单的多态。但它在编译时可以确定调用哪个方法，根据调用形式来做决定。

   但，真正的多态，通常要求等到运行时才能做决定。

   java中，根据变量所引用的对象类型决定调用。
   

6. 继承

   对象的构造总是一个两步的过程。第一步构造对象的父类部分，第二步才构造对象的子类部分。

   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

7. 子类可以访问父类的public成员，不可以访问父类的private成员。

   protected变量和成员除了可以在类内部被访问外，还可以被子类使用。

   默认访问权限，只有当2个类在同一包中的时候，才可以互访对方的默认访问权限的成员。

   

   
   

   
   

   
   

8. 数据域

   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
   

9. 类型

   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
   

10. 后(动态)绑定

    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()
    

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

12. BufferedReader   ImprovedReader

13. 定义一个父类，其中某些方法没有有意义的定义；也就是说，有必要让某些方法成为父类的部分，使得其他代码可以利用java的多态能力。这种类被称之为抽象类。

    abstract public class GeometricObject

    {

      Point position;

      public Point getPosition(){ return position;}

      abstract public void paint(Graphics g);

    }

14. 接口

    接口不是一个类，而是一个部分模板，它必然存在于实现该接口的类中。

    接口是java的类型。

    public interface name

    {

      //常量

      //方法的声明

    }

    //所有变量，不论显式指定与否，都是类常量（也就是public static final）

    //所有列出的方法，不论显式与否，都是public的

    接口与抽象类的三个重要区别：

    (1)接口不能有任何方法实现；

    (2)接口的所有方法都是public；

    (3)接口中所有变量都是public，final以及static的

15. java允许一个类实现多个接口，而一个类只能扩展一个父类；

    接口不是一个类，它也不属于类层次的一部分。

16. 接口的使用

    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);