【Java语言设计】——期末复习（冲刺篇）

HinsCoder

已于 2023-12-25 23:08:11 修改

阅读量1.5k

点赞数 28

文章标签： java 开发语言

于 2023-12-19 17:46:16 首次发布

❗ 转载请注明出处作者：HinsCoder 博客链接：

本文链接：https://blog.csdn.net/HinsCoder/article/details/135080593

版权

📖 前言：快考试了，做篇期末总结，都是重点与必考点。

题型：判断题、单选题、程序综合题（阅读程序并填空）、改错题、代码评价题、英语专业阅读题（如给出某函数的开发文档（英文）用法解释要求翻译为中文）、一道编程设计题（继承、接口、多态）

课本：
在这里插入图片描述

🕒 1. 程序设计基础
🕒 2. 循环结构
🕒 3. 类和对象
🕒 4. 方法
🕒 5. 数组
🕒 6. 类的深入探讨
- 🕘 6.1 泛型
- 🕘 6.2 枚举
🕒 7. 继承和多态
🕒 8. 接口
🕒 9. 异常处理
🕒 10. Java常用类
🕒 11. 文件和流
🕒 12. 程序评价题举例
🕒 13. 专业阅读题举例
🕒 14. 往年真题（部分）

🕒 1. 程序设计基础

Java中，当两个 byte 或 short 类型的变量进行算术运算时，它们会首先被提升到 int 类型，然后再进行运算

数据类型	字节数	值范围
byte	1	-2⁷ 到 2⁷-1
short	2	-2¹⁵ 到 2¹⁵-1
int	4	-2³¹ 到 2³¹-1
long	8	-2⁶³ 到 2⁶³-1
float	4	有效位数15位
double	8	有效位数15位
char	2	0 到 2¹⁶-1（Unicode）
boolean		true 或 false

	类内部	本包	子类	外部包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

🕒 2. 循环结构

☆ 1、输出如下图所示的九九乘法表

 1X1=1	
 2X1=2	 2X2=4	
 3X1=3	 3X2=6	 3X3=9	
 4X1=4	 4X2=8	 4X3=12	 4X4=16	
 5X1=5	 5X2=10	 5X3=15	 5X4=20	 5X5=25	
 6X1=6	 6X2=12	 6X3=18	 6X4=24	 6X5=30	 6X6=36	
 7X1=7	 7X2=14	 7X3=21	 7X4=28	 7X5=35	 7X6=42	 7X7=49	
 8X1=8	 8X2=16	 8X3=24	 8X4=32	 8X5=40	 8X6=48	 8X7=56	 8X8=64	
 9X1=9	 9X2=18	 9X3=27	 9X4=36	 9X5=45	 9X6=54	 9X7=63	 9X8=72	 9X9=81

public class MultTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) { // 循环输出每行的数据
            // 对每一行，循环输出每一个运算式
            for (int j = 1; j <= i; j++) {
                if (j <= i) {
                    //输出一个运算式
                    System.out.print(" " + i + "X" + j + "=" + i * j + "\t");
                }
            }
            System.out.println(""); // 换行
        }
    }
}

2、分别使用三种循环，求100以内奇数的乘积。

public class Oddproduct {
    public static void main(String[] args) {
        double product = 1;
        int i = 1;

        // while 循环实现
        while (i < 100) {
            product *= i;
            i += 2;
        }
        System.out.println("while 循环: " + product);

        // for 循环实现
        product = 1;
        for (i=1; i < 100; i += 2) {
            product *= i;
        }
        System.out.println("for 循环: " + product);

        // do-while  循环实现
        product = 1;
        i = 1;
        do {
            product *= i;
            i += 2;
        } while (i < 100);
        System.out.println("do-while 循环: " + product);
    }
}

🕒 3. 类和对象

Java中，构造方法的名称必须与类名相同，并且它们没有返回类型。
成员方法里的局部变量不能用static修饰

1、定义一个风扇类Fan，包含属性叶片数，并定义相应的 setter和getter方法，定义无参的构造方法，另外定义描述该风扇信息的方法，最后写测试类验证该类。

