Java期末复习题库（刷题）

本学期讲java课，进程截止到IO流线程那部分
有题库当然用题库了
顺手自己写一下代码复习一下

关于内存那些事

Java 内存结构

一个知识点：java.lang包下的类都可以直接用不用导入（import）包

判断题

判断题凡是 x（√）或者√（x）这种，建议按第一个写，对应有解释

1.构造方法定义返回值类型时，必须用void修饰 
答案：x
解析：构造方法不用写返回值类型,不同于别的方法 
public class-name(){//这就是一个构造方法
}

2.abstract关键字不能用来修饰成员信息
答案：√
解析：abstract只能修饰方法（抽象方法）或者类（抽象类）

3.同一个类中，不能有名称相同的方法
答案：x
解析：方法的重载

4.类的静态成员的生命周期要长与（于）类的对象
答案：√
解析：掌握对象的概念，静态成员属于类，而对象是通过类实例化出来的，所以肯定先由类，类夹杂这静态成员一起加载，最后实例化的时候，对象连同那些非静态变量，非静态方法才会加载。so 肯定静态成员的声明周期要长

5.Java接口的方法一定是抽象方法
答案：x
解析：老师说修改了题目，到时看jdk版本根据与下面结论的判断
注意：在jdk7.0前接口里所有的方法都没有方法体
jdk8.0以后接口里可以有静态方法，默认方法，也就是说接口中可以有方法的实现

6.Null是空常量，可以调用String类中的isEmpty()方法
答案：×
解析：无稽之谈，你不是string对象怎么调用人家方法

7.StringBuilder类是线程安全的
答案：x
解析：StringBuffer线程安全，效率低，StringBuilder,线程不安全，效率高

8.子类对象在实例化时，一定会调用并执行父类的构造方法
答案：√
解析：子类构造器的第一行必是父类的构造器（默认可以不写）

9.String类中的equals()方法比较是对象的内容，而非对象的地址值
答案：√
解析：String底层进行了equals()方法的重写

10.Java多态中静态成员方法访问的特点是：编译看父类，运行看子类
答案：×
解析：？静态有个锤子的多态

11.Java的Object类没有父类
答案：√
解析：Java的顶级父类就是Object

12.Java的虚拟机JVM会对局部变量赋默认初值
答案：×
解析：不会。只会给堆内的赋默认值，局部变量属于栈内变量

13.Java的抽象类中没有构造方法
答案：x
解析：有的，毕竟抽象类中有一些自己的方法（非抽象（abstract）方法）和变量，子类继承用抽象类的变量
你怎么着也得赋值（这就是构造方法干的活），不像接口中的变量（或者说常量）都是final的
需要你定义的时候就赋好值，就不用构造方法了

14.Java中，私有类的构造方法没有意义，因为不能实例化对象
答案：x
解析：不不不，你可以在本类通过这个实例化一个对象，然后通过一个public的方法获取对应对象
枚举的原理就是私有化构造器

15.Java中，类的构造方法必须定义为public，否则无法实例化对象
答案：x
解析：同14题

16.Java中，局部变量放在类中，方法外。
答案：x
解析：类中，方法中

17.Java中，局部变量在试用之前必须赋值，否则报错。
答案：√
解析：同12

18.Java中，成员变量在使用之前必须赋值，否则报错
答案：x
解析：同12（成员变量在堆中）

19.Java中，方法中的形式参数是局部变量。
答案：√
解析：！！！别理解错了，方法里面的都是局部变量，就算你实参传的是成员变量，人家问的是形参！

20.在Java中：long类型占8个Byte，float类型占4个Byte，所以long类型表示的范围大于float类型。
答案：x
解析：表述方式不一样，建议学一下计算机组成原理.

21.凡是能用条件运算符实现的语句，都可以用if语句实现。
答案：√
解析：找不出反例，其实就是不会，比较if是条件判断的底层

22.for循环的循环体可以一次都不执行
答案：√
解析：条件不符就不执行呗

23.Java中，do-while，for和while三种循环可以任意嵌套
答案：√
解析：感觉用不着解析，有终止条件就行啊

24..Java的方法一定要有return语句，否则编译报错。
答案：x
解析：构造方法和void返回类型的方法就不用写return语句，也不报错
注意：构造方法和void底层都是有一个return;的，你可以不写但是它实打实是有的

