尚学堂（java）1到13章所有练习题答案详解

尚学堂1到13章所有练习题答案详解

未完待续…

B站网课链接

配合网课食用学习效果更佳bilibili JAVA300集
尚学堂文档

第一章

一、选择题

1. 以下（ C ）不是Java的特点。（选择一项）

A.平台无关性

B.高可靠性和安全性

C.指针运算

D.分布式应用和多线程

2. 以下选项中关于Java跨平台原理的说法正确的是（A C ）。（选择二项）

A Java源程序要先编译成与平台无关的字节码文件(.class)，然后字节码文件再被解释成机器码运行

B. Java语言只需要编译，不需要进行解释

C. Java虚拟机是运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的

D. Java语言具有一次编译，到处运行的特点，可以在所有的平台上运行

原因：D中“到处”运行的隐含条件是“装有JVM”

3. 以下选项中是对一个Java源文件进行正确编译的语句是（ D ）（选择一项）

A. java Test

B. java Test.class

C. javac Test

D. javac Test.java

4. 在Java中，源文件Test.java中包含如下代码，则程序编译运行的结果是（ B ）。（选择一项）

public class Test {
    public static void main(String[ ] args) {
        system.out.println("Hello!");
    }
}

A 输出：Hello！

B. 编译出错，提示“无法解析system”

C. 运行正常，但没有输出任何内容

D. 运行时出现异常
原因：system中S得大写

5. 有一段Java 程序，其中public类名是A1，那么保存它的源文件名可以是（ A ）。（选择一项）

A A1.java

B. A1.class

C. A1

D. 都不对

二、简答题

1.计算机语言发展史中的主线。

计算机语言经历了三代：第一代是机器语言，第二代是汇编语言，第三代是高级语言。

机器语言通常由数字串组成（最终被简化成01）
汇编语言：使用英文缩写的助记符来表示基本的计算机操作

2.Java的跨平台的实现原理。

源文件（.java）编译之后变成字节码文件（.class）在jvm上解释运行，不同的操作系统有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，随处运行”。

3.JDK、JRE、JVM 的区别和联系。

JVM(Java Virtual Machine)就是一个虚拟的用于执行bytecode字节码的”虚拟计算机”。他也定义了指令集、寄存器集、结构栈、垃圾收集堆、内存区域。JVM负责将Java字节码解释运行，

Java Runtime Environment (JRE) 包含：Java虚拟机、库函数、运行Java应用程序所必须的文件。

Java Development Kit (JDK)包含：包含JRE，以及增加编译器和调试器等用于程序开发的文件

4.Java程序的开发和执行过程。

progarmming _——javac *.java ——java

5.环境变量Path的作用和配置。

它告诉操作系统，当要求系统运行一个程序而没有告诉它程序所在的完整路径时，系统除了在当前目录下寻找此程序外，还应到哪些目录下寻找。

三、上机操作

1. 使用记事本编写第一个Java程序。
注意掌握快捷键

2. 使用记事本编写Java程序(重点练习打印语句System.out.println())，开发学生管理系统主菜单界面
输出打印即可

3. 照着敲小游戏代码，完成小游戏。遇到问题找到出错的行，对照代码进行修改。

/**
 * 2019年9月11日
 */
package prj1_TaiQiu;

import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

import java.awt.*;
import java.util.Random;

/**
 * 
 *
 * 2019年9月11日
 */
public class ball1 extends JFrame {

	Image ball = Toolkit.getDefaultToolkit()
			.getImage("G:/Major/Eclipse/coding/Java_300/src/prj1_TaiQiu/image/ball.png");
	Image desk = Toolkit.getDefaultToolkit()
			.getImage("G:/Major/Eclipse/coding/Java_300/src/prj1_TaiQiu/image/desk.jpg");

	// 小球的坐标
	double x = 100;
	double y = 100;
	double speed=5;
	boolean right = true,down=true;

