java基础课后习题答案

文章目录

• 第1章 Java开发入门
• 第2章 Java编程基础
• 第3章 面向对象（上）
• 第4章 面向对象（下）
• 第5章 异常
• 第6章 Java API
• 第7章 集合类
• 第8章 泛型
• 第9章 反射
• 第10章 IO（输入输出）
• 第11章 JDBC
• 第12章 多线程
• 第13章 网络编程

第1章 Java开发入门

一、
1．对象
2．面向对象、跨平台性
3．javac
4．Java虚拟机（或JVM）
5．JRE
二、
1．错
2．错
3．错
4．对
5．对
三、
1．C
2．ABCD
3．D
4．ABD
5．D
四、
1．简答性、面向对象、安全性、跨平台性、支持多线程、分布性。
2. Java程序运行时，必须经过编译和运行两个步骤。首先将后缀名为.java的源文件进行编译，生成后缀名为.class的字节码文件，然后Java虚拟机将字节码文件进行解释执行，并将结果显示出来。
五、
HelloWorld.java

public class HelloWorld { public static void main(String[] args) { System.out.println("这是第一个Java程序!");} }

第2章 Java编程基础

一、
1．class
2．单行注释、多行注释、文档注释
3．4
4．==
5．容器、0
二、
1．对
2．错
3．对
4．错
5．对
三、
1．AC
2．A
3．BD
4．C
5．C
四、
1.Java语言的八种基本数据类型有：byte字节型，占一个字节。short短整型，占两个字节。int整型，占4个字节。long长整型，占8个字节。float单精度浮点型，占4个字节。double双精度浮点型，占8个字节。char字符型，占两个字节。boolean型，表示逻辑值，有true和false两个值，分别占一个字节。
2. 在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码；continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
五、
1.

 public class getSum { public static void main(String[] args) { int sum = 0; for (int i = 1; i < 100; i++) { if (i % 2 != 0) sum += i; } System.out.println(sum); } }

 public class Test { public static void main(String[] args) {int i = 1; long sum = 1; do {sum *= i;i++; } while (i <= 5); System.out.println(sum); } }

第3章 面向对象（上）

一、
1．封装、继承、多态
2．private、default、protected、public
3．static
4．private
5．参数类型 参数个数
6．this
二、
1．对
2．对
3．错
4．对
5．对
三、
1．C
2．B
3．D
4．B
5．C
四、
1．
面向对象的特点主要可以概括为封装性、继承性和多态性。
其中封装是面向对象核心思想”,“将对象的属性和行为封装起来”,“不需要让外界知道具体实现细节”,“这就是封装思想。
继承性主要描述的是类与类之间的关系”,“通过继承”,“可以在无需重新编写原有类的情况下”,“对原有类的功能进行扩展。
多态性指的是在程序中允许出现重名现象”,“它指在一个类中定义的属性和方法被其它类继承后”,“它们可以具有不同的数据类型或表现出不同的行为”,”这使得同一个属性和方法在不同的类中具有不同的语义。
2．
(1)构造方法名与类名相同
(2)在构造方法名的前面没有返回值类型的声明
(3)在构造方法中不能使用return语句返回一个值
五、
Example.java

class Resume {private String name;private String sex;private int age;public Resume(){}public Resume(String name,String sex,int age){this.name = name;this.sex = sex;this.age = age;}public String getName(){return name;}public String getSex(){return sex;}public int getAge(){return age;}public void introduce(){ System.out.println("姓名："+this.getName()+"\n性别："+this.getSex()+"\n年龄："+this.getAge());}}public class Example{ public static void main(String[] args){ Resume re = new Resume("李四","男",20); re.introduce(); }}

第4章 面向对象（下）

一、
1．继承
2．重写
3．final
4．implements
5．抽象类
6．super
二、
1．错
2．对
3．对
4．对
5．对
6．错
7．对

