Java期末习题速通

变量与运算

编写 Java 程序，完成以下操作：

1. 声明并初始化两个整型变量 a（值为 25）、b（值为 12）；
2. 声明并初始化一个浮点型变量 c（值为 3.14）、d（值为 2.0）；
3. 计算并输出 a + b、a - b、a * b、a / b（整型除法）、a % b（取余）的结果；
4. 计算并输出 c + d、c - d、c * d、c / d（浮点型除法）的结果；
5. 要求：所有结果需附带文字说明。

答案示例

public class MyTest {
    public static void main(String[] args) {
        int a=25,b=12;
        float c=3.14f;    // Java中小数默认为double类型,给float类型的变量赋值,需在数值后加上f或F,说明该值为float类型    
        double d=2.0;     // double类型可加可不加D或d
        System.out.println("a+b="+(a+b)+" "+"a-b="+(a-b)+" "+"a*b="+(a*b)+" "+"a/b="+(a/b));     // 利用字符串拼接特性
        System.out.println("c+d="+(c+d)+" "+"c-d="+(c-d)+" "+"c*d="+(c*d)+" "+"c/d="+(c/d));
    }
}

编写 Java 程序，利用字符型变量的 ASCII 码特性完成操作：

1. 声明并初始化字符变量 ch1 = 'A'，ch2 = 'b'；
2. 输出 ch1 和 ch2 的字符值及其对应的 ASCII 码值；
3. 利用算术运算完成以下转换并输出结果：
   • 将 ch1 转换为小写字母
   • 将 ch2 转换为大写字母
   • 计算 'Z' - 'A' + 1，输出英文字母的总个数；
4. 声明字符变量 ch3 = '5'，将其转换为对应的整数 5，并输出转换后的整数。

public class MyTest {
    public static void main(String[] args) {
        char ch1='A',ch2='b';
        System.out.println("ch1的字符值为:"+ch1+"ASCII码值为"+(int)ch1);
        System.out.println("ch2的字符值为:"+ch2+"ASCII码值为"+(int)ch2);
        System.out.println("ch1对应的小写字母为:"+(char)(ch1+32));
        System.out.println("ch2对应的大写字母为:"+(char)(ch2-32));
        System.out.println("大写英文字母的总个数为:"+('Z'-'A'+1));
        char ch3='5';
        System.out.println("ch3对应的整数为:"+(int)(ch3-'0'));
    }
}

编写 Java 程序，完成比较运算和逻辑运算的验证：

1. 声明并初始化变量 p = 15，q = 22，r = 9；
2. 依次计算以下比较表达式的值（布尔类型），并输出表达式和结果
   • p > q
   • p < r
   • q >= 22
   • p == 15
   • q != 20
3. 基于上述变量，计算以下逻辑表达式的值，输出表达式和结果：
   • (p > q) && (q > r)
   • (p > q) || (q > r)
   • ! (p == 15)
   • (p < q) && (r > 5) || (q == 20)
4. 额外要求：输出逻辑与（&&）的 "短路特性" 验证。

public class MyTest {
    public static void main(String[] args) {
        int p=15,q=22,r=9;
        System.out.println("p>q:"+(p>q)+" p<r:"+(p<r)+" q>=22:"+(q>=22)+" p==15:"+(p==15)+" q!=20"+(q!=20));
        System.out.println("(p>q)&&(q>r):"+((p>q)&&(q>r))+" (p>q)||(q>r):"+((p>q)||(q>r))+" !(p==15):"+(!(p==15)));
        System.out.println("(p<q)&&(r>5)||(q==20):"+((p<q)&&(r>5)||(q==20)));
        boolean shortCircuit=(p>q)&&(++r>5);
        System.out.println("shortCircuit:"+shortCircuit+" r:"+r);
        //System.out.println("验证&&的短路特性:"+((p>q)&&(r/0)));   --&&是逻辑运算符,要求两边都是布尔值,Java中其它类型值不能与布尔类型进行相互转换
    }
}

程序控制结构if else,for

给定 Java 数组 int[] nums = {15, 28, 9, 33, 21, 19, 40, 7}，完成以下操作：

1. 先计算数组所有元素的平均值（保留 2 位小数）；
2. 筛选出数组中大于平均值的所有元素，存入新数组（注意：新数组长度动态匹配筛选结果）；
3. 打印平均值和筛选后的新数组。

