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
      关于访问控制修饰符的介绍见后续笔记“面向对象的三大特性”一文。
     提起覆盖也得说下“遮盖”，在子类中定义了和父类一样的属性叫“遮盖”。
     关于“继承”介绍见“面向对象的三大特性”一文 。