java之继承，封装，多态

转发请注明出处：http://blog.csdn.net/qq_28055429/article/details/51170401

一，封装

理解：把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能的隐藏对象内部实现细节

例如：我们写一个简单的输入两个数和一个操作符（+，-，*，/)的的运算，

可以把具体操作和属性封装成一个类

如：

主类：

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. import java.util.Scanner;  
  4.   
  5. public class Program {  
  6.     public static void main(String[] args) {  
  7.         try {  
  8.             // 输入端  
  9.             Scanner scanner = new Scanner(System.in);  
  10.             System.out.println("请输入数字A : ");  
  11.             String numberA = scanner.next();  
  12.             System.out.println("请输入操作符（+,-,*,/）：");  
  13.             String numberOperation = scanner.next();  
  14.             System.out.println("请输入数字B : ");  
  15.             String numberB = scanner.next();  
  16.             String numberResult = "";  
  17.             // 这里把参数A,B装换成double型再传入，  
  18.             numberResult = String.valueOf(Operation.GetResult(  
  19.                     Double.parseDouble(numberA), Double.parseDouble(numberB),  
  20.                     numberOperation));  
  21.             System.out.println("输出结果为：" + numberResult);  
  22.   
  23.         } catch (Exception e) {  
  24.             System.out.println("您的输入有误：");  
  25.             e.printStackTrace();  
  26.         }  
  27.     }  
  28. }  



 

//另一个类

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. /* 
  4.  * 运用封装思想 
  5.  */  
  6. public class Operation {  
  7.     // 自定义方法，根据传入的操作符执行相应操作  
  8.     public static double GetResult(double numberA, double numberB,  
  9.             String numberOperation) {  
  10.         double numberResult = 0d;  
  11.         /* 
  12.          * 判断操作符 字符串化为Double:Double.parseDouble(字符串); 
  13.          * Double化为字符串：String.valueOf(double值); 
  14.          */  
  15.         switch (numberOperation) {  
  16.         case "+":  
  17.             numberResult = numberA + numberB;  
  18.             break;  
  19.         case "-":  
  20.             numberResult = numberA - numberB;  
  21.             break;  
  22.         case "*":  
  23.             numberResult = numberA * numberB;  
  24.             break;  
  25.         case "/":  
  26.             // 先判断除数是否为0  
  27.             if (numberB != 0) {  
  28.                 numberResult = numberA / numberB;  
  29.             } else {  
  30.                 try {  
  31.                     throw new Exception("除数不能为0");  
  32.                 } catch (Exception e) {  
  33.                     // TODO Auto-generated catch block  
  34.                     e.printStackTrace();  
  35.                 }  
  36.             }  
  37.             break;  
  38.         default:  
  39.             break;  
  40.   
  41.         }  
  42.         return numberResult;  
  43.     }  
  44. }  



 

 

 

二，继承:

目的：减少代码的重复性（extends)

注意：

（1）子类不能继承父类的构造函数，只能继承父类的成员函数和成员变量

（2）在子类的构造函数中，必须调用父类的构造函数

可用super（）调用父类的构造函数

和super(参数)调用父类的成员函数

 