public class Fan {
    int piece;

    public int getPiece() {
        return piece;
    }

    public void setPiece(int piece) {
        this.piece = piece;
    }

    public Fan() {
        piece = 3;
    }

    public String getInfo() {
        return String.format("风扇叶片数为%d", piece);
    }
}

public class Fantest {
    public static void main(String[] args) {
        Fan fan = new Fan();
        System.out.println(fan.getInfo());
        fan.setPiece(4);
        System.out.println(fan.getInfo());
    }
}

instanceof 运算符

二元运算符：object instanceof class

判断运算符左边的对象是否是右边类的一个实例
运算结果为boolean类型，如果左边对象是右边类的一个实例，则运算结果为true，否则为false

CircleWithConstructor c1 = new CircleWithConstructor();
Rectangle r1 = new Rectangle();
//判断c1是否是圆类对象
boolean result1 = c1 instanceof CircleWithConstructor;
System.out.println("c1 instanceof CircleWithConstructor =" + result1);

面向对象软件开发采用的是对象建模方式。

🕒 4. 方法

方法的定义：一个类里定义多个同名的方法，但要求每个方法具有不同的参数类型或参数个数。
方法的调用
参数值传递
方法重载

特点

方法名相同；
方法的形参表不相同，以此区分不同的方法。形参不同含义为：参数个数不同，如果参数个数相同，那么参数的类型或者参数的顺序必须不同；
方法的返回类型、修饰符与方法重载无关，方法的返回类型、修饰符可以相同，也可不同。

1、写一个方法，方法名为SumN，用递归方式求1，…，N前N个数之和，并对其进行测试。

public class SumN {
    public int sumN(int n) {
        if (n == 1)
            return 1;
        else
            return sumN(n - 1) + n;
    }
}

import java.util.Scanner;

public class SumNtest {
    public static void main(String[] args) {
        int num;
        System.out.print("请输入一个数：");
        Scanner sc = new Scanner(System.in);
        num = sc.nextInt();
        SumN a = new SumN();
        int sum = a.sumN(num);
        System.out.println("1+2+....+" + num + "=" + sum);
    }
}

🕒 5. 数组

声明、创建和初始化数组：int[] arr = new int[] { 1, 2, 3 };
数组与方法
数组与对象
数组的基本使用方法

Student s1 = new Student(“张三”);
Student s2 = new Student(“李四”);
Student[] students = new Student[] { s1, s2 };
for (Student student : students) {
…
}

1、定义一个一维数组并通过键盘输出数据，对其进行降序排序，并输出。

import java.util.Scanner;