	// 画窗口
	public void paint(Graphics g) {
		// 创建图片对象
		ImageIcon icon_desk = new ImageIcon("G:/Major/Eclipse/coding/Java_300/src/prj1_TaiQiu/image/desk.jpg");
		ImageIcon icon_ball = new ImageIcon("G:/Major/Eclipse/coding/Java_300/src/prj1_TaiQiu/image/ball.png");
		
		g.drawImage(desk, 0, 0, null);
		g.drawImage(ball, (int) x, (int) y, null);
		
		Random ra = new Random();

		// 小球运动
		if (right) {
			x = x + speed;
		} else {
			x = x - speed;	
		}
		if(down){
			y = y +speed;
		}else{
			y = y -speed;
		}

		if (x > 856 - 40 - 30) { // 856是窗口宽度，40是桌子边框的宽度，30是小球的直径
			right = false;
			speed = ra.nextInt(6)+1;
		}
		if(y>500-40-30){
			down = false;
			speed = ra.nextInt(3)+1;
		}

		if (x < 40) { // 40是桌子边框的宽度
			right = true;
			
		}
		if(y<70){
			down = true;
		}

	}

	// 窗口加载
	void ballFrame() {
		setSize(856, 500);
		setLocation(50, 50);
		setVisible(true);

		// 重画窗口,每秒画25次
		while (true) {
			repaint();
			try {
				Thread.sleep(40); // 20ms, 1秒=1000毫秒. 大约一秒画50次窗口
			} catch (Exception e) {
				e.printStackTrace();
			}

		}

	}

	public static void main(String[] args) {
		
		ball1 game = new ball1();
		game.ballFrame();
	}

}

第二章

第三章

第四章

一、选择题

1.以下语句中关于Java构造方法的说法错误的是(B )。(选择一项)

A.构造方法的作用是为创建对象进行初始化工作，比如给成员变量赋值

B.一个Java类可以没有构造方法，也可以提供1个或多个构造方法

C.构造方法与类同名，不能书写返回值类型

D.构造方法的第一条语句如果是super()，则可以省略，该语句作用是调用父类无参数的构造方法

Java类一定有构造方法，如果我们没有定义，系统会自动定义

2.在Java中，以下程序编译运行后的输出结果为(D )。(选择一项)

public class Test {
  int x, y;
  Test(int x, int y) {
      this.x = x;
      this.y = y;
  }
  public static void main(String[] args) {
      Test pt1, pt2;
      pt1 = new Test(3, 3);
      pt2 = new Test(4, 4);
      System.out.print(pt1.x + pt2.x);
  }
}
A.6

B.34

C.8

D.7

两个对象的两个属性，不涉及“多个变量指向同一个对象”

3.在Java中关于静态方法，以下说法中正确的是( A C)。(选择二项)

A.静态方法中不能直接调用非静态方法

B.非静态方法中不能直接调用静态方法

C.静态方法可以用类名直接调用

D.静态方法里可以使用this

A。static修饰的成员变量和方法，从属于类。普通变量和方法从属于对象的。知道类，并不一定可以推出具体的对象，就好像知道这个是车，但是并不能推出它是什么型号的车
D. this是指向当前对象的，当前对象在堆里面，但是静态方法在静态区（方法区）中，此时使用this不能获取到当前类的地址

4.下列选项中关于Java中类方法的说法错误的是(BC )。(选择二项)

A.在类方法中可用this来调用本类的类方法

B.在类方法中调用本类的类方法时可直接调用

C.在类方法中只能调用本类中的类方法

D.在类方法中调用实例方法需要先创建对象
原因：
1.非静态方法必须采用对象.方法名来调用，不能直接调用
2.java类如果存在继承，子类可以访问父类非私有方法，不仅仅是本类方法

5.分析如下Java程序的代码所示，则编译运行后的输出结果是(C )。(选择一项)

public class Test {
  int count=9;
  public void count1(){
      count=10;
      System.out.print("count1="+count);
  }
  public void count2(){
      System.out.print("count2="+count);
  }
  public static void main(String[ ] args) {
      Test t=new Test();
      t.count1();
      t.count2();
  }
}

A.count1=9; count2=9;

B.count1=10;count2=9;

C.count1=10; count2=10;

D.count1=9; count2=10;

二、简答题

1. 面向过程和面向对象的区别。
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；

面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了多个步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

2. 类和对象的关系

