【Java PTA作业】当老师一口气布置八个作业（ 8 / 8 ）

1、若有定义:int x=3,y=2;float a=2.5,b=4.5;则下面表达式的值为（）。

(x+y)%2+(int)a/(int)b。

A.1.0

B.1

C.1.5

D.2

(int)a=2 (int)b=4 int转化float类型只保留整数

5%2=1 + 2/4 = 1 + 0 = 1

2、下列代码的执行结果是（）

public class Main {
    public static void main(String[] args) {
       int a=2,b=8,c=6;
       String s = "abc";
       System.out.println(a+b+s+c);
       System.out.println();
    }
}

10abc6

3、JAVA中，下面哪个赋值表达式正确：（）

A.float f=1.3; java默认类型是double 应该是float f=1.3f

B.char c="a";

C.byte b=257;

257是int类型，直接赋值给byte类型报错，正确的写法应该是 byte b = (byte) 257

D.int i=10;

4、Java源代码文件的扩展名为（ C ）

A..txt

B..class

C..java

D..doc

5、下列关于变量作用域的说法中，正确的是（）

A.在main()方法中任何位置定义的变量，其作用域为整个main()方法。

B.代码块中定义的变量，在代码块外也是可以使用的。

C.变量的作用域为：从定义处开始，到变量所在代码块结束的位置。

D.变量的作用域不受代码块的限制。

6、以下（）不是Java中正确的整数表示。

A.22

B.0x22

C.022

D.22H

选项A中表示的是十进制的整数

选项B中表示的是十六进制的整数

选项C中表示的是八进制的整数

选项D它表示的也是十六进制整数，只不过它的表示方法在Java中不能使用，它是在汇编或接口中使用的十六进制表示整数的方法

作业二：程序控制结构

一、单选题

1、对于break语句和continue语句，说法正确的是（）。

A.break语句只应用于循环体中 switch也可以用break

B.continue语句只应用于循环体中

C.break是无条件跳转语句，continue不是

D.break和continue的跳转范围不够明确，容易产生问题

二、程序填空题

1、功能：计算正整数num的各位上的数字之积。

例如：输入252，则输出应该是20。

import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //int n=sc.next();//此行语句有错误，改正后填到下侧空格内
        int n=sc.nextInt();
        //System.out.println(fun(int n));//此行语句有错误，改正后填到下侧空格内
        System.out.println(fun(n));
    }
    //public int fun(int num)//此行语句有错误，改正后填到下侧空格内
    public static int fun(int num)
    {
        //int k;//此行语句有错误，改正后填到下侧空格内
        int k=1;
        do{
            k=k*(num%10);
            //num\=10;//此行语句有错误，改正后填到下侧空格内
            num/=10;
        }while(num>0);
        return k;
    }
}

注意：public class Main主函数里所有方法必须是静态的static！！！

三、编程题

7-3 sdut-循环-5-百钱买百鸡

一只公鸡五块钱，一只母鸡三块钱，三只小鸡一块钱，现在要用一百块钱买一百只鸡，问公鸡、母鸡、小鸡各多少只？

输入格式:

无输入。

输出格式:

输出所有的解决方案。

每种解题方案各在一行内输出，一行按顺序输入公鸡、母鸡、小鸡的数量，其中每个数值占2个字符的位置，不足2位的数值右对齐放置。

多种解题方案，按公鸡数量从小到大的顺序排列。

输入样例:
输出样例:
公鸡 0只，母鸡25只，小鸡75只
公鸡 4只，母鸡18只，小鸡78只
公鸡 8只，母鸡11只，小鸡81只
公鸡12只，母鸡 4只，小鸡84只

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<20;i++)
           for(int j=0;j<33;j++)
               for(int k=0;k<300;k+=3)
                   if(i*5+j*3+k/3==100&&i+j+k==100)
                   {
                       System.out.printf("公鸡%2d只，母鸡%2d只，小鸡%2d只\n",i,j,k);
                   }
    }
}

作业三：类与对象

一、单选题

1、在Java中，负责对不再使用的对象自动回收的是（）

A.垃圾回收器

B.虚拟机

C.编译器

D.多线程机制

2、下面哪句说法是正确的？ A

A.在类中若无显式定义构造函数，会自动产生一个缺省构造器。

B.必须显式定义一个构造函数。

C.每个类都有一个缺省构造函数。 可以没有

D.缺省构造函数可以有参数也可以没有参数。 缺省构造函数没有参数

类可以有多个构造函数,但最多只能有一个缺省的构造函数,当然类也可能没有缺省的构造函数

3、已如类A的定义如下，程序代码执行结果是：（）。

class A {
 int v = 10;

 public void print() {
  int v = 100;
  System.out.println(v);
 }
}

public class Main {
 public static void main(String[] args) {
  A a=new A();
  a.print();
 }
}

100

4、关于类和对象的关系，下列说法哪种说法是错误的？

A.类和对象都是具体的。

B.类是抽象的，对象是具体的。

C.一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。

D.类是引用型数据类型。

5、下列关于修饰符使用的说法，错误的是（）。

