习题7_Java面向对象03
1.请设计类，描述一系列的几何图形，包括矩形，圆形，三角形。
1)这些图形都有面积，周长两种属性
2)这些图形，都可以被画出来(输出或打印出来，即都有一个draw方法)
请定义类，来描述以上几何图形，并考虑类中成员变量的访问权限，并提供必要的方法进行属性(成员变量的)访问。
代码：
public class Graphics {
public static void main(String[] args) {
//矩形
Rectangle rectangle = new Rectangle(12,14);
rectangle.draw();
System.out.println("area = " + rectangle.getArea() + "，perimeter = " + rectangle.getPerimeter());
//圆形
Round round = new Round(3, 6);
round.draw();
System.out.println("area = " + round.getArea() + "，perimeter = " + round.getPerimeter());
//三角形
Triangle triangle = new Triangle(6,12);
triangle.draw();
System.out.println("area = " + triangle.getArea() + "，perimeter = " + triangle.getPerimeter());
}
}
abstract class BasicGraphics{
private double area;//面积
private double perimeter;//周长
//构造方法
public BasicGraphics(double area, double perimeter){
this.area = area;
this.perimeter = perimeter;
}
//画图形的行为
public abstract void draw();
public double getArea(){
return area;
}
public void setArea(double area){
this.area = area;
}
public double getPerimeter(){
return perimeter;
}
public void setPerimeter(double perimeter){
this.perimeter = perimeter;
}
}
//矩形类
class Rectangle extends BasicGraphics{
public Rectangle(double area, double perimeter){
super(area, perimeter);
}
@Override
public void draw(){
System.out.println("画一个矩形");
}
}
//圆形类
class Round extends BasicGraphics{
public Round(double area, double perimeter){
super(area, perimeter);
}
@Override
public void draw(){
System.out.println("画一个圆形");
}
}
//三角形类
class Triangle extends BasicGraphics{
public Triangle(double area, double perimeter){
super(area, perimeter);
}
@Override
public void draw(){
System.out.println("画一个三角形");
}
}
运行结果：
2.为某研究所编写一个通用程序，用来计算每一种交通工具运行1000公里所需的时间.已知每种交通工具的参数都是3个整数常量A、B、C的表达式。
现有两种工具：Car 和Plane，
其中Car 的速度运算公式为：A*B/C，
Plane 的速度运算公式为 ：A+B+C。
要求在未来如果增加第3种交通工具（如Ship）的时候，可以做到复用已有代码。
Ship的速度运算公式为 ：A+B/C。
要求自己设计该系统，并测试。
代码：
interface TimeCalculator {
/*
该方法的作用是 计算某种交通工具，移动指定距离例所花的时间
*/
double calculateTime(int distance);
}
/**
* 该类抽象所有，类型交通工具的共性，3个参数a, b, c,
* 同时，所有交通工具都需要计算所需的时间，该计算方法放在了TimeCalculator接口中
*/
abstract class Vehicle implements TimeCalculator{
/*
不管哪种交通工具都需要这些参数来计算自己的速度
*/
private int a;
private int b;
private int c;
public Vehicle(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
/*
获取某交通工具的速度的方法，因为每种交通工具速度的计算方式不一样
留给子类去实现就好了
*/
public abstract double getSpeed();
/*
计算某种交通工具移动指定距离需要的时间，该方法
放在一个接口中声明，也可以不使用接口
因为只要知道了速度，和距离时间是按照相同的方式计算，
所以这里直接实现了计算时间的方法
*/
@Override
public double calculateTime(int distance) {
return distance / getSpeed();
}
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
public int getB() {
return b;
}
public void setB(int b) {
this.b = b;
}
public int getC() {
return c;
}
public void setC(int c) {
this.c = c;
}
}
class Car extends Vehicle {
public Car(int a, int b, int c) {
super(a, b, c);
}
@Override
public double getSpeed() {
return getA() + getB() + getC();
}
}
class Plane extends Vehicle {
public Plane(int a, int b, int c) {
super(a, b, c);
}
@Override
public double getSpeed() {
return 1.0 * getA() * getB() / getC();
}
}
class Ship extends Vehicle {
public Ship(int a, int b, int c) {
super(a, b, c);
}
@Override
public double getSpeed() {
return 1.0 * getA() + getB() / getC();
}
}
// 测试类
public class Test {
public static void main(String[] args) {
TimeCalculator calculator = new Car(10, 20, 2);
System.out.println(calculator.calculateTime(1000));
calculator = new Plane(10, 20, 2);
System.out.println(calculator.calculateTime(1000));
calculator = new Ship(10, 20, 2);
System.out.println(calculator.calculateTime(1000));
}
}
运行结果：
3.完成教练和运动员案例：
乒乓球运动员和足球运动员。
乒乓球教练和足球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类
乒乓球运动员 属性 name age salary
行为 eat() sleep() train() match() learnEnglish()
足球运动员 属性 name age salary
行为 eat() sleep() train() match()
乒乓球教练 属性 name age salary bonus
行为 eat()，sleep(), teach()，learnEnglish()
足球教练 属性 name age salary bonus
行为 eat()，sleep(), teach()
代码：
public class InterfaceExercise {
public static void main(String[] args) {
Athlete tabletennisAthelete = new TabletenisAthelete();
tabletennisAthelete.setName("lili");
tabletennisAthelete.setAge(18);
tabletennisAthelete.setSalary(5400.0);
//以乒乓球运动员为例输出
tabletennisAthelete.eat();
tabletennisAthelete.sleep();
tabletennisAthelete.train();
tabletennisAthelete.match();
((TabletenisAthelete) tabletennisAthelete).learnEnglish();
}
}
//定义一个Human类
class Human{
private String name;
private int age;
private double salary;
public Human() { }
public Human(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public void eat(){
System.out.println(name + "吃饭");
}
public void sleep(){
System.out.println(name + "睡觉");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
//定义Athlete抽象类
abstract class Athlete extends Human{
public abstract void train();
public abstract void match();
}
//定义Coach抽象类
abstract class Coach extends Human{
private double bonus;
public abstract void teach();
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
//定义SpecialSkill接口
interface SpecialSkill{
void learnEnglish();
}
//定义TabletenisAthelete类
class TabletenisAthelete extends Athlete implements SpecialSkill{
@Override
public void train(){
System.out.println(getName() + "训练乒乓球");
}
@Override
public void match(){
System.out.println(getName() + "参加乒乓球比赛");
}
@Override
public void learnEnglish(){
System.out.println(getName() + "学习英语");
}
}
//定义FootballAthlete类
class FootballAthlete extends Athlete{
@Override
public void train(){
System.out.println(getName() + "训练足球");
}
@Override
public void match(){
System.out.println(getName() + "参加足球比赛");
}
}
//定义TableTenisCoach类
class TableTenisCoach extends Coach implements SpecialSkill{
@Override
public void teach(){
System.out.println(getName() + "教乒乓球");
}
@Override
public void learnEnglish(){
System.out.println(getName() + "学习英语");
}
}
//定义FootballCoach类
class FootballCoach extends Coach{
@Override
public void teach(){
System.out.println(getName() + "教足球");
}
}
运行结果：
4.根据注释填写(1), (2),(3)处的代码
public class Test{
public static void main(String[] args){
//创建并初始化Bean1类对象bean1
(1)
bean1.i++;
// 创建并初始化Bean2类对象bean2
(2)
bean2.j++;
//创建并初始化Bean3类对象bean3
(3)
bean3.k++;
}
class Bean1{
public int i = 0;
}
static class Bean2{
public int j = 0;
}
}
class Bean{
class Bean3{
public int k = 0;
}
}
代码：
public class Test{
public static void main(String[] args){
//创建并初始化Bean1类对象bean1
//（1）在外部类的静态方法中，创建普通成员位置内部类对象
Test.Bean1 bean1 = new Test().new Bean1();
bean1.i++;
System.out.println(bean1.i);
// 创建并初始化Bean2类对象bean2
//（2）在外部类的静态方法中，创建静态成员位置内部类
Bean2 bean2 = new Bean2();
bean2.j++;
System.out.println(bean2.j);
//创建并初始化Bean3类对象bean3
//（3）在外部类的外部，创建其他类普通成员位置内部类对象
Bean.Bean3 bean3 = new Bean().new Bean3();
bean3.k++;
System.out.println(bean3.k);
}
class Bean1{
public int i = 0;
}
static class Bean2{
public int j = 1;
}
}
class Bean{
class Bean3{
public int k = 2;
}
}
运行结果：
5 .
a. 定义一个接口Compute，用来完成计算器的功能，比如最简单的加减乘除功能
interface Compute {
double compute(double a, double b)
}
b. 定义一个ShowCompute类，里面定义一个工具方法compute(Compute com,double a, double b)
该方法可以执行，两个double类型数据的加减乘除
（也就是需要定义不同的Compute接口的子类，实现具体的加减乘除功能，当执行该方法时，传递不同的子类对象，就可以完成不同的计算）
编写一个测试类，通过调用ShowCompute类的compute(Compute com,double a, double b)方法来完成加减乘除功能。
代码：
public class Computer {
public static void main(String[] args) {
double a = 5.0;
double b = 2.5;
//所有的计算结果，都是通过ShowCompute类的calculate方法完成的
// 不同的Compute匿名内部类对象，决定了不同的计算方式(比如，加减乘除)
// 执行加法 创建了执行加法操作的Compute接口匿名内部类对象
double addResult = ShowCompute. calculate(new Compute(){
@Override
public double compute(double a, double b) {
return a + b;
}
}, a, b);
System.out.println(a + " + " + b + " = " + addResult);
// 执行减法 创建了执行减法操作的Compute接口匿名内部类对象
double subtractResult = ShowCompute. calculate(new Compute(){
@Override
public double compute(double a, double b) {
return a - b;
}
}, a, b);
System.out.println(a + " - " + b + " = " + subtractResult);
// 执行乘法 创建了执行乘法操作的Compute接口匿名内部类对象
double multiplyResult = ShowCompute. calculate(new Compute(){
@Override
public double compute(double a, double b) {
return a * b;
}
}, a, b);
System.out.println(a + " * " + b + " = " + multiplyResult);
// 执行除法 创建了执行除法操作的Compute接口匿名内部类对象
double divideResult = ShowCompute. calculate(new Compute(){
@Override
public double compute(double a, double b) {
return a / b;
}
}, a, b);
System.out.println(a + " / " + b + " = " + divideResult);
}
}
//定义一个接口Compute，用来完成计算器的功能
interface Compute {
double compute(double a, double b);
}
class ShowCompute{
/*
定义工具方法，对两个操作数a和b的计算(加减乘除)
至于，具体对a和b执行哪种计算，有方法接收的具体的Compute接口子类对象决定
*/
public static double calculate(Compute com,double a, double b){
return com.compute(a,b);
}
}
运行结果：
#个人学习记录，如发现有错误之处，欢迎与我交流