超星Java程序设计_34课后答案(学习通2023题目答案)

超星Java程序设计_34课后答案(学习通2023题目答案)

点击查看答案

第1讲 Java语言与面向对象的超星程序程序设计

Week1 测试

1、Java的设计三大平台不包括
A、JavaSE
B、课后JavaEE
C、答案JavaME
D、学习Android

2、通题Java出现于哪年
A、目答1990
B、超星程序1995
C、设计2000
D、课后2005

3、答案Java的学习开发工具是
A、JavaAPI
B、通题JDK
C、目答JRE
D、超星程序JVM

4、面向对象语言的特点包括：
A、封装
B、继承
C、多态
D、难维护

5、Java相关的网站包括
A、java.sun.com
B、https://www.oracle.com/technetwork/java/index.html
C、java.com
D、jcp.org

6、Java的运行环境叫JRE

7、JDK包括JRE及开发工具

8、JRE包括JVM及API

9、Java是跨平台的语言

10、Java是一种面向对象的语言

11、Java不直接使用指针

12、Java的垃圾回收要由程序员自己来进行

13、Java有丰富的库供我们调用

14、java程序编译的结果（class文件）中包含的是实际机器的CPU指令

3月31日课前预习

1、编译Java Application源文件将产生相应的字节码文件，扩展名是（）。
A、.java
B、.class
C、.html
D、.exe

2、Java语言具有许多优点和特点，下列选项中，哪个反映了Java中“一次编译，随处运行”的特点。（）
A、简单性
B、平台无关性
C、面向对象性
D、安全性

3、Java语言具有许多优点和特点，下列选项中，哪个反映了Java中并行机制的特点（）。
A、多线程
B、平台无关性
C、面向对象性
D、安全性

4、一个Java源文件中最多只能有多少个public类。（）
A、1个
B、2个
C、3个
D、任意多个

5、JDK提供的编译器是。（）
A、java.exe
B、javac.exe
C、javap.exe
D、javaw.exe

4月1日课前预习

1、Java源文件的扩展名必须是（）。
A、java
B、class
C、javac
D、public

2、下面属于单行注释的是（）。
A、/*...*/
B、//
C、/** ...*/
D、--!

3、作为Java应用程序入口的main方法，其声明格式可以是（ ）。
A、public void main(String [] args)
B、public static void main(String [] args)
C、public static void Main(String * args)
D、public int main(String [] args)

4、下列说法正确的是（ ）。
A、JAVA程序的main方法必须写在类里面
B、JAVA程序中可以有多个main方法
C、JAVA程序中类名必须与文件名一样
D、JAVA程序的main方法中如果只有一条语句，可以不用{ }(大括号)括起来

5、下面哪一项在java中是非法的标识符（）。
A、$user
B、point
C、You&me
D、_endline

第2讲 简单的Java程序

4月2日课前预习

1、main()的写法是public void main(String[]arg)

2、public类名与文件同名

3、package名与路径同名

4、import表示导入

5、编译程序的基本命令是javac

6、运行程序时java后面跟的是文件名

7、path表示前者是命令（javac及java)的路径

8、path是所要引用的类的路径

9、在javac及java命令行上使用-classpath （或-cp)选项可以引用别的库

10、可以使用jar来打包程序

11、jar文件中的清单信息文件中Main-Class表示主类

12、可以使用javadoc来生成文档

13、Javap 查看类信息及反汇编

14、jar打包常用的参数是cvfm

15、运行jar时，使用 java -jar 文件名.jar

16、文档注释是用/** */

17、@param表示对方法的说明 对方法中某参数的说明

18、使用Scanner的next()方法可以得到一个实数

19、用Integer.parseInt( s )可以用来解析一个整数

20、用Double.parseDouble(s) 可以用来解析一个实数

21、add(xxxx) 可以将按钮等对象加入到Frame中

22、btn.addActionListener可以用来处理事件

23、处理事件的真正函数是actionPerformed（）函数

第3讲 数据运算、流控制和数组

4月3日课前预习考核

1、数据类型决定数据的存储方式和运算方式

2、Java中的数据类型分为两大类

3、String属于引用类型

4、Java中引用类型在赋值时，复制的是对象实体。

5、Java中的char是一个字节。

6、Java中的long是4个字节。

7、3.14是float型。

8、0b0001是二进制写法。

9、534L表示长整数。

10、Java中没有无符号数。

11、Java中非零即真。

12、Java是大小写敏感的语言。

13、按惯例，类名首字母大写，变量名首字母小写。

14、字符串连接运算符其实是用append来实现的。

15、^表示乘方运算。

16、15/4的结果是3.75。