A.abstract不能与final并列修饰同一个类

B.abstract类中可以有private的成员

C.abstract方法必须在abstract类中

D.static方法中能访问非static的属性

二、编程题

6-2 长方形长方体类

定义一个长方形类Rectangle，拥有长、宽属性，提供构造方法，能够计算周长getPerimeter()和面积getArea() 。

定义一个子类长方体类，拥有长、宽、高属性，提供构造方法，getPerimeter()方法计算所有边的周长，getArea()方法计算表面积，新增getVolume()方法，计算体积。

在main()方法中，分别构造长方形类和长方体类的对象，并输出他们的周长、面积、体积，保留两位小数。

class Rectangle
{
    double length,wide;
    
    public Rectangle(double length,double wide)
    {
        this.length=length;
        this.wide=wide;
    }
    public double getPerimeter() //计算周长
    {
        return (length+wide)*2;
    }
    public double getArea() //计算面积
    {
        return length*wide;
    }
}

class Cuboid extends Rectangle
{
    double height;
    
    public Cuboid(double length,double wide,double height)
    {
        super(length,wide);
        this.height=height;
    }
    //@Override
    public double getPerimeter() //计算周长
    {
        return (length+wide+height)*4;
    }
    //@Override
    public double getArea() //计算面积
    {
        return (length*wide+height*length+height*wide)*2;
    }
    public double getVolume()
    {
        return length*wide*height;
    }
}

作业四：继承与多态

一、单选题

1、以下对重载描述错误的是

A.方法重载只能发生在一个类的内部

B.构造方法不能重载

C.重载要求方法名相同，参数列表不同

D.方法的返回值类型不是区分方法重载的条件

2、下列哪个叙述是正确的？

A.一个类最多可以实现两个接口

B.允许接口中只有一个抽象方法

C.如果一个抽象类实现某个接口，那么它必须要重写接口中的全部方法

D.如果一个非抽象类实现某个接口，那么它可以只重写接口中的部分方法

如果子类是抽象类，则可以写接口中的部分方法，因为抽象类允许抽象方法的存在
如果子类是非抽象类，则它必须重写接口中所有方法

3、Java关于方法的重写，哪个说法是错误的？（）

A.对一个方法的重写必须发生在具有继承关系的两个类中，即子类对父类方法的重写。

B.方法的重写在一般意义上要求：两个方法的参数个数和类型以及返回值类型都一致。

C.方法的重写是一个类的两个方法，方法的名称相同，但参数不同。

D.子类对象调用子类重写了父类的方法时，优先调用子类的方法。

4、输出结果是

class A {
    int a = 11;
    int b = 12;

    public void print() {
        System.out.println(a + " " + b);
    }
}

class B extends A {
    int a = 20;

    public void print() {
        System.out.println(a + " " + b);
    }
}

public class Main {
    public static void main(String[] args) {
        A aObj = new A();
        aObj.print();
        B bObj = new B();
        bObj.print();
    }
}

11 12

20 12

5、

class A {
 double f(double x, double y) {
  return x * y;
 }
}

class B extends A {
 double f(double x, double y) {
  return x + y;
 }
}

public class Test {
 public static void main(String args[]) {
  A obj = new B();
  System.out.println(obj.f(4, 6));
 }
}

10.0

6、以下关于继承的叙述正确的是（）。

A.在Java中类只允许单一继承

B.在Java中,一个类只能实现一个接口

C.在Java中，一个类不能同时继承一个类和实现一个接口

D.在Java中，接口也具有单继承性

7、接口是一种特殊的类，由（）和公共的抽象方法组成，不能包含普通方法和构造方法。

A.全局常量

B.成员变量

C.成员方法

D.构造方法

二、程序填空题

super使用--有如下父类和子类的定义，根据要求填写代码

class Father {
     int a;
     public Father(int a) 
     {
        this.a=a;
     }
     public void print() 
     {
        System.out.println(a);
     }
}

class Child extends Father {
     int a;
     public Child(int a) 
     {
         super(a);      // 将形参a的数值赋给父类成员变量a 
         this.a=a*10;   // 将父类成员变量a的值*10赋给本类的成员变量a
     }
     public void print()
     {
          System.out.println(super.a);    // 输出父类成员变量a的值
          System.out.println(this.a);      // 输出子类成员变量a的值
     }
}

public class Main {
    public static void main(String[] args) 
    {
        Child child=new Child(10);
        child.print();
    }
}

设计一个ComparableCircle类继承自Circle类并实现Comparable接口

class Circle {
    private double radius;

    public Circle()
     {
        radius = 1;
    }

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

    public double getRadius() {
        return radius;
    }

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

    public double getArea() {
        return Math.PI*radius*radius;
    }
    public String toString() {
        return "Cirlce: radius = "+radius;
    }
}

class ComparableCircle extends Circle implements Comparable<ComparableCircle> {

    public ComparableCircle() 
    {
    }

    public ComparableCircle(double radius) 
    {
        super(radius);
    }

    @Override // Implement the compareTo method defined in Comparable
    public int compareTo(ComparableCircle o) {
        if (getArea() > o.getArea())
            return 1;
        else if (getArea() < o.getArea())
            return -1;
        else
            return 0;
    }

