21天学通JAVA习题

最新推荐文章于 2024-09-14 18:46:05 发布

凤凰AI

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量326

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/Daniel_Singularity/article/details/105814768

版权

Java 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

第一章

1，JAVA作为一门优秀的编程语言有何特点？

java语言具有简单，面向对象，分布式，安全，可移植性，多态性特点。
java语言是一门面向对象语言
java语言主要用在设计类和接口方面，提供了继承和多态机制。
java语言不支持指针
java语言编译产生字节码文件。
java语言支持多线程技术，将多个程序任务分成几个并行的子任务。

2，简述Java程序开发过程

创建一个源文件
将源文件编译为一个.class文件
运行程序

3，什么是Java虚拟机？

Java虚拟机是java的基础和核心，Java虚拟机处于Java编译器和os平台之间的虚拟平台。java虚拟机可以运行字节码文件。虚拟机中的Java解释器将字节码文件解释成适合该硬件平台和操作系统的机器语言。

4，Java语言的安全机制有哪些？

类装载器结构 (class loader)
class文件检查器 (the class file verifier)
内置于Java虚拟机(及语言)的安全特性
安全管理器及Java API (security manager)

二，

public class HelloWorld {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("Hello World!");
	}

}

第二章

一，简述题

1，叙述标识符的定义规则。

标识符要以英文字母开头，由英文字母，数字，$，_组成，其他的符号不能出现在标识符里。

英文字母是大写的A-Z或小写的a-z。以及“_"和“$”。
数字包括0-9
其他的符号不能用在标识符里
不能用Java所保留的关键字
Java标识符是区分大小写的

2，什么情况下能够进行自动转换？什么情况下需要进行强制类型转换？

自动转换就是不需要明确指出所要转换的类型是什么，而是由Java虚拟及自动转换。小数据类型变大数据类型。

强制类型转换。大类型向小类型转换要进行强制类型转换。

3，写出几个正确的Java标识符

i,name2等

4，Java中有哪几种基本数据类型？

整型，浮点型，字符型，布尔型。

二，编程题

1，对几种类型进行自动提升的转换。自动提升发生的条件是：两种类型是兼容的，或者目标类型的范围比原类型的范围大。

public class Exercise01 {
	public static void main(String[] args) {
		byte b = 111;
		System.out.println(b);
		int i = 222;
		byte c = (byte)i;
		System.out.println(c);
	}
}

2，根据不同的数据类型进行转换？

Java数据类型转换

3，编写一个程序，输出各种数据类型的初始值？

public class Exercise02 {
	
	private static int intType;
	private static short shortType;
	private static long longType;
	private static float floatTypt;
	private static double doubleType;
	private static boolean booleanType;
	private static char charType;
	private static String stringType;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("intType:"+intType);
		System.out.println("shortType:"+shortType);
		System.out.println("longType:"+longType);
		System.out.println("floatTypt:"+floatTypt);
		System.out.println("doubleType:"+doubleType);
		System.out.println("booleanType:"+booleanType);
		System.out.println("charType:"+charType);
		System.out.println("stringType:"+stringType);
	}
}

4，编写程序分别使用不同的标识符？

public class Exercise02 {
	
	private static int intType;
	private static short shortType;
	private static long longType;
	private static float floatTypt;
	private static double doubleType;
	private static boolean booleanType;
	private static char charType;
	private static String stringType;

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("intType:"+intType);
		System.out.println("shortType:"+shortType);
		System.out.println("longType:"+longType);
		System.out.println("floatTypt:"+floatTypt);
		System.out.println("doubleType:"+doubleType);
		System.out.println("booleanType:"+booleanType);
		System.out.println("charType:"+charType);
		System.out.println("stringType:"+stringType);
	}
}

5，编写一个程序，使用到行注释和块注释？

public class Exercise02 {
	