public class MyTest {
    public static void main(String[] args) {
        int[] nums={15,28,9,33,21,19,40,7};
        int sum=0;
        for(int num:nums){
            sum+=num;
        }
        double average=sum*1.0/nums.length;
        System.out.printf("Average:%.2f",average);
        sum=0;
        for(int num:nums){              // foreach形式遍历
            if(num>average){
                sum++;
            }
        }  
        int[] result=new int[sum];     
        for(int i=0,j=0;i<nums.length;i++){
            if(nums[i]>average){
                result[j]=nums[i];
                j++;
            }
        }
        for(int num:result){
            System.out.print(num+" ");
        }
    }
}

使用 Java 的嵌套 for 循环打印标准九九乘法表，要求格式工整（每行表达式对齐）。

public class MyTest {
    public static void main(String[] args) {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.printf("%d*%d=%-4d",j,i,j*i);    // 左对齐，占4个字符宽度
            }
            System.out.println();
        }
    }
}

编写Java程序，验证哥德巴赫猜想，即大于6的偶数等于两个素数的和。编程将6~100所有偶数表示成两个素数之和

public class MyTest {
    static boolean isSusu(int x){
        if(x<2) return false;
        for(int i=2;i*i<=x;i++){
            if(x%i==0) return false;
        }
        return true;
    }
    public static void main(String[] args) {
        for(int i=6;i<=100;i+=2){
            for(int j=2;j<i;j++){
                if(isSusu(j) && isSusu(i-j)){
                    System.out.println(i + " = " + j + " + " + (i-j));
                    break;
                }
            }
        }
    }
}

（注意，非静态方法不能在静态方法中直接调用，所以isSusu()方法不能直接在main()方法调用。要么给isSusu加static，要么创建MyTest实例再调用方法。）

编写程序，根据公式Π/4=1-1/3+1/5-1/7+...，求Π的值。要求精确到最后一项的绝对值小于10的-6次方，输出Π值，保留6位小数

public class MyTest {
    public static void main(String[] args) {
        int flag=1;
        double sum=0;
        for(int i=1;;i+=2){
            sum+=flag*(1.0/i);
            flag=-flag;
            if(1.0/i<0.000001){      // 10的-6次方这样写就好咯
                break;
            }
        }
        System.out.printf("%.6f",sum*4);
    }
}

数组

动态初始化数组

int arr[]=new int[3];   // 或者
int[] arr=new int[3];

编写程序计算矩阵的鞍点。鞍点指矩阵中的一个元素，既是所在行的最大值，又是所在列的最小值。

public class MyTest {
    public static void main(String[] args) {
        int[][] nums={{11,3,5,6,9},
                      {12,4,7,8,10},
                      {10,5,6,9,11},
                      {8,6,4,7,2},
                      {15,10,11,20,25}
                    };
        int r=-1,c=-1;
        for(int i=0;i<nums.length;i++){
            int flag=1;
            int max=-1;
            for(int j=0;j<nums[i].length;j++){
                if(nums[i][j]>max){
                    max=nums[i][j];
                    c=j;
                }
            }
            for(int k=0;k<nums.length;k++){
                if(nums[k][c]<max){
                    flag=0;
                    break;
                }
            }
            if(flag==1){
                r=i;
                break;
            }
        }
        if(r!=-1 && c!=-1){
            System.out.println(r+1+" "+(c+1)+" "+nums[r][c]);
        }
    }
}

编写程序实现整数去重功能。输入含有n个整数的序列，对这个序列中每个重复出现的数，只保留该数第一次出现的位置，删除其余位置。

类和子类

设计一个复数类Complex，其要求如下：

1.类的成员变量包括复数实部和复数虚部

2.定义两个构造方法，分别提供两个形参和一个形参（仅实部）

3.定义输出复数的方法，其格式为"实部"+/-"虚部i"，如其虚部为0则不输出

4.定义复数的加法、减法和乘法

5.在主方法中创建Complex类型的复数，测试上述方法

class Complex{     // 一个程序中只能有一个public类
    int real;      
    int imag;
    public Complex(int r, int i){
        real = r;
        imag = i;
    }
    public Complex(int r){
        this(r,0);
    }
    public void print(){
        if(imag==0){
            System.out.println(real);
        }else if(imag>0){
            System.out.println(real+"+"+imag+"i");
        }else{
            System.out.println(real+""+imag+"i");           // 注意正负号
        }
    }
    public Complex add(Complex c){                   // 返回Complex类型，支持连加
        return new Complex(this.real + c.real, this.imag + c.imag);
    }
    public Complex sub(Complex c){
        return new Complex(this.real - c.real, this.imag - c.imag);
    }
    public Complex mul(Complex c){
        return new Complex(this.real * c.real - this.imag * c.imag,this.real * c.imag + this.imag * c.real);
    }
}
public class MyTest {
    public static void main(String[] args){
        Complex c1=new Complex(1,2);
        Complex c2=new Complex(3);
        Complex c3=new Complex(0,4);
        Complex result=c1.add(c2).sub(c3).mul(c1);
        result.print();   
    }
}