    @Override
    public String toString() 
    {
        return super.toString()+ "\nArea: " + getArea();
    }
}
public class Main {
    public static void main(String[] args) {
        ComparableCircle c1 = new ComparableCircle(7);
        ComparableCircle c2 = new ComparableCircle(5);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println((c1.compareTo(c2)>=0)?"c1较大":"c2较大");
}
}

三、函数题

6-1 重写父类方法equals

在类Student中重写Object类的equals方法。使Student对象学号(id)相同时判定为同一对象。

裁判样例：

import java.util.Scanner;
class Student {
     int id;
     String name;
     int age;
     public Student(int id,     String name,     int age) {
         this.id = id;
         this.name = name;
         this.age = age;
     }
     
     /* 请在这里填写答案 */
         
}
public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
        Student s1 = new Student(sc.nextInt(),sc.next(),sc.nextInt());
        Student s2 = new Student(sc.nextInt(),sc.next(),sc.nextInt());
        System.out.println(s1.equals(s2));
        sc.close();
    }
}

public boolean equals(Student stu)
{
    if(this.id==stu.id) return true;
    return false;
}

6-2 设计一个Circle类

构造一个Circle类，该类有一个double变量radius存放半径，该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。
该段程序会自动提交

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {

        // TODO Auto-generated method stub
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextFloat()){
            double r=scanner.nextDouble();
            Circle c = new Circle(r);
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
            c.radius = 2*r;
            System.out.printf("%.2f %.2f\n",c.getArea(),c.getLength());
        }
    }
}
输入样例：

在这里给出一组输入。例如：
5
输出样例：

在这里给出相应的输出。例如：
78.54 31.42
314.16 62.83

class Circle
{
    double radius;
    
    public Circle(double r)
    {
        radius=r;
    }
    public double getArea()
    {
        return Math.PI*radius*radius;
    }
    public double getLength()
    {
        return Math.PI*radius*2;
    }
}

四、编程题

7-2 接口--四则计算器

利用接口做参数，写个计算器，能完成加减乘除运算。

定义一个接口ICompute含有一个方法int computer(int n, int m)。
定义Add类实现接口ICompute，实现computer方法，求m，n之和
定义Sub类实现接口ICompute，实现computer方法，求n-m之差
定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。

输入格式:

输入在一行中给出2个整数

输出格式:

输出两个数的和、差

输入样例:

在这里给出一组输入。例如：
6 7
输出样例:

在这里给出相应的输出。例如：
13
-1

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int a=sc.nextInt(),b=sc.nextInt();
        Add add=new Add(a,b);
        Sub sub=new Sub(a,b);
        System.out.println(add.computer(a,b));
        System.out.println(sub.computer(a,b));
    }
}

interface ICompute
{
    abstract int computer(int n,int m);
}

class Add implements ICompute
{
    int m,n;
    
    Add(int n,int m)
    {
        this.n=n;
        this.m=m;
    }
    
    public int computer(int n,int m)
    {
        return m+n;
    }
}

class Sub implements ICompute
{
    int m,n;
    
    Sub(int n,int m)
    {
        this.n=n;
        this.m=m;
    }
    
    public int computer(int n,int m)
    {
        return n-m;
    }
}

作业五：数组与字符串

一、单选题

1、关于字符串的构造方法，如下代码执行结果是（ BCD ）。
String str="ABCDEFG";
char[] chars=str.toCharArray(); 
System.out.println(new String(chars,1,3));
String(chars,idx,len) 从idx下标开始 len长度的字符串

二、程序填空题

1、实现字符串大小写的转换并倒序输出。

import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        StringBuffer sb = new StringBuffer();
        String s1 = null;
        
        for (int i = str.length() - 1; i >= 0; i--) 
        {
            char curChar = str.charAt(i);
            if (curChar >= 'a' && curChar <= 'z')
                s1 = String.valueOf(curChar).toUpperCase();
            else if (curChar >= 'A' && curChar <= 'Z')
                s1 = String.valueOf(curChar).toLowerCase();
            else
                s1 = String.valueOf(curChar);
            sb.append(s1);
        }
        
        System.out.println(sb.toString());
    }
}

三、编程题

7-1 找出10个整数中的最大值、最小值、偶数的个数、偶数的平均值

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int[] a=new int[10];
        
        for(int i=0;i<10;i++) a[i]=sc.nextInt();
        int maxx=a[0],minx=a[0];
        int sum=0,cnt=0;
        for(int i=0;i<10;i++)
        {
            if(a[i]>maxx) maxx=a[i];
            if(a[i]<minx) minx=a[i];
            if(a[i]%2==0)
            {
                sum+=a[i];
                cnt++;
            }
        }
        double avg=0.0;
        if(cnt!=0) avg=sum*1.0/cnt;
        System.out.println("最大值是"+maxx);
        System.out.println("最小值是"+minx);
        System.out.println("偶数的个数是"+cnt);
        System.out.printf("偶数的平均值是%.1f",avg);
    }
}