	private static int intType;   //行注释
	private static short shortType;
	private static long longType;
	private static float floatTypt;
	private static double doubleType;
	private static boolean booleanType;
	private static char charType;
	private static String stringType;
	/*
	 * 块注释
	 */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("intType:"+intType);
		System.out.println("shortType:"+shortType);
		System.out.println("longType:"+longType);
		System.out.println("floatTypt:"+floatTypt);
		System.out.println("doubleType:"+doubleType);
		System.out.println("booleanType:"+booleanType);
		System.out.println("charType:"+charType);
		System.out.println("stringType:"+stringType);
	}
}

6，编写一个程序，使用行注释，并输出生成doc注释。

/**
 * 
 * @author PETER
 *
 */
public class Exercise03 {
	
	public String name;   //成员变量
	/**
	 * JAVA程序的主入口方法
	 * @param args
	 */

	public static void main(String[] args) {
		System.out.println("环境使用Java来编写程序！");
	}

}

7，编写一个程序，使用标识符定义不同的数据类型？

public class Exercise02 {
	
	private static int intType;   
	private static short shortType;
	private static long longType;
	private static float floatTypt;
	private static double doubleType;
	private static boolean booleanType;
	private static char charType;
	private static String stringType;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("intType:"+intType);
		System.out.println("shortType:"+shortType);
		System.out.println("longType:"+longType);
		System.out.println("floatTypt:"+floatTypt);
		System.out.println("doubleType:"+doubleType);
		System.out.println("booleanType:"+booleanType);
		System.out.println("charType:"+charType);
		System.out.println("stringType:"+stringType);
	}
}

第三章

一，简答题

1，判断下面的程序是否能正常运行。如果不能运行，请说出不能运行的原因。

public class Exercise01 {
	public static void main(String[] args) {
		int x=3;
		double y=3.0;
		boolean b=(x=y);
		System.out.println(b);
	}
}

不能正常运行。

2，Java中常用的运算符有哪些

算术运算符，自增自减运算符，关系运算符，逻辑运算符，三元运算符，位运算符。位移运算符，赋值运算符。

3，“>>>’'和">>"的区别是什么？

”>>>“:无符号右移运算

">>"：带符号右移运算

二，操作题

1.对一个四位数x,编程计算x的每一位数字相加之和，例如x=1234,则由1234分别分离出千位，百位，十位，个位，然后计算出1+2+3+4=10，于是在屏幕上输出10。

public class Exercise02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int num = 1234;
		int ge = 1234%10;
		int shi = (1234/10)%10;
		int bai = (1234/100)%10;
		int qian = (1234/1000);
		
		int total = ge+shi+bai+qian;
		System.out.println(total);
	}
}

第四章

一，简答题

1，简述while循环语句和do...while循环语句有什么不同。

while循环先判断后运行。do....while先执行后判断。

2，简述break中断语句和continue继续语句有什么不同

break跳出一个循环；continue跳出本循环

3，switch表达式中可以使用哪几种类型？

switch表达式只能是整数类型和有顺序的数列。

二，编程题

1，打印99乘法表

public class Exercise01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		for(int i=1;i<=9;i++) {
			for(int j=1;j<=i;j++) {
				System.out.print(j+"*"+i+"="+i*j+"  ");
			}
			System.out.println();
		}
	}
}

2，使用循环打印一个菱形

public class Exercise02 {
	public static void main(String[] args) {
		
		for (int i = 0; i < 9; i++) {//行     9是菱形的高度
            for (int j = 0; j < Math.abs(4-i); j++) {//空格   Math.abs绝对值
                System.out.print(" ");
            }
            for (int j = 0; j < 9 - 2 * Math.abs(i - 4); j++) {//打印星星
                System.out.print("*");
            }
            System.out.println();//换行
        }
	}
}

第五章

一，简答题

1.简述多维数组的含义。

多维数组是一种嵌套的数组，一维数组的每个元素又是一维数组。

2，简述Java中的数组是如何完成数组边界检测的