public class DesSort {
    public static void main(String[] args) {
        int[] a = new int[5];
        System.out.print("请向数组输入数据：\n");
        Scanner sc = new Scanner(System.in);
        // 接收键盘数据
        for (int i = 0; i < a.length; i++) {
            System.out.printf("a[%d] = ", i);
            a[i] = sc.nextInt();
        }
        // 降序排列
        for (int i = 0; i < a.length - 1; i++)
            for (int j = i + 1; j < a.length; j++)
                if (a[i] < a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
        // 输出
        System.out.println("排序后的数组为：");
        for (int num : a)
            System.out.print(num + " ");
    }
}

🕒 6. 类的深入探讨

面向对象编程的三个特征（特性）

封装：把客观事物封装成抽象的类，封装是把方法和数据包围起来，对数据的访问只能通过已定义的方法。
继承：可以让某个类型的对象获得另一个类型的对象的属性和方法。
多态性：允许为不同类的对象对同一消息进行响应，即一个类的实例的相同方法在不同情形有不同表现形式（执行了不同的代码）。多态性语言具有灵活、抽象、行为共享、代码共享的优势，并能很好地解决了应用程序方法同名的问题。

抽象类（Abstract Class）：抽象类是一种特殊的类，它不能被实例化。只有继承了抽象类的子类才能被实例化。抽象类可以包含抽象方法和非抽象方法。
抽象方法（Abstract Method）：抽象方法是一种只有声明没有实现的方法。抽象方法必须在抽象类中定义，并且它们没有方法体，只有方法签名

super()表示使用父类的无参构造方法。
java.lang.Object是所有类的终极父类。

🕘 6.1 泛型

☆ 1、定义一个泛型类Circle。
思路：要描述一个圆，主要特征就是半径，半径可以是整数也可能是浮点数。因此半径的数据类型不确定，定义为参数类型，代码如下：

// 定义圆 带参数T为泛型
class Circle<T> {
	private T radius;	// radius的类型未定
	public void setRadius(T radius) {
		this.radius = radius;
	}
	public T getRadius() {
		return radius;
	}
	public Circle(T radius) {
		super();
		this.radius = radius;
	}
}

// 使用
Circle<Integer> circle1 = new Circle<>(5);	// 创建一个int类型的Circle对象
Circle<Double> circle2 = new Circle<>(5.5);	// 创建一个double类型的Circle对象
System.out.println(circle1.getRadius());  // 输出circle1的半径

🕘 6.2 枚举

public enum Season {
     SPRING, SUMMER, AUTUMN, WINTER
}

Season se = Season.SPRING;	//	声明并赋值枚举变量se

🕒 7. 继承和多态

继承：从已有的类中派生出新类，新类能拥有已有类的属性和行为，并能拥有扩展新的功能的能力。继承使复用以前的代码变得非常容易，因此能够提高软件开发的效率。
在继承中，父类是所有子类的共性抽象，是一般，而子类可以有自己的特征和行为，是特殊。
方法重写：子类重写父类继承的方法，重写表示重写继承方法的方法体语句，而不是改变方法首部（这与方法重载不同）。
多态：父类引用指向子类对象（或抽象基类对象（变量）引用派生类实例）：Animal animal = new Tiger();

☆ 例题：定义一个动物类，并由此派生出子类老虎类。
思路：在动物类中，定义的属性包括动物的名称、体重，同时，所有的动物都有吃、运动的行为，因此，定义eat方法和run方法。

老虎类继承动物类，因此，继承相关的属性和方法，同时，老虎有自己的新特性，例如狩猎，因此在老虎类有新方法hunt。

package animal;

public class Animal {// 定义动物类
    protected String name; // 定义变量name

    public void run() {
        System.out.println("run");
    }

    public void eat() {
        System.out.println("eat");
    }

    public Animal(String name) {
        this.name = name;
    }

    public Animal() {
        name = "未知";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animal [name=" + name + "]";
    }
}

package animal;

public class Tiger extends Animal {
    public void hunt() { // 添加新方法 狩猎
        System.out.println("hunt");
    }
}

package animal;

public class TigerTest {
    public static void main(String[] args) {
        //  测试老虎类拥有的方法
        Tiger tiger = new Tiger();
        tiger.setName("老虎");    //调用父类方法，设置name属性
        tiger.eat();    //调用父类方法
        tiger.run();    //调用父类方法
        tiger.hunt();   //调用子类新加方法
    }
}

对上述代码的Tiger类继承的方法 walk 和 eat进行方法重写。
思路：Tiger类继承Animal的类的walk 和eat 方法，但Animal类的walk和eat方法不适合Tiger类，因此要重写两个方法的方法体。

package animal;

public class TigerOverride extends Animal {
    //Tiger 继承Animal 并方法重写
    @Override 	// 注解表示该方法为重写父类方法
    public void run() {// 重写父类方法run，重写方法体
        System.out.println("run fast");
    }
    @Override
    public void eat() {// 重写父类方法eat
        System.out.println("eat meat");
    }
    public void hunt() {
        System.out.println("fierce hunting");
    }
}

package animal;

public class TigerOverrideTest {
    public static void main(String[] args) {
        TigerOverride tiger = new TigerOverride();
        tiger.setName("老虎");        // 调用父类方法，设置name属性
        tiger.eat();        // 调用子类重写父类的方法
        tiger.run();        // 调用子类重写父类的方法
        tiger.hunt();       // 调用子类新加方法
    }
}

尝试定义Bird类继承Animal类，并进行测试。
思路：因为鸟是动物，所以Bird可以继承Animal类，同时Bird类有自己的新特征，翅膀，所以定义新属性翅膀，同时重写Animal类的run方法，并在构造方法中对自己的属性进行初始化。

package animal;

public class Bird extends Animal { //Bird继承Animal演示构造方法
    private int wing; // 翅膀个数