对象是对客观事物的抽象，类是对对象的抽象。类是一种抽象的数据类型。 它们的关系是，对象是类的实例，类是对象的模板。

3. 构造方法的作用和特征

作用：用于对象的初始化

特征：

1）通过new调用

2）虽然有返回值，但是不能定义返回值的类型，

3）如果我们没有定义，系统自动定义

4）构造器的方法名和类名一致

4. this关键字的作用和用法

作用：它是创建好的对象的地址，用来指代当前对象

用法：
1）当程序有二义性时，用来指代当前对象
2）使用this调用构造器重载，避免相同初始化代码
3）this不能用于static中
5. 简述static关键字的作用。
提示：从static可以修饰变量，方法，代码块，三个方面来回答。

1）声明成员变量为静态成员变量， static修饰的成员变量和方法，从属于类。

普通变量和方法从属于对象的。

2）静态初始化块，用于类的初始化操作

三：编程题

package prj1_TaiQiu;

/**
 * 
 *
 * 2019年9月18日
 */
//


/*
 * 编程题     1。 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性：
 *  姓名 (name) 和年龄 (age) 。定义构造方法用来初始化数据成员。
 * 再定义显示(display()) 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
 */
class Person {
	String name;
	int age;
	
	//构造方法
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	//普通display()方法
	public void display() {
		System.out.println("她的姓名是：" + name + "," + "年龄是：" + age);
	}
}
/*
 *编程题 2. 定义一个圆类——Circle，在类的内部提供一个属性：半径(r)，同时 提供 两个 方 法 ： 
 * 计算 面积 ( getArea() ) 和 计算 周长(getPerimeter()) 。 
 * 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
 */
class Circle {
	//属性r
	double r;
	
	//构造方法
	public Circle(double r) {
		this.r = r;
	}
	
	//普通方法
	public double getArea() {
		double area = Math.PI * Math.pow(this.r, 2);
		System.out.println("圆的面积是：" + area);
		return area;
	}
	
	public double getPerimeter() {
		double perimeter = 2 * Math.PI * this.r;
		System.out.println("圆的周长是：" + perimeter);
		return perimeter;
	}
}
/*
 * 3. 构造方法与重载：定义一个网络用户类，信息有用户 ID、用户密码、 email 地址。
 * 在建立类的实例时把以上三个信息都作为构造函数的参数输入，
 *  其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。
 */
class WebUser{
	//属性
	int id;
	String pwd;
	String email;
	
	//构造方法1
	public WebUser(int id,String pwd) {
		this.id = id;
		this.pwd = pwd;
		this.email = this.id + "@gameschool";
	}
	//构造方法2
	public WebUser(int id,String pwd,String email) {
		this(id,pwd);
		this.email = email;
	}
	//普通方法，用于测试结果
	
	public void Test() {
		System.out.println(id + "\t" +  pwd + "\t" + email);
	}
}

public class Task {
	public static void main(String[] args){
		//第一题测试
		Person p = new Person("李国平",18);
		p.display();
		
		//第二题测试
		Circle yuan = new Circle(6.0);
		yuan.getArea();
		yuan.getPerimeter();
		
		//第三题测试
		WebUser user = new WebUser(10,"Guoping");
		user.Test();
		
	}
}

第五章

一、选择题

1.使用权限修饰符( )修饰的类的成员变量和成员方法，可以被当前包中所有类访问，也可以被它的子类(同一个包以及不同包中的子类)访问。A (选择一项)

A.public

B.protected

C.默认

D.private

2.以下关于继承条件下构造方法执行过程的代码的执行结果是( A )。(选择一项)

class Person {   
    public Person() {
        System.out.println("execute Person()");
    }
}
class Student extends Person { 
    public Student() {       
        System.out.println("execute Student() ");
    }  
}
class PostGraduate extends Student {   
    public PostGraduate() {  
        System.out.println("execute PostGraduate()");
    }  
}
public class TestInherit {
    public static void main(String[] args) {
        new PostGraduate();       
    }
}

A.execute Person()

execute Student()

execute PostGraduate()

B.execute PostGraduate()

C.execute PostGraduate()

execute Student()

execute Person()

D.没有结果输出

