Overloading和Overriding

一、 Overloading

          在一个类的内部，方法名相同,参数列表不同（类型，顺序，个数）的方法，返回值不要求，这种情况叫重载。编译器选择使用的方法，所以重载又被称之为编译时多态，对使用者屏蔽因为参数不同所造成的方法间的差异 。

 

          找方法时如果没有合适的，采取自动向上扩展原则，如：

public class TestOverLoading{ public static void main(String[] args){ Student s=new Student(); s.print(3); } } class Student{ public void print(short num){ System.out.println(num); } public void print(double num){ System.out.println(num); } }

 

此时s.print(3)没有找到相应的print(int num)的方法，这时它会自动向上扩展，找到print(double num)。

 

        尽管如此，对方法的调用一定要明确，如：

public class TestOverLoading{ public static void main(String[] args){ Student s=new Student(); char a = '中'; char b = '国'; s.print(a,b); } } class Student{ public void print(byte b,short c){ System.out.println(b + c); } public void print(short c,byte b){ System.out.println(c + b); } }   

此时s.print(a,b)就找不到相应的方法而报错了。

 

    注：简单类型会自动向上扩展，但封装类(包装类)则不会这样做，如调用s.print(new Integer(10))，没有相应的方法，它不会去调用print(Double d)这个方法。

简单类型向上扩展是按这样的顺序扩展：byte-->char-->short-->int-->long-->float-->double，boolean是独立的。所以打印简单类型可以简化如下：

public class TestOverLoading{ public static void main(String[] args){ PrintAll p = new PrintAll(); byte b = 10; p.print(b); p.print('c'); short s = 10; p.print(s); p.print(10); p.print(10L); p.print(10.0F); p.print(10.0); p.print(true); } } class PrintAll{ public void print(double d){ System.out.println(d); } public void print(boolean b){ System.out.println(b); } }  

打印结果如下：

          10.0
          99.0
          10.0
          10.0
          10.0
          10.0
          10.0
          true

 

     对于父类和子类间也可以重载，这个就看自己人理解了，在子类可以看成重载也可以看成是子类独立的方法(我是这样理解的)。如：

public class TestOverLoading{ public static void main(String[] args){ B b = new B(); b.print(10); b.print("100"); } } class A{ public void print(int num){ System.out.println(num); } } class B extends A{ public void print(String str){ System.out.println(str); } }

 

 

二、Overriding

      继承了父类的方法以后，用自己特殊的实现改写父类里面共性的实现，这种情况叫覆盖。覆盖的特点如下：

        1）发生在父类和子类之间
        2）方法名相同，参数相同，返回类型相同
        3）访问权限不能更严格(或更小)，只能等于或者更加宽松(访问权限见下面)
        4)  抛出的异常不能比父类更多

 

        如：

           父类：
                 private void eat() throws Exception {}
           子类：
                 public vodi eat(){}

 

      访问权限(访问控制修饰符)：从宽松到严格以次如下：

           public  ---->   protected  ---->   default  ---->  private

      关于访问控制修饰符的介绍见后续笔记“面向对象的三大特性”一文。

     提起覆盖也得说下“遮盖”，在子类中定义了和父类一样的属性叫“遮盖”。

     关于“继承”介绍见“面向对象的三大特性”一文 。