简单的说，就算检查你的索引是否在0~(len-1)之内

3，简述数组创建的过程

假如创建一个String类型的数组。先开辟一条内存空间String [] x = new String[5];然后分别对数组中的5个元素进行赋道值。

也可以在创建的时候直接初始属化： String [] x = {"a","b","c","d","e"};

4，数组的内存分配是如何完成的

数组在堆内分配内存

二，编程题

1，先声明一个数组，这个数组中可能会存在重复的元素，而且顺序也是混乱的，要求将数组中的重复元素排除掉且将新得到的数组进行递增排序。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class Exercise06 {

	public static void main(String[] args) {
		int a[] = {1,2,5,7,2,3};
		List<Integer> list = new ArrayList<Integer>();
		for(int i=0;i<a.length;i++) {
			if(!list.contains(a[i])) {
				list.add(a[i]);
			}
		}
		
		Collections.sort(list);
		for(int i=0;i<list.size();i++) {
			System.out.print(list.get(i));
		}
	}
}

2,定义一个Double类型的数组，使用for循环对数组中的每个元素进行赋值，再使用for循环将最大与最小值和平均值进行输出。

public class Exercise07 {

	public static void main(String[] args) {
		double a[] = {1.3,1,2.4,5,6,7.8};
		double sum=0;
		double max = a[0];
		double min = a[0];
		for(int i=0;i<a.length;i++) {
			sum += a[i];
			if(a[i]>max) {
				max = a[i];
			}
			if(a[i]<min){
				min = a[i];
			}
		}
		System.out.println("最大值:"+max);
		System.out.println("最小值:"+min);
		System.out.println("平均值："+sum/a.length);

	}

}

3，

奇数阶幻方指的是有一个行数和列数都相等的数据组成一个方阵，即由1~n*n个数据组成，由于是奇数阶幻方，所以阶数n必须是奇数。

其要求为：每行、每列和对角线上的数据之和相等。

奇数阶幻方

4，编写程序输入一个n阶方阵各元素的值，求出两条对角线元素值之和（交叉位置的元素只计算一次），之后将它们的和值输出到终端上。

import java.util.Scanner;

public class Exercise08 {
	public static void main(String[] args) {
		System.out.println("请输n矩阵的n");
		int a[][];
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		a = new int[n][n];
		System.out.println("请为数组输入数");
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				a[i][j] = sc.nextInt();
			}
		}
		int sum = 0, sum1 = 0, sum2 = 0;
		if (n % 2 == 0) {
			for (int i = 0; i < n; i++) {
				sum1 = sum1 + a[i][i];
			}
			for (int i = 0; i < n; i++) {
				sum2 = sum2 + a[i][n - i - 1];
				sum = sum1 + sum2;
			}
		} else {
			for (int i = 0; i < n; i++) {
				sum1 = sum1 + a[i][i];
			}
			for (int i = 0; i < n; i++) {
				sum2 = sum2 + a[i][n - i - 1];
				sum = sum1 + sum2 - a[n / 2][n / 2];
			}
		}
		System.out.println("对角线数的和的值是：" + sum);
	}
}

第六章

一，简答题

1，概述面向对象编程的特点，以及面向对象编程和面向过程有什么不同。

面向对象编程的特点：面向对象编程的特点为继承，封装，多态。

面向对象和面向过程有什么不同。继承是发生在类与类之间，是子类共享父类成员变量和方法的一种模式。

多态是指对象在运行期间和编译期间具有两种状态，多态的使用使代码具有了更多的灵活性和重用性。

封装：在Java中成员变量和方法就被封装在类里。

区别：

面向过程和面向对象最明显的区别是，面向对象是按照要求的功能来实现的，面向过程是按照解决这个问题的步骤来实现的。

面向对象按照程序中的功能进行划分；面向过程是按照问题的解决思路来划分的，是一步步来解决的。

面向过程更看重的是完成问题的过程，面向对象看中的是功能。