构造方法从顶向下

3.编译运行如下Java代码，输出结果是( D )。(选择一项)

class Base {
    public void method(){
        System.out.print ("Base method");
    }
}
class Child extends Base{   
    public void methodB(){
        System.out.print ("Child methodB");
    }
}
class Sample {
    public static void main(String[] args) {
        Base base= new Child();
        base.methodB();
    }
}
A.Base method

B.Child methodB

C.hild methodB

D.编译错误

父类向子类转型可以自动转，但是子类必须强制转换才能向下转型
4.在Java中关于abstract关键字，以下说法正确的是(B )。

A.abstract类中可以没有抽象方法

B.abstract类的子类也可以是抽象类

C.abstract方法可以有方法体

D.abstract类可以创建对象

抽象类的使用要点:
1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。
如果子类实现了所有的抽象方法，则不再是抽象类…

5.在Java接口中，下列选项中属于有效的方法声明是( AC )。(选择二项)

A.public void aMethod( );

B.final void aMethod( );

C.void aMethod();

D.private void aMethod( );

private：不能使用的原因
　　很好理解，类和接口如果定义成private，那么其他任何类都不能访问，这样的类写出来也没有意义。
protected：不能使用的原因
　　这个问题用反证法比较好解释清楚，假设类B和A不在同一个包，A又是protected类， 那么B能访问A的前提是B是A的子类，而B能成为A的子类（或者说B能继承A）的前提又是B能访问A。这两个条件互为前提，无法实现。

第六章

第七章

一、 选择题

1.在Java中，以下程序段能正确为数组赋值的是(A CD)。(选择二项)

A. int a[]={1,2,3,4};
B. int b[4]={1,2,3,4};
C. int c[]; c=new int[] {1,2,3,4};
D. int d[]; d=new int[]{1,2,3,4};

应该是题目有问题。

2.已知表达式int [] m={0,1,2,3,4,5,6};下面( )表达式的值与数组最大下标数相等。(选择一项) B

A.m.length()
B.m.length-1
C.m.length()+1
D.m.length+1
3.在Java中，以下定义数组的语句正确的是( BC )。(选择二项)

A.int t[10]=new int[ ];
B.char [ ]a=new char[5];
char []a={‘a’,’b’};
C.
String [ ] s=new String [10];
D.
double[ ] d [ ]=new double [4][ ];
double[][] d;
double d[][];
4.分析下面的Java源程序，编译后的运行结果是(B )。(选择一项)

import java.util.*;
public class Test {
    public static void main(String[ ] args) {
        int [ ] numbers=new int[ ]{1,2,3};
        System.out.println(Arrays.binarySearch(numbers, 2));
    }
}

A.输出：0

B.输出：1

C.输出：2

D.输出：3

5.以下选项中能够正确创建一个数组的是( AD )。(选择二项)

A. float []f[] = new float[6][6];
B. float f[][] = new float[][];
C. float [6][]f = new float[6][6];
D. float [][]f = new float[6][];

二、 简答题

1. 数组的特点。
   数组的三个基本特点：

   (1). 长度是确定的。

   (2.) 其元素必须是相同类型，

   (3). 数组类型可以是任何数据类型，包括基本类型和引用类型。

2. 数组的优缺点
   优点：
   数组定义简单，而且访问很方便
   缺点：
   数组中所有元素类型都必须相同
   数组大小必须定义时给出，而且大多数情况下，数组空间的大小一旦确定后就不能更改
   数组的空间必须是连续的，这就造成数组在内存中分配空间时必须找到一块连续的内存空间。所以数组不可能定义得太大，因为内存中不可能有那么多大的连续的内存空间，而解决这个问题的方法就是使用链表。

3. 冒泡排序的算法。
   比较相邻 的元素，正序排列时，如果前面的元素比后面的大就交换

4. 数组的三种初始化方式是什么?
第一种:先声明长度，再赋值

