· #Java测试题
1.jdk jre jvm三者之间的关系，以及jdk，jre包含的主要结构有哪些？
jdk>>jre>>jvm
JDK= JRE+Java的开发工具（javac.exe,java.exe javadoc.exe）
jrk=jam+java核心类库
2.为什么要配置path环境变量
在任何路径下都可以执行java开发工具
3.常见的几个命令行操作都有哪些？
cd
md
rd
del
cd …
cd/
4.创建如下类，使得运行结果如下
public class Test{
public static void main(String[] args){
System.out.println(“姓名：昭浅”+"\n");
System.out.println(“性别：男”);
System.out.println(“家庭住址：China”);
}
}
5.字符串练习
public class StringTest{
public static void main(String[] args){
//练习1 判断对错
//String str1=4; //false
String str2=3.5f+""; true
System.out.println(str2); //true
System.out.println(3+4+"hello!");//true 7hello
System.out.println("hello!"+3+4); //true hello34
System.out.println('a'+1+4);//true 102
System.out.println("hello"+'a'+1); //true helloa1
//练习2
char c ='a';// a=97 A=65
int num=10;
String str="hello";
System.out.println(c+num+str);//107hello
System.out.println(c+str+num);//ahello10
System.out.println(c+(num+str));//s10hello
System.out.println((c+num)+str);//107hello
System.out.println(str+num+c);//hello10a
//练习3
System.out.println("* *"); //* *
System.out.println('*'+'\t'+'*');//93
System.out.println('*'+"\t"+'*');//* *
System.out.println('*'+'\t'+"*");//51*
System.out.println('*'+('\t'+"*"));//* *
}
}
数据类型转换练习
public class ShortTest{
public static void main(String[] args){
short s=5;
s=s-2; //判断 ：no
byte b =3;
b=b+4; //判断 ： no
b=(byte)(b+4); //判断: yes
char c ='a';
int i=5;
float d=.341f; //定义一个0.341的float类型
double result=c+i+d; //判断：yes
byte h=5;
short z=3;
short t=h+z; //判断： no
}
}
标识符的命名规则有哪些？
答：驼峰命名法，不能用空格，不能使用但可以包含关键字和保留字，不能使用数字开头，区分大小写标识符的命名规范有哪些
答：包名：xxxyyyzzz
类名、接口名：XxxYyyZzz（大驼峰）
变量名、方法名：xxxYyyZzz（小驼峰）
常量名：XXX_YYY_ZZZ
3.Java变量按照数据类型怎么划分?并指出java的基本数字类型有哪8种？并指出各自占用的内存空间大小
答：（1）整形，浮点型、字符型、布尔型、引用数据类型：类、接口、数组 、String
（2）int、short、long、byte、float、double boolean(false true) char
4.说明基本数据类型变量之间自动类型提升的运算规则
答：byte、short、char→int→long→float→double
5 .说明基本数据类型变量之间的强制类型转换的使用规则和强制转换可能出现的问题
答：容量大→容量小
强制转换前要注意高精度向低精度转换时是否会丢失精度
运算符程序练习
- &和&&的异同
答：&与&&
相同点 ：一假则假，
不同点： &在左边遇到false时，右边 会继续运行
&&在左边遇到false时,右边不会执行，会直接结束
public class LogicTest2{
public static void main(String[] args){
boolean x= true;
boolean y =false;
short z= 40;
if((z++ == 40) && (y = true)){ //z=41 y=true 这个是赋值符号，不要被误导了
z++; //z=42
}
if((x = false) || (++z == 43)){ //z=43
z++; //z=44
}
System.out.println("z="+z); //z=44
}
}
结果为： z=44
3.定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现
public class LogicTest{
public static void main(String[] args){
int x=3,y=13,z=4;
int max=x>y? (x>z ? x : z) : (y>z ? y :z);
System.out.println("max="+max);
if(x>y){
if(x>z)
System.out.println("x最大");
else
System.out.println("z最大");
}
else {
if(y>z)
System.out.println("y最大");
else
System.out.println("z最大");
}
}
}
4.编写程序，声明2个double 型变量并赋值，判断第一个数大于10.0,且第二个数小于20.0 打印两数之和，否则，打印两数的乘积
double n=13.0;
double m=15.0;
if((n>10.0) && (m<20.0)) {
double num=n+m;
System.out.println("结果为："+num);
}
else {
double num=n*m;
System.out.println("结果为："+num);
}
5.交换两个变量值的代码的实现
int num1 = 10;
int num2 = 14;
int temp = 0;
temp=num1;
num1=num2;
num2=temp;
System.out.println("num1："+num1);
System.out.println("num2："+num2);
6.你能否写出最高效的 2 * 8 的实现方式
答： 2 << 3 或 8 << 1
if- else 结构测试题
1.月小鹏参加java考试，他和父亲达成承诺
如果：
成绩为100分时，奖励一台电脑
成绩为（80，90]时，奖励一部手机
成绩为[60, 80]时，奖励一台平板电脑
成绩为其他时，什么都没有
请从键盘输入月小鹏的期末成绩，并加以判断
import java.util.Scanner;
public class IfelseTest {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入月小鹏的成绩：");
int exam= scan.nextInt();
if(exam>=60) {
if(exam<=80) {
System.out.println("奖励一个平板电脑");
}
else if(exam>80 && exam<=99) {
System.out.println("奖励一台手机");
}
else if(exam == 100) {
System.out.println("奖励一台电脑");
}
}else System.out.println("不及格，一顿胖揍");
}
}
2.从键盘输入三个整数分别存入num1、num2、num3对他们进行排序（使用if-else） 并且从小到大输出
int num1 = scan.nextInt();
int num2 = scan.nextInt();
int num3 = scan.nextInt();
if(num1>num2) {
if(num1>num3) {
System.out.println("num1最大");
}
else System.out.println("num3最大");
}else if(num2>num3) {
System.out.println("num2最大");
}else System.out.println("num3最大");
3.我家的狗5岁了，5岁的狗相当于人类的多大呢，其实，狗的前两年相当于人类的10.5岁，之后每增加一年，就增加四岁，那么5岁的狗相当于人类的多少年龄呢，应该是：10.5+10.5+4+4+4=33岁。
编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄，如果用户输入的为负数，请显示一个提示信息
Scanner scan = new Scanner(System.in);
System.out.println("请输入狗的年龄");
int age = scan.nextInt();
if(age>=0) {
if(age<=2) {
double dogAge=age*10.5;
System.out.println("狗的真实年龄为："+dogAge);
}else {
double dogAge=2*10.5+(age-2)*4;
System.out.println("狗的真实年龄为："+dogAge);
}
}else System.out.println("请输入正确的年龄");
临时学习
如何获取随机数
public class RandomTest {
public static void main(String[] args) {
//如何获取一个随机数
//调用random方法获取随机数
//在Math类中有一个random方法，Math.random()
//此方法会在[0.0，1.0）中随机取值，返回值为double类型
//所以，在我们使用的过程中，如果想在一段范围内随机取值，需要我们自行去分配区间
double value = Math.random();//从[0.0,1.0)中随机取值
//如何在区间[10,100)中随机取值呢 --》10--99
int value1= (int)(Math.random()*90+10);//在10-99之间随机取值[10,100)
//强转返回int类型
// random方法返回值公式 ：
// [a,b] : (int)(Math.random()*(b-a+1)+a)
}
}
if-else和switch之间的问题
1.switch后面的表达式可以是哪些数据类型：
答 ：byte、short、char、int、枚举类型、String类型
2.使用swtich语句改写下列if语句
int a = 3;
int x = 100;
if(a==1)
x+=5;
else if(a==2)
x+=10;
else if(a==3)
x+=16;
else
x+=34;
//改写后：
int a = 3;
int x = 100;
switch(a){
case 1:
x+=5;
break;
case 2:
x+=10;
break;
case 3:
x+=16;
break;
default :
x+=34;
break;
}
3.谈谈对三元运算符，if-else ，switch-case结构使用场景的理解
答：在可以同时使用三种方式的同时，可以先优先使用三元和switch，因为三元和switch的执行效率稍微高一些，三元和switch都可以转化成if-else，反之则不成立
4.如何从控制台获取String和int型的变量并输出，使用代码实现？
import java.util.Scanner;//要先导入Scanner包，可以获取我们从控制台输入的变量
public class Test{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);//在main方法中，将Scanner实例化为对象scan
String a=scan.next(); //用String类型变量a接受字符串
//注意：Scanner没有获取char类型的方法
}
}
5.使用for循环遍历100以内的奇数，并计算所有的奇数的和并输出
public class Test{
public static void main(String[] args){
int sum = 0;
for(int i=0;i<=100;i++){
if(i%2==1){
sum+=i;
System.out.println(i+"是奇数");
}
}
System.out.println("100以内奇数的和为："+sum);
}
}
6.break关键字的使用
输入两个正整数m和n,求其最大公约数和最小公倍数
比如12和20的最大公约数是4，最小公倍数是60
import java.util.Scanner;
public class BreakTest{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
System.out.println("请输入第一个数：");
int m=scan.nextInt();
System.out.println("请输入第二个数：");
int n=scan.nextInt();
for(int i=1;i<=99999;i++){
if(i%m==0 && i%n==0){
System.out.println(m+"和"+n+"的最小公倍数为"+i);
break;
}
}
for(int i=99999;i>=1;i--){
if(m%i==0 && n%i==0){
System.out.println(m+"和"+n+"的最大公约数为"+i);
break;
}
}
}
}
7.如图输出一下以下菱形图形
for(int i=1;i<=5;i++) {
for(int j=5;j>=i;j--) {
System.out.print(" ");
}
for(int m=1;m<=i;m++) {
System.out.print("* ");
}
System.out.println();
}
for(int i=1;i<=5;i++) {
for(int j=1;j<=i;j++) {
System.out.print(" ");
}
for(int m=5;m>=i;m--) {
System.out.print("* ");
}
System.out.println();
}
项目一
做一个程序， 存款余额程序，计入自己的存款，支出，余额，退出程序
package Question;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
String[][] notes=new String[10][4];
notes[0][0]="收支";
notes[0][1]="账户金额";
notes[0][2]="收支金额";
notes[0][3]="说 明";
int all=0;
boolean isFlag=true;
while(isFlag) {
System.out.println("__________"+"家庭收支记账软件"+"__________");
System.out.println();
System.out.print(" ");
System.out.println("1 收支明细");
System.out.print(" ");
System.out.println("2 登记收入");
System.out.print(" ");
System.out.println("3 登记支出");
System.out.print(" ");
System.out.println("4 退 出");
System.out.println("请选择（1-4）：");
int select=scan.nextInt();
switch(select){
case 1:
System.out.println("__________"+"当前收支计入明细"+"__________");
for(int i=0;i<5;i++) {
for(int j=0;j<=3;j++) {
if(notes[i][j]==null) {
break;
}else{
System.out.print(notes[i][j]+"\t");
}
}
System.out.println();
}
System.out.println("--------------------------------------------");
break;
case 2:
System.out.println("2 登记收入");
System.out.print("本次收入金额：");
int income=scan.nextInt();
System.out.print("本次收入说明：");
String inexplain=scan.next();
for(int i=0;i<5;i++) {
if(notes[i][0]==null) {
notes[i][0]="收入";
all=all+income;
notes[i][1]=String.valueOf(all);
notes[i][2]=String.valueOf(income);
notes[i][3]=inexplain;
break;
}
}
System.out.println("__________"+"登记完成"+"__________");
break;
case 3:
System.out.println("3 登记支出");
System.out.print("本次支出金额：");
int pay=scan.nextInt();
System.out.print("本次支出说明：");
String outexplain=scan.next();
for(int i=0;i<5;i++) {
if(notes[i][0]==null) {
notes[i][0]="支出";
if(all>=pay){
all=all-pay;
notes[i][1]=String.valueOf(all);
notes[i][2]=String.valueOf(pay);
notes[i][3]=outexplain;
System.out.println("__________"+"登记完成"+"__________");
break;
}
if(all<pay){
System.out.println("__________"+"登记失败,支付金额大于存款"+"__________");
break;
}
}
}
break;
case 4:
System.out.println("4 退 出");
System.out.println("是否要退出(Y or N)?：");
String exit=scan.next();
for(;;) {
if(exit.equals("y") || exit.equals("Y")) {
isFlag=false;
break;
}else if(exit.equals("n") || exit.equals("N")) {
break;
}else {
System.out.println("请重新输入!!");
exit=scan.next();
}
}
default:
System.out.println("请重新输入");
}
}
}
}
循环结构问题
1.循环结构是如何最后退出循环的，有哪些不同的情况说明？
答：①循环结构中，当循环条件不满足或循环体执行结束后退出循环，
②也可以添加break指令结束循环（continue：结束当次循环 return：结束方法的指令）
2.标签指令练习
laber: for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++ ){
if(j%4==0) {
continue laber;
}
System.out.print(j);
}
System.out.println();
}
3.求1000以内的所有完数，（一个数如果恰好等于他的出去本身的因子之和，这个数就称为完数）
package Question;
//求1000以内的所有完数，（一个数如果恰好等于他的出去本身的因子之和，这个数就称为完数）
public class Test2 {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=1000;i++) {
for(int j=1;j<i;j++) {
if(i%j==0) {
sum+=j;
//System.out.print(j+"\t");
//System.out.print(sum+"\t");
}
if(j==i-1 && sum==i) {
System.out.println(i+"为完数");
}
}
sum=0;//重置sum
}
}
}
4.说明break和continue使用上的相同点和不同点
答：相同点：在循环结构中使用，都有跳转的功能
不同点：break ：跳出当前循环
continue：跳出本次循环
5.从控制台输出如下结构
public class ForTest {
public static void main(String[] args) {
for(int i=6;i>=1;i--) {
for(int j=1;j<=i;j++) {
System.out.print("*");
}
System.out.println();
}
}
}
数组类型问题
一维数组习题
1.读出代码中该人的电话号码
int[] arr=new int[] {8,2,1,0,3};
int[] index = new int[] {2,0,3,2,4,0,1,3,2,3,3};
String tel="";
for(int i=0;i<index.length;i++) {
tel+=arr[index[i]];
}
System.out.println("联系方式："+tel);
System.out.println("18013820100");//输出电话号码
2
Scanner scan = new Scanner(System.in);
System.out.print("请输入学生人数");
int num=scan.nextInt();
System.out.println("请输入"+num+"个人的成绩");
int[] score = new int[num];
for(int i=0;i<score.length;i++) {
score[i]=scan.nextInt();
}
int max=0;
for(int i=0;i<score.length;i++) {
if(score[i]>max) {
max=score[i];
}
}
System.out.println("最高分是"+max);
for(int i=0;i<score.length;i++){
if(score[i]>=max-10) {
System.out.println("student "+i+" score is "+score[i]+" grade is A");
}else if(score[i]>=max-20 && score[i]<=max-10) {
System.out.println("student "+i+" score is "+score[i]+" grade is B");
}else if(score[i]>=max-30 && score[i]<=max-20) {
System.out.println("student "+i+" score is "+score[i]+" grade is C");
}else System.out.println("student "+i+" score is "+score[i]+" grade is D");
}
1.写出一维数组初始化的两种方式
一：
int[] arr = new int[]{1,2,3};
二：
int[] arr = new int[3];
arr[]={1,2,3};
2.写出二维数组初始化的两种方式
一：
int[][] arr =new int[][]{{1,2},{3,4},{5,6}};
二：
int[][] arr =new int[3][4];
三：
int[][] arr = new int[3][];
arr[0]=new int[4];
arr[1]=new int[4];
arr[2]=new int[4];
3.如何遍历如下的二维数组
int[][] arr = new int[][]{{1,2,3},{4,5},{6,7,8}};
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.println(arr[i][j]);
}
}
4、不同类型的一维数组元素的默认初始化值是多少`
int类型：0
浮点类型：0.0
char类型：0或'/u0000'
boolean类型：false
引用数据类型：null
5、一维数组的内存解析
String[] strs = news String[5];//定义长度为5的引用数据类型数组
strs[2] = "Tom"; //为数组中的第二位赋值为 Tom
strs = new String[3]; //重定义数组长度为3 数组地址指向新地址，旧长度数组没有利用被回收
多维数组的练习
1、
int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}};
int sum=0;
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr[i].length;j++) {
sum+=arr[i][j];
}
}
System.out.println(sum);
System.out.println(3+5+8+12+9+7+6+4);
2、
答案 ： B、E
数组类型的常见算法
1、杨辉三角练习
public class ArrayTest2 {
public static void main(String[] args) {
int[][] arr= new int[10][];//定义一个外层数组为10
for(int i=0;i<arr.length;i++) {
arr[i]=new int[i+1];
for(int k=1;k<=arr.length-i-1;k++) {
System.out.print(" ");
}
for(int j=0;j<=i;j++){
if(j==0 || j==i) {
arr[i][j]=1;
}
else {
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
2.面试练习题，一维数组
创建一个长度为6的int型数组，要求数组元素的值都在1-30之间，且是随机赋值，同时，要求元素的值各不相同
import java.util.Random;
public class ArrayTest {
public static void main(String[] args) {
Random random = new Random();
int[] arr=new int[6];
for(int i=0;i<arr.length;i++) {
arr[i]=random.nextInt(30)+1;
for(int j=0;j<i;j++) {
if(arr[i]==arr[j]) {
i--;
break;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
3、回型数
package Question;
import java.util.Scanner;
public class Array1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num=scan.nextInt();
int[][] arr = new int[num][num];
int i=0,j=0,sum=1;
int min=0,max=num-1;
while(i<arr.length && j<arr[i].length) {
if(i==0 && j==0) {
arr[i][j]=sum;
if(num==1) {
arr[i][j]=sum;
break;
}
}
sum++;
if(j==max) {
if(i!=max) {
i++;
}
}else {
if(i==min) {
j++;
}
}
if(i==max) {
arr[i][j]=sum;
if(j==min) {
i--;
}
if(j>min)
j--;
}else {
arr[i][j]=sum;
if(j==min && i>min) {
i--;
}
}
if(i==min+1 && j==min) {
sum++;
arr[i][j]=sum;
min++;
max--;
}
if(sum==num*num) {
break;
}
}
for(int m=0;m<arr.length;m++) {
for(int n=0;n<arr[m].length;n++) {
System.out.print(arr[m][n]+"\t");
}
System.out.println();
}
}
}
4、定义一个长度为10的一维数组，定义一些随机数存入数组中 ，求所有元素的最大值，最小值，总和。平均值，（要求：所有随机数都为二位数）
import java.util.Random;
public class ArrayTest3 {
public static void main(String[] args) {
Random random = new Random();
int[] arr = new int[10];
for(int i=0;i<arr.length;i++) {
arr[i]=random.nextInt(90)+10;
System.out.print(arr[i]+" ");
}
System.out.println();
int max=0,min=100,sum=0;
for(int i=0;i<arr.length;i++) {
if(max<arr[i]) {
max=arr[i];
}
if(min>arr[i]) {
min=arr[i];
}
sum+=arr[i];
}
System.out.println("最大值："+max);
System.out.println("最小值："+min);
System.out.println("平均值："+sum/arr.length);
System.out.println("总和："+sum);
}
}
数组的复制、反转、查找（现行查找。二分法查找）
练习：使用简单数组 数组复制
①创建一个名为ArrayTest的类，在main（）方法中声明array1和array2两个变量，他们是int[]类型的数据
②使用大括号｛｝把array1初始化为8个素数：2,3,5,7,11,13,17,19
③显示array1的内容
④赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值，如（array[0]=0,array[2]=2）打印出array1
思考： array1和array2是什么关系？
答：array1和array2地址值相同，都指向堆空间的唯一的一个数组实体
拓展：怎么实现array2对array1的复制
array2=new int[array1.length];
for(int i=0;i<array2.length;i++){
array2[i]=array1[i];
}
int[] array1,array2;//①
array1=new int[] {2,3,5,7,13,17,19};//②
for(int i=0;i<array1.length;i++) {//③
System.out.print(array1[i]+" ");
}
System.out.println();
array2=array1;//④ 此时赋值是将array1的地址赋值为array2，并没有将array1的值复制。所以操作array2也会改变array1,不能叫做数组的复制
for(int i=0;i<array2.length;i++) {
if(i%2==0) {
array2[i]=i;
}
System.out.print(array2[i]+" ");
}
System.out.println();
for(int i=0;i<array1.length;i++) {//③
System.out.print(array1[i]+" ");
}
System.out.println();
数组的反转
//数组的练习
//数组的反转练习
public class Array2 {
public static void main(String[] args) {
//数组的反转
String[] arr=new String[] {"a","b","c","d","e","f"};
String temp="";
int length=arr.length-1;
for(int i=0;i<arr.length;i++) {
temp=arr[i];
arr[i]=arr[length];
arr[length]=temp;
length--;
if(i==length || i>length) {
break;
}
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
//优化
for(int i=0;i<arr.length/2;i++) {
String temp1=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp1;
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
数组的查找
遍历查找
String[] arr=new String[]{"a","b","c","d","e"};
String find="c";
boolean isFlag=false;
for(int i=0;i<arr.length;i++){
if(find.equals(arr[i])){
System.out.println("找到了，位置在"+i);
isFlag=true
}
}
if(isFlag){
System.out.println("没有找到");
}
二分法查找：（注意二分法查找，所查找的数组必须是有序）
int[] arr1=new int[] {1,2,3,4,5,6,7};
int find1=2;
int head=0;
int end=arr1.length-1;
int middle=0;
boolean Flag=true;
while(head<=end) {
middle=(head+end)/2;
if(find1==arr1[middle]) {
System.out.println("找到了，位置在"+middle);
Flag=false;
break;
}else if(find1>arr1[middle]) {
head=middle+1;
}else {
end=middle-1;
}
}
if(Flag) {
System.out.println("没有找到");
}
eclipse快捷键
数组的常用算法题
1、冒泡排序算法题：
import java.util.Arrays;
public class BubbleTest {
public static void main(String[] args) {
int[] arr = new int[] {10,30,20,40,70,60,50,80};
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr.length-i-1;j++) {
if(arr[j]>arr[j+1]) {
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
2、如何反转上面的数组，请实现
int length=arr.length-1;
for(int i=0;i<arr.length;i++) {
int temp=arr[i];
arr[i]=arr[length];
arr[length]=temp;
length--;
if(length<i)
break;
}
System.out.println(Arrays.toString(arr));
3、复制上述数组
//复制数组
int[] arr2=new int[arr.length];
for(int i=0;i<arr.length;i++) {
arr2[i]=arr[i];
}
System.out.println(Arrays.toString(arr2));
//线性查找（遍历查找）找出22是否存在与数组中，返回提示信息
for(int i=0;i<arr2.length;i++) {
if(arr2[i]==22) {
System.out.println("22存在于数组中的"+i+"号");
}else if(i==arr.length-1 && arr2[i]!=22) {
System.out.println("22不存在于数组中");
}
}
4、线性查找，查询22是否存在于数组中
//线性查找（遍历查找）找出22是否存在与数组中，返回提示信息
for(int i=0;i<arr2.length;i++) {
if(arr2[i]==22) {
System.out.println("22存在于数组中的"+i+"号");
}else if(i==arr.length-1 && arr2[i]!=22) {
System.out.println("22不存在于数组中");
}
}
5、数组中常见的异常：
//数组中常见的异常有：角标越界异常、空指针异常（指定的数组地址为空或元素为null时发生空指针异常）
面向对象测试题
1.创建Person类，设置属性及方法并调用，掌握类方法及属性的使用
package Notes;
//创建Person类，设置属性及方法并调用，掌握类方法及属性的使用
public class PersonTest {
public static void main(String[] args) {
Person p1=new Person();
p1.study();
p1.showAge();
p1.age=p1.addAge(2);
System.out.println("年龄："+p1.age);
}
}
class Person{
String name="Tom";
int age=18;
boolean isMale=true;//是否为男性
public void study() {
System.out.println("studying");
}
public void showAge() {
System.out.println("年龄："+age);
}
public int addAge(int i) {
age+=i;
return age;
}
}
2.利用面向对象的变成方法，设计类Circle计算圆的面积
package Question;
//利用面向对象的变成方法，设计类Circle计算圆的面积
import java.util.Scanner;
//测试类
public class CircleTest {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
Circle area=new Circle();
System.out.println("请输入边长:");
double radius=scan.nextDouble();//输入边长
System.out.println("圆的面积为："+area.circleArea(radius));
}
}
//圆
class Circle{
double pi=3.14;
public double circleArea(double radius) {
double area=pi*radius*radius;
return area;
}
}
3.编写程序，声明一个method方法，在方法中打印一个108的型矩阵，在main方法中调用该方法
package Object;
//编写程序，声明一个method方法，在方法中打印一个10*8的*型矩阵，在main方法中调用该方法
public class Object {
public static void main(String[] args) {
Object test = new Object();
test.square();
System.out.println("矩形面积："+test.Area());
}
public void square() {//方形矩阵方法
for(int i=1;i<=8;i++) {
for(int j=1;j<=10;j++) {
System.out.print("*");
}
System.out.println();
}
}
public int Area() {
return 10*8;
}
}
4.定义类Student，包含三个属性，学号number(int),年级state(int),成绩score(int)
创建20个学生对象，学号为1到20，年级和成绩都由随机数确定
问题1打印出三年级的学生信息
问题2 使用冒泡排序按学生成绩排序，并遍历所有学生信息
package Object;
//定义类Student，包含三个属性，学号number(int),年级state(int),成绩score(int)
//创建20个学生对象，学号为1到20，年级和成绩都由随机数确定
//问题1打印出三年级的学生信息
//问题2 使用冒泡排序按学生成绩排序，并遍历所有学生信息
public class StudentTest {
public static void main(String[] args) {
Student[] stu= new Student[20];//创建引用类型数组
for(int i=0;i<stu.length;i++) {
stu[i]= new Student();//为数组元素创建对象,调用类中的属性
stu[i].number=i+1;
stu[i].state=(int)(Math.random()*3+1);
stu[i].score=(int)(Math.random()*101);
}
// for(int i=0;i<stu.length;i++) {//遍历数组输出属性
// System.out.println("学号："+stu[i].number+" "+"年级："+stu[i].state+" "+"分数:"+stu[i].score);
// }
//问题一，打印出3年级的学生信息
for(int i=0;i<stu.length;i++) {//遍历数组属性
if(stu[i].state==3) {//判断当年级为3时输出
System.out.println("学号："+stu[i].number+" "+"年级："+stu[i].state+" "+"分数:"+stu[i].score);
}
}
System.out.println("**************************");
//问题二 冒泡排序给学生成绩排序 遍历学生信息
for(int i=0;i<stu.length-1;i++) {
for(int j=0;j<stu.length-1-i;j++) {
if(stu[j].score>stu[j+1].score) {
Student temp = new Student();
temp=stu[j+1];
stu[j+1]=stu[j];
stu[j]=temp;
}
}
}
for(int i=0;i<stu.length;i++) {//遍历数组输出属性
System.out.println("学号："+stu[i].number+" "+"年级："+stu[i].state+" "+"分数:"+stu[i].score);
}
}
}
class Student{
int number;//学号
int state;//年级
int score;//得分
}
5.//声明一个日期类型Mydate：有属性：年year,月month，日day
//创建两个日期对象，分别赋值为：你的生日，你对象的生日，并显示信息
package Object;
//声明一个日期类型Mydate：有属性：年year,月month，日day
//创建两个日期对象，分别赋值为：你的生日，你对象的生日，并显示信息
public class Birthday {
public static void main(String[] args) {
Mydate myDate1= new Mydate();
Mydate myDate2= new Mydate();
myDate1.year=2001;
myDate1.month=9;
myDate1.day=18;
myDate2.year=2011;
myDate2.month=9;
myDate2.day=18;
myDate1.info();
myDate2.info();
}
}
class Mydate{
int year;//年
int month;//月
int day;//日
//显示信息的方法
public void info() {
System.out.println("生日："+year+"年"+month+"月"+day+"日");
}
}
面向对象复习题：
1.面向对象思想编程内容的三条主线是什么？
答：java类及类的成员（属性、方法、构造器、代码块、内部类）、面向对象三大特征（封装、继承、多态）、其他关键字（this、super、interface、static、final、package、import）
2.谈谈对面对对象中类和对象的理解，指出二者的关系
答：类：抽象的，概念上的内容，对一类事物的描述
对象：实实在在存在的一个个体
对象是由类派生出来的
3.面向对象思想的体现一：类和对象的创建和执行有哪三步？
答：创建类、类的实例化、调用对象的结构（“对象,属性”,“对象,方法”）
4.类的方法内是否可以定义变量？是否可以调用属性？是否可以定义方法？是否可以调用方法？
答：可以、可以、不可以、可以
4。怎么理解“万事万物皆对象”？
答：1、在java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
2、涉及到java语言与前端html、后端的数据库交互式，前后端的结构在Java层面交互时，都体现为类、对象
对象、方法、值传递的应用
1.定义一个类PassObject，在类中定义一个方法printAreas(),
该方法的定义如下：public void printAreas(Circle c,int time)
在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积
例如time为5,则输出半径1，2，3，4，5以及对应的圆面积
package Object;
public class AreaPrint {
public static void main(String[] args) {
Circle1 c=new Circle1();
PassObject pass = new PassObject();
System.out.println("Raduis"+"\t"+"Area");
pass.printArea(c,5);
System.out.println("Now the radius is "+c.radius);
}
}
class Circle1{
double radius;
public double findArea(double radius) {
return Math.PI*radius*radius;
}
}
class PassObject{
public void printArea(Circle1 c,int time) {
for(int i=1;i<=time;i++) {
c.radius=i;
System.out.println(c.radius+"\t"+c.findArea(c.radius));
//System.out.println(c.radius);
}
c.radius=time+1;
}
}
执行结果为：
章节练习题
1.什么是方法的重载？
答：同一类中的同命方法，参数列表，参数个数，参数类型不同的方法为重载方法
“两同一不同”
如何调用确定的方法：方法名->参数列表
2.说明Java方法中的参数传递机制的具体体现？
答：基本数据类型 ：数据值
引用数据类型：地址值（含变量的数据类型）
构造器练习题
package Question;
//构造器测试题
//1.在定义的类中添加构造器，利用构造器设置所有人的age属性初始化为18
//2.修改上题的类和构造器，增加name属性，使得每次创建对象时同时初始化
//对象的age属性值和name属性值
public class ConstructTest {
public static void main(String[] args) {
Construct test =new Construct();
System.out.println(test.getAge());
test.showInfo();
Construct test2= new Construct("tom",21);
test2.showInfo();
}
}
class Construct{
//属性
private String name;
private int age;
//构造器
public Construct() {
age=18;
name="mike";
}
public Construct(String n,int a) {//创建新构造器，创建对象时同时初始化name和age
name=n;
age=a;
}
//方法
public void setAge(int a) {
}
public int getAge() {
return age;
}
public void showInfo() {
System.out.println("name: "+name+" age:"+age);
}
}
面向对象三大特征习题
1.构造器的作用是什么，注意点？
答：①创建对象，②初始化对象结构
注意：构造器可重载，不写的话系统会自动建立无参构造器等
2.关于类的属性的赋值，有几种赋值方式，谈谈先后顺序
答：
①默认初始化赋值
②显式初始化赋值
③构造器赋值
④"对象.属性"或"对象.方法"方式赋值
顺序：1-2-3-4
3.this关键字可以用来调用那些结构，
答：this.属性、方法、构造器
this：理解为当前对象，当前正在创建的对象
4.java目前学习涉及的四种权限修饰符都有什么，说明各自的权限范围
答：public-protected-缺省（default）-private
public：在任何结构中都可调用
protect：只可在不同包中调用
缺省：只可在同一包中调用
private：只可在本类中使用
方法重写的练习题：
1.如果现在父类的一个方法定义成private访问权限，再子类中将此方法声明为default访问权限，那么这样还叫重写吗？
答：不叫重写，父类中的方法权限为private，方法可见性太低，子类中看不到父类的private方法，所以子类的定义的default方法只是重新定义一个方法
多态性练习题
1.什么是多态性，什么是虚拟方法调用
答：对象的多态性：父类的引用指向子类的对象
Person p = new Man();
p.eat();
调用方法时，编译时看左边，运行是看右边
2.一个类可以有多少个直接父类（只有一个） ，一个父类可以有多少个子类（多个） ，子类能获取直接父类中的结构吗（可以） 子类能否获取父类中private权限的属性或方法(不能)
3.方法重写的具体规则有哪些
答：方法名和形参列表相同
子类方法权限修饰符不小于父类
返回值类型
抛出异常
4.super调用构造器，有哪些注意点
this(形参列表)：本类重载的其他的构造器
super(形参列表) ：调用父类的指定构造器
①.super（）必须在首行，
②.和this(形参列表)必须二选一
③.如果都没写，默认写super()空参
④.子类中有n个构造器,最多n-1个使用this(形参列表)，一个使用super(形参列表)
1.如何向下转型，需要注意什么，如何解决问题
答：
使用强转符：()
Person p = new Student()//向上转型
Person p1 = new Person()
Student stu = (Student)p1//向下转型
可能ClassCastExxception异常
使用instanceof在进行向下转型前判断
if( p1 instanceof Student)
Student stu = (Student)p1
2.单元测试方法：
答：注意：
提供公共类与无参构造器
3.为什么要有包装类
答：为了使基本数据类型的变量有类的特征，引入包装类
4.基本数据类型<===>包装类：自动装箱。自动拆箱
基本数据类型、包装类===>String:调用String重载的valueOf()
String===>基本数据类型、包装类:调用包装类重载的parseXxx()
//注意：转换时可能会遇到NumberForamtException
1.static修饰的属性：相较于实例变量，有哪些特别之处
答：随着累的加载而加载，早于对象的创建，只要权限允许，可以通过"对象.static属性" 进行调用，
static修饰的属性存在于方法区的静态域当中
2.final可以修饰那些结构，，分别表示什么意思
答：属性，方法，内部类，局部变量。形参
3.单例模式
public A{
//饿汉式
private int i;
private A(){
}
private static A a = new A();
public static A getA(){
return a;
}
public B{
//懒汉式
private int i=1;
private B(){
}
private static B b=null;
public static B getB(){
if(b==null){
b=new B();
}
return b;
}
}
接口的测试
1.
package InterfaceTest;
/*
* 当一个类是一个子类，并实现了接口时，接口与父类同时定义了
* 相同的属性，则当该类调用用此属性时，调用的是哪个属性
*/
public class InterfaceTest2 {
public static void main(String[] args) {
new C().pC();
}
}
interface A{
int x=0;
}
class B{
int x=1;
}
class C extends B implements A{
public void pC() {
// System.out.println(x);//当类为子类并且实现接口时，想要调用父类或接口中同名的属性，必须指定调用
System.out.println(super.x);//调用父类中的x
System.out.println(A.x);//调用接口中的x 接口中的变量为 全局变量
}
}
package InterfaceTest;
/*
* 当接口继承了其他接口时，实现类 所实现的抽象方法会当做同时实现两个接口中的方法
*/
public class InterfaceTest3 {
}
interface AAA{
void play();
}
interface BBB{
void play();//接口中定义的属性 可省略了public abstract
}
interface CCC extends AAA,BBB{
Ball ball = new Ball();//接口中定义的属性 可省略了public static final
}
class Ball implements CCC{
public void play() {
// ball = new Ball();//ball为常量，不可改变
}
}