    //子类带参构造方法，给name和wing赋值
    public Bird(int wing, String name) {
        super(name); // 调用父类带参的构造方法给name赋值，必须放在第一句
        this.wing = wing;
    }

    public Bird() { //子类无参构造方法，给name和wing赋值
        super("小鸟"); // 调用父类带参的构造方法，给name赋值，必须放在第一句
        wing = 2;
    }

    @Override
    public void run() { // 方法重写
        System.out.println("can fly,can't run");
    }

    @Override
    public String toString() {
        return "Bird [wing=" + wing + ", name=" + name + "]";
    }
}

package animal;

public class BirdTest {
    public static void main(String[] args) {
        //Bird测试类，验证构造方法
        Bird b = new Bird();
        b.run();
        System.out.println(b.toString());
    }
}

1、设计一个抽象类Shape，该类有抽象方法getArea()和 getName()。然后利用继承机制设计出 Shape类的子类Circle，并且重写方法 getArea()和getName()，同时设计另一个子类长方形类Rectangle。在主程序中调用该类，并提示用户输入半径，然后显示该圆的面积。

package Graph;

public abstract class Shape {
    public abstract String getName();
    public abstract double getArea();
}

package Graph;

public class Circle extends Shape {
    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle(double radius) {
        super();
        this.radius = radius;
    }

    public Circle() {
        super();
        radius = 1;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public String getName() {
        return "圆形";
    }
}

package Graph;

public class Rectangle extends Shape {

    private double width;

    public Rectangle(double width, double length) {
        super();
        this.width = width;
        this.length = length;
    }

    public Rectangle() {
        super();
        width = 1;
        length = 1;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    private double length;

    public String getName() {
        return "长方形";
    }

    public double getArea() {
        return width * length;
    }

}

package Graph;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        System.out.print("请输入半径:");
        Scanner sc = new Scanner(System.in);
        double radius = sc.nextDouble();

        Shape s = new Circle(radius);

        System.out.print("请输入长度:");
        double length = sc.nextDouble();
        System.out.print("请输入宽度:");
        double width = sc.nextDouble();

        Shape s1 = new Rectangle(width,length);
        System.out.println(s.getName());
        System.out.println("area = " + s.getArea());
        System.out.println(s1.getName());
        System.out.println("area = " + s1.getArea());
    }
}

2、以电话Phone 为父类，包含本机号码、打电话、接电话等属性和功能，该父类派生智能电话SmartPhone和固定电话Fixedphone为两个子类，在测试类中声明Phone类的数组，将Smartphone对象和Fixedphone对象存入数组，并调用某个方法实现多态。

package TelePhone;

public class Phone {
    private String number;

    public Phone() {
        super();
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public void callUp(String num) {
        System.out.println("呼叫" + num);
    }

    public void acceptCall() {
        System.out.println("有人来电");
    }
}

package TelePhone;

public class Fixedphone extends Phone {
    public void hasLine() {
        System.out.println("固定电话占线");
    }
}

package TelePhone;

public class SmartPhone extends Phone {
    public void takePhoto() {
        System.out.println("take phone......");

    }