17、&表示短路与运算。

18、>>>表示无符号右移。

19、书写表达式要少用或不用括号。

20、javap –c命令可以反汇编代码。

21、程序的三种基本流程是顺序、分支、循环。

22、Java中可以在任一表达式后面加分号构成表达式语句。

23、case后面可以跟变量。

24、循环语句有三种写法。

25、循环一般有五个要素。

26、do.while循环至少执行一次。

27、break及continue后面可以跟一个语句标号。

28、增强的for语句可以方便地遍历数组。

29、数组都有一个属性length。

30、main()的写法是public void main(int argc, String[]argv)

31、声明数组时可以直接指定数组的大小。

32、数组都是引用类型。

33、数组元素都会隐式初始化。

4月7日课前预习考核

1、如下哪个是Java中有效的关键字（）
A、name
B、hello
C、false
D、good

2、下面的代码段执行之后count的值是什么() int count = 1; for (int i = 1; i <= 5; i++) { count += i; } System.out.println(count);
A、5
B、1
C、15
D、16

3、定义一个接口必须使用的关键字是()
A、public
B、class
C、interface
D、static

4、声明并创建一个按钮对象b，应该使用的语句是()
A、Button b=new Button();
B、button b=new button();
C、Button b=new b();
D、b.setLabel(“确定”);

5、下列哪一个import命令可以使我们在程序中创建输入/输出流对象（）
A、import java.sql.*;
B、import java.util.*;
C、import java.io.*;
D、import java.net.*;

第4讲 类、包和接口

4月8日课前预习

1、类（class）是组成Java程序的基本要素。

2、类将变量与函数封装到一个类中。

3、方法（method）是类的功能，是用函数来表示的。

4、构造方法（constructor )与类名同名。

5、如果没有定义任何构造方法，系统会自动产生一个构造方法。

6、new表示新建并初始化一个对象。

7、方法重载（overloading)是指多个方法有相同的名字。

8、方法重载是多态（polymorphism）的一种方式。

9、一个类只能有一个直接父类。

10、继承可以实现代码重用，提高开发效率和可维护性。

11、Java中的继承是通过extends关键字来实现的。

12、如果没有extends子句，则该类默认为java.lang.Object的子类。

13、所有的类都是通过直接或间接地继承java.lang.Object得到的。

14、继承关系在UML图中，是用一个箭头来表示子类与父类的关系的。

15、父类的非私有方法可以被子类自动继承。

16、子类也可以重新定义与父类同名的方法，实现对父类方法的覆盖(Override)。

17、使用super访问父类的域和方法。

18、在覆盖父类的方法的同时，使用super可以利用已定义好的父类的方法。

19、子类在构造方法中，可以用super来调用父类的构造方法。

20、在构造方法中，使用super()时，必须放在第一句。

21、子类对象可以被视为其父类的一个对象。

22、如果一个方法的形式参数定义的是父类对象，那么调用这个方法时，可以使用子类对象作为实际参数。

23、包及子包的定义，实际上是为了解决名字空间、名字冲突。

24、同一包中的各个类，默认情况下可互相访问。

25、Java编译器自动导入包java.lang.*。

26、类的访问控制符或者为public，或者默认。

27、将字段用private修饰，从而更好地将信息进行封装和隐藏。

28、使用setter及getter是一种好的编程习惯。

29、static表示静态的、非实例的、类的。

30、static变量可以表示全局变量。

31、如果一个类被abstract所修饰，说明这个类不能被实例化。

32、final所修饰的方法，是不能被子类所覆盖的方法。

33、final所修饰的变量，是只读量。

34、一个字段被static final两个修饰符所限定时，它可以表示常量。

35、在定义final局部变量时，也必须且只能赋值一次。

36、抽象方法在子类中必须被实现，否则子类仍然是abstract的。

37、一旦某个类中包含了abstract方法，则这个类必须声明为abstract类。

38、在类的声明中用implements子句来表示一个类使用某个接口。

39、接口类型是引用类型。

40、在接口中定义的常量具有public, static, final的属性。

41、一个文件中最多只能有一个package语句。

42、在接口中定义的方法具有public, abstract的特点（Java8以前）。

43、Java8中，在接口中可以有static的方法，也可以有方法体的方法。

44、enum表示枚举。

45、一个类只能实现一个接口。

46、abstract类必须包含abstract方法。

47、接口不能有父接口。

48、java中的enum是整数。

49、final abstract可以同时修饰一个方法。

50、一个文件中最多只能有一个class定义。

51、构造方法是可以继承的。

52、this和super是两个不同的对象。