25.Java中方法必须有返回值类型，如果没有返回值类型必须用void修饰。
答案：x
解析：构造方法

26.Java中，用void修饰的没有返回值的方法，方法体中不能有return语句。
答案：x
解析：可以有啊，同24，可以自己写一个return;

27.Java中，数组只可以存储基本类型的数据，不可以存储引用类型数据
答案:x
解析:我直接 new String[2];

28.Java中，int[]arr=new int[5];语句是数组动态初始化。
答案：√
解析：没赋值就是动态初始化，赋值那种是静态

29.Java中，语句int[]arr=new int[]{1,2,3}；是数组静态初始化。
答案：√
解析:同28

30.Java中，int[]arr=new int[5]{1,2,3,4,5};语句定义数组正确。
答案：x
解析：动静态结合没有这种写法，要么去5。要么去{}里面的句子

31.Java定义二维数组时，第二维元素个数可以不相等
答案：√
解析：没看懂，看了下文章，应该是对的，可以自己搜一下

32.Java中，匿名内部类不能向下转型。
答案：√
解析：只能用一次的匿名内部类，怎么转？

33.Java中，integer类自动装箱拆箱的范围在-128~127之间。
答案：√
解析：牛，这个都考,想看的话可以看一下我的-Java之包装类 里面最后一点有说到，还有源码

34.Java中，类的构造方法中，不可同时有super和this两种方法。
答案:√
解析：第一行要么是super要么是this，你不能同时都存在，要不然矛盾了

35.Java中，方法的形式参数是局部变量。
答案：√
解析：同19

36.Java中，类的构造代码块优先于其构造方法执行，且可以执行多次。
答案：√
解析：代码块确实先于构造方法执行，建造一次对象代码块执行一次
（静态代码块只有在类第一次加载的时候执行一次）

37.Java中，成员变量在使用前必须赋值，否则报错。
答案：x
解析：同上某一个题，堆中有默认值
！！！！！注意题目中的成员和局部

38.Java中，局部变量在使用之前必须赋值，否则报错。
答案：√
解析：同上某一个题，栈中没有

39.Java接口的子类不能是抽象类。
答案：x
解析：为什么不能，是类就能继承

40.Java接口中的变量都是常量。
答案：√
解析：接口中变量默认都是final修饰的

41.Java中，方法中的形式参数是局部变量。
答案：√
解析：同上面某个题

42.Java中, 使用protected关键字修饰的、 包下的无关类之间可以直接互相访问。
答案：x
解析：默认的可以，protected修饰的只有父子类和同类可以访问

填空题

总结一个小规律
正数溢出从最大的负数向0靠
负数溢出从最大的正数向0靠
数字溢出总是从相反数的最大值开始向0靠

1.Java语句byte b=(byte)(127+1);执行后b=()
答案：-128
解析：127原码和补码相同为01111111，用补码进行加减运算
0111111+1=10000000
当然这个10000000为补码，（这个10000000是原码的话就是-0）
这种情况用那个取反+1求出来是不匹配的！！！，因为原码只有-127-127
而补码-128-127（补码10000000无法用原码表示）
官方的话是根据补码和真值之间的公式来算真值
[x]补=2^n+1+x
x=[x]补-2^n+1=-10000000(-2^7)=-128
我一般都记这种补码1000..的都是=-（正数最大值+1）
这个范围就是-128-127 so，这个是-128

2.Java语句byte b=(byte)129;执行后b=()
答案：-127
解析：129=127+2 
01111111+00000010=10000001
这种不是1000...的
可以转成原码比较容易看出真值（1000...的按照上面那个判断方法）
10000001补码对应原码（除符号位取反+1）=11111111
11111111对应的真值位-127

3.Java中，语句byte b=(byte)128执行后b=()
答案：-128
解析：127+1根据上面的规律，127+1整数溢出，应为最大负数-128
原码补码解法：01111111+1=10000000（补码对应-128）

4.语句byte b=(byte)(-0);执行后b=()
答案：0
解析：补码里面只有一个0，0和-0对应的补码都是00000000，我觉得考点是这个

5.java中，可以对字符串本身进行改变操作的、线程不安全的类是()
答案：StringBuilder
解析：记住

6.Java中，可以对字符串本身进行改变操作的、线程安全的类是()
答案：StringBuffer
解析：记住

7.接口中的变量默认修饰符是()
答案：public static final
解析：注意是变量还是方法，对应下面14是方法

