2017.10.10 java中的继承与多态（重载与重写的区别）

1. 类的继承

　　继承是面向对象编程技术的主要特征之一，也是实现软件复用的重要手段，使用继承特性子类（subclass）

可以继承父类（superclass）中private方法和属性，继承的目的是使程序代码重用，减少冗余。

1.1 类的继承的实现

　　·java语言中子类对父类的继承是通过在子类定义时，使用关键字extends来实现的；

　　·如果定义一个java类时并未显示的指定这个类的直接父类，则这个类默认继承java.land.Object类

　　·继承的特点，子类中的对象可以使用父类中的非private成员（方法和变量），故在子类中不必重写，这就是继承。

/**
 * Created by qichunlin on 2017/10/10.
 */
public class Fruit {
    public String fruitName;
    public double weight;
    public void info()
    {
        System.out.print("我是一个"+fruitName+"~重"+weight+"g!");
    }
}
 public class Apple extends Fruit{
    public static void main(String[] args){
        Apple a=new Apple();
        a.fruitName="苹果";
        a.weight=200;
        a.info();
    }
 }

2.方法的重载（overloading）

　　·定义：是指在一个类中用相同的方法名字定义多个方法，当然每个方法应该具有不同的代码，以实现不同的功能

　　　　　　方法的重载是实现多态性的重要手段。

　　·方法的名称、类型和形式参数构成了方法的签名，编译器根据方法的签名确定使用的是什么方法，因此方法的签名必须唯一。方法的返回值类型对方法的签名没有影响，因此方法没有返回值

2.2 看下面一个例子

/**
 * Created by qichunlin on 2017/10/5.
 */
/**
    定义一个矩形类MyRect，重载buildRect方法
描述一个矩形，如：可使用矩形的左上角和右下角坐标，使用两个点类的对象point，
* */
import java.awt.Point;
class MyRect         //定义矩形类
{
    int x1=0;          //左上角坐标初始化
    int y1=0;
    int x2=0;          //右下角坐标初始化
    int y2=0;
    MyRect buildRect(int x1,int y1,int x2,int y2)    //方法1，左上角和右下角
    {
        this.x1=x1;
        this.y1=y1;
        this.x2=x2;
        this.y2=y2;
        return this;
    }
    MyRect buildRect(Point topLeft,Point bottomRight)    /*方法2，两个point'对象，指定左上角和右下角坐标*/
    {
        x1=topLeft.x;
        y1=topLeft.y;
        x2=bottomRight.x;
        y2=bottomRight.y;
        return this;
    }
    MyRect buildRect(Point topLeft,int w,int h)
            //方法3，左上角和宽度与高度
    {
        x1=topLeft.x;
        y1=topLeft.y;
        x2=(x1+w);
        y2=(y1+h);
        return this;
    }
    void printRect()            //打印输出坐标
    {
        System.out.print("MyRect:<"+x1+","+y1);         //打印后不换行
        System.out.print(","+x2+","+y2+">");            //继续上行打印
    }
    public static void main(String[] args)
    {
        MyRect rect=new MyRect();       //创建对象
        System.out.print("Calling buildRect with coordinates 25,25,50,50:");  //创建矩形1，调用方法1
        rect.printRect();     //打印出坐标
        System.out.print("* * *");
        System.out.println("Calling buildRect with points (10,10),(20,20):");  //矩形2，调用方法2
        rect.buildRect(new Point(10,10),new Point(20,20));
        rect.printRect();               //打印出坐标
        System.out.println("* * *");
        System.out.print("Calling buildRect with 1 point(10,10),");
        System.out.println("width(50)and height(50):");
        rect.buildRect(new Point(10,10),50,50);   //矩形3，调用方法3
        rect.printRect();     //打印出坐标
        System.out.println("* * *");
    }
}

　　例子2：

/**
 * Created by qichunlin on 2017/10/7.
 */
class MethodOverloading
{
    void receive(int i)
    {
        System.out.println("Received one int data");
        System.out.println("i="+i);
    }  void receive(float f)
{
    System.out.println("Received one float data");
    System.out.println("f="+f);
}
void receive(String s)
{
    System.out.println("Received a String");
    System.out.println("s="+s);
}
public static void main(String [] args)
{
    MethodOverloading m = new MethodOverloading();
    m.receive(3456);
    m.receive(34.56f);
    m.receive("方法重载");
    }
}

3.方法的重写（overriding）

　　·方法的重写是指在子类中使用与父类中同名的方法，且方法的参数（个数类型、排列顺序）和返回类型完全一样

　　　即子类中的方法的代码覆盖掉父类中的方法代码，实现于父类中的方法的不同功能。

　　·父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，

　　　我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时

　　　子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。

　　·方法重写又称方法覆盖。

　　·若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。

　　　如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

　　·子类函数的访问修饰权限不能少于父类的；

4.方法重载与重写的区别

·重写与重载的区别在于：

　　重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.

·课外拓展：

　　（1）多态性是面向对象编程的一种特性，和方法无关，简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，

　　　  即方法的重载——有不同的参数列表（静态多态性）；

（2）而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，

　　　　即在子类中重写该方法——相同参数，不同实现（动态多态性）；

（3）oop的三大特性：继承、多态、封装.

·重写的优点主要在于能够定义某个子类的特征；

·重写方法只能存在于具有继承关系中，重写方法只能重写父类非私有的方法。

·重写方法的规则：

（1）参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

（2）返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

（3）访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

（4）重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

·而重载的规则：

（1）必须具有不同的参数列表；

（2）可以有不责骂的返回类型，只要参数列表不同就可以了；

（3）可以有不同的访问修饰符；

（4）可以抛出不同的异常；

1. 方法重载判断：

   (1)方法名必须相同。

   (2)形式参数个数不同或者参数类型不同（满足其中一个条件就行）。

2. 方法重写判断：

   (1)访问修饰符权限一定要大于被重写的方法。（当被重写的方法被私有（private）时无法重写）。

   (2)当被重写的方法一旦被final时也无法重写，如果编译会报错。

   (3)返回值类型必须相同。

   (4)参数列表必须与被重写的方法完全相同。