JDK_实例（自定义形状类）

长方形

package book.oo;

public class PassParamter {

	public PassParamter() {
	}

	public void methodA(ComplexNumber comNum) {
		// comNum这个引用指向了一个新new出来的对象。
		comNum = new ComplexNumber(1, 2);
	}

	public void methodB(ComplexNumber comNum) {
		// comNum这个引用指向的还是同一个对象，但是，这里修改该对象的值。
		comNum.setRealPart(1);
		comNum.setRealPart(2);
	}

	public void methodC(int num) {
		// 将num的值加1
		num++;
	}

	public static void main(String[] args) {

		PassParamter test = new PassParamter();
		ComplexNumber comNum = new ComplexNumber(5, 5);
		System.out.println("调用methodA方法之前，comNum: " + comNum.toString());
		test.methodA(comNum);
		System.out.println("调用methodA方法之后，comNum: " + comNum.toString());
		System.out.println("调用methodB方法之前，comNum: " + comNum.toString());
		test.methodB(comNum);
		System.out.println("调用methodB方法之后，comNum: " + comNum.toString());
		int num = 0;
		System.out.println("调用methodC方法之前，num: " + num);
		test.methodC(num);
		System.out.println("调用methodC方法之后，num: " + num);

//		 调用methodA方法之前，comNum: 5.0 + 5.0i
//		 调用methodA方法之后，comNum: 5.0 + 5.0i
//		 调用methodB方法之前，comNum: 5.0 + 5.0i
//		 调用methodB方法之后，comNum: 2.0 + 5.0i
//		 调用methodC方法之前，num: 0
//		 调用methodC方法之后，num: 0

		/**
		 * Java的参数传递策略：
		 * 0，所谓传值的意思是：在调用方法时，将参数的值复制一份，方法里面用复件，方法外面用原件，复件改变了，不影响原件；原件改变了，不影响复件。
		 * 1，对于基本数据类型，比如int，long等类型，采用传值的策略。将参数的值复制一份后传给方法，方法可以改变参数值的复件，但不会改变参数值的原件。
		 * 2，对于对象类型，也采用的传值策略，不过，是将参数的引用复制（2个引用指向同一个对象）一份传给方法，方法可以改变参数引用的复件，但不会改变参数引用的原件。
		 * 
		 * 解释三个输出：
		 * 1，调用methodA方法时，首先将comNum对象的引用复制一份，将引用的复件传递给methodA方法，main方法保持引用的原件，此时，引用原件和引用复件都指向comNum对象。
		 * 执行comNum = new ComplexNumber(1,2);语句后，将引用复件指向了另外一个新的对象，此时，引用复件和引用原件指向的是不同的对象。回到main方法时，操作的仍然是引用原件指向的comNum对象。
		 * 2，调用methodB方法时，首先将comNum对象的引用复制一份，将引用的复件传递给methodB方法，main方法保持引用的原件，此时，有引用原件和引用复件都指向comNum对象。
		 * 执行comNum.setRealPart(1);comNum.setRealPart(2);语句后，修改了引用复件所指对象的内容，而此时，引用复件和引用原件指向的是同一个对象，因此，引用原件指向的对象的内容也改变了。回到main方法时，comNum对象也改变了。
		 * 3，调用methodC方法时，首先将num的值复制一份，将值的复件传递给methodC方法，main方法保持值的原件。 执行num
		 * ++;语句后，复件的值会加1。回到main方法时，操作的仍然是原件，值保持不变。
		 */

	}
}

 

三角形

package book.oo.shape;

/**
 * 三角形
 */
public class Triangle extends MyShape{

	//边a的长度
	private double sideA;
	//边b的长度
	private double sideB;
	//边c的长度
	private double sideC;
	//边长错误
	public static final String SIDEERR = "三角形的边长不能够小于0！";
	//不能构成三角形错误
	public static final String SHAPEERR = "三角形的二边之和必须大于第三边！";
	/**
	 *默认构造函数
	 */
	public Triangle(){
		init();
	}
	/**
	 * 用三条边构造一个三角形
	 * @param a	边a的边长
	 * @param b 边b的边长
	 * @param c 边c的边长
	 */
	public Triangle(double a, double b, double c){
		//如果给定的三条边能够组成三角形，便用给定的边长构成三角形
		if (isTrianglelegal(a, b, c)){
			this.sideA = a;
			this.sideB = b;
			this.sideC = c;
		} else {
			//否则，用默认值构造三角形
			init();
		}
	}
	/**
	 * 缺省的三角形
	 */
	private void init(){
		this.sideA = 3;
		this.sideB = 4;
		this.sideC = 5;
	}
	/**
	 * 判断三条边是否能够组成一个三角形
	 * @param a 边a的边长
	 * @param b 边b的边长
	 * @param c 边c的边长
	 * @return 布尔类型，如果能够组成三角形，便返回true，否则返回false
	 */
	private boolean isTrianglelegal(double a, double b, double c){
		//三条边的长度必须大于0
		if ((a <= 0) || (a <= 0) || (a <= 0)){
			System.err.println(SIDEERR);
			return false;
		} else if ((a + b < c) || (a + c < b) || (b + c < a)){
			//两边之和必须大于第三边
			System.err.println(SHAPEERR);
			return false;
		}
		return true;
	}
	public double getGirth() {
		return this.sideA + this.sideB + this.sideC;
	}
	public double getArea() {
		//根据海伦公式计算三角形的面积
		double s = (this.sideA + this.sideB + this.sideC) / 2;
		//利用Math.sqrt()方法进行开方运算
		return Math.sqrt(s * (s - this.sideA) * (s - this.sideB) * (s - this.sideC));
	}
	public String toString() {
		return "三角形的名字是：" + this.name + ", 它的三条边的边长分别是：" 
				+ this.sideA + ", " + this.sideB + ", " + this.sideC;
	}
	public double getSideA() {
		return sideA;
	}
	public void setSideA(double sideA) {
		//在设置边长的时候，依然要检测采用新的边长后，是否能够组成三角形。
		if (this.isTrianglelegal(sideA, this.sideB, this.sideC)){
			this.sideA = sideA;
		} 
	}
	public double getSideB() {
		return sideB;
	}
	public void setSideB(double sideB) {
		if (this.isTrianglelegal(this.sideA, sideB, this.sideC)){
			this.sideB = sideB;
		}
	}
	public double getSideC() {
		return sideC;
	}
	public void setSideC(double sideC) {
		if (this.isTrianglelegal(this.sideA, this.sideB, sideC)){
			this.sideC = sideC;
		}
	}
	public static void main(String[] args) {
		Triangle test = new Triangle();
		test.setName("myTriangle");
		System.out.println(test.toString());
		System.out.println("三角形的周长是：" + test.getGirth());
		System.out.println("三角形的面积是：" + test.getArea());
	}
}

 

 

自定义图形

package book.oo.shape;
/**
 * 自定义图形的基类
 */
public abstract class MyShape {
	/**图形的名字*/
	protected String name; //protected访问控制符表示只有本类和子类能够访问该属性。
	/**
	 * 抽象方法，获取形状的周长
	 */
	public abstract double getGirth();
	/**
	 * 抽象方法，获取形状的面积
	 */
	public abstract double getArea();
	/**
	 * 抽象方法，输出形状
	 */
	public abstract String toString();
	/**
	 * 获取图形的名字
	 * @return 返回图形的名字
	 */	
	public String getName(){
		return this.name;
	}
	/**
	 * 为图形设置名字
	 * @param name	要设置的图形的名字
	 */
	public void setName(String name){
		this.name = name;
	}
}