8.Java中，面向对象的三大特征：()
答案：封装，继承和多态

9.JVM中匿名类存放在（）内存中
答案：方法区
解析：！！！！！！！！！！！！！！！！
看清题，就是是匿名类的类（class对象）应该是储存在方法区的
如果是对象就是堆里了

10.Java中，非静态的同步方法的锁对象是（）
答案：this
解析：同步方法的锁对象，涉及多线程？
锁对象一般是this，或者对应的类.class
既然说非静态那就是this喽

11.Java中，static修饰的变量，存放在（）内存中
答案：方法区
解析：静态的变量都是放在方法区

12.Java的内存分为堆、（）、方法区、本地方法区和寄存器五部分
答案：栈
解析：内存这块确实不太懂，我一直以为只有前三个，不过确实是这五部分
整个文章最开头放篇文章自己看吧

13.Java中，final修饰的变量，存放在（）内存中  
答案：常量池
解析：！！！！！！！！！！！
jdk1.7前常量池在方法区，jdk1.7后常量池移到了堆中
不过我们记写常量池就行

14.Java中，接口中的方法默认修饰符是（）
答案：public abstract

15.JVM中，静态的同步函数的锁是（）
答案：class对象
解析：这不就预言喽
对应10的解析，静态就是class对象

16.Java给局部内部类对象分配的是（）内存空间
答案：堆
解析：局部内部类也是new出来的对象啊，so在堆里

17.Java中，System.out.println(~(-9));输出的结果为（）
答案：8
解析：可以自己推一下
~是按位取反的操作 
公式：
~x=-(x+1)

18.java中，System.out.println(~101);输出的结果为（）
答案：-102
解析：同17（上面那个）

19.java中，编译时检查父类有没有此方法，运行时执行的是子类的方法。
在多态中这种成员方法访问的特点叫（）
答案：动态绑定
解析：自己去看文章，方法有动态绑定，属性是那个近就用哪个没有动态绑定

20.java中，基本类型char所对应的包装类是（）
答案：Character

21.java中，引用数据类型的成员变量默认初始化值是（）
答案：null

22.java中，基本类型int所对应的包装类是（）
答案：Integer

23.Java中，同步代码块和同步方法用（）关键字修饰
答案：synchronzied
解析：可以记一下这个单词

24.java中，判断一个对象是否为某个类或接口的实例或者子类实例的关键字是（）
答案：instanceof
解析：注意该关键字是检查的运行类型

25.java中，父类名  变量名=new 子类名();在多态中叫（）
答案：向上转型

26..Java中，多态的本质是：（）
答案：父类引用指向子类对象
解析：记住!!!

27.Java中，匿名内部类的本质是：（）
答案：一个继承了该类或者实现了该类接口的子类匿名对象
解析：记住!!!!!!!!!!!!!!

单选题

一些简单的直接写答案就不写选项了奥
不是我不写是他压根没选项！

一些杂乱的知识点
Arrays类 位于java.util包下

Pattern类位于java.util.regex包下

util简介包含集合框架、遗留的 collections 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包，Random类

java.lang包包含类为：比较器类、八大基本包装类(Nubmer是它们的父类！)、class类、enum类、包类、Object类、String类、System类、Thread类、Throwable类、Math类！

Object类里面的方法：
如下图

System类
常用方法
1.exit()2.arraycopy()3.currentTimeMillens()4.gc()
具体想了解可以看一下下面这篇文章
Java之System类

Thread里面的常用方法
1.start 2.sleep 3.interrupted()4.join()

Java中的快捷键
Alt+Shift+S 调用菜单
+R封装get() set()
+O 有参构造
+V 重写抽象方法

1.Eclipse中生成get、set方法的快捷键是
答案：Alt+Shift+s（调用菜单） +R(好像有)
2.在Java中，Scanner类判断是否还有下一个字符串的方法是
答案：hashNext()

3.final关键词不能修饰（）
A.成员方法和变量
B.匿名内部类
C.局部变量
D.类
答案：B

4.以下Java程序运行输出的结果是（）
Public static void main（string[]args）{
	int x＝1，y=9；
	if（x＞y）
	x=y；
	y=x；
	else
	x++；
	y++；
	System.out.println(x+“，”+y)；
}
A.2,10
B.程序错误
C．2,2
D．1,1
答案：B
解析：if和else没对应上会报编译错误