7-2 字符串加密

输入一个原始字符串（长度小于80），然后输入一个5位的数字字符串作为加密密钥，对原始字符串中的每个字符根据其位置（对5取模）变换为加上数字字符串中的数字的字符。如输入原始字符串student，然后输入5位的加密数字12345，因此:
原始字符   加密数字  变换后的字符
   s          1         t
   t          2         v
   u          3         x
   d          4         h
   e          5         j
   n          1         o
   t          2         v
        
加密后的字符串位：tvxhjov

输入格式:

第一个输入一个原始字符串
第二行输入一个5位用来加密的数字字符串

输出格式:

加密后的字符串

输入样例1:

在这里给出一组输入。例如：
student
12345
输出样例1:

在这里给出相应的输出。例如：
tvxhjov
输入样例2:

在这里给出一组输入。例如：
Welcome to Java!
10932
输出样例2:

在这里给出相应的输出。例如：
Xeufqne)wq!Jjyc"

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        String n=sc.next();
        StringBuffer res=new StringBuffer();
        int[] num=new int[5];
        for(int i=0;i<5;i++) num[i]=n.charAt(i)-'0';
        for(int i=0;i<s.length();i++)
        {
            int cur=i%5;
            char ch=(char)(s.charAt(i)+num[cur]);
            res.append(ch);
        }
        System.out.print(res);
    }
}

作业六：集合与容器

一、单选题

1、要去除字符串" i t c a s t "中的所有空格，用以下哪种方法更合适（C）

A.String substring(int beginIndex)

B.String substring(int beginIndex, int endIndex)

C.String replace(CharSequence oldstr, CharSequence newstr)

D.String trim()
clean_words = words.replace(' ', '')

2、在Java中，关于HashMap类的描述，以下选项错误的是

A.HashMap使用键/值得形式保存数据

B.HashMap 能够保证其中元素的顺序

C.HashMap允许将null用作键

D.HashMap允许将null用作值

二、函数题

6-1 tjrac - Java集合类之List的ArrayList之增删改查

仔细阅读下面编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，创建 ArrayList 集合并使用它的增删改查方法，具体要求如下：

接收给定的一行字符串（如：32 rfsd fwq g3r3qt t3q4t。）；
通过空格（一个）切割字符串；
创建一个 ArrayList 集合；
将切割后的字符串元素添加至集合中；
删除集合的第一个和最后一个元素；
添加两个字符串：hello，educoder 至集合中；
修改集合的第三个元素，改为：list；
打印集合。

裁判测试程序样例：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 第一步：接收给定的一行字符串

        // 第二步：切割字符串

        // 第三步：创建集合

        // 第四步：往集合中添加元素

        // 第五步：删除第一个元素和最后一个元素

        // 第六步：往集合中添加hello和educoder
        
        // 第七步：修改集合中第三个元素为list

        // 第八步：打印集合

        /********** End **********/
    }
}
输入样例：
32 rfsd fwq g3r3qt t3q4t qt ta
输出样例：
[rfsd, fwq, list, t3q4t, qt, hello, educoder]

Scanner sc=new Scanner(System.in);
String[] s=sc.nextLine().split(" ");
List<String> a=new ArrayList<>();
for(String x:s) a.add(x);
a.remove(0);
a.remove(a.size()-1);
a.add("hello");
a.add("educoder");
a.set(2,"list");
System.out.print("[");
for(int i=0;i<a.size();i++)
{
    if(i!=0) System.out.print(" ");
    System.out.print(a.get(i));
    if(i!=a.size()-1) System.out.print(",");
}
System.out.print("]");

6-2 tjrac - Java集合类之Map的HashMap之常用方法的使用

仔细阅读下面编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，使用 HashMap 集合的常用方法完成所给要求，具体如下：

接收给定的一行字符串（如：红烧鱼：50，小炒牛肉：75，...）；
切割字符串，把切割后的元素添加进 HashMap 集合中；
往集合中添加一道菜，菜名：lamb，价格：50；
输出所有菜名（不含价格）；
删除红烧鱼和小炒牛肉这两道菜后输出集合长度；
打印集合。

注意：字符串中的逗号和分号都是中文符号。

裁判测试程序样例：
/*
仔细阅读给出的代码框架及注释，在 Begin-End 间编写程序代码，使用 HashMap 集合的常用方法完成所给要求，具体如下：
- 接收给定的一行字符串（如：红烧鱼：50，小炒牛肉：75，...）；
- 切割字符串，把切割后的元素添加进 HashMap 集合中；
- 往集合中添加一道菜，菜名：lamb，价格：50；
- 输出所有菜名（不含价格）；
- 删除红烧鱼和小炒牛肉这两道菜后输出集合长度；
- 打印集合。
注意：字符串中的逗号和分号都是中文符号。
*/

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 第一步：接收给定字符串

        // 第二步：切割字符串

        // 第三步：创建 HashMap 集合,key为菜名，value为价格

        // 第四步：添加数据到集合中

        // 第五步：往集合中添加给定的一道菜

        // 第六步：输出所有菜名

        // 第七步：删除红烧鱼和小炒牛肉这两道菜后输出集合长度

        // 第八步：打印集合

        /********** End **********/
    }
}
输入样例：
粉蒸肉：50，红烧鱼：50，小炒牛肉：75，手撕包菜：20，蒜蓉虾：100
输出样例：
[手撕包菜, 蒜蓉虾, lamb, 小炒牛肉, 粉蒸肉, 红烧鱼]
4
{手撕包菜=20, 蒜蓉虾=100, lamb=50, 粉蒸肉=50}

