（一）类与对象
编写一个Java Application程序，该程序中有3个类：Triangle，Lader 和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。
- Triangle类：具有类型为double的三个边、周长、面积属性，具有返回周长、面积以及修改三个边的功能。另外，还具有一个boolean类型的属性，该属性用来判断三个数能否构成一个三角形。
- Lader类：具有类型为double的上底、下底、高、面积属性，具有返回面积的功能。
- Circle类：具有类型为double的半径、周长和面积属性，具有返回周长、面积的功能。
标准答案：
class Triangle {
double sideA, sideB, sideC, area, length;
boolean boo;
public Triangle(double a, double b, double c) {
sideA = a;
sideB = b;
sideC = c;// 参数a, b, c分别赋值给sideA, sideB, sideC
if (a + b > c && a + c > b && c + b > a)// a, b, c构成三角形的条件表达式
{
boo = true;// 给boo赋值
} else {
boo = false;// 给boo赋值
}
}
double getLength() { // 方法体，要求计算出length的值并返回
if (boo) {
length = sideA + sideB + sideC;
return length;
} else {
System.out.println("不是一个三角形,不能计算周长");
return 0;
}
}
public double getArea() {
if (boo) {
double p = (sideA + sideB + sideC) / 2.0;
area = Math.sqrt(p * (p - sideA) * (p - sideB) * (p - sideC));
return area;
} else {
System.out.println("不是一个三角形,不能计算面积");
return 0;
}
}
public void setABC(double a, double b, double c) {
sideA = a;
sideB = b;
sideC = c;// 参数a, b, c分别赋值给sideA, sideB, sideC
if (a + b > c && a + c > b && c + b > a)// a, b, c构成三角形的条件表达式
{
boo = true;// 给boo赋值。
} else {
boo = false;// 给boo赋值
}
}
}
class Lader {
double above, bottom, height, area;
Lader(double a, double b, double h) {// 方法体
above = a;
bottom = b;
height = h;
}
double getArea() {
area = (above + bottom) / 2 * height;// 方法体，,要求计算出area返回
return area;
}
}
class Circle {
double radius, area;
Circle(double r) { // 方法体
radius = r;
}
double getArea() { // 方法体，要求计算出area返回
return 3.14 * radius * radius;
}
double getLength() { // getArea方法体的代码,要求计算出length返回
return 3.14 * 2 * radius;
}
void setRadius(double newRadius) {
radius = newRadius;
}
double getRadius() {
return radius;
}
}
public class AreaAndLength {
public static void main(String args[]) {
double length, area;
Circle circle = null;
Triangle triangle;
Lader lader;
// circle=new Circle(10);//创建对象circle
triangle = new Triangle(3, 4, 5);// 创建对象triangle
lader = new Lader(3, 4, 10);// 创建对象lader
length = circle.getLength();// circle调用方法返回周长并赋值给length
System.out.println("圆的周长:" + length);
area = circle.getArea();// circle调用方法返回面积并赋值给area
System.out.println("圆的面积:" + area);
length = triangle.getLength();// triangle调用方法返回周长并赋值给length
System.out.println("三角形的周长:" + length);
area = triangle.getArea();// triangle调用方法返回面积并赋值给area
System.out.println("三角形的面积:" + area);
area = lader.getArea();// lader调用方法返回面积并赋值给area
System.out.println("梯形的面积:" + area);
triangle.setABC(12, 34, 1);// triangle调用方法返修改三个边的代码，要求将三个边修改为12，34，1
area = triangle.getArea();// triangle调用方法返回面积并赋值给area
System.out.println("三角形的面积:" + area);
length = triangle.getLength(); // triangle对象调用方法返回周长并赋值给length
System.out.println("三角形的周长:" + length);
}
}个人作业：
class Triangle
{ double sideA,sideB,sideC,area,length;
boolean boo;
public Triangle(double a,double b,double c)
{ sideA=a;sideB=b;sideC=c; // 参数a, b, c分别赋值给sideA, sideB, sideC
if(a+b>c&&a+c>b&&b+c>a&&a>0&&b>0&&c>0) //a, b, c构成三角形的条件表达式
{ boo=true; // 给boo赋值
}
else
{ boo=false; // 给boo赋值
}
}
double getLength()
{
length=sideA+sideB+sideC;
return length; // 方法体，要求计算出length的值并返回
}
public double getArea()
{ if(boo)
{ double p=(sideA+sideB+sideC)/2.0;
area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ;
return area; }
else
{ System.out.println("不是一个三角形,不能计算面积");
return 0; }
}
public void setABC(double a,double b,double c)
{ sideA=a;sideB=b;sideC=c; // 参数a, b, c分别赋值给sideA, sideB, sideC
if(a+b>c&&a+c>b&&b+c>a&&a>0&&b>0&&c>0) // a, b, c构成三角形的条件表达式
{ boo=true; //给boo赋值。
}
else
{ boo=false; // 给boo赋值
}
}
public double getA()
{
return sideA;
}
}
class Lader
{ double above,bottom,height,area;
Lader(double a,double b,double h)
{above=a;bottom=b;height=h; // 方法体
}
double getArea( )
{
area=(above+bottom)*height/2;
return area; // 方法体，,要求计算出area返回
}
}
class Circle
{ double radius,area;
Circle(double r)
{ radius=r; //方法体
}
double getArea( )
{
area=radius*radius*Math.PI;
return area; //方法体，要求计算出area返回
}
double getLength( )
{ return 2*radius*Math.PI; //getArea方法体的代码,要求计算出length返回
}
void setRadius(double newRadius)
{ radius=newRadius;
}
double getRadius( )
{ return radius;
}
}
public class AreaAndLength
{
public static void main(String args[ ])
{ double length,area;
Circle circle=null;
Triangle triangle;
Lader lader;
circle=new Circle(2); //创建对象circle
triangle=new Triangle(3,5,4); //创建对象triangle
lader=new Lader(2,3,4); //创建对象lader
length=circle.getLength(); // circle调用方法返回周长并赋值给length
System.out.println("圆的周长:"+length);
area=circle.getArea(); // circle调用方法返回面积并赋值给area
System.out.println("圆的面积:"+area);
length=triangle.getLength(); // triangle调用方法返回周长并赋值给length
System.out.println("三角形的周长:"+length);
area=triangle.getArea(); // triangle调用方法返回面积并赋值给area
System.out.println("三角形的面积:"+area);
area=lader.getArea(); // lader调用方法返回面积并赋值给area
System.out.println("梯形的面积:"+area);
triangle.setABC(12, 34, 1); // triangle调用方法返修改三个边的代码，要求将三个边修改为12，34，1
area=triangle.getArea(); // triangle调用方法返回面积并赋值给area
System.out.println("三角形的面积:"+area);
length=triangle.getLength(); // triangle调用方法返回周长并赋值给length
System.out.println("三角形的周长:"+length);
}
}运行结果：
（二）继承
有一个abstract类，类名为Employee。Employee的子类有YearWorker，MonthWorker和WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract方法：public abstract earnings(); 子类必须重写父类的earnings()方法，给出各自领取报酬的具体方式。
有一个Company类，该类用employee数组作为成员，employee数组的单元可以是YearWorker对象的上转型对象、MonthWorker 对象的上转型对象或WeekWorker对象的上转型对象。程序能输出Company 对象一年需要支付的薪水总额。
标准答案：
abstract class Employee {
public abstract double earnings();
}
class YearWorker extends Employee {
public double earnings() {
return 50000.456;
}
}
class MonthWorker extends Employee {
public double earnings() {
return 12 * 2000;
}
}
class WeekWorker extends Employee {
public double earnings() {
return 52 * 500;
}
}
class Company {
Employee[] employee;
double salaries = 0;
Company(Employee[] employee) {
this.employee = employee;
}
public double salariesPay() {
salaries = 0;
for (int i = 0; i < employee.length; i++) {
salaries = salaries + employee[i].earnings();
}
return salaries;
}
}
public class HardWork {
public static void main(String args[]) {
Employee[] employee = new Employee[20];
for (int i = 0; i < employee.length; i++) {
if (i % 3 == 0)
employee[i] = new WeekWorker();
else if (i % 3 == 1)
employee[i] = new MonthWorker();
else if (i % 3 == 2)
employee[i] = new YearWorker();
}
Company company = new Company(employee);
System.out.println("公司工资总额:" + company.salariesPay());
}
}个人作业：
abstract class Employee
{
public abstract double earnings( );
}
class YearWorker extends Employee
{
public double earnings() {
double salary=200;
return salary*12;
} // 重写earnings( )方法
}
class MonthWorker extends Employee
{
public double earnings() {
double salary=200;
return salary;
}// 重写earnings( )方法
}
class WeekWorker extends Employee
{
public double earnings() {
double salary=200;
return salary/4;
}// 重写earnings( )方法
}
class Company
{
Employee[ ] employee;
double salaries=0;
Company(Employee[ ] employee)
{
this.employee=employee;
}
public double salariesPay( )
{
salaries=0;
for(int i=0;i<employee.length;i++) {
salaries+=employee[i].earnings();// 计算salaries
}
return salaries;
}
}
public class HardWork
{
public static void main(String args[ ])
{
Employee[ ] employee=new Employee[20];
for(int i=0;i<employee.length;i++)
{
if(i%3==0)
employee[i]=new WeekWorker( );
else if(i%3==1)
employee[i]=new MonthWorker( );
else if(i%3==2)
employee[i]=new YearWorker( );
}
Company company=new Company(employee);
System.out.println("公司年工资总额:"+company.salariesPay( ) );
}
}个人作业运行结果：
（三）实例成员与类成员
class A
{ float a; // 声明一个float型实例变量：a
static float b; // 声明一个float型类变量：b
void setA(float a)
{ this.a=a; // 将参数a的值赋值给成员变量a
}
void setB(float b)
{ this.b=b; // 将参数b的值赋值给成员变量b
}
float getA( )
{ return a;
}
float getB( )
{ return b;
}
void inputA( )
{ System.out.println(a);
}
static void inputB( )
{ System.out.println(b);
}
}
public class Example
{ public static void main(String args[ ])
{ A.b=100; // 通过类名操作类变量b,并赋值100
A.inputB(); // 通过类名调用方法inputB( )
A cat=new A( );
A dog=new A( );
cat.setA(200);// cat象调用方法setA(int a)将cat的成员a的值设置为200
cat.setB(400); // cat调用方法setB(int b)将cat的成员b的值设置为400
dog.setA(200); // dog象调用方法setA(int a)将dog的成员a的值设置为200
dog.setB(400);// dog调用方法setB(int b)将dog的成员b的值设置为400
cat.inputA();// cat调用inputA( )
cat.inputB();// cat调用inputB( )
dog.inputA();// dog调用inputA( )
dog.inputB();// dog调用inputB( )
}
}运行结果：
注意：inputB( )不能对非静态字段 a 进行静态引用。
（四）package语句与import语句
tom.jiafei包内：
package tom.jiafei;
public class Triangle
{
double sideA,sideB,sideC;
boolean boo;
public Triangle(double a,double b,double c)
{
sideA=a;sideB=b;sideC=c;
if(a+b>c&&a+c>b&&c+b>a)
{
System.out.println("我是一个三角形");
boo=true;
} else
{
System.out.println("我不是一个三角形");
boo=false;
}
}
public void 计算面积( )
{
if(boo)
{
double p=(sideA+sideB+sideC)/2.0;
double area=Math.sqrt(p*(p-sideA)*(p-sideB)*(p-sideC)) ;
System.out.println("是一个三角形,能计算面积");
System.out.println("面积是:"+area);
}
else
{
System.out.println("不是一个三角形,不能计算面积");
}
}
public void 修改三边(double a, double b, double c)
{
sideA=a;sideB=b;sideC=c;
if(a+b>c&&a+c>b&&c+b>a)
{
boo=true;
}
else
{
boo=false;
}
}
}其他包内调用：
import tom.jiafei.Triangle;
import java.util.Date;
class SunRise
{
public static void main(String args[ ])
{
Triangle triangle=new Triangle(12,3,104);
triangle.计算面积( );
triangle.修改三边(3,4,5);
triangle.计算面积( );
Date date=new Date( );
System.out.println(date);
}
}运行结果：
（五）接口的定义与使用
（1）定义和实现接口
interface Listener{
void action();
}
public class Test implements Listener{
public static void main(String a[]){
new Test();
}
}
编译程序指示什么错误，写出原因。
类型 Test 必须实现继承的抽象方法 Listener.action（），因为接口没有默认实现，如果不实现继承的抽象方法，则该类为抽象类，抽象类不能用来创建对象。
（2）在Test类中增加如下方法：
public void action(){
System.out.println("stand up ");}
public static void main(String a[]){
Test x=new Test();
x.action();
}
编译并执行程序，说说为什么要在action方法头增加public修饰?
因为不能降低自 Listener 继承的方法的可视性。如果为private，则不能被子类继承，子类便无法实现该方法。
（3）再增加一个类Test2实现Listener接口
class Test2 implements Listener {
public void action(){
System.out.println("sit down");}
}
并修改Test类的main方法：
public static void main(String a[]){
Listener x[]={new Test(),new Test2()};
x[0].action();
x[1].action();
}
调试程序，观察通过接口引用变量访问对象方法的动态多态行为，写出程序的输出。
程序输出：
stand up
sit down
（4）在方法参数中使用接口类型
给test类增加一个方法add，设计如下：
public void add(Listener a){
a.action();
}
main方法改动如下：
public static void main(String a[]){
Test x=new Test();
x.add(x);
x.add(new Test2());
}
观察输出结构，分析内在关系，写出程序的输出。
不同类类型的变量调用的是各自类中实现的方法，实现了多态。
程序输出：
stand up
sit down
完整Test代码：
interface Listener{
void action();
}
public class Test implements Listener{
public void action(){
System.out.println("stand up ");}
public void add(Listener a){
a.action();
}
public static void main(String a[]){
Test x=new Test();
x.add(x);
x.add(new Test2());
}
/*
* public static void main(String a[]){ Listener x[]={new Test(),new Test2()};
* x[0].action(); x[1].action(); }
*/
}
class Test2 implements Listener {
public void action(){
System.out.println("sit down");}
}2、编写程序
- 定义一个接口，它含有两个抽象方法：第一个抽象方法用于实现在两个数中求最小的数；第二个抽象方法用于实现在三个数中求最大的数；
- 定义一个类实现这个接口；
- 再定义一个含有main（）方法的主类,实现最小和最大的数的输出。
标准答案：
interface MaxAndMin {
public abstract int Min(int a, int b);
public abstract int Max(int x, int y, int z);
}
class ABC implements MaxAndMin {
public int Min(int a, int b) {
if (a > b)
return b;
else
return a;
}
public int Max(int x, int y, int z) {
int max = x;
if (y > max)
max = y;
if (z > max)
max = z;
return max;
}
}
public class Tester {
public static void main(String args[]) {
ABC t = new ABC();
System.out.println("最小值是" + t.Min(10, 20));
System.out.println("最大值是" + t.Max(10, 30, 20));
}
}个人作业：
interface Listener2{
int FindMin(int a,int b);
int FindMax(int a,int b,int c);
}
public class MaxMin implements Listener2{
public int FindMin(int a,int b){
if(a<b)
return a;
else
return b;
}
public int FindMax(int a,int b,int c){
int max=a;
if(b>max)
max=b;
if(c>max)
max=c;
return max;
}
public static void main(String a[]){
MaxMin x=new MaxMin();
System.out.println("最大数为："+x.FindMax(2,1,3));
System.out.println("最小数为："+x.FindMin(5,7));
}
}运行结果：
（六）选做题
1、参看UML图，编写类Shape和Triangle，实现类中的方法（斜体字是抽象方法）,并自定义构造函数、get、set等方法。
标准答案：
abstract class Shape {
public abstract double getArea();
public String toString() {
return "This is a Shape";
}
}
class Triangle extends Shape {
private double side1, side2, side3;
public Triangle(double s1, double s2, double s3) {
side1 = s1;
side2 = s2;
side3 = s3;
}
public double getArea() {
double s = (side1 + side2 + side3) / 2;
return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
}
public String toString() {
return "This is a Triangle, sides are :" + side1 + "," + side2 + "," + side3;
}
}
class Circle extends Shape {
private double radius;
public Circle(double r) {
radius = r;
}
public double getRadius() {
return radius;
}
public double getArea() {
return Math.PI * radius * radius;
}
public boolean equals(Object obj) {
if (obj instanceof Circle)
return this.radius == ((Circle) obj).getRadius();
else
return false;
}
public String toString() {
return "this is a Circle with radius " + radius;
}
}个人作业：
import java.util.Objects;
public abstract class Shape {
public abstract double getArea();
public abstract String toString();
public static void main(String args[ ])
{
Triangle triangle=new Triangle(3,5,4);
Circle circle1=new Circle(2);
Circle circle2=new Circle(3);
System.out.println("三角形的面积:"+triangle.getArea());
System.out.println(triangle.toString());
System.out.println("圆1的面积:"+circle1.getArea());
System.out.println("圆2的面积:"+circle2.getArea());
System.out.println("半径是否相等: " + circle1.equals(circle2));
System.out.println(circle1.toString());
System.out.println(circle2.toString());
}
}
class Triangle extends Shape {
private double side1,side2,side3;
public Triangle(double a,double b,double c) {
side1=a;side2=b;side3=c;
}
public double getArea() {
double p=(side1+side2+side3)/2.0;
return Math.sqrt(p*(p-side1)*(p-side2)*(p-side3));
}
public void setSide(double side1,double side2,double side3) {
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public String toString() {
return ("三角形的三边长分别为："+side1+'、'+side2+'、'+side3+','+"面积为："+getArea());
}
}
class Circle extends Shape {
private double radius;
public Circle(double r) {
radius=r;
}
public double getArea() {
return radius*radius*Math.PI;
}
public String toString() {
return ("圆的半径为："+radius+','+"面积为："+getArea());
}
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj instanceof Circle) {
Circle c = (Circle)obj;
return this.radius == c.radius;
}
return false;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}个人作业运行效果：
2、按照要求编写程序
- 定义一个StartStop接口，含有start()和stop()两个抽象方法；
- 分别创建“会议”和“汽车”两个类实现StartStop接口；
- 定义测试类，利用接口StartStop定义一个数组，创建一个“会议”对象和一个“汽车”对象赋值给数组，通过数组元素访问对象的start()和stop()方法。
标准答案：
interface StartStop {
void Start();
void Stop();
}
class Conference implements StartStop {
public void Start() {
System.out.println("Start the conference!");
}
public void Stop() {
System.out.println("Stop the conference!");
}
}
class car implements StartStop {
public void Start() {
System.out.println("Insert key in ignition and turn!");
}
public void Stop() {
System.out.println("Turn key in ignition and remove!");
}
}
public class Interfacetest {
public static void main(String[] args) {
StartStop s[] = { new car(), new Conference() };
for (int i = 0; i < s.length; i++) {
s[i].Start();
s[i].Stop();
}
}
}个人作业：
interface StartStop {
public void start();
public void stop();
}
class Car implements StartStop {
public void start(){
System.out.println("车启动了");
}
public void stop(){
System.out.println("车停止了");
}
}
class Metting implements StartStop {
public void start(){
System.out.println("会议开始了");
}
public void stop(){
System.out.println("会议停止了");
}
}
public class CarAndMeeting {
public static void main(String[] args) {
StartStop ss[]={ new Metting(), new Car() };
for(StartStop s: ss) {
s.start();
s.stop();
}
}
}个人作业运行效果：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