三、
1．B
2．D
3．C
4．D
5．C
四、
1．概念：在Java中”,“类的继承是指在一个现有类的基础上去构建一个新的类”,“构建出来的新类被称作子类”,“现有类被称作父类”,“子类会自动拥有父类所有可继承的属性和方法。
好处：继承性主要描述的是类与类之间的关系”,“通过继承”,“可以无需重新编写原有类的情况下”,“对原有类的功能进行使用和扩展。
2．应用程序不必为每一个子类编写功能调用”,“只需要对抽象父类进行处理即可。大大提高程序的可复用性。
子类的功能可以被父类的方法或引用变量所调用”,“这叫向后兼容”,“可以提高可扩充性和可维护性。
使用多态可以解决项目中紧偶合的问题”,”提高程序的课扩展性.是OCP原则的一个具体的实现。
3.
成员定义的差异：抽象类可以包含抽象方法和非抽象方法，其中非抽象方法可以直接实现，从而提高代码的复用性。而接口中只能定义抽象方法，所有方法在接口中都不能有实现。

成员变量的差异：抽象类的成员变量可以是任何类型，包括私有成员变量。但是，接口中的成员变量只能是public和static的，也就是只能是常量。

继承的差异：一个类只能继承一个抽象类，从而确保了Java单继承的体系结构。然而，一个类可以实现多个接口，这就提供了一种多重继承的机制。
五、
Employee.java

abstract class Employee{private String name; //定义姓名name并私有化属性private int month; //定义生日月份month并私有化属性public Employee(){}//无参构造器public Employee(String name,int month){//有参构造方法this.name = name;//给属性name初始化赋值this.month = month;//给属性month初始化赋值}//获取属性name的方法public String getName(){return name; //返回name属性}//获取属性month的方法public int getMonth(){return month;//返回month属性}//给属性name赋初始值public void setName(String name){this.name = name;//本类中的属性name}//给属性month赋初始值public void setMonth(int month){this.month = month; //本类中的属性month}//创建一个方法getSalary()用来计算工资，参数month是月份，如果当月是员工生日，奖励100元public double getSalary(int month){double salary = 0;//定义工资变量//判断当前月份是否是员工的生日月份，如果是奖励100元if(this.month == month){salary = salary + 100;return salary;//返回工资salary}}}

SalariedEmployee.java

class SalariedEmployee extends Employee{private double monthSalary;//封装monthSalary属性public SalariedEmployee(){}//无参构造方法//有参构造方法 参数姓名 生日月份月薪public SalariedEmployee(String name,int month,double monthSalary){super(name,month);//调用父类有参构造方法this.monthSalary = monthSalary; //为属性monthSalary初始化赋值}//获取monthSalary的值public double getMonthSalary(){return monthSalary;}//给monthSalary赋值public void setMonthSalary(double monthSalary){this.monthSalary = monthSalary;}//覆盖父类中的方法public double getSalary(int month){double salary = monthSalary+super.getSalary(month); //定义工资变量return salary;}}

HourlyEmployee.java

class HourlyEmployee extends Employee{private double hourlySalary; //定义属性hourlySalary每小时的工资private int hours; //定义属性hours每月工作的小时数public HourlyEmployee(){}//无参构造方法//有参构造方法参数 姓名 生日月份每小时的工资 每月工作的小时数public HourlyEmployee(String name,int month,double hourlySalary,int hours){super(name,month);//调用父类有参构造方法 this.hourlySalary = hourlySalary ;//为属性hourlySalary初始化赋值this.hours = hours; //为属性hours 初始化赋值}public double getHourlySalary(){//获取hourlySalary的值return hourlySalary;}public int getHours(){ //获取hours的值return hours;}//定义set方法设置hourlySalaryhours的值public void setHourlySalary(double hourlySalary){this.hourlySalary =hourlySalary;}public void setHourly(int hours){this.hours = hours;}//覆盖父类方法public double getSalary(int month){if(hours < 0){//如果工作小时数小于0输出数据错误System.out.println("数据错误");return 0;}//小于160个小时的 按照每个月的工作小时数乘以每小时的工资else if(hours <= 160) return hourlySalary*hours+super.getSalary(month); //超出160个小时的小时数 按照1.5倍计算else return hourlySalary*160+hourlySalary*1.5*(hours-160)+super.getSalary(month);}}

SalesEmployee.java

class SalesEmployee extends Employee{private double sales ;//定义销售额salesprivate double rate; //定义提成率ratepublic SalesEmployee(){}public SalesEmployee(String name,int month,double sales,double rate){super(name,month);this.sales = sales;this.rate = rate;}public double getSales(){return sales;}public double getRate(){return rate;}public void setSales(double sales){this.sales = sales;}public void setRate(double rate){this.rate = rate;}public double getSalary(int month){return this.getSales()*(1+this.getRate())+super.getSalary(month);}}

BasePlusSalesEmployee.java

class BasePlusSalesEmployee extends SalesEmployee{private double baseSalary; //定义基础工资baseSalary//无参构造方法public BasePlusSalesEmployee(){}//有参构造方法public BasePlusSalesEmployee(String name,int month,double sales,double rate,double baseSalary){super(name,month,sales,rate);this.baseSalary = baseSalary;}//get/set方法对私有属性的调用和设置public double gatBaseSalary(){return baseSalary;}public void setBaseSalary(){this.baseSalary = baseSalary;}public double getSalary(int month){return baseSalary+super.getSalary(month);}}

Test.java

//定义一个测试类public class Test{public static void main(String[] args){//声明一个Employee类型的数组，并创建不同子类型的对象Employee[] employee = {new SalariedEmployee(“张三”,1,6000),new HourlyEmployee(“李四”,2,50,180),new SalesEmployee(“王五”,3,6500,0.15),new BasePlusSalesEmployee(“赵六”,4,5000,0.15,2000)};//打印每个员工的工资for(int i = 0; i < employee.length ;i++)System.out.println(Math.round(employee[i].getSalary(10)));}}

第5章 异常

一、
1．RuntimeException
2．运行时异常 编译时异常
3．throw
4．throws
5．Exception
二、
1．错
2．对
3．对
4．对
5．错
三、
1．C
2．A
3．C
4．C
5．A
四、
1.
try、catch、finally、throw、throws。
2.
程序通过try语句捕获可能出现的异常，如果try语句没有捕获到异常，则直接跳出try…catch语句块执行其他程序；如果在try语句中捕获到了异常，则程序会自动跳转到catch语句中找到匹配的异常类型进行相应的处理。如果try语句捕获到的异常与catch语句例的异常匹配，则先执行catch中的语句，最后执行其他程序语句。

处理编译时期的异常有两种方式如下：
（1）使用try…catch语句对异常进行捕获处理。
（2）使用throws关键字声明抛出异常，调用者对异常进行处理。

第6章 Java API

一、
1．String StringBuffer StringBuilder
2．length()
3．DateFormat
4．Random
5．edcba
二、
1．错
2．错
3．对
4．对
5．错
三、
1．B
2．C
3．A
4．B
5．A
四、
1．
String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer与StringBuilder类。如果有大量字符串拼接操作，不要求线程安全的情况下，采用StringBuilder更高效。相反如果需要线程安全则需要使用StringBuffer。
2．
基本数据类型 对应的包装类

byteBytecharCharacterintIntegershortShortlongLongfloatFloatdoubleDoublebooleanBoolean

五、
1.
Example.java

