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;
}
}