5.java中Arrays类属于哪个包
答案：java.util
解析：上面总结了

6.在java中关于内部类的说法正确的是?
答案：内部类可以直接访问其所在的外部类的私有成员

7.Java中，关于抽象类，说法错误的是
答案：抽象类中一定要有抽象方法
解析：抽象类不一定要有抽象方法的，不过抽象类不能实例化，它有构造方法

8.JVM中，存放局部内部类对象的内存区域是：
答案：堆区
解析：！！！！！！！！！！！！不会

9.java中，匿名内部类的定义格式正确的是：
答案：new接口名（）{}
解析：看文章，Java之内部类

10.14.哪个修饰符能修饰构造方法()
A.final		B.static  		C.abstract			D.private
答案：D
解析：构造方法和对象有关ab都和实例化对象冲突，c的abstract你让谁继承你构造方法
所以选d

11.java API中，以下哪个选项不是抽象类()
A.MathInoutStream    B.Calendar    C.DateFormat 	D.Math
答案：D

12.不是合法标识符的是
答案：#point
解析：没有其他选项，不过java合法标识符 a-z A-Z $ _ 1-9 这几种字符构成，首字母不能是数字
不能将关键字作为标识符

13.java中，表示空行的正则表达式是：
答案：^$

14.匹配11位手机号码的正则表达式是；
答案：1[34578]\d{9}

15.在Java中，匹配AABB叠词的正则表达式是；
答案：(.)\1(.)\2

16.java中的Math类中，功能实现的是四舍五入的方法是
答案：round（）

17.java中权限修饰符中，不能修饰外部类的是；
答案：private
解析：注意protected也不能修饰外部类

18.java中，Math类中生成（0，1）之间，伪随机小数的方法是；
解析：random（）

19.以下程序片段，打印结果是；
int[] arr=new int[5];
arr=null;
System.out.println(arr[0]);
答案：  程序运行后异常
解析：空指针呗

20.以下Java循环嵌套代码中，i--执行的次数是；   
public class HelloWorld{
   public static void main(String[] args){
      int i=5,j=0,k;
while(i){ i必须是boolean类型
   k=i+j;
   for(j=10;j>0;j--)
      i--;}
      }
}
答案：语法错误
解析：i必须是boolean类型！

21.Java语句System.out.println(‘a’+1);输出结果是：
答案：98
解析：‘a’在unicode对应的编码是97

22.以下java代码段，输出的结果为:

   Byte b=10；
   b=b+1;
  System.out.println(b);
答案：编译错误
解析：byet类型的b+1后会变为int类型，b=int类型（高到低）这种需要强转

23.java的四种权限修饰符中方，访问控制级别最严格的是；
答案：private

24.在java中，int i=10和3做两次相同的（）运算后，结果i仍是10；
答案：^
解析：！！！
一个数异或另一个数两次得出的结果不变
原因：
0异或0=0  对应位置还是0再异或0 结果还是0
1异或1=0 对应位置0异或1 结果还是1
0异或1 =1 1异或对位置1 结果还是1
1异或0=1  1异或对应位置0 结果还是1

25.在java中，垃圾回收方法finalize（），属于那个类：
答案：Object

26.java中，System类中运行垃圾回收器的方法是（）:
答案：gc（）

27.java中，修饰方法时，abstract关键字可以与哪个关键字并存（）
答案：public

28.java中，关于类与接口的描述错误的是（）；
答案：类和类之间可以是多继承关系
解析：java只有单继承

29.以下Java程序片段，输出的结果是（）；
int i＝1，j＝2，k＝3，m＝4；
boolean b;
b=i＞j＆＆k++＞m；
System.out.println(k);

答案：3
解析：这里程序简写了奥，认为它是能运行就行
因为i>j本身就不对，后面那个（k++）也不会执行了，所以k为原来的值

30.以下java程序片段,for循环执行的次数是()；
int i;for(i=1;i＜189;i++)
if(i==3)break;
else continue;
答案：3
解析：也是简写了程序
1时判断一次 2时判断一次 3时判断一次

31.Java中，哪个方法属于Thread类：
答案：join()
解析：！！！！！！！！！！！！！！！该类题下面写总结

32.Java语句System.out.println("x="+5+6)，输出的结果是；x=56
答案：x=56
解析：从左到右一步一步执行"x="后面那个+认为是连接的然后变成"x+5"后面有变成连接的喽
就是x=56