 import java.util.Random; public class Example { public static void main(String[] args) { for(int i=0;i<10;i++){ System.out.println(new Random().nextInt(100)); } } }

Test.java

 import java.text.DateFormat; import java.util.Calendar; import java.util.Date; public class Test { public static void main(String[] args) { Calendar calendar = Calendar.getInstance(); calendar.add(Calendar.DATE, 100); Date date = calendar.getTime(); DateFormat format = DateFormat.getDateInstance(DateFormat.FULL); String string = format.format(date); System.out.println(string); } }

第7章 集合类

一、
1．Collection
2．hashNext() next()
3．Comparable
4．Key（键）、Value（值）
5．数组
二、
1．错
2．对
3．对
4．对
5．对
三、
1．D
2．D
3．C
4．A
5．C
四、
1．
List的特点是元素有序、可重复。List接口的主要实现类有ArrayList和LinkedList。Set的特点是元素无序、不可重复。Set接口的主要实现类有HashSet和TreeSet。Map的特点是存储的元素是键(Key)、值(Value)映射关系，元素都是成对出现的。Map接口的主要实现类有HashMap和TreeMap。
2．
由于ArrayList集合的底层是使用一个数组来保存元素，在增加或删除指定位置的元素时，会导致创建新的数组，效率比较低，因此不适合做大量的增删操作。但这种数组的结构允许程序通过索引的方式来访问元素，因此使用ArrayList集合查找元素很便捷。
五、
1.
Example.java

