1.请求出最后的输出结果______
class Test
{
private int data;
int result = 0;
public void m()
{
result += 2;
data += 2;
System.out.print(result + " " + data);
}
}
class ThreadExample extends Thread
{
private Test mv;
public ThreadExample(Test mv)
{
this.mv = mv;
}
public void run()
{
synchronized(mv)
{
mv.m();
}
}
}
class ThreadTest
{
public static void main(String args[])
{
Test mv = new Test();
Thread t1 = new ThreadExample(mv);
Thread t2 = new ThreadExample(mv);
Thread t3 = new ThreadExample(mv);
t1.start();
t2.start();
t3.start();
}
}
2.Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 _____
3.下面代码输出结果是？_______
class C {
C() {
System.out.print("C");
}
}
class A {
C c = new C();
A() {
this("A");
System.out.print("A");
}
A(String s) {
System.out.print(s);
}
}
class Test extends A {
Test() {
super("B");
System.out.print("B");
}
public static void main(String[] args) {
new Test();
}
}
4.下列描述错误的是_____
A.类只能继承一个父类，但是可以实现多个接口
B.抽象类自身可以定义成员而接口不可以
C.抽象类和接口都不能被实例化(忽略匿名内部类)
D.一个类可以有多个父类和多个基接口
5.在java中重写方法应遵循规则的包括_____
A.访问修饰符的限制一定要大于被重写方法的访问修饰符
B.可以有不同的访问修饰符
C.参数列表必须完全与被重写的方法相同
D.必须具有不同的参数列表
6.java7后关键字 switch 支不支持字符串作为条件_____
7.关于下面代码 int[] x=new int[25]; 描述正确的是____
A.x[25]存放了数据“\0”。
B.x[24] 存放了数据“\0”。
C.若访问x[25]，程序将抛出异常。
D.x[1]访问此数组的第一个元素。
8.关于抽象类与最终类，下列说法错误的是_____
A.抽象类能被继承，最终类只能被实例化。
B.抽象类和最终类都可以被声明使用
C.抽象类中可以没有抽象方法，最终类中可以没有最终方法
D.抽象类和最终类被继承时，方法可以被子类覆盖
9.关于Java中参数传递的说法，哪个是错误的_____
A.在方法中，修改一个基础类型的参数不会影响原始参数值
B.在方法中，改变一个对象参数的引用不会影响到原始引用
C.在方法中，修改一个对象的属性会影响原始对象参数
D.在方法中，修改集合和Maps的元素不会影响原始集合参数
10.在Java中下面Class的声明哪些是错误的___
//A.
public abstract final class Test {
abstract void method();
}
//B.
public abstract class Test {
abstract final void method();
}
//C.
public abstract class Test {
abstract void method() {
}
}
//D.
public class Test {
final void method() {
}
}
（1）解析：
Test mv =newTest()声明并初始化对data赋默认值
使用synchronized关键字加同步锁线程依次操作m()
t1.start();使得result=2,data=2,输出即为2 2
t2.start();使得result=4,data=4,输出即为4 4
t3.start();使得result=6,data=6,输出即为6 6
System.out.print(result +" "+ data);是print()方法不会换行,
输出结果为2 24 46 6
（2）解析:
Math类中提供了三个与取整有关的方法：ceil,floor,round,这些方法的作用于它们的英文名称的含义相对应，例如：ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil（11.3）的结果为12，Math.ceil(-11.6)的结果为-11；floor的英文是地板，该方法就表示向下取整，Math.floor(11.6)的结果是11，Math.floor(-11.4)的结果-12；最难掌握的是round方法，他表示“四舍五入”，算法为Math.floor(x+0.5),即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果是12，Math.round(-11.5)的结果为-11.
换个好理解的解释：
Math.round() 函数：加0.5，进行下取整；
console.log(Math.floor(20.49+0.5)); //20
console.log(Math.floor(20.5+0.5)); //21
console.log(Math.floor(20.51+0.5)); //21
console.log(Math.floor(-20.49+0.5)); //-20
console.log(Math.floor(-20.5+0.5)); //-20
console.log(Math.floor(-20.51+0.5)); //-21
补充
- round方法，在Math中有重载的，一个参数是float，一个是double，对应返回int和long值。返回值是当前值+0.5向下取整（-0.5 —> 0）；
- ceil方法，没有重载，参数就是double，返回值也是double，但是这个时候就有区别了，向上取整（-0.5 —> -0.0），注意一下，负号是保留的，和round有区别的；
- floor，和ceil一样，没有重载，参数和返回值都是double，向下取整（-0.5 --> -1.0）。
（3）解析
初始化过程是这样的：
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化；
3.其次，初始化父类的普通成员变量和代码块，在执行父类的构造方法；
4.最后，初始化子类的普通成员变量和代码块，在执行子类的构造方法；
（1）初始化父类的普通成员变量和代码块，执行 C c = new C(); 输出C
（2）super(“B”); 表示调用父类的构造方法，不调用父类的无参构造函数，输出B
（3） System.out.print(“B”);
所以输出CBB
（4）解析：
A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。
(5)解析：
方法重写
参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
方法重载
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。
(6)解析：
switch(exp)，在JDK7之前，只能是byte、short、char、int或者对应的包装类，或者枚举常量（内部也是由整型或字符类型实现）。
为什么必须是这些呢，因为其实exp只是对int型支持的，其他都是因为可以自动拆卸或者自动向上转型到int，所以才可以。
到了JDK7的时候，String被引入了，为什么String能被引入呢？
其实本质上还是对int类型值得匹配。
原理如下，通过对case后面得String对象调用hashCode方法，得到一个int类型得hash值，然后用这个hash值来唯一标识这个case。那么当匹配时，首先调用exp的hashCode，得到exp的hash值，用这个hash值来匹配所有case，如果没有匹配成功，就说明不存在；如果匹配成功了，接着会调用字符串的equals方法进行匹配。（hash值一致，equals可不一定返回的就是true）。
所以，exp不能为null，cas子句使用的字符串也不能为null，不然会出现空指针异常。
(7)解析：
A:不存在x[25] 索引从0开始到length-1
B:x[24] 存的是默认值0(java中没有’\0’这一说)
C:超出内存 正确
D:第二元素
(8)解析：
1，抽象类中可以有抽象方法，也可以没有抽象方法。
2，抽象类当然可以被继承，因为它就是用来继承的，
3，继承抽象类，若有抽象方法，则子类必须将其抽象方法实现，
4，抽象类中的非抽象方法可以被重写。
最终类和抽象类正好相反
5，加上final的类就叫最终类，加上final的方法就叫最终方法，
6，最终类中可以有最终方法也可以没有
7，最终类不能有子类，最终方法不能被重写
补充：抽象类中的非抽象方法不用重写，其他必须重写，接口的方法必须重写；
接口和抽象类中只有方法名，没有定义的，如果你不定义 也就是空方法，接口就是为了弥补java不能多重继承，接口针对的是对象而不是实现。实现的部分可以交由对象去实现。这就是java中的多态啊。
(9)解析：
注意!Java中方法的参数传递都是值传递
A. 在方法中，修改一个基础类型的参数不会影响原始参数值
public static void main(String []args){
int i = 5;
func(i);
System.out.println(i);
}
static void func(int j){
j = 10;
}
//输出结果
5
在主方法调用func(int j) 时 , 参数i是实际参数 , 值为5 , 参数j是形式参数 , 值是i给的 , 也是5 , i和j没有任何关系 , 是两个独立的参数 , 所以修改j的值时与i没有关系 , 仍然输出5。
B. 在方法中，改变一个对象参数的引用不会影响到原始引用
public static void main(String []args){
User names = new User();
names.setName("rabbiter");
func(names);
System.out.println(names.getName());
}
static void func(User user){
user = new User();
user.setName("zhangsan");
}
//输出结果
rabbiter
在主方法调用func(User user) 时 , 对象rabbiter保存的是一个地址值 , 本质上就是把rabbiter的地址值给了形参user , 所以此时实参rabbiter和形参user指向在堆中的同一个对象 , 他们的地址值相同 , 只是指向的对象一致 , 所以并不违反值传递的理论。
此时 , 如果修改形参user , new一个新的对象并让user指向它 , 修改的只是形参保存的地址 , 与实参rabbiter无关 , rabbiter指向的对象仍然是之前的那个对象。
C. 在方法中，修改一个对象的属性会影响原始对象参数
public static void main(String []args){
User names = new User();
names.setName("rabbiter");
func(names);
System.out.println(names.getName());
}
static void func(User user){
user.setName("zhangsan");
}
//输出结果
zhangsan
在主方法调用func(User user) 时 , 对象rabbiter保存的是一个地址值 , 本质上就是把rabbiter的地址值给了形参user , 所以此时实参rabbiter和形参user指向在堆中的同一个对象 , 他们的地址值相同 , 指向的对象一致 , 所以并不违反值传递的理论。
那么user对其指向的对象的属性name进行修改 , rabbiter指向的对象的name属性也就被修改了。
D. 在方法中，修改集合和Maps的元素不会影响原始集合参数
集合和Maps都是对象 , 所以此项跟C选项的解析一致。
(10)解析：
A、final修饰的类为终态类，不能被继承，而 抽象类是必须被继承的才有其意义的，因此，final是不能用来修饰抽象类的。
B、 final修饰的方法为终态方法，不能被重写。而继承抽象类，必须重写其方法。
C、抽象方法是仅声明，并不做实现的方法。
扫一扫
2648
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
