java基础课后习题答案-Toy模板网

这篇具有很好参考价值的文章主要介绍了java基础课后习题答案。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

第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方法设置hourlySalary  hours的值
	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 ;	//定义销售额sales
	private double rate; //定义提成率rate
	public 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．
基本数据类型对应的包装类

byte	Byte
char	Character
int  	Integer
short	Short
long	Long
float	Float
double	Double
boolean	Boolean

五、
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文章来源地址https://www.toymoban.com/news/detail-812494.html

/**
  *
  * 在线客服客户
  *
  */
 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();
         }
     }
}