个人测试五

谁言0413

已于 2022-06-24 14:51:18 修改

阅读量2.6k

点赞数 3

分类专栏：个人测试文章标签： java

于 2021-03-02 18:46:23 首次发布

本文链接：https://blog.csdn.net/qq_44188658/article/details/114291440

版权

个人测试专栏收录该内容

8 篇文章 1 订阅

订阅专栏

选择题：

1.下面关于import, class和package的声明顺序哪个正确？( A )

A. package, import, class
B. class, import, package
C. import, package, class
D. package, class, import

2.下面哪个是正确的？( D )

A. String temp [] = new String {“a” “b” “c”};
B. String temp [] = {“a” “b” “c”}
C. String temp = {“a”, “b”, “c”}
D. String temp [] = {“a”, “b”, “c”}

3.关于java.lang.String类，以下描述正确的一项是（ A）

A. String类是final类故不可以继承；
B. String类是final类故可以继承；
C. String类不是final类故不可以继承；
D. String类不是final类故可以继承；

String类是final的，在java中final修饰类的不能被继承

4.关于实例方法和类方法，以下描述正确的是：(D )

A. 实例方法只能访问实例变量
B. 类方法既可以访问类变量，也可以访问实例变量
C. 类方法只能通过类名来调用
D. 实例方法只能通过对象来调用

A 实例方法可以访问类变量
B类方法只能访问类变量
C类方法可以通过对象调用

5.接口是Java面向对象的实现机制之一，以下说法正确的是：( B )

A. Java支持多重继承，一个类可以实现多个接口；
B. Java只支持单重继承，一个类可以实现多个接口；
C. Java只支持单重继承，一个类只可以实现一个接口；
D. Java支持多重继承，但一个类只可以实现一个接口。

Java支持单重继承，一个类只能继承自另外的一个类，但是一个类可以实现多个接口。

6.下列关于interface的说法正确的是：( D )

A. interface中可以有private方法
B. interface中可以有final方法
C. interface中可以有function实现
D. interface可以继承其他interface

A.接口中不可以有private的方法
B．接口中不可以有final的方法接口中的方法默认是 public abstract的
C．接口中的方法不可以有实现

7.已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为, protected控制方式。C类也位于packageA包，且继承了B类。则以下说话正确的是（ C ）

A. A类的实例不能访问到B类的实例
B. A类的实例能够访问到B类一个实例的x成员
C. C类的实例可以访问到B类一个实例的x成员
D. C类的实例不能访问到B类的实例

不同包子类的关系，可以访问到父类B的protected成员

8.以下程序正确的输出是（ A ）

package test;
public class FatherClass {
public FatherClass() {
System.out.println(“FatherClass Create”);
}
}
package test;
import test.FatherClass;
public class ChildClass extends FatherClass {
public ChildClass() {
System.out.println(“ChildClass Create”);
}
public static void main(String[] args) {
FatherClass fc = new FatherClass();
ChildClass cc = new ChildClass();
}
}

A.
FatherClass Create
FatherClass Create
ChildClass Create

B.
FatherClass Create
ChildClass Create
FatherClass Create

C.
ChildClass Create
ChildClass Create
FatherClass Create

D.
ChildClass Create
FatherClass Create
FatherClass Create

在子类构造方法的开始默认情况下有一句super();来调用父类的构造方法

9.给定如下代码，下面哪个可以作为该类的构造函数 ( B )

public class Test {
		?
}

A. public void Test() {?}
B. public Test() {?}
C. public static Test() {?}
D. public static void Test() {?}

构造方法：与类同名没有返回类型

10.题目:

 public class test (
    public static void main (String args[]) {
 		int i = 0xFFFFFFF1;
 		int j = ~i;

 	}
 )

程序运行到第5行时,j的值为多少?(D )

A. –15
B. 0
C. 1
D. 14
E. 在第三行的错误导致编译失败