如：

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. class Student extends Person {  
  2.     Student(){  
  3. //在此，无调用，故会自动生成父类无参数的构造函数  
  4. super();  
  5. System.out.println('Student的无参数构造函数");  
  6. }  
  7. }  



 

(可参考我之前发的Java中的重载和重写）

 

 

三，多肽

目的：提高程序的抽象程度和简洁性（减少代码的重复性）

 

理解1：

同一东西，对于不同的对象的不同反映，在java中就是说，同一个方法，但这个方法却有许多不一样的方法体

比如说：有个方法public double getArea(),我们可以知道这个方法的返回类型是double ,名字叫做getArea,

但是对于不同的图形，它的参数个数，形参类型，方法体必然会有不一样的，

例如：

对于圆形：

public double getArea(float r){

return (double)(Math.PI * r  * r);

}

对于矩形：

public double getArea(float a , float b){

return a * b ;

}

 

理解2：

(1)指同名的不同方法在程序中共存（其实也跟理解1差不多）

即为同一个方法定义几个版本，运行时根据不同的情况执行不同的版本，调用者只需要使用同一个方法名，

系统会根据不同的情况，调用相应的不同的方法，从而实现不同的功能

(2)在java语言中，多肽的两种实现方式：

A, 覆盖（又叫复写或者重写）

B, 重载

这两者的应用和区别（在我之前发表的java中的重载和重写就有，可以去看一看，这里不再详解）

 

四，继承，封装，多肽这三者有什么用？为什么要用？如何用？

这里我也是初步认识而已，若有错误，望指教：

例如：

还是以前面的那个例子吧，

假如某公司要你写一个简单的求输入两个数的四则运算，你so easy的写出如下：

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. import java.util.Scanner;  
  4.   
  5. public class Program {  
  6.   
  7.     public static void main(String[] args) {  
  8.         try {  
  9.             // 输入端  
  10.             Scanner scanner = new Scanner(System.in);  
  11.             System.out.println("请输入数字A : ");  
  12.             String numberA = scanner.next();  
  13.             System.out.println("请输入操作符（+,-,*,/）：");  
  14.             String numberOperation = scanner.next();  
  15.             System.out.println("请输入数字B : ");  
  16.             String numberB = scanner.next();  
  17.             String numberResult = "";  
  18.   
  19.             switch (numberOperation) {  
  20.             case "+":  
  21.                 numberResult = String.valueOf(Double.parseDouble(numberA)  
  22.                         + Double.parseDouble(numberB));  
  23.                 break;  
  24.             case "-":  
  25.                 numberResult = String.valueOf(Double.parseDouble(numberA)  
  26.                         - Double.parseDouble(numberB));  
  27.                 break;  
  28.             case "*":  
  29.                 numberResult = String.valueOf(Double.parseDouble(numberA)  
  30.                         * Double.parseDouble(numberB));  
  31.                 break;  
  32.             case "/":  
  33.                 // 先判断除数是否为0  
  34.                 if (numberB != "0") {  
  35.                     numberResult = String.valueOf(Double.parseDouble(numberA)  
  36.                             / Double.parseDouble(numberB));  
  37.                 } else {  
  38.                     try {  
  39.                         throw new Exception("除数不能为0");  
  40.                     } catch (Exception e) {  
  41.                         // TODO Auto-generated catch block  
  42.                         e.printStackTrace();  
  43.                     }  
  44.                 }  
  45.                 break;  
  46.             default:  
  47.                 break;  
  48.   
  49.             }  
  50.             // 打印结果  
  51.             System.out.println("输出结果为：" + numberResult);  
  52.   
  53.         } catch (Exception e) {  
  54.             System.out.println("您的输入有误：");  
  55.             e.printStackTrace();  
  56.         }  
  57.   
  58.     }  
  59.   
  60. }  



 

第二天：老板说，我现在要求你写一个电脑版的计算器，你的代码还能用吗？

你可能说：复制过去再改改就行啦，但是，如果代码超级多，一复制就问题多啦，，

这时就要用封装（例子在前面，分为两个类，有需要直接调用）

第三天：老板觉得加法要改一改，增加求平方根，你又如何呢？

第四天：只在加法增加，3次方根，

......

第n天，在，，，，增加，，，

这时就要考虑继承，封装，多肽的使用了，

以下是一个例子：（改自博客园一位名字叫伍迷的大神，我不知他真名是谁）

（1）主类

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. import java.util.Scanner;  
  4.   
  5. public class Program {  
  6.     public static void main(String[] args) {  
  7.         try {  
  8.             // 输入端  
  9.             Scanner scanner = new Scanner(System.in);  
  10.             System.out.println("请输入数字A : ");  
  11.             String numberA = scanner.next();  
  12.             System.out.println("请输入操作符（+,-,*,/）：");  
  13.             String numberOperation = scanner.next();  
  14.             System.out.println("请输入数字B : ");  
  15.             String numberB = scanner.next();  
  16.   
  17.             // 在这里调用格式工厂的方法  
  18.             Operation oper;  
  19.             oper = OperationFactory.createOperate(numberOperation);  
  20.             oper.numberA = Double.parseDouble(numberA);  
  21.             oper.numberB = Double.parseDouble(numberB);  
  22.             double numberResult = oper.getResult();  
  23.             // 打印结果  
  24.             System.out.println("输出结果为：" + numberResult);  
  25.   
  26.         } catch (Exception e) {  
  27.             System.out.println("您的输入有误：");  
  28.             e.printStackTrace();  
  29.         }  
  30.     }  
  31.   
  32. }  



 

（2）格式工厂类

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. import operation.Operation;  
  4.   
  5. /** 
  6.  * 多肽实现 
  7.  *  
  8.  * @author maiyu 
  9.  *  
  10.  */  
  11. public class OperationFactory {  
  12.   
  13.     public static Operation createOperate(String operate) {  
  14.         Operation oper = null;  
  15.         switch (operate) {  
  16.         case "+":  
  17.             // 向上转型  
  18.             oper = new NumberAdd();  
  19.             break;  
  20.         case "-":  
  21.             oper = new NumberSub();  
  22.             break;  
  23.         case "*":  
  24.             oper = new NumberMul();  
  25.             break;  
  26.         case "/":  
  27.             oper = new NumberDiv();  
  28.             break;  
  29.         default:  
  30.             break;  
  31.         }  
  32.         return oper;  
  33.     }  
  34. }  



 

（3）操作父类：Operation

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. /* 
  4.  * 运用封装思想 
  5.  */  
  6. public class Operation {  
  7.   
  8.     double numberA = 0;  
  9.     double numberB = 0;  
  10.   
  11.     public double getNumberA() {  
  12.         return numberA;  
  13.     }  
  14.   
  15.     public void setNumberA(double numberA) {  
  16.         this.numberA = numberA;  
  17.     }  
  18.   
  19.     public double getNumberB() {  
  20.         return numberB;  
  21.     }  
  22.   
  23.     public void setNumberB(double numberB) {  
  24.         this.numberB = numberB;  
  25.     }  
  26.   
  27.     public double getResult() {  
  28.         double result = 0d;  
  29.         return result;  
  30.     }  
  31. }  



 

（4）四个类：NumberAdd,NumberSub,NumberMul,NumberDiv

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2. /** 
  3.  * 加法类，继承父类Operation 
  4.  *  
  5.  * @author maiyu 
  6.  *  
  7.  */  
  8. public class NumberAdd extends Operation {  
  9.     @Override  
  10.     public double getResult() {  
  11.         // 假如某一天公司老板要求在乘法增加一个开根号，即可只需要改动这里  
  12.         // double result = Math.sqrt(getNumberA() + getNumberB());  
  13.         double result = getNumberA() + getNumberB();  
  14.         return result;  
  15.     }  
  16. }  
[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2. /** 
  3.  * 减法类，继承父类Operation 
  4.  *  
  5.  * @author maiyu 
  6.  *  
  7.  */  
  8. public class NumberSub extends Operation {  
  9.     @Override  
  10.     public double getResult() {  
  11.         double result = getNumberA() - getNumberB();  
  12.         return result;  
  13.     }  
  14. }  

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 乘法类，继承父类Operation 
  3.  *  
  4.  * @author maiyu 
  5.  *  
  6.  */  
  7.   
  8. public class NumberMul extends Operation {  
  9.     @Override  
  10.     public double getResult() {  
  11.         double result = getNumberA() * getNumberB();  
  12.         return result;  
  13.     }  
  14. }  

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. package operation;  
  2.   
  3. /** 
  4.  * 除法类，继承父类Operation 
  5.  *  
  6.  * @author maiyu 
  7.  *  
  8.  */  
  9. public class NumberDiv extends Operation {  
  10.     @Override  
  11.     public double getResult() {  
  12.         double result = 0d;  
  13.         if (getNumberB() != 0) {  
  14.             result = getNumberA() / getNumberB();  
  15.         } else {  
  16.             try {  
  17.                 throw new Exception("除数不能为0");  
  18.             } catch (Exception e) {  
  19.                 // TODO Auto-generated catch block  
  20.                 e.printStackTrace();  
  21.             }  
  22.             // System.out.println("除数不能为0！");  
  23.             // System.out.println("以下结果是错误的!");  
  24.         }  
  25.         return result;  
  26.     }  
  27.   
  28. }  




 

测试结果：

 

[java] view plain copy
 
 在CODE上查看代码片派生到我的代码片
  1. 请输入数字A :   
  2. 8  
  3. 请输入操作符（+,-,*,/）：  
  4. /  
  5. 请输入数字B :   
  6. 3  
  7. 输出结果为：2.6666666666666665  
  8. 请输入数字A :   
  9. 8  
  10. 请输入操作符（+,-,*,/）：  
  11. /  
  12. 请输入数字B :   
  13. 0  
  14. java.lang.Exception: 除数不能为0  
  15. 输出结果为：0.0  
  16. at operation.NumberDiv.getResult(NumberDiv.java:16)  
  17. at operation.Program.main(Program.java:24)  



 

 

 

五，你可能说这么多个类更麻烦，

其实不然，这样更简洁，只需在子类中修改，而且不容易犯错，

posted @ 2016-12-17 16:39  天涯海角路  阅读(256)  评论(0)    收藏  举报