java学习之路：26.方法的重载，多态，抽象类与接口

---

1.方法的重载

方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或者类型不同即可。
代码演示：

public class OverLoadTest {
 // 定义一个方法
    public static int add(int a,int b) { 
        return a + b; 
    }
 // 定义与第一个方法相同名称，参数类型不同的方法
    public static double add(double a,double b) { 
        return a + b; 
    }
 // 定义与第一个方法参数个体不同的方法
    public static int add(int a) { 
        return a; 
    }
    public static int add(int a,double b) { 
        return 1; 
    }
 // 这个方法与前一个方法参数次序不同
    public static int add(double a,int b) { 
        return 1; 
    }
     public static void main(String[] args) {
 // TODO Auto-generated method stub
        System.out.println("调用add(int,int)方法："+add(1,2)); 
        System.out.println("调用add(double,double)方法："+add(1.2,2.1)); 
        System.out.println("调用add(int)方法："+add(1)); 
    }
}

运行结果：

根据方法重载的定义：
参数类型不同，构成重载。
参数顺序不同，构成重载。
参数个数不同，构成重载。

在谈到参数个数不同，构成重载，会涉及到不定长参数方法。
在刚才的类中添加如下代码：

public static int add(int...a) { 
    int s = 0; 
    for (int i = 0;i < a.length;i++) { 
        s += a[i]; 
    }
    return s; 
}

运行结果没有问题，由于它的参数是不定长的，所以满足根据参数个数不同，构成重载条件。

---

2.多态

public class Quadrangle {
// 实例化保存四边形对象的数组对象
    private Quadrangle[] qtest = new Quadrangle[6]; 
    private int nextlndex = 0; 
    public void draw(Quadrangle q) { 
        if (nextlndex < qtest.length) { 
            qtest[nextlndex] = q; 
            System.out.println(nextlndex); 
            nextlndex++;
        }
    }
    public static void main(String[] args) {
    // 实例化两个四边形对象，用于调用draw()方法
        Quadrangle q = new Quadrangle(); 
        q.draw(new Square()); // 以正方形对象为参数调用draw()方法
        q.draw(new Parallelogramgle()); // 以平行四边形对象为参数调用draw()方法
    }
}
// 定义一个正方形类，继承四边形类
class Square extends Quadrangle{ 
    public Square() { 
        System.out.println("正方形"); 
    }
}
// 定义一个平行四边形类，继承四边形类
class Parallelogramgle extends Quadrangle{ 
    public Parallelogramgle() {
        System.out.println("平行四边形"); 
    }
}

运行结果：

多态是出现在具有继承关系的两个类的对象之间，所以它不像方法重载（发生在一个类中）在编译期间发生（也就是确定下来），而是在运行期间发生（确定下来）。

比较经典的多态实例是：
有一个Animal类，它有Cat，和Dog两个子类，在Animal中有个say方法，当Cat调用这个方法的时候输出的是“小猫喵喵喵”，当Dog调用这个方法时，输出的是“小狗汪汪汪”，这就是Java多态的实现。

---

3.抽象类

public abstract class Test{ 
    abstract void testAbstract(); // 定义抽象方法
}

       其中，abstract是定义抽象类的关键字。使用abstract关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承之外没有任何意义。
       反过来，如果声明一个抽象的方法，就必须将承载这个抽象方法的类定义为抽象类，不可能在非抽象类中获取抽象方法，换句话说，只要类中有一个抽象方法，此类就被标记为抽象类。
       抽象类被继承后需要实现其中所有的抽象方法，这样在多态机制中，就可以将父类修改为抽象类，将draw()方法设置为抽象方法，然后每个子类都重写这个方法来处理。但是程序中就会有太多冗余的代码，有时不需要draw()方法的子类也不得不重写的draw()方法，如果将draw()方法放置在另外一个类中，这样需要draw()方法的类继承该类，而不需要draw()方法的类继承图形类，但如果所有的子类都需要图形类，而且Java规定，类不能同时继承多个父类，面临这种问题，接口出现了。

---

4.接口

接口使用interface关键字进行定义：

public interface drawTest{ 
    void draw(); //接口内的方法，省略abstract关键字
}

在接口中定义的方法必须被定义为public或abstract形式，其他修饰权限不被Java编译器认可，即使不将该方法声明为public形式，它也是public形式的。
在接口中定义的任何字段都自动是static和final的。

class Parallelogramgle implements drawTest{
// 实现接口 覆盖draw()方法
    public void draw(){
    // 功能实现
    }
}

Java中无论是将一个类向上转型为父类对象，还是向上转型为抽象父类对象，或者向上转型为该类实现接口都是可以的。
Java不允许多重继承，但是可以使用多个接口:
class 类名 implements 接口 1,接口 2,接口 3,

---

若有错误，欢迎指正批评，欢迎评论。
每文一句：受挫受辱之时，务须咬牙励志，蓄其气而长其智。