java中的继承和多态以及重载和重写

继承(inheritance)

       简单的说，继承就是在一个现有类型的基础上，通过增加新的方法或者重定义已有方法（下面会讲到，这种方式叫重写）的方式，产生一个新的类型。继承是面向对象的三个基本特征--封装、继承、多态的其中之一，我们在使用JAVA时编写的每一个类都是在继承，因为在JAVA语言中，java.lang.Object类是所有类最根本的基类（或者叫父类、超类），如果我们新定义的一个类没有明确地指定继承自哪个基类，那么JAVA就会默认为它是继承自Object类的。

我们可以把JAVA中的类分为以下三种：

类：使用class定义且不含有抽象方法的类。
抽象类：使用abstract class定义的类，它可以含有，也可以不含有抽象方法。
接口：使用interface定义的类。

在这三种类型之间存在下面的继承规律：

类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。
抽象类可以继承（extends）类，可以继承（extends）抽象类，可以继承（implements）接口。
接口只能继承（extends）接口。

请注意上面三条规律中每种继承情况下使用的不同的关键字extends和implements，它们是不可以随意替换的。大家知道，一个普通类继承一个接口后，必须实现这个接口中定义的所有方法，否则就只能被定义为抽象类。我在这里之所以没有对implements关键字使用“实现”这种说法是因为从概念上来说它也是表示一种继承关系，而且对于抽象类implements接口的情况下，它并不是一定要实现这个接口定义的任何方法，因此使用继承的说法更为合理一些。

以上三条规律同时遵守下面这些约束：

类和抽象类都只能最多继承一个类，或者最多继承一个抽象类，并且这两种情况是互斥的，也就是说它们要么继承一个类，要么继承一个抽象类。
类、抽象类和接口在继承接口时，不受数量的约束，理论上可以继承无限多个接口。当然，对于类来说，它必须实现它所继承的所有接口中定义的全部方法。
抽象类继承抽象类，或者实现接口时，可以部分、全部或者完全不实现父类抽象类的抽象（abstract）方法，或者父类接口中定义的接口。
类继承抽象类，或者实现接口时，必须全部实现父类抽象类的全部抽象（abstract）方法，或者父类接口中定义的全部接口。

继承给我们的编程带来的好处就是对原有类的复用（重用）。就像模块的复用一样，类的复用可以提高我们的开发效率，实际上，模块的复用是大量类的复用叠加后的效果。除了继承之外，我们还可以使用组合的方式来复用类。所谓组合就是把原有类定义为新类的一个属性，通过在新类中调用原有类的方法来实现复用。如果新定义的类型与原有类型之间不存在被包含的关系，也就是说，从抽象概念上来讲，新定义类型所代表的事物并不是原有类型所代表事物的一种，比如黄种人是人类的一种，它们之间存在包含与被包含的关系，那么这时组合就是实现复用更好的选择。

多态(Polymorphism)

多态是又一个重要的基本概念，上面说到了，它是面向对象的三个基本特征之一。究竟什么是多态呢？我们先看看下面的例子，来帮助理解：

//汽车接口 
interface Car { 
  // 汽车名称 
  String getName(); 
  
  // 获得汽车售价 
  int getPrice(); 
} 
  
// 宝马 
class BMW implements Car { 
  public String getName() { 
    return "BMW"; 
  } 
  
  public int getPrice() { 
    return 300000; 
  } 
} 
  
// 奇瑞QQ 
class CheryQQ implements Car { 
  public String getName() { 
    return "CheryQQ"; 
  } 
  
  public int getPrice() { 
    return 20000; 
  } 
} 
  
// 汽车出售店 
public class CarShop { 
  // 售车收入 
  private int money = 0; 
  
  // 卖出一部车 
  public void sellCar(Car car) { 
    System.out.println("车型：" + car.getName() + " 单价：" + car.getPrice()); 
    // 增加卖出车售价的收入 
    money += car.getPrice(); 
  } 
  
  // 售车总收入 
  public int getMoney() { 
    return money; 
  } 
  
  public static void main(String[] args) { 
    CarShop aShop = new CarShop(); 
    // 卖出一辆宝马 
    aShop.sellCar(new BMW()); 
    // 卖出一辆奇瑞QQ 
    aShop.sellCar(new CheryQQ()); 
    System.out.println("总收入：" + aShop.getMoney()); 
  } 
} 

?

运行结果：

车型：BMW  单价：300000
车型：CheryQQ  单价：20000
总收入：320000

继承是多态得以实现的基础。从字面上理解，多态就是一种类型（都是Car类型）表现出多种状态（宝马汽车的名称是BMW，售价是300000；奇瑞汽车的名称是CheryQQ，售价是2000）。将一个方法调用同这个方法所属的主体（也就是对象或类）关联起来叫做绑定，分前期绑定和后期绑定两种。下面解释一下它们的定义：

前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和final方法，注意，这里也包括private方法，因为它是隐式final的。
后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的耦合关系，使程序更容易扩展。比如在上例中，新增加一种类型汽车的销售，只需要让新定义的类继承Car类并实现它的所有方法，而无需对原有代码做任何修改，CarShop类的sellCar(Car car)方法就可以处理新的车型了。

Java多态特性———重载(overloading)和重写(overriding)

Java重载:

• 在同一个类中
• 方法具有相同的名字，相同或不同的返回值，但参数不同的多个方法（参数个数或参数类型）

 public class MethoDemo{
     public static void main(String args[]){
         int one = add(10,20) ;      // 调用整型的加法操作
         float two = add(10.3f,13.3f) ;  // 调用浮点数的加法操作
         int three = add(10,20,30) ; // 调用有三个参数的加法操作
         System.out.println("add(int x,int y)的计算结果：" + one) ;
         System.out.println("add(float x,float y)的计算结果：" + two) ;
         System.out.println("add(int x,int y,int z)的计算结果：" + three) ;
     }
     // 定义方法，完成两个数字的相加操作，方法返回一个int型数据
     public static int add(int x,int y){
         int temp = 0 ;          // 方法中的参数，是局部变量
         temp = x + y ;          // 执行加法计算
         return temp ;           // 返回计算结果
     }
     public static int add(int x,int y,int z){
         int temp = 0 ;          // 方法中的参数，是局部变量
         temp = x + y + z ;          // 执行加法计算
         return temp ;           // 返回计算结果
     }
     // 定义方法，完成两个数字的相加操作，方法的返回值是一个float型数据
     public static float add(float x,float y){
         float temp = 0 ;        // 方法中的参数，是局部变量
         temp = x + y ;          // 执行加法操作
         return temp ;           // 返回计算结果
     }
 };

输出结果:

add(int x,int y)的计算结果：30

add(float x,float y)的计算结果：60

add(int x,int y,int z)的计算结果：23.6

Java覆写:

• 子类覆写父类的方法，在不同的类中
• 重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型
• 重写方法不能使用比被重写方法更严格的访问权限

 class Person{       // 定义父类
     void print(){   // 默认的访问权限
         System.out.println("Person --> void print()。") ;
     }
 };
 class Student extends Person{   // 定义继承关系
     public void print(){
         System.out.println("Student --> void print()。") ;
     }
 };
 public class OverrideDemo{
     public static void main(String args[]){
         Student s = new Student() ;
         s.print() ;
     }
 };

输出结果:

Student --> void print()。

小结:

java的三大特性:封装,继承,多态.而方法的重载和覆写正是多态的体现.