 public class Example { public static void main(String[] args) { ArrayList list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("a"); for(Iterator it = list.iterator();it.hasNext();){ System.out.println(it.next());} } }

Test.java

 import java.util.*; class Student { private int age; private String name; public Student(int age, String name) { this.age = age; this.name = name; } public String toString() { return age + ":" + name; } public int hashCode() { return name.hashCode() + age; } public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof Student)) return false; Student stu = (Student) obj; return this.name.equals(stu.name) && this.age == stu.age; } } public class Test { public static void main(String[] args) { HashSet<Student> hs = new HashSet<Student>(); hs.add(new Student(18, "zhangsan")); hs.add(new Student(20, "lisa")); hs.add(new Student(20, "lisa")); System.out.println(hs); } }

第8章 泛型

一、
1．参数化
2．泛型类 泛型接口 泛型方法
3．泛型方法
4．实现
二、
1．错
2．对
3．对
4．对
5．对
三、
1．D
2．A
3．A
4．AC
四、
1．
（1）提高类型的安全性。
泛型的主要目标是提高Java程序的类型安全性，即可以通过泛型定义对变量类型进行限制，在对变量类型限制之后编译器可以更好的进行类型验证。
（2）避免强制类型转换。
使用泛型的另一个好处是避免源代码中的许多强制类型转换。这使得代码可读性更高，并且减少出错机会。尽管减少强制类型转换可以降低使用泛型类代码的复杂度，但是声明泛型变量会带来相应的复杂操作。
五、
1.

 interface Generic<T>{public abstract void get(T t){}}class Generic<T> implements Generic{ public void get(T t){}}

第9章 反射

一、
1．动态
2．newInstance()
3．Method
4．getDeclaredFields()
5．Class
二、
1．对
2．对
3．对
4．错
5．对
三、
1．D
2．C
3．AC
4．A
5．C
四、
1．
Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以得到任意一个对象所属的类的信息，可以调用任意一个类的成员变量和方法，可以获取任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。
2．
（1）根据类名获取：类名.class；
（2）根据对象获取：对象.getClass()；
（3）根据全限定类名获取：Class.forName(“全限定类名”)。

第10章 IO（输入输出）

一、
1．字节流 字符流
2．Reader
3．BufferedInputStream BufferedOutputStream
4．InputStreamReader OutputStreamWriter
5．OutputStream
二、
1．对
2．错
3．错
4．对
5．错
三、
1．A
2．A
3．B
4．C
5．C
四、
1．
字节流的两个基类是InputStream和OutputStream，字符流的两个基类是Reader和Writer，它们都是Object类的直接子类，字节流是处理以8位字节为基本单位的字节流类；Reader和Writer类是专门处理16位字节的字符流类。
2．
InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符。OutputStreamWriter是Writer的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符。
五、
1.
Test01.Java