33.以下哪个类，不在Java.lang包中：
答案：Pattern（）
解析：建议及以下lang，until常用包里面的类，顺便把Thread里面的方法记一下

34.Scanner类中获取一个字符串的方法是：
答案：nextLine()

35.下面Java程序执行的结果是；
public static void main(String[] args){
ing x=2;
ing y=3;
switch(x){
      default:y++;break;
      case 2: x++;
      case 3: y++;
      case 4: x++;break;
}
System.out.println("y="+y);
答案：y=4
解析：只经历了一次y++ so y=y+1=4

编程填空题

没题目，不过感觉只有匿名内部类难一点

匿名内部类文章
Java之内部类

1.答案：Zi z = new Zi();              // 空参实例化Zi类对象
2.答案：People p = new People("Tom",80);    //实例化People对象，参数为Tom，80
3.答案：super.num   //写变量，使输出内容为Father类的num值
4.这个勉强找了下题目
题目
class Test2_NoNameInnerClass {
	public static void main(String[] args) {
		Outer.method().show();
	}
}
interface Inter {
	void show();
}
class Outer {
	//补齐代码
}
要求在控制台输出"HelloWorld"
注意：到时看要输出什么改那个重写的方法
答案： 
class Outer{
	  public static Inter function(){
		  return new Inter(){
			  public void show(){
				  
				  System.out.println("HelloWorld");
			  }	  
		  };		  
	  }	  
  }             //用匿名内部类的方式，补全Outer类体
5.答案：
Son s = new Son();   //空参实例化Son类对象
public Father(){
		System.out.println("Father的空参构造方法被执行了");
	}       //Father类的空参构造方法，输出”Father的空参构造方法被执行了”
public Son(){
		System.out.println("Son的空参构造方法被执行了");
	}   //Son类的空参构造方法，输出”Son的空参构造方法被执行了”
6.答案：  
 System.out.println(s1==s2);  //输出s1和s2是否相等
	System.out.println(s1==s3);	//输出s1和s3是否相等
	System.out.println(s2==s4); //输出s2和s4是否相等
	System.out.println(s3==s5);  //输出s3和s5是否相等
	System.out.println(s2.equals(s3));   //用equals()方法比较s2和s3的内容是否相等
	System.out.println(s4==s6);  //输出s4和s6是否相等
7.也是匿名内部类，不过这是做参数，上一个是返回值
答案：
pd.method(new Person(){
	public void show(){
		System.out.println("Anonymous Arguments");
	}
	
});        //使用匿名内部类，重写show()方法输出Anonymous Arguments
8.答案：  B b =new C();  //B类引用指向空参构造C类对象
9.答案：
class Outer{
	public static Inter method(){
		return  new Inter (){
			public void show(){
			System.out.println("Hello world");	
					}
				};
			}
		}   //method()方法中返回匿名内部类
Outer.method().show();  //调用Outer类的method()方法，使show()方法打印hello world
10.答案：
public Animal(){}    //空参构造
public abstract void eat();     //公共的无返回值的抽象方法eat()
public abstract void sleep(); public void jump();  //公共的无返回值的抽象方法sleep()

简答题

1、	简述this和super的区别

A：this和supuer都代表什么
	this：代表当前对象的引用，谁来调用我，我就代表谁
	super：代表当前对象 父类的引用
	一个是本类，一个是父类
B：this和super的使用区别
	a：调用成员变量
		this.成员变量	调用本类的成员变量，也可以调用父类的成员变量
		super.成员变量	调用父类的成员变量
	b：调用构造方法
		this(...)	调用本类的构造方法
		super(...)	调用父类的构造方法
	c：调用成员方法
		this.成员方法	调用本类的成员方法，也可以调用父类的方法
		super.成员方法	调用父类的成员方法
		
2、简述静态变量和成员变量的区别

A：所属不同
	静态变量属于类，所以也称为类变量
	成员变量属于对象，所以也称为实例变量（对象变量）
B：内存中位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存
C：内存出现时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而存在，随着对象的消失而消失
D：调用不同
	静态变量可以通过类名调用，也可以通过对象调用
	成员变量只能通过对象名调用
	
3、简述局部变量和成员变量的区别

A：在类中的位置不同
	成员变量：在类中，方法外
	局部变量：在方法定义中，或方法声明上
B：在内存中的位置不同
	成员变量：在堆内存（成员变量属于对象，对象进堆内存）
	局部变量：在栈内存（局部变量属于方法，方法进栈内存）
C：生命周期不同
	成员变量：随着对象的创建而存在，随着对象的消失而消失
	局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D：初始化值不同
	成员变量：有默认初始化值
	局部变量：没有默认初始化值，必须定义、赋值，然后才能使用。只定义不赋值，直接使用时，编译报错。
补：成员变量：直接定义在类中的量；局部变量：在方法内部定义的变量
String name;				//成员变量
	int num;
	public void speak(int x){
		int num = 10;			//x和num都是局部变量
		System.out.println(name);
		System.out.println(num);	//输出的是10
成员变量默认初值详见知识点2。


4、简述抽象类和接口的区别
A：成员区别
	抽象类：
		成员方法：可以是变量，也可以是常量
		构造方法：有
		成员方法：可以抽象，也可以非抽象
			非抽象的子类可以继承，抽象的子类必须对它进行重写
	接口：
		成员变量：只可以常量。前有public static final三个关键字
		成员方法：只可以抽象。前有public abstract两个关键字。没有构造方法。
B：关系区别
	类与类
		继承、单继承
	类与接口
		实现，单实现，多实现
	接口与接口
		继承，单继承，多继承
C：设计理念区别
	抽象类：被继承体现的是“is a”的关系。抽象类中定义的是该继承体系的共性功能。
		向上抽取出共性的属性和方法。
	接口：被实现体现的是“like a”的关系（谁像谁的关系）。接口中定义的是该继承体系的扩展功能。

5、override和overload的区别
先说明override是方法重写，overload是方法重载
方法重写：子类出现了和父类中方法声明一模一样的方法。
		  与返回值类型有关，返回值是一致的（或者是子父类）
方法重载：本类中出现的方法名一样，参数列表不同的方法。
		  与返回值类型无关。
		  
6：==号和equals()方法的区别
A：共同点：
	都可以做比较，返回值都是boolean
B：区别：
	1.==是比较运算符，基本可以比较基本数据类型，也可以比较引用数据类型。
	  基本数据类型比较的是值，引用数据类型比较的是地址值。
	2.equals()方法只能比较的是引用数据类型。equals()方法在没重写之前，比较的是地址值，底层依赖的是==号，
	但是比较地址值是没有意义的。 我们需要重写equals()方法，比较对象中的属性。


7：""和null的区别
""是字符串常量，同时也是一个String类的对象，既然是对象当然可以调用String类中的方法
null是空常量，不能调用任何的方法，否则会出现空指针异常，null常量可以给任意的引用数据类型赋值


8：String、StringBuffer和StringBuilder的区别
String是一个不可变的字符序列,一旦被初始化，就不能被改变。
StringBuffer、StringBuilder是可变的字符序列,通过调用其方法，对其进行改变
作为参数传递:String对象虽然是引用数据类型，但是它当做参数传递时和基本数据类型是一样的,因为String类一旦初始化就不会被改变。
StringBuffer对象作为参数传递的时候，是传的地址。

编程题

也没题目，不过敲一遍就差不读能明白需求

导包好像它自己会帮你自动导入不用担心

1.点学号
第一个程序是点一个
第二个程序是点五个
注意： throws java.lang.Exception(好像不加也可以)

import java.util.Random;
class test{
public static void main(String [] args) throws java.lang.Exception
{
	Random rand=new Random();//Random属于util包需要导入
	
	int []ban=new int[5];
	int []num=new int[5];
	int i=1;
		ban[i]=1+rand.nextInt(5);
		num[i]=1+rand.nextInt(30);
		System.out.println("班级"+ban[i]);
		System.out.println("学号"+num[i]);
	}
}

import java.util.Random;
class test{
public static void main(String [] args) throws java.lang.Exception
{
	System.out.println("班级");
	Random rand=new Random();//Random属于util包需要导入
	int []ban=new int[1];
	int []num=new int[5];
	for(int i=0;i<ban.length;i++){
		ban[i]=1+rand.nextInt(5);
		System.out.println(ban[i]);
		}
		System.out.println("学号");
	Random r = new Random();
	
	for(int i=0;i<num.length;i++){
	num[i]=1+r.nextInt(30);
	System.out.println(num[i]);
	}
		
	}
}

2.正方形和圆的面积
注意：Math.PI和implements
类继承类也是extends

interface Shape(){
	public double area(double d);
}
class Square implements Shape(){
	public double area(double l){
	return l*l;
	}
}
class Cricle implements Shape{
	public double area(double r){
		return Math.PI*r*r;
	}
}

3.Stuednt和Undergraduate
get和set后面的属性首字母大写 getXxxx这样

class Student(){
	private String name;
	private int age;
	public Student(){}
	public Student(String name,int age){
	this.name=name;
	this.age=age;
	}
	public void setName(String name){
	this.name=name;
	}
	public String getName(){
	return this.name;
	}
	public void setAge(int age){
	this.age=age;
	}
	
	public int getAge(){
	return age;
	}
	public void show(){
	System.out.println("姓名"+getName()+"年龄"+getAge());
	}
}
class Undergrduate extends Student{
	private String degree;
	public Undergraduate(){}
	public Undergraduate(String name,int age,String degree){
	super(name,age);
	this.degree=degree;//答案没写这行，不过我认为应该写
	//到时看需求
	}
	public void setDegree(String degree){
	this.degree=degree;
	}
	public String getDegree(){
	return degree;
	}
	public void show(){
	System.out.println("姓名"+getName()+"年龄"+getAge()+"学位"+getDegree());
	}
}

4.一道关于车的题
能用父类构造器就用父类的，方便

import java.util.Random;
import java.util.Scanner;
class Demo2_Person{
	public static void main(String [] args){
	BenzCar amg=new BenzCar();
	amg.setType("AMGcls");
	amg.setColor("red");
	amg.setTyreNum(5);
	amg.setPrice(2300000.00);
	amg.usingCar();
	amg.fullFilling();
	amg.lauch();
	amg.selectGear();
	amg.stepAccelerator();
	amg.turnSteeringWheel();
	amg.run();
	amg.autoPilot();
	amg.autoHold();
	System.out.println("-------------------------");
	BenzCar eqc = new BenzCar("EQC1886","black",4,500000.00);
	eqc.usingCar();
	eqc.fullFilling();
	eqc.lauch();
	eqc.selectGear();
	eqc.stepAccelerator();
	eqc.turnSteeringWheel();
	eqc.run();
    eqc.autoPilot();
    eqc.autoHold();

	}
}
//这之前的好像不用写的，题目会给到时写下面的接口，抽象类和方法就行
interface AutoMobile{//默认接口方法都是public abstract
//变量默认修饰就是public static final
	void lauch();
	void turnSteeringWheel();
	void run();
	void fullFilling();
}
abstract class Car{
	private String color;
	private String type;
	private int tyreNum;
	private double price;
	 public Car(){}
    public Car(String color, String type,int tyreNum,double price){
    	this.color=color;
    	this.type=type;
    	this.price=price;
    	this.tyreNum=tyreNum;
    }
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public int getTyreNum() {
		return tyreNum;
	}
	public void setTyreNum(int tyreNum) {
		this.tyreNum = tyreNum;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}

    public void stepAccelerator(){
    	System.out.println("正在踩油门");
    }
    public void selectGear(){
    	System.out.println("挂x挡");
    	
    }
}
class BenzCar extends Car implements AutoMobile{
	public BenzCar(){}
	public BenzCar(String color,String type,int tyreNum,double price){
		super(color,type,tyreNum,price);//这里调用这个就行
	}
	public void autoHold(){
	System.out.println("自动泊车中");
	}
	public void autoPilot(){
	System.out.println("自动导航中");
	}
	public void usingCar(){
	System.out.println(super.getColor()+"的奔驰汽车"+
	super.getType()+"型号"+"售价"+super.getPrice());
	}
	public void lauch(){
	System.out.println("已大火发动汽车");
	}
	public void turnSteeringWheel(){
	System.out.println("根据实际情况左右打方向盘");
	}
	public void run(){
	System.out.println("汽车跑起来啦");
	}
	public void fullFilling(){
	System.out..println("加满汽油");
	}
	
	
}

}

总结

YEYEYE，写完了
给我的提升就是关于匿名内部类的知识的巩固
还有就是java内存结构的进一步巩固
其他东西就是关于java包的一些认识
以前没有系统了解过哪方面知识点对应那些包

java.lang包不用导入就可以用！

还有
！！！正则表达式！！！
需要看看