53、子类不能Overload与父类同名的方法。

54、字段（field）是类的属性，是用函数来表示的。

55、构造方法（constructor )的返回类型是void。

56、作何一个类，系统都会自动产生一个不带参数的构造方法。

57、方法签名（signature)包括参数的类型及参数的名字。

58、private可以修饰类、也可以修饰类的成员（字段、方法）。

59、protected修饰的成员，不能在包中访问，只能在子类中访问。

60、如果省略访问控制符，则表示private。

61、static函数中可以使用this。

62、static函数可以直接使用类名来访问，不能用对象实例来访问。

63、import static可以导入任何一个类。

64、如果一个类被final所修饰，说明这个类不能被实例化。

65、如果一个类被abstract所修饰，说明这个类没有构造方法。

学习通Java程序设计_34：Java中的多线程编程

Java是一种支持多线程编程的编程语言。多线程编程能够最大化地利用计算机的性能，提高程序的执行效率。

什么是线程

线程是指程序中执行的最小单元。在Java中，线程是通过Thread类来实现的。一个Java程序至少有一个主线程，也可以创建多个子线程。线程是并发执行的，可以同时执行多个线程，执行过程中可以相互切换。

创建线程

在Java中，创建线程有两种方式：继承Thread类和实现Runnable接口。

继承Thread类

继承Thread类是创建线程的一种方式，具体方法如下：

<pre>        <code>public class MyThread extends Thread {             public void run() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 MyThread thread = new MyThread();                thread.start();            }        }    </code></pre>

上述代码中，MyThread继承了Thread类，并重写了run()方法。在主函数中，创建了一个MyThread对象，并调用了start()方法。start()方法会启动一个新线程，并执行MyThread的run()方法。

实现Runnable接口

实现Runnable接口是创建线程的另一种方式，具体方法如下：

<pre>        <code>public class MyRunnable implements Runnable {             public void run() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 MyRunnable runnable = new MyRunnable();                Thread thread = new Thread(runnable);                thread.start();            }        }    </code></pre>

上述代码中，MyRunnable实现了Runnable接口，并重写了run()方法。在主函数中，创建了一个MyRunnable对象，并创建了一个Thread对象，将MyRunnable对象作为参数传递给Thread对象的构造函数。调用Thread对象的start()方法可以启动一个新线程，并执行MyRunnable的run()方法。

线程同步

Java中的多线程执行是异步的，多个线程之间的执行顺序是不确定的。在多线程编程中，需要确保线程之间的安全，避免出现数据不一致等问题。线程同步是保证线程之间安全的一种方法。

synchronized关键字

synchronized关键字用来确保同一时间只有一个线程执行某个方法或代码块。具体方法如下：