Scanner sc=new Scanner(System.in);
String[] s=sc.nextLine().split("，");
Map<String,String> mp=new HashMap<>();
for(int i=0;i<s.length;i++)
{
    String[] a=s[i].split("：");
    mp.put(a[0],a[1]);
}
mp.put("lamb","50");
Set st=mp.keySet();
System.out.print(st);
mp.remove("红烧鱼");
mp.remove("小炒牛肉");
System.out.println();
System.out.println(mp.size());
System.out.print(mp);

6-3 tjrac - Java集合类之Set的HashSet之常用方法的使用

仔细阅读下面编辑区内给出的代码框架及注释，在 Begin-End 间编写程序代码，使用 HashSet 的常用方法完成所给要求，具体如下：

接收给定的一行字符串（如：hello,hi,ask）；
根据英文逗号切割字符串，把切割后的元素添加进 HashSet；
判断集合中元素个数，当个数大于 4，且集合中没有元素 hello 时，往集合中添加元素 hello，如果集合中已有元素 hello，请输出提示语句：“集合中已有该元素”，当个数小于等于 4 时，请输出提示语句：“元素个数小于4”；
打印集合。

裁判测试程序样例：
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        // 请在Begin-End间编写代码
        /********** Begin **********/
        // 第一步：接收给定的字符串

        // 第二步：切割字符串

        // 第三步：创建集合

        // 第四步：将切割后的元素添加进集合

        // 第五步：判断集合中元素个数是否大于4

        // 第六步：当元素个数大于4，且元素中含有hello时，输出指定提示语

        // 第七步：当元素个数大于4，且元素中不含hello时，把hello添加进集合

        // 第八步：当元素个数小于4，输出指定提示语

        // 第九步：输出集合

        /********** End **********/
    }
}
输入样例：
hello,hi,kiko,solo,so
输出样例：
集合中已有该元素
[kiko, hi, solo, hello, so]

Scanner sc=new Scanner(System.in);
String[] s=sc.next().split(",");
Set<String> st=new HashSet<>();
for(String x:s) st.add(x);
if(st.size()>4)
{
    if(!st.contains("hello")) st.add("hello");
    else System.out.println("集合中已有该元素");
}
else System.out.println("元素个数小于4");
System.out.print(st);

作业七：GUI组件与设计

一、单选题

1、JFrame的缺省布局管理器是( )。

A.FlowLayout

B.CardLayout

C.BorderLayout

D.GridLayout

JPanel的缺省布局管理器是FlowLayout

2、下列哪一项不属于布局管理器? ( )

A.GridLayout

B.CardLayout

C.BorderLayout

D.BagLayout

3、在类中若要处理ActionEvent事件，则该类需要实现的接口是( )

A.Runnable

B.ActionListener

C.Serializable

D.Event

4、抽象窗口工具包( )是Java提供的建立图形用户界面GUI的开发包。

A.AWT

B.Swing

C.java.io

D.java.lang

5、在复选框中移动鼠标，然后单击一选项，要捕获所选项必需实现哪个接口？（）

A.ActionListener

B.MouseListener

C.MouseMotionListern

D.ItemListener

6、paint( )方法使用哪种类型的参数? （）

A.Graphics

B.Graphics2D

C.String

D.Color

7、执行以下Java程序代码后，描述与显示外观最接近的选项是？
import java.awt.*;
public class MyClass extends Frame{
       public static void main(String args[]){ MyClass cl=new MyClass();}
       MyClass(){ Panel p=new Panel();
       p.add(new Button("1")); p.add(new Button("2")); p.add(new Button("3"));
       add(p,BorderLayout.NORTH); setLayout(new FlowLayout());
       setSize(300,300);setVisible(true);
}}
A.按钮将沿窗体的底部从左至右排列

B.按钮将沿窗体的顶部从左至右排列

C.按钮不会显示

D.只有按钮3将显示，并占用了窗体的全部空间

二、程序填空题

1、本题通过JButton、JLabel和JTextField组件实现简单加法计算器。程序运行界面如下：

public class Main extends JApplet implements ActionListener {
Container cp=getContentPane();

JButton JButton1=new JButton("确定");//创建JButton1，并初始化

JLabel JLabel1=new JLabel("+");
JLabel JLabel2=new JLabel("=");
JTextField JTextField1=new JTextField(10);
JTextField JTextField2=new JTextField(10);
JTextField JTextField3=new JTextField(10);
public void init()
{cp.setLayout(new FlowLayout());
    cp.add(JTextField1);    cp.add(JLabel1);
    cp.add(JTextField2);    cp.add(JLabel2);
    cp.add(JTextField3);    cp.add(JButton1);

JButton1.addActionListener(this);//为JButton1增加监听

}
public void actionPerformed(ActionEvent e) {
    if(e.getSource()==JButton1)//用getSource()方法获取事件源
    {
   double sum=Double.valueOf(JTextField1.getText())+Double.valueOf(JTextField2.getText());//获取两个操作数，并转化为double型
   JTextField3.setText(String.valueOf(sum)); 
}}}