 import java.io.*; public class Test01 { public static void main(String[] args) throws Exception { // 字节流拷贝 FileInputStream in = new FileInputStream("E:/src.txt"); FileOutputStream out = new FileOutputStream("E:/des1.txt"); byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) != -1) { out.write(buf, 0, len); } in.close(); out.close(); // 字符流拷贝 BufferedReader bf = new BufferedReader(new FileReader("E:/src.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("E:/des2.txt")); String str; while ((str = bf.readLine()) != null) { bw.write(str); bw.newLine(); } bf.close();bw.close();}}

第11章 JDBC

一、
1．java.sql.DriverManager
2．classpath
3．update
4．预编译
5．1
二、
1．错
2．对
3．对
4．对
5．错
三、
1．B
2．B
3．C
4．C
5．A
5．AD

四、
1．

1、加载并注册数据库驱动；2、通过DriverManager获取数据库连接；3、通过Connection对象获取Statement对象； 4、使用Statement执行SQL语句； 5、操作ResultSet结果集；6、回收数据库资源。

2． 所谓预编译,就是说当相同的SQL语句再次执行时,数据库只需使用缓冲区中的数据,而不需要对SQL语句再次编译,从而有效提高数据的访问效率。

第12章 多线程

一、
1．Thread Runnable
2．新建状态（New）、就绪状态（Runnable）、运行状态（Running）
3．start()
4．sleep()
5．synchronized
二、
1．对
2．对
3．对
4．错
5．错
三、
1．C
2．B
3．B
4．D
5．BC
四、
1．
一种是继承java.lang包下的Thread类，覆写Thread类的run()方法，在run()方法中实现运行在线程上的代码。

new Thread() {public void run(){}}.start();

另一种就是实现java.lang.Runnable接口，同样是在run()方法中实现运行在线程上的代码。

class MyThread implements Runnable{public void run(){}}

2．
同步代码块的作用是控制线程，保证同步代码块中只能有一个线程在运行，保证了多线程操作数据的安全性。
五、
1.
Example.java

 public class Example { public static void main(String[] args) { TicketWindow tw = new TicketWindow(); new Thread(tw, "线程1").start(); new Thread(tw, "线程2").start(); } } class TicketWindow implements Runnable { private int num = 100; public void run() { while (num > 0) { Thread th = Thread.currentThread(); String th_name = th.getName(); System.out.println(th_name + " 正在发售第 " + num-- + " 张票 "); } }}

第13章 网络编程

一、
1．链路层、网络层、运输层、应用层
2．UDP
3．TCP
4．DatagramSocket
5．ServerSocket
二、
1．错
2．错
3．对
4．对
5．对
三、
1．D
2．A
3．D
4．C
5．D
四、
1．UDP通信与TCP通信的区别在于，UDP中只有发送端和接收端，不区分客户端与服务器端，计算机之间可以任意地发送数据；而TCP通信是严格区分客户端与服务器端的，在通信时，必须先由客户端去连接服务器端才能实现通信，服务器端不可以主动连接客户端，并且服务器端程序需要事先启动，等待客户端的连接。
2．在TCP连接中必须要明确客户端与服务器端，由客户端向服务器端发出连接请求，每次连接的创建都需要经过“三次握手”。第一次握手，客户端向服务器端发出连接请求，等待服务器确认；第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求；第三次握手，客户端再次向服务器端发送确认信息，确认连接。
五、
AskServer.java

/**** 在线客服咨询人员* */ public class AskServer { public static void main(String[] args) { //创建DatagramSocket，发送接收数据都依赖他 DatagramSocket socket = null; try { socket = new DatagramSocket(8888); Scanner input = new Scanner(System.in); while (true) { //准备一个空的数据包，用来接收数据byte[] buf = new byte[1024];DatagramPacket packet = new DatagramPacket(buf, buf.length); //接收数据使用空的数据包socket.receive(packet); //输出信息 String info = new String(packet.getData(), 0,packet.getLength()); System.out.println("客户端请求：" + info); //判断是否退出 if ("bye".equals(info)) { break;} //发送数据 String result = input.nextLine(); byte[] buf2 = result.getBytes(); DatagramPacket packet2 = new DatagramPacket(buf2,buf2.length,packet.getAddress(), packet.getPort()); socket.send(packet2); }} catch (SocketException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { //关闭socket socket.close(); } } }

AskClient.java

/**** 在线客服客户**/ public class AskClient { public static void main(String[] args) { //创建DatagramSocket，发送接收数据都依赖他 DatagramSocket socket = null; try { socket = new DatagramSocket(9999); Scanner input = new Scanner(System.in); while (true){ //准备要发送的数据 String str = input.nextLine();//bye //使用数据包把数据封装起来 byte[] buf = str.getBytes(); DatagramPacket packet = new DatagramPacket(buf, buf.length,InetAddress.getByName("192.168.1.252"), 8888); //发送数据包 socket.send(packet); //判断是否退出 if ("bye".equals(str)) { break; } //接收数据 byte[] buf2 = new byte[1024]; DatagramPacket packet2 = new DatagramPacket(buf2,buf2.length); socket.receive(packet2); System.out.println("服务器端反馈："+ new String(packet2.getData(), 0, packet2.getLength()));} } catch (SocketException e) { e.printStackTrace(); } catch (IOException e) {e.printStackTrace(); } finally { //关闭socket socket.close(); } }}