2，概述成员变量和局部变量有什么不同？

成员变量可以被public,protected,default,private,static,final修饰符修饰；局部变量可以被final修饰符修饰，但不能修饰为public,protected,default,private,static。

成员变量是在堆里创建的，局部变量是在栈里进行创建的。

成员变量是系统默认的，局部变量没有系统默认值，必须手动赋值。

3，什么是对象？基本数据类型和对象有什么不同？

Java中一切皆对象。

基本数据类型在栈中进行分配，对象类型是在堆中进行分配。

4，什么是类

用Class声明的语句块叫做类。类中包含了属性和方法。

二，编程题

使用Date类输出当前系统时间。

import java.util.Date;

public class Exercise02 {
	
	public void show(Date d) {
		System.out.println(d);
	}

	public static void main(String[] args) {
		Exercise02 e = new Exercise02();
		Date d = new Date();
		e.show(d);
	}
}

第七章控制逻辑

访问静态变量的方法

类名.静态成员变量名称

静态成员变量名称

一，简答题

1，什么是封装？封装有什么特点

在Java中封装就是在一个类里定义了一些成员变量和方法，通过限制其成员变量和方法的可见性，使得外界不能访问他们。

封装展现了接口，隐藏了细节。

2，简述finanl修饰符的使用，以及final修饰符的作用。

final修饰变量的基本含义就是该变量一旦被初始化后就不能再被修改。

final修饰的方法，继承不能重写。

3，什么叫静态方法和静态变量？它们同普通的成员方法和成员变量之间有什么不同之处

static修饰的方法和变量叫做静态方法和静态变量

4，什么是修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。

5，修饰符的作用

Java中修饰符的作用主要有两种，一种是用来控制访问权限的，另一种是用来控制其他方面的（比如值是否可改，访问的方式，是否可覆盖等等）

6什么是类的访问级别

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。

7，简单介绍类的访问级别有哪几种，及各自的作用

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

8，介绍什么是包，以及包的优缺点

Java中提供包将不同的类组织起来进行管理。类按照其功能分别存放在各个包里

二，编程题

1，使用静态变量计算内存中实例化的对象数目？

public class Exercise03 {

	static int count = 0;
	
	{
		count++;
	}
	
	public static int getCount() {
		return count;
	}
	
	
	public static void main(String[] args) {
		Exercise03 e1 = new Exercise03();
		Exercise03 e2 = new Exercise03();
		Exercise03 e3 = new Exercise03();
		Exercise03 e4 = new Exercise03();
		System.out.println(e4.getCount());
	}
}

第八章继承

Java中的反射机制

在Java中，反射机制起到放大镜的效果，可以通过类名，加载这个类，显示出这个类的方法等信息。

import java.lang.reflect.Method;

public class racing_cycle {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			//在运行期动态加载Java.util.Date下面的类
			Class c = Class.forName("java.util.Date");
			//把类中的各个方法写入到数组m里
			Method m[] = c.getDeclaredMethods();
			//通过循环取出
			for(int i=0;i<m.length;i++) {
				System.out.println(m[i].toString());
			}
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

一，简答题

1，简述重写，重载之间的关系

重写是基于继承的，是重写父类中的方法，从而在子类中出现一个和该方法相同名称的方法。重载的方法名称相同，但方法的参数列表不同，如参数个数和参数类型等，重载方法的返回值可以相同也可以不同。

2，简述四种访问修饰符的不同

public:表明被它修饰的成员变量为公共类型，这样这个成员变量在任何包里都能访问。包括子类也能访问。

private:表明被修饰的成员变量为私有类型，除了本类外任何类都不能访问到这个成员变量，具有很好的保护性。

default:不添加任何修饰的为default类型，同一包里的类和子类都能访问，不同包里的类或子类没有继承该成员变量，是访问不到的。

protected:不在同包里的成员变量就只能通过子类来访问。

3，介绍抽象类和抽象方法的概念，一个抽象类的所有方法是否都必须为抽象方法？

abstract修饰的类为抽象类，方法为抽象方法。抽象类中的方法必须为抽象方法。

4，类的继承主要优点有哪一些？

继承让代码重复使用，提高效率。

二，编程题

1，编写一个程序，创建一个汽车类Car,并为其定义两个属性：颜色和型号，同时为该类创建两个构造方法：

第一个为无形参的构造方法，其过程是将颜色和型号初始化为红色，轿车。

第二个需定义为两个形参，并将形参的值分别赋值给颜色和型号，为该类创建两个方法，分别用来显示颜色和型号。

public class Car {
	