2、本题采用BorderLayout布局管理器实现对组件的布局，并进行简单的交互实现。程序运行界面如下：

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
public class Main extends JApplet implements ActionListener //实现ActionListener接口
{  Container cp=getContentPane( );
   JButton JB1=new JButton("北面");
   JButton JB2=new JButton("南面");
   JButton JB3=new JButton("东面");
   JButton JB4=new JButton("西面");
   JLabel JL1=new JLabel("显示屏",JLabel.CENTER);//初始化JLabel标签，并居中显示
   public void init() {
     cp.add(JB1, BorderLayout.NORTH);
     cp.add(JB2, BorderLayout.SOUTH);
     cp.add(JB3, BorderLayout.EAST);
     cp.add(JB4, BorderLayout.WEST);
     cp.add(JL1,BorderLayout.CENTER);//将标签放置在容器的中部
     JB1.addActionListener(this);
     JB2.addActionListener(this);
     JB3.addActionListener(this);
     JB4.addActionListener(this);     
   }
    @Override
    public void actionPerformed(ActionEvent e) {//重载事件处理方法
       if(e.getSource()==JB1)
           JL1.setText(JB1.getText());
       if(e.getSource()==JB2)
           JL1.setText(JB2.getText());
       if(e.getSource()==JB3)
           JL1.setText(JB3.getText());
       if(e.getSource()==JB4)
           JL1.setText(JB4.getText());
    }
}

3、本题通过FlowLayout布局管理器实现对组件的操作。请按照提示，完善程序。程序运行结果如下图所示：

import javax.swing.*;
import java.awt.*;
public class Main extends JFrame {
  public Main() {

    setLayout(new FlowLayout());//设置窗体为流式布局，无参数默认为居中对齐

    setFont(new Font("Helvetica",Font.BOLD, 14));//设置窗体中显示的字体样式，加粗,14号

    getContentPane().add(new JButton("Button 1"));//将按钮添加到窗体中
    getContentPane().add(new JButton("Button 2"));
    getContentPane().add(new JButton("Button3"));
    getContentPane().add(new JButton("Button 4"));
  } 
  public static void main(String args[]) {
    Main window = new Main();

    window.setTitle("流式布局");//设置窗体标题

    window.pack();//该代码依据放置的组件设定窗口的大小使之正好能容纳你放置的所有组件
    window.setVisible(true);

    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体的默认关闭方式

    window.setLocationRelativeTo(null);  //让窗体居中显示
  }
}

4、本题目通过GridLayout布局管理器实现对组件的操作。请按照提示，完善程序。程序运行结果如下图所示：

import java.awt.Container;
import java.awt.GridLayout;
import javax.swing.JApplet;
import javax.swing.JButton;
public class Main extends JApplet
{   JButton bt1=new JButton("按钮A");
    JButton bt2=new JButton("按钮B");
    
Container cp=getContentPane( );//获取容器
   
//设置GridLayout为2行2列，组件水平、纵向一定间距分别是20，30
   GridLayout grid=new GridLayout(2,2,20,30);

    @Override
    public void init( ) 
    {  
      cp.setLayout(grid);//设置容器的布局样式

      cp.add(bt1);
      cp.add(bt2);
      cp.add(new JButton("按钮C"));
      cp.add(new JButton("按钮D"));
     }  
 }

5、本题要求实现ActionListener接口中的actionPerformed()方法。如下图所示，点击JButton按钮，可实现JLable中的内容的中英文转换。

public class Main extends JApplet implements ActionListener  //JApplet是Applet的子类
{  Container cp=getContentPane( );  //创建窗口容器对象   
   
   JButton bt=new JButton();  //创建按钮对象 
  
   JLabel lb=new JLabel("Hello",JLabel.CENTER);  //创建标签对象
    @Override 
  public void init()
   { 
     bt.setText("转中文");   //添加按钮文本
     bt.setHorizontalTextPosition(JLabel.CENTER);  //将按钮文字放在图标中间     
     cp.add(lb,BorderLayout.NORTH);  //添加标签在JApple界面的北部位置上
     cp.add(bt,BorderLayout.SOUTH);       
    
     bt.addActionListener(this); //注册bt的监听器对象this

   }
    @Override
   public void actionPerformed(ActionEvent e)
   { 
        if(e.getSource()==bt) //判断动作事件是否由bt引发的

       {          
         if("转英文".equals(bt.getText()))    //修改按钮文本
         {
             lb.setText("Hello");
             bt.setText("转中文");
         }
            else if("转中文".equals(bt.getText()))    //修改按钮文本
         {
             lb.setText("你好");

             bt.setText("转英文");//设置JButton按钮上的文本
         }  
        }
    }
}