int[] a = new int[100];
for(int i = 0;i

第二种:直接赋值，元素数量就是长度

int[] a = {1,2,3}；

第三钟：新建对象

int[] a = new int[] {1,2,3}；

三、 编码题

1. 数组查找操作：定义一个长度为10 的一维字符串数组，在每一个元素存放一个单词;然后运行时从命令行输入一个单词，程序判断数组是否包含有这个单词，包含这个单词就打印出“Yes”，不包含就打印出“No”。
   注意两点：
   （1）输入时使用system.in 通过scanner获取
   (2) 判断字符串内容是否相同使用equal，而不是==

/**
* 2019年9月21日
*/
package array;

import java.util.Scanner;

/**
* 你微微地笑着，不同我说什么话。而我觉得，为了这个，我已经等了很久。
*
* 2019年9月21日
*/
public class isExit {
  
  public static void main(String[] args) {
  	String[] str = new String[]{"You", "smiled", "and", "talked", "to"," me"," of"," nothing"," and ","I"," felt"," that"," for"," this"," I ","had ","been ","waiting ","long"};
      //获取输入字符
  	System.out.println("请输入");
  	Scanner sc = new Scanner(System.in);
  	String mes = sc.nextLine();
  	
  	//是否存在
  	IsExit(str, mes);
  	
  }
  
  
  public static void IsExit(String[] str,String mes){
  	boolean flag=true;
  	
  	for(int i=0;i

2. 获取数组最大值和最小值操作：利用Java的Math类的random()方法，编写函数得到0到n之间的随机数，n是参数。并找出产生50个这样的随机数中最大的、最小的数，并统计其中>=60的有多少个。

提示：使用 int num=(int)(n*Math.random());获取随机数。

public class Task{
	public static void main(String[] args) {
```		System.out.println("请输入随机数区间大值n"); 
		 Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int tempNum = 0;						//临时存储超过60的数
		
		int[] numArray = new int[50];		//numArray数组中存储的是随机
		for(int i= 0;i < 50;i++) {			//生成0~n之间随机数50个
			numArray[i] = (int)(n * Math.random());
			if(numArray[i] >= 60) {			//判断超过60的个数
				tempNum ++;
			}
		}
		Test2 t2 = new Test2();			//定义的test2类实例化的对象
		t2.numTest(numArray);			//调用Test2中的静态方法
		System.out.println("超过60的有" + tempNum + "个");		//输出超60个数
	}
}
//自定义的Test2 类，用来对随机生成的数组排序，通过排序后的数组可以方便输出最大最小数
class Test2 extends BubbleSort{
	public static void numTest(int[] array) {
		bubbleSort(array);						//冒泡排序算法处理array数组
		System.out.println("最大数是：" + array[49] + "\n" + "最小数是：" + array[0]);
	}
}
//自定义的冒泡排序算法
class BubbleSort {
	public static void bubbleSort(int[] array) {
		int temp = 0;
		//冒泡排序
		for(int i = array.length - 1;i > 0;i--) {
			boolean flag = true;
			for(int j = 0;j < i;j++) {
				if(array[j] > array[j + 1]) {
					temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
					flag = false;
				}
			}
			if(flag) {
				break;
			}
		}
	}
}

3. 数组逆序操作：定义长度为10的数组，将数组元素对调，并输出对调前后的结果。

   思路：把0索引和arr.length-1的元素交换，把1索引和arr.length-2的元素交换……

   只要交换到arr.length/2的时候即可。

/**
 * 2019年9月21日
 */
package array;

import java.util.Arrays;

/**
 * 
 *
 * 2019年9月21日
 */
public class reverse {
	
		public static void main(String[] args) {
	    	int[] randomNum = new int[10];					//随机生成一个·包含10个元素的int类数组
			for(int i = 0;i < randomNum.length;i++) {
				randomNum[i] = (int)(30 * Math.random());
			}
			
			//打印随机生成的数组顺序
			System.out.println(Arrays.toString(randomNum));
			
			int temp = 0;
			for(int i = 0;i < randomNum.length / 2;i++) {		//元素交换的方法
				temp = randomNum[i];
				randomNum[i] = randomNum[randomNum.length - 1 - i];
				randomNum[randomNum.length - 1 - i] = temp;
			}
			System.out.println(Arrays.toString(randomNum));		//打印元素交换后的数组
			
		}
	}

第八章

第九章

第十章

第十一章

第十二章

第十三章