	public String color;
	public String type;
	
	public Car() {
		this.color = "red";
		this.type = "car";
	}
	
	public Car(String color,String type) {
		this.color = color;
		this.type = type;

	}
	
	public static void main(String[] args) {
		Car c1 = new Car();
		Car c2 = new Car("green","bus");
		System.out.println(c1.color+" "+c1.type);
		System.out.println(c2.color+" "+c2.type);
	}
}

第九章接口

一，简单题

1，解释接口的概念，Java接口可以有多继承的形式吗？

接口就好比一个规定，用来描述所实现的类能够做什么。接口可以多继承。

2，接口的作用是什么？

接口是特殊的抽象类

3，接口和抽象方法有什么区别

接口里面的方法为抽象方法。

二，编程题

1，

2，创建一个接口，其中设置几个方法

//接口实现多态
public interface food {
	
	//得到食物的名称
	public void getname();
	
	//吃食物的方法
	public void eat();
}

4，写一个测试类实现2题中的接口，并实现其中的各个方法。

public class ora implements fruit {

	public void getname() {
		// TODO Auto-generated method stub
		System.out.println("吃的水果名称为橘子");
		
	}

	
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("此方法是吃橘子的方法");
	}
}

第十章构造器

1，什么是单子模式？如何使用单子模式？

所谓单子模式，就是某一个类在同一时刻之允许有一个对象，是Java模式工厂里的一种。单子模式就是把构造器修饰为private类型的。

2，简述构造器的运行机制。

加载要创建该对象的父类，以及成员变量和其他继承关系。

加载该类的静态块和静态成员变量，并对其进行初始化等操作。

静态块和静态成员变量加载完毕后创建对象并加载非静态成员变量，并对其进行初始化等操作

执行构造器里的方法体，完成后该的对象创建完毕。

父类的运行顺序和该类是一样的。

3，简单概述构造器的加载过程

先执行父类构造器再执行子类构造器。

4，构造方法和普通方法之间有什么区别？

构造器方法只有修饰符和方法名，没有返回类型。普通方法有返回类型。

5，自定义构造器需要注意哪些问题？

方法名与类名相同，public修饰，没有返回值。

第11章异常处理

1，如何定义和使用自定义异常？

创建自定义异常类需要继承Exception类。

class 类名 extends Exception

{

类体

}



public class MyException extends Exception {
	
	public MyException() {
		
	}
	
	public MyException(String s) {
		super(s);
	}

}

public class YiChang13 {

	public static void main(String[] args) {
		//创建一个自定义异常类
		MyException me = new MyException("自定义异常");
		//获取自定义异常信息
		System.out.println("自定义异常对象携带的错误信息为："+me.getMessage());
		System.out.println("自定义异常的字符串表示为："+me.toString());
	}
}

2.try...catch有哪些注意点？

try语句块中放可能出现异常的代码；catch语句块中需要给出一个异常的类型和该类型的引用，并在catch语句中放当出现该异常类型时需要执行的代码。

3.catch和try语句的作用是什么？

catch语句用来处理异常，try语句块里放可能出现异常的代码。

4，在什么情况下执行finally后面的代码块

finally语句中放的就是肯定会被执行的语句

5Java是如何处理异常的

