java之继承，封装，多肽

最新推荐文章于 2024-05-14 09:55:25 发布

Android开始之路

最新推荐文章于 2024-05-14 09:55:25 发布

阅读量3.6k

点赞数 4

分类专栏： java 文章标签：多肽继承封装

本文链接：https://blog.csdn.net/qq_28055429/article/details/51170401

版权

java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

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

一，封装

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

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

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

如：

主类：

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;
/**
 * 加法类，继承父类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;
	}
}

/**
 * 乘法类，继承父类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)

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

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

Android开始之路

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
java之继承，封装，多肽

一，封装理解：把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能的隐藏对象内部实现细节例如：我们写一个简单的输入两个数和一个操作符（+，-，*，/)的的运算，可以把具体操作和属性封装成一个类如：主类：package operation;import java.util.Scanner;public class Program { public st
复制链接

扫一扫