java基础课后习题答案

发布时间:2024年01月12日


第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

/**
  *
  * 在线客服客户
  *
  */
 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();
         }
     }
}
文章来源:https://blog.csdn.net/m0_61350160/article/details/135540958
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。