在Java程序中，对异常的处理都是一样的，一般情况下是通过try-catch语句来进行异常处理。在该语句中还可以存在finally语句。

6，什么是异常？

程序中可能发生的错误。

7，说出Java中常见的几种异常。

Java中异常分为捕获异常和未捕获异常。

二，编程题

1，创建一个自定义异常，并使用该异常？

public class MyException extends Exception {
	
	public MyException() {
		
	}
	
	public MyException(String s) {
		super(s);
	}

}

public class YiChang13 {

	public static void main(String[] args) {
		//创建一个自定义异常类
		MyException me = new MyException("自定义异常");
		//获取自定义异常信息
		System.out.println("自定义异常对象携带的错误信息为："+me.getMessage());
		System.out.println("自定义异常的字符串表示为："+me.toString());
	}
}

第12章内部类

1，简述非静态内部类和静态内部类的异同。

静态内部类用static修饰。非静态内部类不用static修饰。

2，简述局部内部类和成员内部类的异同

作用范围不同

3，什么叫内部类

类里面的类叫做内部类

4，使用内部类的优点是什么？

Java中的内部类和接口加在一起，可以实现多继承。可以使某些编程更简洁。隐藏你不想让别人知道的操作。

第13章多线程

一，简答题

1，简述定义线程的两种方法，并说明它们异同。

定义线程一种是继承Thread。另一种是实现Runnable接口。

2，简述线程的声明周期

新建状态，准备状态，运行状态，等待/阻塞状态，死亡状态。

3，线程中有哪些调度方法？

sleep(),setPriority(),yield()，join()。

4，什么叫线程

多线程是Java中的并发机制，表示能够在同一实践内同时执行多个操作。让程序具有多个并发的执行线索。

5，有几种创建线程的方法？

有两种方法

6，sleep(）和yield()方法有什么区别？

当线程处于运行状态时，调用sleep睡眠方法将使线程从运行状态进入等待/阻塞状态，从而使程序停止运行，这是使正在运行的线程让出CPU的最简单方法之一。

yield让步方法是可以使当前正在运行的线程让出当前CPU，使线程回到准备状态，让其它线程有进入运行状态的机会，而将CPU让给哪一个线程是不确定的，由系统来进行选择。

二，编程题

1，编写一个多线程，定义两个不同优先级的线程，通过使用调度方法，使优先级较低的线程获得更多的运行机会。

package cn.thread;
 
/**
 * 线程的调度(优先级)
 * 
 * @author 林计钦
 * @version 1.0 2013-7-24 上午09:30:42
 */
public class ThreadPriority {
    
    public static void main(String[] args) {
           ThreadPriority thread=new ThreadPriority();
           Thread t1 = thread.new MyThread1(); 
           Thread t2 = new Thread(thread.new MyRunnable()); 
           t1.setPriority(10); 
           t2.setPriority(1); 
 
           t2.start(); 
           t1.start(); 
    }
    
    class MyThread1 extends Thread {
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("线程1第" + i + "次执行！");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    class MyRunnable implements Runnable {
        public void run() {
            for (int i = 0; i < 10; i++) {
                System.out.println("线程2第" + i + "次执行！");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

第18章 Java中输入/输出流

一，简答题

1，什么是流？Java中的流的分类是按照什么来分的？分为哪几类？

数据流是形象的概念，可以理解为是一种“数据的管道”。管道中流动的东西可以是基于字节的，也可以是基于字符的。Java中数据流分为两类，一种是字节流，另一种是字符流。

2，Java中如何使用流对文件进行操作？

进行文件操作的类包括File,FileInputStream,FileOutputStream,FileReader,FileWriter。

3,输入/输出流抽象基类？

字节流和字符流的抽象基类包括InputStream类、OutputStream类、Reader类和Writer类。

4，简述文件字节流和文件字符流的区别？

文件字节流主要传送二进制文件，如图片信息。

文件字符流主要传送文本文件。