    public SmartPhone() {
        super();
    }
}

package TelePhone;

public class Test {
    public static void main(String[] args) {
        Phone[] phones = new Phone[3];
        phones[1] = new SmartPhone();
        phones[2] = new SmartPhone();
        phones[0] = new Fixedphone();

        phones[1].setNumber("19866778899");
        phones[2].setNumber("13268421364");
        phones[0].setNumber("8228611");

        for (int i = 0; i < phones.length; i++) {
            phones[i].callUp("10086");
            phones[i].acceptCall();
        }
    }
}

🕒 8. 接口

1、设计超强安全门，首先要设计一张抽象的门Door，那么对于这张门来说，就应该拥有所有门的共性，开门openDoor()和关门closeDoor()；然后对门进行另外的功能设计，防盗–theftproof()、防水–waterproof()、防弹–bulletproof()、防火、防锈…… 请利用继承、抽象类、接口的知识完成超强安全门的实现过程。

public interface IWaterProof {
    public void waterProff();
}

public interface IBulletProof {
    public void bulletProof();
}

public interface ITheftProof {
	public void pickProof();
}

public abstract class Door {
	public abstract void openDoor();
	public abstract void closeDoor();
}

public class SuperDoor extends Door implements IBulletProof,IWaterProof,ITheftProof{

	@Override
	public void pickProof() {
		System.out.println("The door can pick proof");		
	}

	@Override
	public void waterProff() {
		System.out.println("The door can water proof");
		
	}

	@Override
	public void bulletProof() {
		System.out.println("The door can bullet proof");
		
	}

	@Override
	public void openDoor() {
		System.out.println("The door is open");
		
	}

	@Override
	public void closeDoor() {
		System.out.println("The door is closing");
		
	}
}

常用接口：Comparable接口，此接口的比较方法首部如下：

public int comareTo(Object other);

🕒 9. 异常处理

Exception异常类，是所有异常的直接或间接的父类
try-catch-finally语句
要理解在捕获异常（catch）时，先子类（特殊），后父类（一般）
throws子句：表示需要由方法调用者来处理异常

import java.io.File;
import java.io.FileNotFoundException;
//写一个方法testException，在该方法中抛出FileNotFound异常，并对其调用测试。
public class Exception {
	public static void main(String[] args) {
		try {
			testException("a.txt");
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("File not exist");
		}
	}
	
	public static void testException(String filename) throws FileNotFoundException {
		try {
			 java.io.FileInputStream fis = new 					 java.io.FileInputStream(filename); 		
		}
		catch(Exception e)
		{
			throw new FileNotFoundException();
		}		
	}
}

🕒 10. Java常用类

String类和StringBuffer类
字符串特性

+运算符
toLowerCase, toUpperCase
startsWith, endsWith
charAt
indexOf, lastIndexOf
substring
toCharArray
split

字符串对象不可变性

List列表接口：实现List接口的类ArrayList
sort方法：使用sort方法要求列表中的所有元素都必须实现Comparable接口
max方法
min方法
Collections类：Collection 位于集合框架的顶层

与List、Set、Queue不同，Map是包含一组元素的集合框架
Map以键-值对（key-value）形式保存元素
访问时只能根据每项元素的key来访问其value。key必须唯一，value的值可以重复
Map有两种比较常用的实现类：HashMap和TreeMap

🕒 11. 文件和流

File类：既可以用于描述文件也可以用于描述目录
常用方法

boolean exists(): 判断File对象所对应的文件或目录是否存在
boolean canWrite(): 判断File对象所对应的目录或文件是否可写
boolean canRead(): 判断File对象所对应的目录或文件是否可读
boolean isFile(): 判断File对象所对应的是否是文件，而不是目录
boolean isDirectory(): 判断File对象所对应的是否是目录，而不是文件
long lastModified(): 返回文件最后的修改时间
long length(): 返回文件内容的长度

数据表中的getString()方法

String getString(int columnIndex) throws SQLException
getString表示以 Java 编程语言中String的形式获取此 ResultSet对象的当前行中指定列的值。
参数：columnIndex - 第一个列是 1，第二个列是 2，……
返回：列值；如果值为 SQL NULL，则返回值为 null

1、编写一个程序，从键盘输入一串字符，从屏幕输出并将其存入a.txt文件中。

import java.io.FileOutputStream;
import java.util.Scanner;

public class GetString {