设计类People，成员变量包括姓名、性别和年龄，方法包括构造方法，并重写toString()方法，输出类成员信息；设计People的子类Teacher，成员变量还包括专业、职称，方法包括构造方法，并重写toString()方法，输出类成员信息；设计People的子类Graduate，包含成员变量专业和导师，方法包括构造方法，并重写toString()方法

class People{
    private String name,sex;       // 默认是包访问权限
    private int age;
    public People(String n,String s,int a){
        name=n;       // 注意规范;才是语句结束符
        sex=s;
        age=a;
    }
    public String toString() {
        return "Name: " + name + ", Sex: " + sex + ", Age: " + age;
    }
}
class Teacher extends People{
    private String title;
    private String major;
    public Teacher(String n,String s,int a,String t,String m){
        super(n,s,a);                           // 调用父类的构造方法
        title=t;
        major=m;
    }
    public String toString() {
        return super.toString() + ", Title: " + title + ", Major: " + major;  // 使用super.toString()调用父类的同名方法
    }
}
class Graduate extends People{
    private String major;
    private Teacher teacher;
    public Graduate(String n,String s,int a,String m,Teacher t){
        super(n,s,a);                           // 调用父类的构造方法
        major=m;
        teacher=t;
    }
    public String toString() {
        return super.toString() + ", Major: " + major + "\nTeacher: " + teacher.toString();
    }
}
public class MyTest {
    public static void main(String[] args){
        Teacher t=new Teacher("Alice","Female",35,"Professor","Computer Science");
        Graduate g=new Graduate("Bob","Male",24,"Computer Science",t);
        System.out.println(g.toString());
    }
}

接口

设计接口Computable，包含抽象方法compute(int a,int b)

设计类Add、Sub分别实现接口Computable，完成加、减运算

设计类Computer，包含方法useCompute(Computable c,int a,int b)，进行运算并输出结果

interface Computable {                        // 接口定义
    int compute(int a,int b);
}
class Add implements Computable {             // 类实现Computable接口
    public int compute(int a,int b){
        return a + b;
    }
}
class Sub implements Computable {
    public int compute(int a,int b){
        return a - b;
    }
}
class Computer{
    public void useCom(Computable c,int a,int b){           // 接口类型作为方法参数，实现多态
        System.out.println(c.compute(a, b));          
    }
}
public class MyTest {
    public static void main(String[] args){
        Computer computer = new Computer();
        computer.useCom(new Add(), 5, 3);                   // 接口类型变量可以接收任意它的实现类对象
        computer.useCom(new Sub(), 5, 3);
    }
}

异常

设计类Triangle，成员变量包括三角形3条边长，方法包括构造方法和showInfo()方法

自定义异常类NotTriangleException，当3条边长不能构成三角形时抛出异常，捕获异常并处理

class Triangle{
    int a,b,c;
    public Triangle(int a,int b,int c) throws NotTriangleException{   // 关键字throws，声明方法可能抛出异常信息
        if(a+b>c&&a+c>b&&b+c>a){
            this.a=a;
            this.b=b;
            this.c=c;
        } else {
            throw new NotTriangleException();                         // throw抛出异常 
        }
    }
    void showInfo(){
        System.out.println("a="+a+", b="+b+", c="+c);
    }
}
class NotTriangleException extends Exception{              // 自定义异常类
    public String toString(){                              // 重写toString()方法，输出异常信息
        return "发生异常，输入的三条边无法构成三角形！";
    }
}
public class MyTest {
    public static void main(String[] args){
        try{
            Triangle t = new Triangle(3, 4, 5);
            t.showInfo();
            Triangle t2 = new Triangle(1, 2, 3);    // 此处会抛出异常
            t2.showInfo();
        } catch (NotTriangleException e) {
            System.out.println(e);
        }
    }
}

try...catch...finally

public class MyTest {
    public static int test(int b){
        try{
            b+=10;
            return b;
        }catch(Exception e){
            return 1;
        }
        finally            // 无论try块是否抛出异常、是否执行return，都会在方法返回前强制执行finally代码块
        {
            b+=5;
            return b;
        }
    }
    public static void main(String[] args){
        int num = 5;
        System.out.println(test(num));      // 输出20
    }
}

集合类