6、本题目要求实现将JTextField中的文本复制到JTextArea中。程序运行结果如下：

public class Main extends JApplet
{  String s,s1;
   JLabel lb1=new JLabel("请按键盘");//初始化lb1标签
   JLabel lb2=new JLabel("复制结果");//初始化lb2标签

   JTextField tf1=new JTextField(10);  //初始化tf1，长度为10

   JTextArea tf2=new JTextArea(5,10);  //初始化tf2，为5行10列的文本
   Container cp=getContentPane( );
   FlowLayout flow=new FlowLayout(FlowLayout.CENTER,5,5);
    @Override
   public void init( )
   {  
      cp.setLayout(flow);//设置布局样式为流式布局

      cp.add(lb1);
      cp.add(tf1);
      cp.add(lb2);
      cp.add(tf2);
      
      tf1.addKeyListener(new koLis());//为tf1组件增加监听
   }
   class  koLis  extends  KeyAdapter
   {    @Override
     public void keyTyped(KeyEvent e)
     {   s=tf1.getText( )+e.getKeyChar( );  //获取文本框的内容及键入的字符
         if(e.getKeyChar( )=='\n')  
          {   s1=tf2.getText( )+s;
              tf1.setText("");
              
              tf2.setText(s1); //设置tf2中的文本内容为s1
          }   
     }
   }
}

7、本题通过MouseAdapter适配器，实现鼠标单击、鼠标按下、鼠标进入窗口、鼠标离开窗口和鼠标松开等方法，并通过MouseMotionListener实现鼠标的移动和拖动鼠标的操作。程序运行结果如下：

public  class  Main extends JApplet
{  int x,y;
   JLabel lb1=new JLabel("X:"), lb2=new JLabel("Y:"), lb3=new JLabel("");
   JTextField tf1=new JTextField(5), tf2=new JTextField(5);
   Container cp=getContentPane( );
   FlowLayout flow=new FlowLayout(FlowLayout.CENTER,5,5);
   public void init( )
   {  
      cp.setLayout(flow);//设置容器的布局样式为流式布局

      cp.add(lb1);
      cp.add(tf1);
      cp.add(lb2);
      cp.add(tf2);
      cp.add(lb3);
      addMouseListener(new mouseListener( ));//通过MouseAdapter增加监听
      addMouseMotionListener(new koLis( ));
     }
   class  mouseListener  extends MouseAdapter//继承父类
  { 
    public void mouseClicked(MouseEvent e)
       { lb3.setText("点击鼠标");  }
    public void mousePressed(MouseEvent e)
       { lb3.setText("鼠标按钮按下"); }
    public void mouseEntered(MouseEvent e)
       { lb3.setText("鼠标进入窗口"); }
    public void mouseExited(MouseEvent e)
       { lb3.setText("鼠标不在窗口"); }
    public void mouseReleased(MouseEvent e)
       { lb3.setText("鼠标按钮松开"); }
    }
    class  koLis implements  MouseMotionListener //继承接口
    {   
     public void mouseMoved(MouseEvent e)
       {  x=e.getX( );
          y=e.getY( );
          tf1.setText(String.valueOf(x));
          tf2.setText(String.valueOf(y));
       }
     public void mouseDragged(MouseEvent e)//实现鼠标拖动的方法
       { lb3.setText("拖动鼠标"); }
    }
 }

作业八：异常处理与多线程

一、单选题

1、关于异常(Exception)，下列描述错误的是（）。

A.异常的基类为Exception，所有异常都必须直接或者间接继承它

B.异常可以用try{ }catch(Exception e){ }来捕获并进行处理

C.如果某异常继承RuntimeException，则该异常可以不处理

D.异常必须在内部自己处理，不能抛给外层的程序进行处理

2、在try-catch-finally语句块中，以下可以单独与finally一起使用的是

A.catch

B.try

C.throws

D.throw

3、下面关于try块的说法正确的是?

A.try块后至少应有一个catch 块

B.try块后必须有finally块

C.可能抛出异常的语句应放在try块中

D.对抛出的异常的处理应放在try块中

4、如果一个方法会产生必检异常，下列说法正确的是

A.可以不做任何处理。

B.必须在方法内部用try-catch语句捕获并处理。

C.必须在方法内部用try-catch语句捕获并处理，或者用throws语句声明异常。

D.必须用throws语句声明异常。

5、要创建一个新目录，可以用下面( )类实现。

A.FileInputStream

B.FileOutputStream

C.RandomAccessFile

D.File

6、如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（）。

A.FileInputStream

B.FileOutputStream

C.DataOutputStream

D.FileWriter

7、要从“file.dat”文件中读出第10个字节到变量c中，下列哪个方法适合? （ C ）

FileInputStream in=new FileInputStream("file.dat"); 
int c=in.read();

RandomAccessFile in=new RandomAccessFile("file.dat"); 
in.skip(9); 
int c=in.readByte();

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(9); 
int c=in.read();

FileInputStream in=new FileInputStream("file.dat"); 
in.skip(10); 
int c=in.read();