	public static void main(String[] args) throws Exception {
		FileOutputStream fo = new FileOutputStream("a.txt");
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入内容:");
		String str =sc.nextLine();
		System.out.println("内容是:" + str);
		byte[] bytes = str.getBytes();
		
		fo.write(bytes);
		fo.close();
	}
}

2、利用文件输入/输出流编写一个实现文件复制的程序，源文件名和目标文件名通过命令行参数传入。

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class IOCopy {

	public static void main(String[] args) throws Exception {

		FileInputStream in = new FileInputStream("a.txt");
		FileOutputStream out = new FileOutputStream("b.txt");
		int data;
		while((data=in.read())!=-1){
			out.write(data);
		}
		in.close();
		out.close();
	}
}

🕒 12. 程序评价题举例

问题背景：编程模拟和表达老虎Tiger和猫咪Cat等具体种类的生物都是一种动物。即它们都具有共同的名字属性name和运动行为run，只不过具体的名字叫法不同，运动行为的具体方式也不同。比如Tiger可以叫“一只东北虎”等，它是“在森林里猎物”，Cat可以叫“一只宠物猫”，它是“在沙发上卖萌”。为简单起见，模拟程序系统暂时只考虑运动行为run，将来该模拟程序系统可能还要扩展支持更多动物的特征。

版本0.9：下面是一个实现，暂且称为v0.9。

class Tiger{		// 老虎类
	String name;
	Tiger(String name){
		this.name = name;
	}
	
	public void run(){
		System.out.println("%s在森林里猎物\n", name);
	}
}

class Cat{			// 猫咪类
	String name;
	Tiger(String name){
		this.name = name;
	}
	
	public void run(){
		System.out.println("%s在沙发上卖萌\n", name);
	}
}

public class AnimalTest {		// Demo

	public static void main(String[] args) {
		Tiger t = new Tiger("一只东北虎");
		t.run();
		
		Cat c = new Cat("一只宠物猫");
		c.run();
	}
}

问题：请用面向对象思想和技术简单评价该版本的程序实现，并给出一个你认为更好的实现。
作答要求：
（1）用面向对象思想和技术简单评价版本0.9的程序实现，指出其不足。
答：通过建立两个类Tiger和Cat,各自定义了局部变量name和run()方法，后编写公有测试类AnimalTest去新建Tiger对象和Cat对象去调用run()方法，实现功能。不足：当添加的动物对象够多时，就得再新建很多个类，新建多个构造方法去标示name，以及多个run()方法，提高了代码的冗杂度。

（2）把你的改进版本实现的代码有条理的粘贴到下面。

abstract class Animal {
    public abstract String run();

}

class Cat extends Animal {

    public String run() {
        return ("一只猫在沙发上卖萌");
    }
}

class Tiger extends Animal {

