java之继承，封装，多肽
一，封装
理解：把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能的隐藏对象内部实现细节
例如：我们写一个简单的输入两个数和一个操作符（+，-，*，/)的的运算，
可以把具体操作和属性封装成一个类
如：
主类：
package operation;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try{
//输入端
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A : ");
String numberA = scanner.next();
System.out.println("请输入操作符（+,-,*,/）：");
String numberOperation = scanner.next();
System.out.println("请输入数字B : ");
String numberB = scanner.next();
String numberResult = "";
//这里把参数A,B装换成double型再传入，
numberResult = String.valueOf(Operation.GetResult(Double.parseDouble(numberA) ,
Double.parseDouble(numberB) ,numberOperation));
System.out.println("输出结果为：" + numberResult);
}catch(Exception e){
System.out.println("您的输入有误：" );
e.printStackTrace();
}
}
}
//另一个类
package operation;
/*
* 运用封装思想
*/
public class Operation {
//自定义方法，根据传入的操作符执行相应操作
public static double GetResult(double numberA , double numberB, String numberOperation)
{
double numberResult = 0d;
/*判断操作符
* 字符串化为Double:Double.parseDouble(字符串);
* Double化为字符串：String.valueOf(double值);
*/
switch(numberOperation){
case "+":
numberResult = numberA + numberB;
break;
case "-":
numberResult = numberA - numberB;
break;
case "*":
numberResult = numberA * numberB;
break;
case "/":
//先判断除数是否为0
if(numberB != 0){
numberResult = numberA / numberB;
}
else{
try {
throw new Exception("除数不能为0");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} }
break;
default:
break;
}
return numberResult;
}
}
二，继承:
目的：减少代码的重复性（extends)
注意：
（1）子类不能继承父类的构造函数，只能继承父类的成员函数和成员变量
（2）在子类的构造函数中，必须调用父类的构造函数
可用super（）调用父类的构造函数
和super(参数)调用父类的成员函数
如：
class Student extends Person{
Student(){
//在此，无调用，故会自动生成父类无参数的构造函数
super();
System.out.println('Student的无参数构造函数");
}
}
(可参考我之前发的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的写出如下：
package operation;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try{
//输入端
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A : ");
String numberA = scanner.next();
System.out.println("请输入操作符（+,-,*,/）：");
String numberOperation = scanner.next();
System.out.println("请输入数字B : ");
String numberB = scanner.next();
String numberResult = "";
switch(numberOperation){
case "+":
numberResult = String.valueOf(Double.parseDouble(numberA) + Double.parseDouble(numberB));
break;
case "-":
numberResult = String.valueOf(Double.parseDouble(numberA) - Double.parseDouble(numberB));
break;
case "*":
numberResult = String.valueOf(Double.parseDouble(numberA) * Double.parseDouble(numberB));
break;
case "/":
//先判断除数是否为0
if(numberB != "0"){
numberResult = String.valueOf(Double.parseDouble(numberA) / Double.parseDouble(numberB));
}
else{
try {
throw new Exception("除数不能为0");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
break;
default:
break;
}
//打印结果
System.out.println("输出结果为：" + numberResult);
}catch(Exception e){
System.out.println("您的输入有误：" );
e.printStackTrace();
}
}
}
第二天：老板说，我现在要求你写一个电脑版的计算器，你的代码还能用吗？
你可能说：复制过去再改改就行啦，但是，如果代码超级多，一复制就问题多啦，，
这时就要用封装（例子在前面，分为两个类，有需要直接调用）
第三天：老板觉得加法要改一改，增加求平方根，你又如何呢？
第四天：只在加法增加，3次方根，
......
第n天，在，，，，增加，，，
这时就要考虑继承，封装，多肽的使用了，
以下是一个例子：（改自博客园一位名字叫伍迷的大神，我不知他真名是谁）
（1）主类
package operation;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try{
//输入端
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A : ");
String numberA = scanner.next();
System.out.println("请输入操作符（+,-,*,/）：");
String numberOperation = scanner.next();
System.out.println("请输入数字B : ");
String numberB = scanner.next();
//在这里调用格式工厂的方法
Operation oper;
oper = OperationFactory.createOperate(numberOperation);
oper.numberA = Double.parseDouble(numberA);
oper.numberB = Double.parseDouble(numberB);
double numberResult = oper.getResult();
//打印结果
System.out.println("输出结果为：" + numberResult);
}catch(Exception e){
System.out.println("您的输入有误：" );
e.printStackTrace();
}
}
}
（2）格式工厂类
package operation;
import operation.Operation;
/**
* 多肽实现
* @author maiyu
*
*/
public class OperationFactory {
public static Operation createOperate(String operate){
Operation oper = null;
switch(operate){
case "+":
//向上转型
oper = new NumberAdd();
break;
case "-":
oper = new NumberSub();
break;
case "*":
oper = new NumberMul();
break;
case "/":
oper = new NumberDiv();
break;
default:
break;
}
return oper;
}
}
（3）操作父类：Operation
package operation;
/*
* 运用封装思想
*/
public class Operation {
double numberA = 0;
double numberB = 0;
public double getNumberA(){
return numberA;
}
public void setNumberA(double numberA){
this.numberA = numberA;
}
public double getNumberB(){
return numberB;
}
public void setNumberB(double numberB){
this.numberB = numberB;
}
public double getResult(){
double result = 0d;
return result;
}
}
（4）四个类：NumberAdd,NumberSub,NumberMul,NumberDiv
package operation;
/**
* 利用继承
* @author maiyu
*
*/
public class NumberAdd extends Operation {
@Override
public double getResult() {
//假如某一天公司老板要求在乘法增加一个开根号，即可只需要改动这里
//double result = Math.sqrt(getNumberA() + getNumberB());
double result = getNumberA() + getNumberB();
return result;
}
}
package operation;
/**
* 减法类，继承父类Operation
* @author maiyu
*
*/
public class NumberSub extends Operation {
@Override
public double getResult() {
double result = getNumberA() - getNumberB();
return result;
}
}
package operation;
/**
* 乘法类，继承父类Operation
* @author maiyu
*
*/
public class NumberMul extends Operation {
@Override
public double getResult() {
double result = getNumberA() * getNumberB();
return result;
}
}
package operation;
/**
* 除法类，继承父类Operation
* @author maiyu
*
*/
public class NumberDiv extends Operation{
@Override
public double getResult(){
double result = 0d;
if(getNumberB() != 0){
result = getNumberA() / getNumberB();
}
else{
try {
throw new Exception("除数不能为0");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//System.out.println("除数不能为0！");
//System.out.println("以下结果是错误的!");
}
return result;
}
}
测试结果：
请输入数字A :
8
请输入操作符（+,-,*,/）：
/
请输入数字B :
3
输出结果为：2.6666666666666665
请输入数字A :
8
请输入操作符（+,-,*,/）：
/
请输入数字B :
0
java.lang.Exception: 除数不能为0
输出结果为：0.0
at operation.NumberDiv.getResult(NumberDiv.java:16)
at operation.Program.main(Program.java:24)
五，你可能说这么多个类更麻烦，
其实不然，这样更简洁，只需在子类中修改，而且不容易犯错，