Java集合是一种容器，按照存储结构可以分为两大类：单列集合Collection和双列集合Map

单列集合数据一个一个存储，双列集合数据一对一对存储（两个）

Collection

Collection包含两个重要的子接口：List和Set（Collection接口是两者的父接口）

List

List系列集合存储的元素是有序（存入顺序和取出顺序一致）、可重复、有索引的

ArrayList

ArrayList是List接口的一个实现类，可以动态分配内存，是一个长度可变的数组，随机访问元素效率高。

Collection<String> col=new ArrayList<>();        // Collection是接口，不能直接创建它的对象
col.add("Hello");                                // 可以通过它的实现类创建对象                                                 
System.out.println(col);                         // 此方式可通过Collection实现多态

同理List

List<String>list=new ArrayList<>();

ArrayList类的使用实例

import java.util.ArrayList;

public class MyTest {
    public static void main(String[] args){
        ArrayList list = new ArrayList();     // 创建ArrayList集合对象
        list.add("Hello");                    // 添加元素
        list.add("World");
        for(int i=0;i<list.size();i++){       // 集合长度获取
            System.out.println(list.get(i));  // 获得指定位置元素
        }
        for(Object ch:list){                  // 增强for（所有类都是Object类的子类哦）
            System.out.println(ch);  
        }
    }                                                    
}

LinkedList

LinkedList也是List接口的实现类，采用双向链表的结构保持元素。插入、删除元素效率高，随机访问效率低。

LinkedList类使用实例

import java.util.LinkedList;

public class MyTest {
    public static void main(String[] args){
        LinkedList list=new LinkedList();       // 创建LinkedList对象
        list.add("Python");                   
        list.add(0,"Java");      // 在索引为0的位置插入对象
        list.add("C");
        System.out.println(list.getFirst());    // 获得第一个元素
        System.out.println(list.pollFirst());   // 移除并返回第一个元素
        for(int i=0;i<list.size();i++){     
            System.out.println(list.get(i));    // 获得索引为i位置的元素
        }
    }                                                    
}

set

set系列集合存储的元素是无序（存入和取出的顺序）、不重复、无索引的。

HashSet

具有良好的查找性能，元素无序

HashSet类使用实例

import java.util.HashSet;

public class MyTest {
    public static void main(String[] args){
        HashSet set=new HashSet();        // 创建HashSet对象
        set.add(new Integer(108));  // 向HashSet中添加不同类型的对象
        set.add(new Float(3.14));
        set.add(new String("你好"));
        set.add(new Integer(108));   // 元素不能重复
        System.out.println(set.size());    
        for(Object c:set){
            System.out.println(c);
        }
        set.remove(108);
        Object[] a=set.toArray();          // 转为数组类型
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }                                                    
}

LinkedHashSet

有序

TreeSet

可排序

Map

Map接口是一种双列集合，集合中的每个元素都由键对象和值对象组成，键和值之间存在映射关系。键不能重复，值可以重复。"键值对"或"键值对对象"在Java中叫做"Entry对象"。

HashMap

HashMap是Map接口的一个实现类。

import java.util.HashMap;

public class MyTest {
    public static void main(String[] args){
        HashMap map=new HashMap();
        map.put("a","b");
        map.put("a","b");  // 若键已存在，会将原有的键值对对象覆盖，会返回被覆盖的值
        map.put("c","d");
        System.out.println(map.get("a"));    // get()方法获取键对象对应的值对象
        System.out.println(map.containsKey("c"));  // 判断键是否存在
        System.out.println(map.keySet());     // 获取集合中所有键的集合
        System.out.println(map.values());
        System.out.println(map);        
        Set<String> keys=map.keySet();
        for(String key:keys){
            String value=map.get(key);
        }
    }                                                    
}

泛型

泛型：可以在编译阶段约束操作的数据类型，并进行检查

泛型格式：<数据类型>

数据类型只能写引用数据类型

ArrayList<String> list=new ArrayList<>();  // 只能添加String类型的元素

泛型类

在定义一个类时，若数据类型不确定时，可定义带有泛型的类，在创建该类对象时再确定类型。

class MyArrayList<E>{ 
    Object[] obj=new Object[10];
    int size;
    public boolean add(E e){    // E是不确定的类型
        obj[size++]=e;
        return true;
    }
    public E get(int index){
        return (E)obj[index];
    }
}

泛型方法

方法中形参类型不确定，可以定义带有泛型的方法

public<E> void addAll(ArrayList<E> list,E e1){
    list.add(e1);
}

哎呀，我已经考完了，就到这里吧