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)); }
}
  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
 

运行结果：

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

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

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

 

  
1
  
2
  
3
  
4
  
5
  
6
 

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

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("平行四边形"); }
}
  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
 

运行结果：

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

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

3.抽象类

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

  

 

  
1
  
2
  
3
 

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

4.接口

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

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

 

  
1
  
2
 

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

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

 

  
1
  
2
  
3
  
4
  
5
 

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

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

文章来源: blog.csdn.net，作者：花狗Fdog，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/Fdog_/article/details/104747587