int i = 0xFFFFFFF1;相当于 int i=-15 然后对i进行取反即取绝对值再减一

11.关于sleep()和wait()，以下描述错误的一项是（ D ）

A. sleep是线程类（Thread）的方法，wait是Object类的方法；
B. sleep不释放对象锁，wait放弃对象锁；
C. sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；
D. wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态。

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

12.下面能让线程停止执行的有（多选）( ABDEF)

A. sleep();
B. stop();
C. notify();
D. synchronized();
E. yield();
F. wait();
G. notifyAll();

sleep：导致此线程暂停执行指定时间
stop: 这个方法将终止所有未结束的方法，包括run方法。
synchronized():对象锁
yield：当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出，这就是yield。
wait：当前正在被服务的线程需要睡一会，醒来后继续被服务

13.下面哪个可以改变容器的布局？( A )

A. setLayout(aLayoutManager);
B. addLayout(aLayoutManager);
C. layout(aLayoutManager);
D. setLayoutManager(aLayoutManager);

Java设置布局管理器setLayout()

14.下面哪个是applet传递参数的正确方式？（ B）

A. < applet code=Test.class age=33 width=100 height=100>
B.< param name=age value=33>
C. < applet code=Test.class name=age value=33 width=100 height=100>
D. < applet Test 33>

15.不能用来修饰interface的有（ ACD）

A．private
B．public
C．protected
D．static

修饰接口只能是public

16.下列说法错误的有（ACD）

A．在类方法中可用this来调用本类的类方法
B．在类方法中调用本类的类方法时可直接调用
C．在类方法中只能调用本类中的类方法
D．在类方法中绝对不能调用实例方法

A.在类方法中不能使用this关键字
C．在类方法中可以调用其它类中的类方法
D．在类方法中可以通过实例化对象调用实例方法

17.从下面四段（A，B，C，D）代码中选择出正确的代码段（）

A．abstract class Name {
	private String name;
	public abstract boolean isStupidName(String name) {}
}

B．public class Something {
	void doSomething () {
		private String s = “”;
		int l = s.length();
	}
}

C．public class Something {
	public static void main(String[] args) {
		Other o = new Other();
		new Something().addOne(o);
	}
	public void addOne(final Other o) {
		o.i++;
	}
}
class Other {
	public int i;
}

D．public class Something {
	public int addOne(final int x) {
		return ++x; 
	}
}

A…抽象方法不能有方法体
B．方法中定义的是局部变量，不能用类成员变量修饰符private
D．final修饰为常量，常量的值不能被改变

18.选择下面代码的运行结果：（C）。

public class Test{
	public void method()
	{
		for(int i = 0; i < 3; i++){
			System.out.print(i);
		}
		System.out.print(i);
	}
}

A．0122
B．0123
C．编译错误
D．没有任何输出

i变量的作用范围是整个for循环

19.请看如下代码

 class Person {
	private int a; 
	public int change(int m){return m;} 
} 
public class Teacher extends Person{ 
	public int b; 
	public static void main(String arg[]){
		Person p = new Person();
		Teacher t = new Teacher();
		int i; 
		// point x
 	}
}

下面哪些放在// point x?行是正确的？(DE )

A, i = m;
B, i = b;
C, i = p.a;
D, i = p.change(30);
E, i = t.b;

A.不同的作用域
B．静态方法中不能直接使用非静态成员变量
C．类外不能访问其它类私有的成员
D，E．在类方法中可以通过实例化对象调用类中的实例成员

简答题：

1.简述SOA架构。

SOA架构即面向服务架构。
面向服务的体系结构，是一个组件模型，它将zhi应用程序的不同功能单元（称为服务）通过这些服务之间定义良好的接口和契约联系起来。
接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种这样的系统中的服务可以以一种统一和通用的方式进行交互。

SOA具有以下五个特征：

 1. 可重用
 2. 松耦合
 3. 明确定义的接口
 4. 无状态的服务设计
 5. 基于开放标准