    public String run() {
        return ("一只东北虎在森林里猎食\n");
    }
}

public class AnimalTest {
    public static void main(String[] args) {
        Animal animal1 = new Cat();
        System.out.println(animal1.run());
        Animal animal2 = new Tiger();
        System.out.println(animal2.run());
    }
}

（3）简述改进版本的合理性。
答：通过构建一个抽象类Animal，抽象类里构造了一个抽象方法run()，供子类Cat,Tiger去继承重写其抽象方法，若是还需要添加多个动物，直接新建个子类去继承父类Animal去重写其抽象方法即可，降低了代码量，降低了代码的冗杂度。

🕒 13. 专业阅读题举例

Set<Integer> s = null;		// 题目：对于Set函数的解释

A collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. As implied by its name, this interface models the mathematical set abstraction.
The Set interface places additional stipulations, beyond those inherited from the Collection interface, on the contracts of all constructors and on the contracts of the add, equals and hashCode methods. Declarations for other inherited methods are also included here for convenience. (The specifications accompanying these declarations have been tailored to the Set interface, but they do not contain any additional stipulations.)
The additional stipulation on constructors is, not surprisingly, that all constructors must create a set that contains no duplicate elements (as defined above).

翻译：这是一种不包含重复元素的集合。更正式地说，集合中不包含任何两个元素e1和e2使得e1.equals(e2)，并且最多只有一个null元素。顾名思义，这个接口模拟了数学中的集合抽象。

Set接口对所有构造函数以及add、equals和hashCode方法的契约，除了从Collection接口继承的规定之外，还增加了额外的规定。为了方便起见，这里也包含了其他继承方法的声明。（这些声明的附带规范已经针对Set接口进行了调整，但它们并未包含任何额外的规定。）

对构造函数的额外规定并不令人惊讶，即所有的构造函数必须创建一个不包含重复元素的集合（如上所定义）。

🕒 14. 往年真题（部分）

1、编程题：编写一个完整的 Java Application程序。包含接口 ShapeArea，类Rectangle、Test，具体要求如下:
（1）传统方式定义的接口 ShapeArea：提供如下两个接口方法:
double getArea()：求一个形状的面积
double getPerimeter()：求一个形状的周长
（2）类Rectangle：实现 ShapeArea 接口，并有以下属性和方法：
① 属性
width: double型，表示长方形的宽度
height: double型，表示长方形的长度
② 方法
Rectangle(double w,double h)：构造函数
toString()：输出矩形的描述信息，如
“width=1.0, height=2.0, perimeter=6.0,area=2.0”
（3）Test 类作为主类完成测试功能，题目已经给出，如下所示，请编程完成其他要求。

public class Test{
	public static void main (string args[]） {
		Rectangle r=new Rectangle(1,2）;
		System.out.println(r.toString());
	}
}

解答：

// 定义接口 ShapeArea
interface ShapeArea {
    public abstract double getArea();
    public abstract double getPerimeter();	// 可以没有public和 abstract
}

// 定义类 Rectangle，实现 ShapeArea 接口
class Rectangle implements ShapeArea {
    double width, height;
    // 构造函数，初始化宽度和高度
    Rectangle(double w, double h) {
        width = w;
        height = h;
    }

    public double getArea() {
        return width * height;
    }

    public double getPerimeter() {
        return 2 * (width + height);
    }

    // 重写 toString 方法，返回 Rectangle 对象的描述信息
    public String toString() {
        return "width=" + width + ", height=" + height + ", perimeter=" + getPerimeter() + ", area=" + getArea();
    }
}

AI评价：这个程序很好地展示了Java的面向对象编程特性，包括类、接口、继承和多态。Rectangle 类实现了 ShapeArea 接口，这意味着它必须提供 getArea 和 getPerimeter 方法的实现。这个程序也很好地展示了如何使用 toString 方法来提供类的字符串表示，这在打印或记录对象时非常有用。

2、设计名为 Circle的类。要求：

一个 double类型私有数据域radius表示圆半径，默认值为1.0；
一个 String类型的私有数据域color表示圆形的颜色，默认值为 “white”
无参数构造方法；
一个创建radius 和 color 为指定值的圆形的带参数构造方法
getColor() 方法返回数据域color的值；
getRadius() 方法返回数据域radius的值；
getArea() 方法返回圆形的面积；

同时编写上面Circle类的测试类，要求:

类名：TestCircle（测试代码写在main方法中）
创建一个圆形的对象：c1，半径为10，颜色为"Black"
依照圆形的半径、颜色、面积显示

解答：

public class Circle {
    private double radius = 1.0;
    private String color = "white";

    public Circle() {
    }

    public Circle(double radius, String color) {
        this.radius = radius;
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public double getRadius() {
        return radius;
    }

    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class TestCircle {
    public static void main(String[] args) {
        Circle c1 = new Circle(10, "Black");
        System.out.println("Radius: " + c1.getRadius());
        System.out.println("Color: " + c1.getColor());
        System.out.println("Area: " + c1.getArea());
    }
}

❗ 转载请注明出处
作者：HinsCoder
博客链接：🔎 作者博客主页

HinsCoder

关注

28
点赞
踩
37

收藏

觉得还不错? 一键收藏
0
评论
【Java语言设计】——期末复习（冲刺篇）

📖 前言：快考试了，做篇期末总结，都是重点与必考点。题型：判断题、单选题、程序综合题（阅读程序并填空）、改错题、代码评价题、英语专业阅读题（如给出某函数的开发文档（英文）用法解释要求翻译为中文）、编程设计题（继承、接口、多态）
复制链接

扫一扫