8、字符流与字节流读写数据的区别在于（）。

A.前者带有缓冲，后者没有

B.前者是块读写，后者是字节读写

C.二者没有区别，可以互换使用

D.每次读写数据的组织单位不同

9、为了从文本文件中逐行读取内容，应该使用哪个处理流对象？（）

A.BufferedReader

B.BufferedWriter

C.BufferedInputStream

D.BufferedOutputStream

10、为实现进程之间的通信，需要使用下列那种流才合适 ?（）

A.Data stream

B.File stream

C.Buffered stream

D.Piped stream

11、以下选项中，哪个流使用了缓冲技术？（）

A.BufferedOutputStream

B.FileInputStream

C.DataOutputStream

D.FileReader

12、哪个关键字可以对对象或方法加互斥锁？( )

A.transient

B.synchronized

C.serialize

D.static

13、线程整个生命周期可以分为五个阶段，以下哪个不属于其生命周期（）

A.新建状态

B.生存状态

C.阻塞状态

D.运行状态

14、通过继承Thread类可以实现多线程，通过实现Runnable接口也可以实现多线程，以下关于线程的两种方法描述错误的是（）

A.继承Thread类方法适合多个相同程序代码的线程去处理同一个资源的情况

B.实现Runnable接口方法把线程同程序代码、数据有效的分离

C.Java的单继承给通过继承Thread类实现多线程带来局限性

D.实现Runnable接口方法很好的体现了面向对象的设计思想

15、下列情况中，不会使线程返还所持有的对象锁的是（）。

A.当 synchronized() 语句块执行完毕

B.当调用了线程的 suspend() 方法

C.当在 synchronized() 语句块中出现异常（Exception）

D.当持有锁的线程调用该对象的 wait() 方法

二、程序填空题

1、下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序

class Main {
    static void procedure() throws IllegalAccessException {
        System.out.println("inside procedure");
        
        throw new IllegalAccessException("demo");
    }

    public static void main(String args[]) {
        try {
            procedure();
        } catch (IllegalAccessException e) {
            System.out.println("捕获：" + e);
        }
    }
}

2、自定义一个异常类ScoreException，继承自Exception类。有一个私有的成员变量message（异常提示信息，String类型）；一个公有的无参数的构造方法，在方法中将message的值确定为“您输入的成绩异常，请核实！”；一个公有的方法show()，该方法的功能是输出message的值。

定义一个学生类Student，有一个私有成员变量score（成绩，double类型）；一个带参数的公有方法setScore()用于设置学生的成绩，该方法声明可能抛出异常ScoreException，当设置的成绩为负数或超过100时，会抛出一个异常对象；一个公有方法getScore()用于获取学生的成绩。

在测试类Main中，创建一个Student类的对象zhangsan，尝试调用setScore()方法来设置他的成绩（成绩从键盘输入，double类型），然后调用getScore()方法获取到该成绩后再将其输出。因用户的输入存在不确定性，以上操作有可能捕捉到异常ScoreException，一旦捕捉到该异常，则调用show()方法输出异常提示。不管是否有异常，最终输出“程序结束”。使用try...catch...finally语句实现上述功能。
import java.util.Scanner;

class ScoreException 
extends Exception
 {
    private String message;
    public ScoreException() {
        message = "您输入的成绩异常，请核实！";
    }
    public void show() {
        System.out.println(message);
    }
}

class Student {
    private double score;
    public void setScore(double score) throws ScoreException{
        if (score<0 || score>100)
            throw new ScoreException();
        else
            this.score=score;
    }
    public double getScore() {
        return this.score;
    }
}

public class Main {        
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        Student zhangsan = new Student();
        try
        {
            zhangsan.setScore(sc.nextDouble());
            System.out.println("成绩为" + zhangsan.getScore());
        }catch(ScoreException e) {
            e.show();
        }finally {
            System.out.println("程序结束");
        }
        sc.close();
    }
}

3、当用多个线程处理共享变量时，线程中对共享变量的处理代码应用同步机制进行保护，才能保证处理的正确性。

import java.util.*;
class BackCounter implements Runnable{
    private int count=100;  //线程共享变量，对它的处理必须用同步机制进行保护
    public int getCount() { return count; }//返回变量值
    //线程体
    public void  run() {        
        for(int i=10;i>0;i--) { //变量值递减 10
            synchronized(this)
     { //以下代码在处理共享变量，需要同步机制保护
                if( count<=0 ) break;
                count--;
     }
            try { Thread.sleep(10); } catch ( InterruptedException e ) { }//模拟延时 10 毫秒
        }
    }//线程体结束
}
public class Main {
    public static void main(String[] args) throws InterruptedException {//某些线程方法会抛出检查型异常
        ArrayList<Thread> lt=new ArrayList<Thread>();
        BackCounter bc=new BackCounter();//创建实现类对象        
        lt.add(new Thread(bc));//创建线程对象
        lt.add(new Thread(bc));
        for (Thread th:lt) th.start(); //启动线程
        for (Thread th:lt) th.join();  //等待线程结束
        System.out.println(bc.getCount());
    }
}