在这里插入图片描述
2.RPC服务和restful服务的区别（建议加深对rpc和restful的了解）

1、从本质区别上看，RPC是基于TCP实现的，RESTFUL是基于HTTP来实现的。
2、从传输速度上来看，因为HTTP封装的数据量更多所以数据传输量更大，所以RPC的传输速度是比RESTFUL更快的。
3、因为HTTP协议是各个框架都普遍支持的。在toC情况下，因为不知道情况来源的框架、数据形势是什么样的，所以在网关可以使用Restful利用http来接受。而在微服务内部的各模块之间因为各协议方案是公司内部自己定的，所以知道各种数据方式，可以使用TCP传输以使各模块之间的数据传输更快。所以可以网关和外界的数据传输使用RESTFUL，微服务内部的各模块之间使用RPC。
4、RESTFUL的API的设计上是面向资源的，对于同一资源的获取、传输、修改可以使用GET、POST、PUT来对同一个URL进行区别，而RPC通常把动词直接体现在URL上

3.什么叫死锁，怎么解决死锁

死锁：有两个进程A和B,A持有资源a等待b资源，B持有资源b等待a资源，两个进程都在等待另一个资源的同时不释放资源，就形成死锁。

 形成死锁的四个必要条件：
 （1） 互斥条件：一个资源每次只能被一个进程使用。
 （2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
 （3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
 （4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

> 解决：
1.首先一个可行的做法是释放所有锁，回退，并且等待一段随机的时间后重试。
这个和简单的加锁超时类似，不一样的是只有死锁已经发生了才回退，而不会是因为加锁的请求超时了。
2.回退和等待，但是如果有大量的线程竞争同一批锁，它们还是会重复地死锁（注：原因同超时类似，不能从根本上减轻竞争）。
3.一个更好的方案是给这些线程设置优先级，让一个（或几个）线程回退，剩下的线程就像没发生死锁一样继续保持着它们需要的锁。
如果赋予这些线程的优先级是固定不变的，同一批线程总是会拥有更高的优先级。为避免这个问题，可以在死锁发生的时候设置随机的优先级。

编程题：

1.题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少（斐波那契数列）？
程序分析：兔子的规律为数列1,1,2,3,5,8,13,21…

 public static void main(String[] args){
		int n = 10;
		System.out.println("第"+n+"个月兔子总数为"+fun(n));
	}
	private static int fun(int n){
		if(n==1 || n==2)
		   return 1;
		else
		   return fun(n-1)+fun(n-2);
	}

2.题目：判断101-200之间有多少个素数，并输出所有素数。
程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。

public static void main(String[] args){
		int m = 1;
		int n = 1000;
		int count = 0;
		//统计素数个数
		for(int i=m;i<n;i++){
			if(isPrime(i)){
				count++;
				System.out.print(i+" ");
				if(count%10==0){
					System.out.println();
				}
			}
		}
		System.out.println();
		System.out.println("在"+m+"和"+n+"之间共有"+count+"个素数");
	}
	//判断素数
	private static boolean isPrime(int n){
		boolean flag = true;
		if(n==1)
		  flag = false;
		else{
			for(int i=2;i<=Math.sqrt(n);i++){
			if((n%i)==0 || n==1){
				flag = false;
				break;
			}
			 else
			   flag = true;
		  }
		}
		return flag;
	}

谁言0413

关注

3
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
个人测试五

选择题：1.下面关于import, class和package的声明顺序哪个正确？( A )2.下面哪个是正确的？( D )3.关于java.lang.String类，以下描述正确的一项是（ A）String类是final的，在java中final修饰类的不能被继承4.关于实例方法和类方法，以下描述正确的是：(D )A 实例方法可以访问类变量B类方法只能访问类变量C类方法可以通过对象调用5.接口是Java面向对象的实现机制之一，以下说法正确的是：( B )Java支持单重继承，一个类只能继承自另外的一个
复制链接

扫一扫