JAVA范例 九）面向对象---面向对象的四大特征

　　9.1 抽象

　　实例162 求自定义几何图形的面积和周长

package Chapter09.Abstract;
public class AbstractDemo_01 {
	public static void main(String[] args) {
		System.out.println("1.获得等边三角形的面积与周长");
		Equilateraltriangle triangle = new Equilateraltriangle(10, 5); 	// 创建等边三角形对象实例
		System.out.println("圆的面积:" + triangle.getArea());
		System.out.println("圆的周长：" + triangle.getPerimeter());
		System.out.println("2.获得长方形的面积与周长");
		Rectangle rectangle = new Rectangle(12, 8); 				// 创建长方形对象实例
		System.out.println("圆的面积:" + rectangle.getArea());
		System.out.println("圆的周长：" + rectangle.getPerimeter());
		System.out.println("3.获得圆的面积与周长");
		Circle circle = new Circle(5.5f); 						// 创建圆对象实例
		System.out.println("圆的面积:" + circle.getArea());
		System.out.println("圆的周长：" + circle.getPerimeter());
	}
}
abstract class Geometry {			// 定义抽象几何图形类
	abstract float getArea(); 		// 抽象构造方法求面积
	abstract float getPerimeter(); 	// 抽象构造方法求周长
}
class Equilateraltriangle extends Geometry { 		// 继承Geometry求等边三角形的面积和周长
	float width;
	float height;
	Equilateraltriangle(float width, float height) {	// 带参数的构造方法
		this.width = width;
		this.height = height;
	}
	float getArea() {							// 实现父类抽象方法求等边三角形的面积
		return (width * height) / 2;
	}
	float getPerimeter() {						// 实现父类抽象方法求等边三角形的周长
		return width * 3;
	}
}
class Rectangle extends Geometry { 			// 继承Geometry求长方形的面积和周长
	float width;
	float height;
	Rectangle(float width, float height) { 			// 带参数的构造方法
		this.width = width;
		this.height = height;
	}
	float getArea() { 						// 实现父类抽象方法求长方形的面积
		return width * height;
	}
	float getPerimeter() { 					// 实现父类抽象方法求长方形的周长
		return 2 * (width * height);
	}
}
class Circle extends Geometry { 				// 继承Geometry，求圆的面积和周长
	float radius;
	Circle(float number) { 					// 带参数的构造方法
		radius = number;
	}
	protected float getArea() { 				// 实现父类抽象方法求圆的面积
		return 3.14f * radius * radius;
	}
	protected float getPerimeter() { 			// 实现父类抽象方法求圆的周长
		return 2 * 3.14f * radius;
	}
}

 

　　实例163 使用抽象方法实现的支票夹

package Chapter09.Abstract;

import java.util.Scanner;

public class AbstractDemo_02 {
	private static CheckBook checkbook = null;
	//@param 使用抽象方法实现的支票夹
	public static void main(String[] args) {		// 程序的主入口
		Scanner sc = new Scanner(System.in);
		System.out.print("正在创建支票，请输入所剩金额： $");
		checkbook = new CheckBook(sc.nextDouble());
		String choice = showMenu();
		while (!choice.equalsIgnoreCase("X")) {		// 在没有退出程序的前提下
			if (choice.equalsIgnoreCase("C"))		// 如果选C则录入支出详细
				checkbook.add(new Check());
			else if (choice.equalsIgnoreCase("D"))	// 如果选D则录入存入详细
				checkbook.add(new Deposit());
			else if (choice.equalsIgnoreCase("L"))	// 如果选L则显示操作列表
				checkbook.list();
			choice = showMenu();
		}
	}
	public static String showMenu() {				// 操作提示列表
		System.out.println("\n\t\t <C>  填写支出金额的数目和支出说明");
		System.out.println("\t\t <D>  填写存入金额的数目和存入说明");
		System.out.println("\t\t <L>  显示操作列表和余额");
		System.out.println("\t\t <X>  退出");
		System.out.print("\n\t请输入你的选择项:");
		Scanner sc = new Scanner(System.in);
		return sc.nextLine();
	}
}
// 事物类
abstract class Transation {
	protected String descript;	// 说明
	protected String type;	// 类型 ，如支出、存入等
	protected double amount;// 金额数目
	public abstract double getAmount();	// 抽象方法，获取
	public void showTransaction() {		// 显示事物的内容
		System.out
				.println("[ " + type + " ]\t" + getAmount() + "\t" + descript);
	}
	protected void getOperationType(String _type) {// 根据操作类型来录入操作说明和金额数目
		type = _type.equals("Check") ? "支出" : "存入";
		System.out.print("\n=> 请输入" + type + "说明：");
		Scanner sc = new Scanner(System.in);
		descript = sc.nextLine();
		System.out.print("=> 请输入金额: $");
		Scanner sc1 = new Scanner(System.in);
		amount = sc1.nextDouble();
	}
}
// Deposit类来存储存入的金额的数目和存入说明
class Deposit extends Transation {
	public Deposit() {			// 在自身的构造方法中调用父类的getDataPor方法
		getOperationType("Deposit");
	}
	public double getAmount() {	// 实现父类的抽象方法getAmount()
		return amount;
	}
}
// Check类来存储支出的金额的数目和支出说明
class Check extends Transation {
	public Check() {			// 在自身的构造方法中调用父类的getDataPor方法
		getOperationType("Check");
	}
	public double getAmount() {	// 实现父类的抽象方法getAmount()
		return amount;
	}
}
// Adjustment类做支出和存入之间差额调整
class Adjustment extends Transation {
	public Adjustment(String _descript, double _amount) {	// 通过构造方法接收余额和说明
		type = "资金调整";
		descript = _descript;
		amount = _amount;
	}
	public double getAmount() {						// 实现父类的抽象方法getAmount()
		return amount;
	}
}
class CheckBook {
	private final static int MAX_TRANSACTIONS = 500;		// 设置能够存储的最大事物数
	private Transation transactiors[] = new Transation[MAX_TRANSACTIONS];// 创建事物对象数组
	private double balance = 0;		// 总金额
	private int numTransactions = 0;	// 标识事物存储的位置
	public CheckBook(double startBalance) {
		add(new Adjustment("剩余金额", startBalance));
	}
	public void add(Transation aTransaction) {// 获取各事物的金额的总数
		if (numTransactions < MAX_TRANSACTIONS) {
			transactiors[numTransactions] = aTransaction;
			balance += aTransaction.getAmount();
			numTransactions++;
		} else
			System.out.println("\nMaximum number of transactions reached\n");
	}
	public void showCheckBook() {// 显示支票的操作结果
		System.out.println("\n=> 事物的比数:\t" + numTransactions);
		System.out.println("=> 金额:\t" + balance + "\n");
	}
	public void list() {// 显示支票列表
		showCheckBook();
		for (int i = 0; i < numTransactions; i++) {
			transactiors[i].showTransaction();
		}
	}
}

 