<pre>        <code>public class Example {             public synchronized void method() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法被synchronized关键字修饰，保证同一时间只有一个线程可以执行该方法。在主函数中，创建了两个Thread对象，并分别调用example对象的method()方法。

Lock对象

除了使用synchronized关键字进行线程同步外，还可以使用Lock对象进行线程同步。Lock对象是Java中的一个接口，具体方法如下：

<pre>        <code>import java.util.concurrent.locks.Lock;        import java.util.concurrent.locks.ReentrantLock;        public class Example {             private Lock lock = new ReentrantLock();            public void method() {                 lock.lock();                try {                     // 线程执行代码                } finally {                     lock.unlock();                }            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中使用了Lock对象进行线程同步。在method()方法中，先调用lock()方法获取锁，执行完线程代码后再调用unlock()方法释放锁。在主函数中，创建了两个Thread对象，并分别调用example对象的method()方法。

线程间通信

在线程编程中，有时需要线程之间进行通信。Java提供了两种线程间通信的方法：wait()和notify()。

wait()和notify()方法

wait()方法使线程进入等待状态，直到其他线程调用notify()方法唤醒该线程。具体方法如下：

<pre>        <code>public class Example {             public synchronized void method() {                 try {                     wait();                } catch (InterruptedException e) {                     e.printStackTrace();                }            }            public synchronized void notifyMethod() {                 notify();            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.notifyMethod();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法调用了wait()方法，使线程进入等待状态。notifyMethod()方法调用了notify()方法，唤醒等待状态的线程。在主函数中，创建了两个Thread对象，并分别调用example对象的method()和notifyMethod()方法。

wait(long)和notifyAll()方法

wait(long)方法和wait()方法类似，只是可以设置等待的时间，时间到了自动唤醒线程。notifyAll()方法可以唤醒所有等待状态的线程。

<pre>        <code>public class Example {             public synchronized void method() {                 try {                     wait(1000); // 等待1秒钟                } catch (InterruptedException e) {                     e.printStackTrace();                }            }            public synchronized void notifyAllMethod() {                 notifyAll(); // 唤醒所有等待状态的线程            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                Thread thread3 = new Thread(() -> {                     example.notifyAllMethod();                });                thread1.start();                thread2.start();                thread3.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法调用了wait(1000)方法，等待1秒钟后自动唤醒线程。notifyAllMethod()方法调用了notifyAll()方法，唤醒所有等待状态的线程。在主函数中，创建了三个Thread对象，并分别调用example对象的method()和notifyAllMethod()方法。

线程池

线程池是一种管理线程的机制，可以避免频繁地创建和销毁线程。Java中的线程池是通过ThreadPoolExecutor类实现的。

ThreadPoolExecutor类

ThreadPoolExecutor类是Java中线程池的核心类，可以通过该类创建线程池。具体方法如下：

<pre>        <code>import java.util.concurrent.ExecutorService;        import java.util.concurrent.Executors;        public class Main {             public static void main(String[] args) {                 ExecutorService pool = Executors.newFixedThreadPool(4);                for (int i = 0; i < 10; i++) {                     Runnable task = new Runnable() {                         public void run() {                             // 线程执行代码                        }                    };                    pool.execute(task);                }                pool.shutdown();            }        }    </code></pre>

上述代码中，使用Executors类的newFixedThreadPool()方法创建一个线程池，线程池中最多可以同时执行4个线程。在循环中创建了10个Runnable对象，每个对象都通过线程池的execute()方法执行。执行完所有线程后，调用pool的shutdown()方法关闭线程池。

线程池的状态

线程池的状态有以下几种：

• RUNNING：线程池处于运行状态。
• SHUTDOWN：线程池处于关闭状态，不再接受新任务，但会执行完已经接受的任务。
• STOP：线程池处于关闭状态，不再接受新任务，也不再执行已经接受的任务。
• TIDYING：线程池正在关闭，并且所有任务已经执行完毕。
• TERMINATED：线程池已经关闭。

可以通过ThreadPoolExecutor类的getPoolSize()、getActiveCount()、getCompletedTaskCount()、getTaskCount()等方法获取线程池的状态信息。

总结

多线程编程在Java中是一种非常常见的编程方式，能够最大化地利用计算机的性能，提高程序的执行效率。Java中提供了多种线程创建、同步和通信的方法，也提供了线程池来管理线程。在使用多线程编程时，需要特别注意线程之间的同步和通信，避免出现数据不一致等问题。

学习通Java程序设计_34：Java中的多线程编程

Java是一种支持多线程编程的编程语言。多线程编程能够最大化地利用计算机的性能，提高程序的执行效率。

什么是线程

线程是指程序中执行的最小单元。在Java中，线程是通过Thread类来实现的。一个Java程序至少有一个主线程，也可以创建多个子线程。线程是并发执行的，可以同时执行多个线程，执行过程中可以相互切换。

创建线程

在Java中，创建线程有两种方式：继承Thread类和实现Runnable接口。

继承Thread类

继承Thread类是创建线程的一种方式，具体方法如下：

<pre>        <code>public class MyThread extends Thread {             public void run() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 MyThread thread = new MyThread();                thread.start();            }        }    </code></pre>

上述代码中，MyThread继承了Thread类，并重写了run()方法。在主函数中，创建了一个MyThread对象，并调用了start()方法。start()方法会启动一个新线程，并执行MyThread的run()方法。

实现Runnable接口

实现Runnable接口是创建线程的另一种方式，具体方法如下：

<pre>        <code>public class MyRunnable implements Runnable {             public void run() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 MyRunnable runnable = new MyRunnable();                Thread thread = new Thread(runnable);                thread.start();            }        }    </code></pre>

上述代码中，MyRunnable实现了Runnable接口，并重写了run()方法。在主函数中，创建了一个MyRunnable对象，并创建了一个Thread对象，将MyRunnable对象作为参数传递给Thread对象的构造函数。调用Thread对象的start()方法可以启动一个新线程，并执行MyRunnable的run()方法。

线程同步

Java中的多线程执行是异步的，多个线程之间的执行顺序是不确定的。在多线程编程中，需要确保线程之间的安全，避免出现数据不一致等问题。线程同步是保证线程之间安全的一种方法。

synchronized关键字

synchronized关键字用来确保同一时间只有一个线程执行某个方法或代码块。具体方法如下：

<pre>        <code>public class Example {             public synchronized void method() {                 // 线程执行代码            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法被synchronized关键字修饰，保证同一时间只有一个线程可以执行该方法。在主函数中，创建了两个Thread对象，并分别调用example对象的method()方法。

Lock对象

除了使用synchronized关键字进行线程同步外，还可以使用Lock对象进行线程同步。Lock对象是Java中的一个接口，具体方法如下：

<pre>        <code>import java.util.concurrent.locks.Lock;        import java.util.concurrent.locks.ReentrantLock;        public class Example {             private Lock lock = new ReentrantLock();            public void method() {                 lock.lock();                try {                     // 线程执行代码                } finally {                     lock.unlock();                }            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中使用了Lock对象进行线程同步。在method()方法中，先调用lock()方法获取锁，执行完线程代码后再调用unlock()方法释放锁。在主函数中，创建了两个Thread对象，并分别调用example对象的method()方法。

线程间通信

在线程编程中，有时需要线程之间进行通信。Java提供了两种线程间通信的方法：wait()和notify()。

wait()和notify()方法

wait()方法使线程进入等待状态，直到其他线程调用notify()方法唤醒该线程。具体方法如下：

<pre>        <code>public class Example {             public synchronized void method() {                 try {                     wait();                } catch (InterruptedException e) {                     e.printStackTrace();                }            }            public synchronized void notifyMethod() {                 notify();            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.notifyMethod();                });                thread1.start();                thread2.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法调用了wait()方法，使线程进入等待状态。notifyMethod()方法调用了notify()方法，唤醒等待状态的线程。在主函数中，创建了两个Thread对象，并分别调用example对象的method()和notifyMethod()方法。

wait(long)和notifyAll()方法

wait(long)方法和wait()方法类似，只是可以设置等待的时间，时间到了自动唤醒线程。notifyAll()方法可以唤醒所有等待状态的线程。

<pre>        <code>public class Example {             public synchronized void method() {                 try {                     wait(1000); // 等待1秒钟                } catch (InterruptedException e) {                     e.printStackTrace();                }            }            public synchronized void notifyAllMethod() {                 notifyAll(); // 唤醒所有等待状态的线程            }        }        public class Main {             public static void main(String[] args) {                 Example example = new Example();                Thread thread1 = new Thread(() -> {                     example.method();                });                Thread thread2 = new Thread(() -> {                     example.method();                });                Thread thread3 = new Thread(() -> {                     example.notifyAllMethod();                });                thread1.start();                thread2.start();                thread3.start();            }        }    </code></pre>

上述代码中，Example类中的method()方法调用了wait(1000)方法，等待1秒钟后自动唤醒线程。notifyAllMethod()方法调用了notifyAll()方法，唤醒所有等待状态的线程。在主函数中，创建了三个Thread对象，并分别调用example对象的method()和notifyAllMethod()方法。

线程池

线程池是一种管理线程的机制，可以避免频繁地创建和销毁线程。Java中的线程池是通过ThreadPoolExecutor类实现的。

ThreadPoolExecutor类

ThreadPoolExecutor类是Java中线程池的核心类，可以通过该类创建线程池。具体方法如下：

<pre>        <code>import java.util.concurrent.ExecutorService;        import java.util.concurrent.Executors;        public class Main {             public static void main(String[] args) {                 ExecutorService pool = Executors.newFixedThreadPool(4);                for (int i = 0; i < 10; i++) {                     Runnable task = new Runnable() {                         public void run() {                             // 线程执行代码                        }                    };                    pool.execute(task);                }                pool.shutdown();            }        }    </code></pre>

上述代码中，使用Executors类的newFixedThreadPool()方法创建一个线程池，线程池中最多可以同时执行4个线程。在循环中创建了10个Runnable对象，每个对象都通过线程池的execute()方法执行。执行完所有线程后，调用pool的shutdown()方法关闭线程池。

线程池的状态

线程池的状态有以下几种：

• RUNNING：线程池处于运行状态。
• SHUTDOWN：线程池处于关闭状态，不再接受新任务，但会执行完已经接受的任务。
• STOP：线程池处于关闭状态，不再接受新任务，也不再执行已经接受的任务。
• TIDYING：线程池正在关闭，并且所有任务已经执行完毕。
• TERMINATED：线程池已经关闭。

可以通过ThreadPoolExecutor类的getPoolSize()、getActiveCount()、getCompletedTaskCount()、getTaskCount()等方法获取线程池的状态信息。

总结

多线程编程在Java中是一种非常常见的编程方式，能够最大化地利用计算机的性能，提高程序的执行效率。Java中提供了多种线程创建、同步和通信的方法，也提供了线程池来管理线程。在使用多线程编程时，需要特别注意线程之间的同步和通信，避免出现数据不一致等问题。