　　9.2 封装

　　实例164 世界小姐参赛资格

import java.util.ArrayList;

public class PackageDemo_02 {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();							// 定义一个集合列表
		Person person1 = new Person("张三","女", 27, "中华人民共和国", false,"高中");		// 创建Person对象
		list.add(person1);									// 将Person对象添加到列表中
		Person person2 = new Person("李克","男", 22, "中华人民共和国", false,"初中");
		list.add(person2);
		Person person3 = new Person("孙小清","女", 19, "加拿大", true,"本科");
		list.add(person3);
		Person person4 = new Person("王叶叶","女", 22, "中华人民共和国", false,"大专");
		list.add(person4);
		System.out.println("2009美丽世界小姐北京大赛报名会现在开始！！");
		System.out.println("请报名者入场～～～");
		for (int i = 0; i < list.size(); i++) {
			int n = 0;
			Person p = (Person) list.get(i);
			System.out.println("第" + (i + 1) + "位报名者" + p.getName()
					+ "的基本信息如下：");
			System.out.println("姓名：" + p.getName());
			System.out.println("性别：" + p.getGender());
			System.out.println("年龄：" + p.getAge());
			System.out.println("国籍：" + p.getCountry());
			System.out.print("婚姻状况：" );
			System.out.println(p.isMarital()?"已婚":"未婚");
			System.out.println("学历：" + p.getEducation());
			if (p.isAge())
				n = n + 1;
			if (p.Education())
				n = n + 1;
			if (p.Behavior())
				n = n + 1;
			if (n == 3)
				p.setElected(true);
		}
		System.out.println("最后的报名结果如下：");
		for (int i = 0; i < list.size(); i++) {
			Person p = (Person) list.get(i);
			if (p.isElected()) {
				System.out.println("恭喜！"+p.getName() + ",可以参加世界小姐大赛！");
			}
		}
	}
}
class Person { 					// 定义人类
	private String name; 		// 人的姓名
	private int age; 			// 人的年龄
	private boolean marital;     //婚姻状况
	private String gender;      //性别
	private String country; 		// 国籍
	private String education; 		// 学历
	private boolean elected = false;// 标志是否当选
	public boolean isElected() {
		return elected;
	}
	public void setElected(boolean elected) {
		this.elected = elected;
	}
	public Person() {
	} // 默认构造方法
	public Person(String name, String gender,int age, String country, boolean marital,String education) { // 带参数的构造方法
		this.name = name;
		this.age = age;
		this.country = country;
		this.education = education;
		this.gender = gender;
		this.marital = marital;
	}
	// 对Person类中定义的属性进行封装
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getEducation() {
		return education;
	}
	public void setEducation(String education) {
		this.education = education;
	}
	public boolean isAge() { // 判断年龄是否在25周岁以下，16周岁以上，且未婚未育
		if (this.getAge() >= 16&&this.getAge() <= 25&&this.marital==false) {
			return true;
		}else if((this.getAge() >= 25||this.getAge() <= 16)&&this.marital==false){
			System.out.println("参赛者的年龄在25周岁以下，16周岁以上，所以"+name + "你的年龄不符合参赛的条件");
			return false;
		}else if (this.getAge() >= 16&&this.getAge() <= 25&&this.marital==true){
			System.out.println("参赛者要求是未婚，所以"+name + "你不符合参赛的条件");
			return false;
		}
		System.out.println("参赛者的年龄在25周岁以下，16周岁以上，且未婚未育。所以"+name + "你不符合参赛的条件");
		return false;
	}
	public boolean Education() { 	// 判断学历是否为中专以上
		if (this.education.endsWith("初中")||this.education.endsWith("小学")||this.education.endsWith("无")) {
			System.out.println("参赛者需中专以上文化程度，所以"+name + "你不符合参赛的条件");
			return false;
		}
		
		return true;
	}
	public boolean Behavior() { // 判断是否是中华人民共和国女性公民
		if (this.country.equals("中华人民共和国")&&this.gender.endsWith("女")) {
						return true;
		}else if (this.country.equals("中华人民共和国")&&!this.gender.endsWith("女")){
			System.out.println("世界小姐只允许女性参加，所以很抱歉，"+name + "你不符合参赛的条件");
			return false;
		}else if (!this.country.equals("中华人民共和国")&&this.gender.endsWith("女")){
			System.out.println("很抱歉,本届世界小姐只允许中华人民共和国公民参加，所以"+name + "你不符合参赛的条件");
			return false;
		}
		System.out.println( "参赛者须是中华人民共和国女性公民，所以"+name+"你不符合参赛的条件");
		return false;
	}
	public String getCountry() {
		return country;
	}
	public void setCountry(String country) {
		this.country = country;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public boolean isMarital() {
		return marital;
	}
	public void setMarital(boolean marital) {
		this.marital = marital;
	}
}

 

　　实例165 自定义复数类

package Chapter09.Abstract;
public class Plural {
	private double realPart; 		// 复数的实部
	private double imaginaryPart; 	// 复数的虚部
	public Plural() {
		this.realPart = 0.0;
		this.imaginaryPart = 0.0;
	}
	// 带参的构造方法，为实部和虚部赋值，其中：x表示实部，y表示虚部
	public Plural(double x, double y) {
		this.realPart = x;
		this.imaginaryPart = y;
	}
	// 复数的加法运算并返回一个Plural对象
	public Plural add(Plural plural) {
		if (plural == null) {
			System.err.println("对象不能够为null！");
			return new Plural();
		}
		return new Plural(this.realPart + plural.getRealPart(),
				this.imaginaryPart + plural.getImaginaryPart());
	}
	// 复数的减法运算并返回一个Plural对象
	public Plural substruction(Plural plural) {
		if (plural == null) {
			System.err.println("对象不能够为null！");
			return new Plural();
		}
		return new Plural(this.realPart - plural.getRealPart(),
				this.imaginaryPart - plural.getImaginaryPart());
	}
	// 复数的乘法运算并返回一个Plural对象
	public Plural multiplication(Plural plural) {
		if (plural == null) {
			System.err.println("对象不能够为null！");
			return new Plural();
		}
		double newReal = this.realPart * plural.realPart - this.imaginaryPart
				* plural.imaginaryPart;
		double newImaginary = this.realPart * plural.imaginaryPart
				+ this.imaginaryPart * plural.realPart;
		Plural result = new Plural(newReal, newImaginary);
		return result;
	}
	// 复数的除法运算并返回一个Plural对象
	public Plural division(Plural plural) {
		if (plural == null) {
			System.err.println("对象不能够为null！");
			return new Plural();
		}
		if ((plural.getRealPart() == 0) && (plural.getImaginaryPart() == 0)) {
			System.err.println("除数不能够为0！");
			return new Plural();
		}
		double temp = plural.getRealPart() * plural.getRealPart()
				+ plural.getImaginaryPart() * plural.getImaginaryPart();
		double crealpart = (this.realPart * plural.getRealPart() + this.imaginaryPart
				* plural.getImaginaryPart())
				/ temp;
		double cimaginaryPart = (this.imaginaryPart * plural.getRealPart() - this.realPart
				* plural.getImaginaryPart())
				/ temp;
		return new Plural(crealpart, cimaginaryPart);
	}
	// 复数用字符串的形式表示
	public String toString() {
		return this.realPart + " + " + this.imaginaryPart + "i";
	}
	// 以下方法是对realPart和imaginaryPart变量进行了封装
	// 获取复数的虚部
	public double getImaginaryPart() {
		return imaginaryPart;
	}
	// 设置复数的虚部
	public void setImaginaryPart(double imaginaryPart) {
		this.imaginaryPart = imaginaryPart;
	}
	// 获取复数的实部
	public double getRealPart() {
		return realPart;
	}
	// 设置复数的实部
	public void setRealPart(double realPart) {
		this.realPart = realPart;
	}
	public static void main(String[] args) {
		Plural x = new Plural(2, 4);
		Plural y = new Plural(1, 2);
		System.out.println("复数 x的值为: " + x.toString());
		System.out.println("复数 y的值为: " + y.toString());
		System.out.println("(x + y) = " + x.add(y).toString());
		System.out.println("(x - y) = " + x.substruction(y).toString());
		System.out.println("(x * y) = " + x.multiplication(y).toString());
		System.out.println("(x / y) = " + x.division(y).toString());
	}
}

 

　　9.3 继承

　　实例166 轿车与本田的关系

package Chapter09.Inheritance;
public class CarTest {
	public static void main(String[] args) {
		Car1 c = new Car1();// 利用无参构造方法创建第一个Car1对象
		System.out.println("第一辆车的详细信息如下:");
		System.out.println("生产厂家：" + c.produce);// 调用Car1的produce属性
		c.showColor();		// 调用其父类Car的showColor方法
		c.showModel();		// 调用其父类Car的showModel方法
		Car1 c1 = new Car1("银白色");
		System.out.println("\n第二辆车的详细信息如下:");
		System.out.println("生产厂家：" + c1.produce);
		c1.showColor();
		c1.showModel();
		Car1 c2 = new Car1("蓝色", "卡车", "天津一汽");
		System.out.println("\n第三辆车的详细信息如下:");
		System.out.println("生产厂家：" + c2.produce);
		c2.showColor();
		c2.showModel();
	}
}
class Car {// 父类
	String color;	// 颜色属性
	String model;	// 车的类型
	public Car() {	// 无参构造方法，为其两个属性赋值
		this.color = "红色";
		this.model = "轿车";
	}
	public Car(String color, String model) {// 带有两个参数的构造方法
		this.color = color;
		this.model = model;
	}
	public void showColor() {// 显示车的颜色
		System.out.println("车的颜色：" + this.color);
	}
	public void showModel() {// 显示车的类型
		System.out.println("车的类型：" + this.model);
	}
}
class Car1 extends Car {		// 子类继承父类
	String produce;			// 生产厂家
	Car1(String color, String model, String produce) {// 带有三个参数的构造方法
		super(color, model);// 调用父类的构造方法
		this.produce = produce;
	}
	Car1(String color) {		// 带有一个参数的构造方法
		this.color = color;
		this.produce = "广洲本田";
	}
	Car1() {				// 无参构造方法
		this("黑色");
	}
}

 

　　实例167 继承关系的加载顺序

package Chapter09.Inheritance;
public class LoadClass {// 测试类
	public static void main(String[] args) {
		System.out.println("不创建对象直接访问静态方法时的输出：");
		Child.childMethod();
		System.out.println();
		System.out.println("通过new创建对象，访问非静态方法时的输出：");
		new Child("").display();
		// 通知虚拟机进行垃圾回收
		System.gc();
	}
}
class Parent {// 父类
	private int x = 15;
	private static int y = getValue(20);
	{
		System.out.println("执行Parent的初始化代码块");
		int x = 70;
		int y = getValue(30);
	}
	static {
		System.out.println("执行Parent的静态初始化代码块");
		int sx = 70;
		int sy = getValue(30);
	}
	public Parent() {
		System.out.println("Parent默认的构造方法被调用");
	}
	public void display() {
		System.out.println("Parent的display方法被调用");
		System.out.print("x=" + this.x);
		System.out.println("; y=" + y);
		parentMethod();
	}
	public static void parentMethod() {
		System.out.println("Parent的parentMethod()被调用");
	}
	public static int getValue(int num) {
		System.out.println("Parent的getValue(int num)被调用");
		return ++num;
	}
	// 当Java在进行垃圾回收时，会自动的调用对象的finalize方法
	protected void finalize() {
		System.out.println("Parent对象被垃圾收回器收回");
	}
}
class Child extends Parent {// 子类
	{
		System.out.println("执行Child的初始化代码块");
		int z = 30;
	}
	static {
		System.out.println("执行Child的静态初始化代码块");
	}
	public Child() {
		super();
		System.out.println("Child的构造方法被调用");
	}
	public Child(String str) {
		System.out.println("Child带参的构造方法被调用");
	}
	public static void childMethod() {
		System.out.println("Child的childMethod()被调用");
	}
	// 当Java在进行垃圾回收时，会自动的调用对象的finalize方法
	protected void finalize() {
		System.out.println("Child对象被垃圾收回器收回");
		super.finalize();
	}
}

 

　　实例168 如何访问同名的方法或变量

package Chapter09.Inheritance;
public class AccessMethod {
	public static void main(String[] args) {
		// 先测试继承时变量的覆盖与隐藏问题
		System.out.println("在继承关系中，同名变量的覆盖与隐藏的执行内容如下：");
		ChildClass child = new ChildClass();
		System.out.println("创建了ChildClass对象，ChildClass的属性信息如下：");
		System.out.println("name: " + child.name + "; age: " + child.age
				+ "; kind: " + child.classvar);// 此时得到的都是ChildClass类的变量值
		// 将ChildClass类型转换成ParentClass对象，
		ParentClass parent = child;
		System.out.println("将创建的ChildClass对象赋值给ParentClass对象，其属性信息如下：");
		System.out.println("name: " + parent.name + "; age: " + parent.age
				+ "; kind: " + parent.classvar);// 此时得到的都是ParentClass类的变量值
		System.out.println("子类可以访问父类被隐藏的实例变量 name：" + child.getParentName());
		System.out.println("子类可以访问父类被隐藏的实例变量 age：" + child.getParentAge());
		System.out.println("子类可以访问父类被隐藏的静态变量 kind："
				+ ChildClass.getParentKind());
		System.out.println();
		// 再测试继承时方法的覆盖与隐藏问题
		System.out.println("在继承关系中，同名方法的覆盖与隐藏的执行内容如下：");
		child.getName();	// 实例方法
		child.getClassVar();	// 静态方法
		parent.getName();	// 实例方法
		parent.getClassVar();// 静态方法
	}
}
class ParentClass {
	public static String classvar = "Chapter09.Inheritance.ParentClass"; // 类变量，ParentClass的类别
	public static int age = 50; 			// 类变量，ParentClass的年龄
	public String name = "ParentClass"; // 实例变量，ParentClass的名字
	// 静态方法，获取ParentClass的类别 */
	public static String getClassVar() {
	// 静态方法中操作的只能是类变量
		System.out.println("ParentClass的getClassVar()方法被调用了！");
		return classvar;
	}
	// 静态方法，获取ParentClass的年龄 */
	public static int getAge() {
		System.out.println("ParentClass的getAge()方法被调用了！");
		return age;
	}
	// 实例方法，获取ParentClass的名字 */
	public String getName() {
		// 实例方法中操作的可以是实例变量，也可以是类变量
		System.out.println("ParentClass的getName()方法被调用了！");
		return this.name;
	}
	// final方法，将ParentClass的减1
	public final int getPreviousAage() {
		System.out.println("ParentClass的getPreviousAage()方法被调用了！");
		return --age;
	}
}
class ChildClass extends ParentClass {
	public static String classvar = "Chapter09.Inheritance.ChildClass"; // 类变量，Child的类别
	public int age = 25;// 实例变量，ChildClass的年龄，在ParentClass类中是static的。
	public String name = "ChildClass"; // 实例变量，ChildClass的名字
	// 静态方法，获取ChildClass的类别
	public static String getClassVar() {
		System.out.println("ChildClass的getClassVar()方法被调用了！");
		return classvar;
package Chapter09.Inheritance;
public class UseSuper {
	public static void main(String[] args) {
		// 分别用不同的4种方法创建State类对象
		State sta1 = new State("张三", '男', 22, "中国");
		State sta2 = new State("琶拉?¤凡?¤连根", '女', 41, "印度");
		State sta3 = new State();
		State sta4 = new State(sta1);
		// 分别调用State类的属性和其父类Person的showMessage方法
		System.out.print("显示第一个人的基本信息：");
		sta1.showMessage();
		System.out.println("此人的国籍是:" + sta1.name);
		System.out.print("\n显示第二个人的基本信息：");
		sta2.showMessage();
		System.out.println("此人的国籍是:" + sta2.name);
		System.out.print("\n显示第三个人的基本信息：：");
		sta3.showMessage();
		System.out.println("此人的国籍是:" + sta3.name);
		System.out.print("\n显示第四个人的基本信息：");
		sta4.showMessage();
		System.out.println("此人的国籍是:" + sta4.name);
	}
}
class Person {
	public String name;	// 姓名
	public char sex;		// 性别
	public int age;		// 年龄
	// 设置默认值
	Person() {
		name = "尹继平";
		sex = '女';
		age = 26;
	}
	// 对象作为构造方法的参数
	Person(Person p) {
		name = p.name;
		sex = p.sex;
		age = p.age;
	}
	// 指定值初始化对象
	Person(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}
	// 输出person的基本信息
	public void showMessage() {
		System.out.println("姓名： " + name + "\n性别： " + sex + "\n年龄： " + age);
	}
}
// 实现所有超类的构造方法
class State extends Person {
	public String name;	// 国家的名字
					// 设置默认值
	State() {
		super();
		name = "中国";
	}
	// 对象作为构造方法的参数
	State(State ch) {
		super(ch);
		super.name = "罗卜特?¤波伊尔";
		this.name = "英国";
	}
	// 指定值初始化类Chinese的对象
	State(String n, char s, int a, String na) {
		super(n, s, a);
		name = na;
	}
}

 	}
	// 静态方法，获取父类的名字
	public static String getParentKind() {
	// 通过类名加"."访问父类中被隐藏的类变量
		return ParentClass.classvar;
	}
	// 实例方法，获取ChildClass的名字
	public String getName() {
		System.out.println("ChildClass的getName()方法被调用了！");
		return this.name;
	}
	// 实例方法，获取父类的名字
	public String getParentName() {
	// 通过super关键字父类中被隐藏的实例变量
		return super.name;
	}
	// 实例方法，获取父类的姓名
	public String getParentAge() {
	// 通过super关键字父类中被隐藏的实例变量
		return super.name;
	}
}

 

　　实例169 super()方法的使用

　　实例170 this方法的使用

package Chapter09.Inheritance;
public class UseThis {
	public static void main(String[] args) {
		Film f = new Film();
		System.out.println("欢迎收看\"佳片有约\"栏目,今天为您推荐的影片如下：");
		// 获取Film类中的所有属性值
		System.out.println("片名：" + f.title);
		System.out.println("导演：" + f.director);
		System.out.println("主演：" + f.star);
		System.out.println("上映日期：" + f.showDate);
	}
}
class Film {
	String title;		// 片名
	String director;		// 导演
	String star;		// 主演
	String showDate;	// 上映的时间
	// 以下实现了该类的构造方法的重写
	Film() {
		this("2009年6月26日");// 调用本身
	}
	Film(String showDate) {
		this("《变形金刚2：卷土重来》", "迈克尔.贝", "希亚.拉博夫");
		this.showDate = showDate;
	}
	Film(String title, String director) {
		this.title = title;
		this.director = director;
	}
	Film(String title, String director, String star) {
		this(title, director);
		this.star = star;
	}
}

 

　　实例171 一张考试成绩单

package Chapter09.Inheritance;
public class ReportCard {
	public static void main(String[] args) {
		// 创建StudentAchievement对象
		StudentAchievement sa = new StudentAchievement("张三", "三年一班");
		sa.print();// 调用自身的print方法
		// 调用父类的Subject_Score方法
		sa.Subject_Score("代数", "英语", "语文", "政治");
		sa.Subject_Score(80.5, 78.5, 88, 91);
		// 调用父类的getRemark方法
		sa
				.getRemark("该生在学表现积极，能够认真对待老师分配的任务，积极配合老师的工作\n但是该生的基本知识不牢固，希望家长能多注意一下补习基本知识。");
		System.out.println("各科成绩如下：");
		// 调用父类的成员变量
		System.out.println(sa.sub1 + ":" + sa.s1 + "\n" + sa.sub2 + ":" + sa.s2
				+ "\n" + sa.sub3 + ":" + sa.s3 + "\n" + sa.sub4 + ":" + sa.s4);
		System.out.println("总成绩为：" + sa.getSum());		// 调用父类的getSum方法
		System.out.println("平均成绩为：" + sa.getAverage());	// 调用父类的getAverage方法
		System.out.println("老师的评语为：" + sa.review);		// 调用父类的review变量
	}
}
class Subject_Score {			// 父类
	String name;				// 姓名
	String classroom;			// 班级
	String sub1, sub2, sub3, sub4;	// 各学科的科目名称
	double s1, s2, s3, s4;		// 各学科的分数
	String review;				// 老师的评语
	Subject_Score(String name, String classroom) {// Subject_Score类的构造方法，为name和classroom赋值
		this.name = name;
		this.classroom = classroom;
	}
	void Subject_Score(String sub1, String sub2, String sub3, String sub4) {// Subject_Score方法为各学科的科目名称赋值
		this.sub3 = sub3;
		this.sub2 = sub2;
		this.sub1 = sub1;
		this.sub4 = sub4;
	}
	void Subject_Score(double s1, double s2, double s3, double s4) {// Subject_Score方法为各学科的分数赋值
		this.s1 = s1;
		this.s2 = s2;
		this.s3 = s3;
		this.s4 = s4;
	}
	public double getSum() {				// 求总成绩
		double sum = this.s1 + this.s2 + this.s3 + this.s4;
		return Math.rint(sum);
	}
	public double getAverage() {			// 求平均成绩
		double sum = this.getSum();
		double avg = sum / 4;
		return Math.rint(avg);
	}
	public String getRemark(String review) {	// 设置评语
		this.review = review;
		return review;
	}
}
class StudentAchievement extends Subject_Score {			// 子类
	StudentAchievement(String name, String classroom) {	// 继承父类的构造方法
		super(name, classroom);
	}
	public void print() {								// 子类自定义方法
		System.out.println(name + "的期末考试成绩单如下：");
	}
}

 

　　实例172 银行自动存取一体机

package Chapter09.Inheritance.card;
//普通用户的功能实现
public class Common_Card {
	String name;	// 账户名
	int ID;		// 账户ID
	int password;	// 密码
	int money;		// 金额
	Common_Card(String name, int ID, int password, int money) {// 构造方法
		this.name = name;
		this.ID = ID;
		this.password = password;
		this.money = money;
	}
	boolean CheckMoney(int m) {// 取款操作
		System.out.println("正在操作，请稍候……！");
		if (m < 0) {
			if (saveMoney(-m)) {
				return true;
			}
			else
				return false;
		} else {
			if (m > money) {
				System.out.println("［?á］：该账户不可透支,本次操作中断！");
				return false;
			}
			this.money -= m;
			System.out.println("［√］：操作成功");
			return true;
		}
	}
	boolean saveMoney(int m) {// 存款操作
		System.out.println("正在验钞，请稍候……！");
		if (m < 0) {
			if (CheckMoney(-m))
				return true;
			else
				return false;
		} else {
			this.money += m;
			System.out.println("［√］：操作成功");
			return true;
		}
	}
	void search() {				// 显示余额操作
		System.out.println(name + "［ID:" + ID + "］ 余额:" + money + "元");
	}
	boolean checkpassword() {	// 检察密码操作
		int i;
		for (i = 0; i < 3; i++) {
			if (i > 0)
				System.out.println("［?á］：密码错误，请输入密码：");
			int pw = EnterAmountOfMoney.scanInt();
			if (pw == password)
				return true;
		}
		if (i == 3)
			System.out.println("［?á］：密码输入出错3次，操作中断！");
		return false;
	}
	void operating(Common_Card st[]) {// 正在执行所选择的项目
		while (true) {
			this.printReceipt();
			int cmd = EnterAmountOfMoney.scanInt();
			switch (cmd) {
			case 1: {
				System.out.println("请输入存款数：");
				int m = EnterAmountOfMoney.scanInt();
				saveMoney(m);
				break;
			}
			case 2: {
				System.out.println("请输入取款数：");
				int m = EnterAmountOfMoney.scanInt();
				CheckMoney(m);
				break;
			}
			case 3:
				search();
				break;
			case 0:
				Machine.end = 0;
				return;
			}
		}
	}
	static void printReceipt() {// 功能提示界面
		System.out.println("我爱我家自动提款机普通用户操作界面");
		System.out.println("——————");
		System.out.println("［存款——1］");
		System.out.println("［取款——2］");
		System.out.println("［余额——3］");
		System.out.println("［退卡——0］");
		System.out.println("——————");
	}
}

 

package Chapter09.Inheritance.card;
//vip用户的功能实现
// vip用户继承了普通用户，普通用户所拥有的功能vip用户全部有
public class Vip_Card extends Common_Card {
	Vip_Card(String name, int ID, int password, int money) {// 构造方法
		super(name, ID, password, money);
	}
	boolean CheckMoney(int m)// 不仅具有存取款的功能还具有可以透支的功能
	{
		System.out.println("正在操作，请稍候……！");
		if (m < 0) {
			if (saveMoney(-m)) {
				return true;
			} else
				return false;
		} else {
			if (m - 5000 > money) {
				System.out.println("［?á］：该账户透支不可超过5000元,本次操作中断！");
				return false;
			}
			this.money -= m;
			System.out.println("［√］：操作成功!");
			return true;
		}
	}
	void TransferMoney(Common_Card st[])// 转账的功能
	{
		System.out.println("请输入目标帐户ID:");
		int id = EnterAmountOfMoney.scanInt();
		int i;
		for (i = 0; i < st.length; i++) {
			if (st[i].ID == id) {
				System.out.println("请输入转账金额：");
				int m = EnterAmountOfMoney.scanInt();
				if (m < 0) {
					System.out.println("请输入目标帐户密码：");
					if (st[i].checkpassword() == false)
						return;
				}
				if (this.CheckMoney(m)) {
					st[i].saveMoney(m);
					System.out.println("［√］：转账成功!");
				} else {
					System.out.println("［?á］:转账失败!");
				}
				break;
			}
		}
		if (i == st.length)
			System.out.println("［?á］:用户不存在!");
	}
	void operating(Common_Card st[])// 正在操作
	{
		while (true) {
			this.printReceipt();
			int cmd = EnterAmountOfMoney.scanInt();
			switch (cmd) {
			case 1: {
				System.out.println("请输入存款数：");
				int m = EnterAmountOfMoney.scanInt();
				saveMoney(m);
				break;
			}
			case 2: {
				System.out.println("请输入取款数：");
				int m = EnterAmountOfMoney.scanInt();
				CheckMoney(m);
				break;
			}
			case 3:
				search();
				break;
			case 4:
				TransferMoney(st);
				break;
			case 0:
				Machine.end = 0;
				return;
			}
		}
	}
	static void printReceipt() {// Vip用户功能提示操作界面
		System.out.println("我爱我家自动提款机-Vip用户操作界面");
		System.out.println("——————");
		System.out.println("［存款——1］");
		System.out.println("［取款——2］");
		System.out.println("［余额——3］");
		System.out.println("［转账——4］");
		System.out.println("［退卡——0］");
		System.out.println("——————");
	}
}

 

package Chapter09.Inheritance.card;
//Machine类本程序的测试类
public class Machine {
	static int end = 1;
	public static void main(String[] args) {
		Common_Card st[] = new Common_Card[4];// 创建一个有4个用户的数组
		// 创建2个普通用户
		st[0] = new Common_Card("未知", 999, 999, 0);
		st[1] = new Common_Card("聂庆亮", 200981501, 10010, 100000);
		// 创建2个VIP用户
		st[2] = new Vip_Card("乐乐", 200981511, 583911, 13000);
		st[3] = new Vip_Card("尹继平", 200981512, 1324114, 22000);
		while (true) {
			if (end == 0) {// 用于退卡操作
				System.out.println("谢谢您的使用，再见");
				return;
			}
			System.out.println("请输入帐户ID：［0:退出］");
			int id = EnterAmountOfMoney.scanInt();	// 获取从键盘上输入的数据
			if (id == 0)
				return;
			int i;
			for (i = 0; i < st.length; i++) {
				if (st[i].ID == id) {				// 如果用户帐户ID正确则输入密码
					System.out.println("请输入帐户密码：");
					if (st[i].checkpassword()) {		// 调用Common_Card类的checkpassword进行核查
						st[i].operating(st);		// 如果密码输入正确则调用
						break;
					}
				}
			}
			if (i == st.length) {
				System.out.println("［?á］：该用户不存在！");
			}
		}
	}
}

 

package Chapter09.Inheritance.card;

import java.io.BufferedReader;
import java.io.InputStreamReader;

//EnterAmountOfMoney类的主要作用是录入数据。
public class EnterAmountOfMoney {
	public static String scan()// 可以从键盘上录入数据
	{
		String str = "";
		try {
			BufferedReader buf = new BufferedReader(new InputStreamReader(
					System.in));
			str = buf.readLine();
		} catch (Exception e) {
		}
		return str;
	}
	public static int scanInt()// 将从键盘上录入数据转换成int型数据
	{
		int temp = 0;
		try {
			temp = Integer.parseInt(scan());
		} catch (Exception e) {
			System.out.println("［?á］：输入不合法，请输入整数：");
		}
		return temp;
	}
}

 

　　9.4 多态 

　　实例173 饮食文化

package Chapter09.Abstract;

import java.util.Date;

public class MyDay { 					// 该程序的测试类
	public static void main(String[] args) {
		Person1 p = new Chinese();		// 实例化对象
		p.name = "张小红"; 				// 为成员变量name赋值
		p.Dinner_Time(p); 				// 吃饭的时间
		Chinese c = new Chinese(); 		// 创建子类Chinese对象
		c.personal(); 					// 调用Chinese类的personal方法
		c.Dinner_Time(c); 				// 调用重写父类的Dinner_Time
		System.out.println();
		Person1 p1 = new Foreigners();
		p1.name = "Tom";
		p1.Dinner_Time(p1);
		Foreigners f = new Foreigners();
		f.personal();
		f.Dinner_Time(f);
	}
}
class Person1 { // 人类
	String name; // 人的姓名
	Date date = new Date();
	int hour = date.getHours(); // 获得时间
	public void Dinner_Time(Person1 person) { 			// 吃饭的时间
		if (this.hour <= 8 && this.hour > 7) { 				// 7点～8点之间-早餐
			this.Breakfast(person);
		} else if (this.hour <= 13 && this.hour > 11) {		// 11点～13点之间-午餐
			this.Lunch(person);
		} else if (this.hour <= 20 && this.hour >= 17) {		// 11点～13点之间-晚餐
			this.Dinner(person);
		}
	}
	public void Breakfast(Person1 person) { 				// 早餐
		System.out.println(this.name + "到该吃早餐的时间了");
	}
	public void Lunch(Person1 person) { 					// 午餐
		System.out.println(this.name + "到该吃午餐的时间了");
	}
	public void Dinner(Person1 person) { 					// 晚餐
		System.out.println(this.name + "到该吃晚餐的时间了");
	}
}
class Chinese extends Person1 { 						// 中国人
	// 继承并重写父类的方法，是Java多态性的一种体现
	public void Dinner_Time(Chinese person) { 			// 吃饭的时间
		Chinese cns = new Chinese();
		if (this.hour <= 8 && this.hour > 7) { 				// 7点～8点之间-早餐
			this.Breakfast(cns);
		} else if (this.hour <= 13 && this.hour > 11) {		// 11点～13点之间-午餐
			this.Lunch(cns);
		} else if (this.hour <= 20 && this.hour >= 17) {		// 11点～13点之间-晚餐
			this.Dinner(cns);
		}
	}
	public void Breakfast(Chinese person) { 				// 早餐
		System.out.println("中国人早晨吃：包子，油条，粥和豆浆");
	}
	public void Lunch(Chinese person) { 				// 午餐
		System.out.println("中国人中午吃：米饭，馒头，蔬菜和肉类");
	}
	public void Dinner(Chinese person) { 				// 晚餐
		System.out.println("中国人晚上吃：粥，馒头，蔬菜和水果");
	}
	// 子类自己特有的方法
	public void personal() {
		System.out.println("我是中国人！");
	}
}
class Foreigners extends Person1 { // 外国人
	// 继承并重写父类的方法，是Java多态性的一种体现
	public void Dinner_Time(Foreigners person) { // 吃饭的时间
		Foreigners frs = new Foreigners();
		if (this.hour <= 8 && this.hour > 7) { // 7点～8点之间-早餐
			this.Breakfast(frs);
		} else if (this.hour <= 13 && this.hour > 11) {// 11点～13点之间-午餐
			this.Lunch(frs);
		} else if (this.hour <= 20 && this.hour >= 17) {// 11点～13点之间-晚餐
			this.Dinner(frs);
		}
	}
	public void Breakfast(Foreigners person) { // 早餐
		System.out.println("外国人早晨吃：面包加黄油，牛奶，火腿");
	}
	public void Lunch(Foreigners person) { // 午餐
		System.out.println("外国人中午吃：汉堡，炸马铃薯，一些蔬菜");
	}
	public void Dinner(Foreigners person) { // 晚餐
		System.out.println("外国人晚上吃：萨饼，蔬菜，牛肉，水果，甜点，面包 ");
	}
	// 子类自己特有的方法
	public void personal() {
		System.out.println("I am a British！");
	}
}

 

　　实例174 使用构造方法的重载计算课程的GPA值

package Chapter09.Abstract;

import java.util.Scanner;

public class HeavyTest {
	public static void main(String[] args) {
		System.out.println("请输入课程的数目：");
		Scanner sc = new Scanner(System.in);// 输入课程的数目
		Student students[] = getStudents(sc.nextInt());
		showStudents(students);
	}
	public static Student[] getStudents(int num) {
		Student students[] = new Student[num];// 创建Student对象数组
		for (int i = 0; i < students.length; i++) {
			System.out.println("请输入课程说明：");
			Scanner sc = new Scanner(System.in);// 输入课程的名字
			String str = sc.nextLine();
			System.out.println("是否有等级[y：有/n：没有]");
			if (sc.nextLine().equalsIgnoreCase("y")) {// 输入结果
				System.out.println("请输入等级号[ABCDE]");
				students[i] = new Student(str, sc.nextLine());	// 创建Student对象
			} else {
				students[i] = new Student(str);				// 创建Student对象
			}
		}
		return students;
	}
	public static void showStudents(Student students[]) {			// 显示所有的课程
		double sum = 0.0, num = 0.0;
		for (int i = 0; i < students.length; i++) {
			students[i].show();				// 显示当前的课程
			if (students[i].getGPA() >= 0.0) {
				num++;					// 获取总个数
				sum += students[i].getGPA();	// 获取总数
			}
		}
		System.out.println("GPA值为:" + (sum / num));// 求GPA的值
	}
}
class Student {
	private String name;// 课程的名字
	private String score;// 课程的分数等级
	// 以下是构造方法的重载
	public Student(String name) {			// 带一个参数的构造方法
		this(name, "没有等级编号");
	}
	public Student(String name, String score) {// 带两个参数的构造方法
		this.name = name;
		this.score = score;
	}
	// 显示课程名和等级
	public void show() {
		System.out.println(name + "[等级：" + score + "]");
	}
	// 根据等级获取相应的成绩点数
	public double getGPA() {
		String scores[] = { "A+", "A", "A-", "B+", "B", "B-", "C+", "C", "C-",
				"D+", "D", "D-" };
		double GPAs[] = { 4.00, 4.0, 3.75, 3.25, 3.0, 2.75, 2.25, 2.0, 1.75,
				1.25, 1.0, 0.75, 0 };
		for (int i = 0; i < scores.length; i++) {
			if (score.equals(scores[i])) {
				return GPAs[i];
			}
		}
		return -1.0;
	}
}