Java 初级软件工程师认证考试试卷1

时间 2019-11-20

标签 java 初级软件工程师认证考试试卷栏目 Java 繁體版

原文原文链接

Java 初级软件工程师java

认证考试试卷数据库

笔试（A卷）编程

考试时间150分钟设计模式

总分 100分数组

姓名_______________________安全

身份证号_______________________服务器

考试结束后考卷必须收回，不然考试成绩无效网络

尚学堂Java 初级软件工程师认证考试试卷多线程

1、 填空题（共20个题目，总计20分）oracle

安装JDK后，为了告诉计算机javac.exe和java.exe等执行文件的位置，须要配置的环境变量是______Path_______。
Java提供了三种注释类型，分别是单行注释，多行注释和_____文档注释________。
char 类型用来表示在Unicode编码表中的字符，长度是___2___个字节。
___&&______是短路与运算符，若是左侧表达式的计算结果是false，右侧表达式将再也不进行计算。
_____contiune________语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中还没有执行的语句，接着进行下一次是否执行循环的断定。
基本数据类型的类型转换中，要将double类型的常量3.14159赋给为整数类型变量n的语句是________int n = int(3.14159);_____________。
执行Person p = new Person();语句后，将在___堆内存________中给Person对象分配空间，并在栈内存中给引用变量p分配空间，存放Person对象的引用。
使用static修饰的变量称为静态变量，静态变量能够有两种访问方式，分别是类名.静态变量名和_______对象名.静态变量名________________。
在一个类文件中的关键字package，import，class出现的可能顺序是________________package，import，class______________。
异常是由Java应用程序抛出和处理的非严重错误，好比所需文件没有找到、零做除数，数组下标越界等，可分为两类：Checked异常和__运行时异常(RuntimeException)________________。
数组在内存中分配连续的空间，数组的长度固定，一经分配没法改变，可使用___length_________属性获取数组的长度。
DateFormat类能够实现字符串和日期类型之间的格式转换，其中将日期类型转换为指定的字符串格式的方法名是_____Forma_________。
JDK1.5后提供了____enum________关键字，用以定义枚举类。枚举类是一种特殊的类，能够有本身的属性、方法和构造方法。
若是但愿将自定义类Student的多个对象放入集合TreeSet，实现全部元素按照某个属性的天然顺序排列，则须要Student类实现___Comparabe_______________接口。
迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是hasNext() 、___next()_________、remove()。
Java IO体系中，__DataInputStream__________________是字节输入流，提供了能够存取全部Java基础类型数据（如：int，double 等）和String的方法,但没有提供存取对象的方法。
____序列化________是指将Java对象转换成字节序列，从而能够保存到磁盘上，也能够在网络上传输，使得不一样的计算机能够共享对象。
Java反射技术中，每一个Method对象对应一个方法，得到Method对象后，能够调用其__invoke_________来调用对应方法。
处于运行状态的线程在某些状况下，如执行了sleep（睡眠）方法，或等待I/O设备等资源，将让出CPU并暂时中止本身的运行，进入____阻塞_____状态。
统一资源定位符URL是指向互联网“资源”的指针,由4部分组成：协议、存放资源的主机域名、____端口号______和资源路径和文件名。

2、 选择题（共25个题目，总计25分）

1)	如下选项中是对一个Java源文件进行正确编译的语句是（ A ）（选择一项）

	A.	javac Test.java
	B.	javac Test
	C.	java Test
	D.	java Test.class
2)	如下选项中属于合法的Java标识符的是（CD ）。（选择两项）

	A.		public
	B.		3num
	C.		name
	D.		_age
3)	如下代码的执行结果是（ B ）。（选择一项）
	boolean m = true; if(m = false){ System.out.println("false"); }else{ System.out.println("true"); }

	A.		false
	B.		true
	C.		编译错误
	D.		无结果
4)	如下do-while循环代码的执行结果是（ A ）。（选择一项）
	int a=0; int c=0; do{ --c; a=a-1; }while(a>0); System.out.println(a+" "+c);

	A.		-1 -1
	B.		死循环
	C.		-1 -2
	D.		-1 0
5)	while循环和do-while循环的区别是（ D ）。（选择一项）

	A.		没有区别，这两个结构在任何状况下效果同样
	B.		while循环比do-while循环执行效率高
	C.		while循环是先循环后判断，因此循环体至少被执行一次
	D.		do-while循环是先循环后判断，因此循环体至少被执行一次
6)	分析下面的Java多重循环代码片断，编译运行后的输出结果是（ D ）。（选择一项）
	for (int i = 0; i < 6; i++) { int k = ++i; while (k < 5) { System.out.print(i); break; } }

	A.		024
	B.		02
	C.		123
	D.		13
7)	如下关于方法调用的代码的执行结果是（ B ）。（选择一项）
	public class Test { public static void main(String args[]) { int i = 99; mb_operate(i); System.out.print(i + 100); } static void mb_operate(int i) { i += 100; } }

	A.		99
	B.		199
	C.		299
	D.		99100
8)	如下关于继承条件下构造方法执行过程的代码的执行结果是（ A ）。（选择一项）
	class Person { public Person() { System.out.println("execute Person()");1 } } class Student extends Person { public Student() { System.out.println("execute Student() ");2 } } class PostGraduate extends Student { public PostGraduate() { System.out.println("execute PostGraduate()");3 } } public class TestInherit { public static void main(String[] args) { new PostGraduate(); } }

	A.		execute Person() execute Student() execute PostGraduate()
	B.		execute PostGraduate()
	C.		execute PostGraduate() execute Student() execute Person()
	D.		没有结果输出
9)	如下语句中关于Java构造方法的说法错误的是（ B ）。（选择一项）

	A.		构造方法的做用是为建立对象进行初始化工做，好比给成员变量赋值
	B.		一个Java类能够没有构造方法，也能够提供1个或多个构造方法
	C.		构造方法与类同名，不能书写返回值类型
	D.		构造方法的第一条语句若是是super()，则能够省略，该语句做用是调用父类无参数的构造方法
10)	如下关于this和super关键字的说法错误的是（ BD ）。（选择二项）

	A.		this关键字指向当前对象自身，super关键字指向当前对象的直接父类
	B.		在main方法中能够存在this或super关键字，但不能同时存在。
	C.		this和super关键字均可以访问成员属性，成员方法和构造方法
	D.		在一个类的构造方法中能够同时使用this和super来调用其余构造方法
11)	如下选项中可使成员变量m 被函数fun()直接访问的是（ C ）。（选择一项）
	class Test { private int m; public static void fun() { System.out.println(m); } }

	A.		将private int m 改成protected int m
	B.		将private int m 改成 public int m
	C.		将private int m 改成 static int m
	D.		将private int m 改成 int m
12)	Person类和Test类的代码以下所示，则代码中的错误语句是（ C ）。（选择一项）
	public class Person { public String name; public Person(String name) { this.name = name; } } public class Test { public static void main(String[] args) { final Person person = new Person("欧欧"); person.name = "美美"; person = new Person("亚亚"); } }

	A.		final Person person = new Person("欧欧");
	B.		person.name = "美美";
	C.		person = new Person("亚亚");
	D.		没有错误
13)	如下关于异常的代码的执行结果是（ C ）。（选择一项）
	public class Test { public static void main(String args[]) { try { System.out.println("try"); return; } catch(Exception e){ System.out.println("catch"); }finally { System.out.println("finally"); } } }

	A.		try catch finally
	B.		catch finally
	C.		try finally
	D.		try
14)	如下关于String类的代码的执行结果是（ B ）。（选择一项）
	public class Test2 { public static void main(String args[]) { String s1 = new String("bjsxt"); String s2 = new String("bjsxt"); if (s1 == s2) System.out.println("s1 == s2"); if (s1.equals(s2)) System.out.println("s1.equals(s2)"); } }

	A.		s1 == s2
	B.		s1.equals(s2)
	C.		s1 == s2 s1.equals(s2)
	D.		以上都不对
15)	如下关于StringBuffer类的代码的执行结果是（ D ）。（选择一项）
	public class TestStringBuffer { public static void main(String args[]) { StringBuffer a = new StringBuffer("A"); StringBuffer b = new StringBuffer("B"); mb_operate(a, b); System.out.println(a + "." + b); } static void mb_operate(StringBuffer x, StringBuffer y) { x.append(y); y = x; } }

	A.		A.B
	B.		A.A
	C.		AB.AB
	D.		AB.B
16)	如下选项中可以正确建立一个数组的是（ AD ）。（选择二项）

	A.		float []f[] = new float[6][6];
	B.		float f[][] = new float[][];
	C.		float [6][]f = new float[6][6];
	D.		float [][]f = new float[6][];
17)	如下选项中关于int和Integer的说法错误的是（ BD）。（选择二项）

	A.		int是基本数据类型，Integer是int的包装类，是引用数据类型
	B.		int的默认值是0，Integer的默认值也是0
	C.		Integer能够封装了属性和方法提供更多的功能
	D.		Integer i=5;该语句在JDK1.5以后能够正确执行，使用了自动拆箱功能
18)	如下选项中关于Java集合的说法错误的是（ AC ）。（选择二项）

	A.		List接口和Set接口是Collections接口有两个子接口
	B.		List接口中存放的元素具备有序，不惟一的特色
	C.		Set接口中存放的元素具备无序，不惟一的特色
	D.		Map接口存放的是映射信息，每一个元素都是一个键值对
19)	如下代码的执行结果是（B ）。（选择一项）
	Set<String> s=new HashSet<String>(); s.add("abc"); s.add("abc"); s.add("abc"); s.add("abcd"); System.out.println(s.size());

	A.		1
	B.		2
	C.		3
	D.		4
20)	下面集合类中属于非线程安全，且结构采用了哈希表的是（ C ）。（选择一项）

	A.		Vector
	B.		ArrayList
	C.		HashMap
	D.		Hashtable
21)	如下选项中关于以下代码的说法正确的是（ AD）。（选择二项）
	public class TestBuffered { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new FileReader("d:/bjsxt1.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("d:/bjsxt2.txt")); String str = br.readLine(); while(str !=null){ bw.write(str); bw.newLine(); str = br.readLine(); } br.close(); bw.close(); } }

	A.		该类使用字符流实现了文件复制，将d:/bjsxt1.txt复制为d:/bjsxt2.txt
	B.		FileReader和FileWriter是处理流，直接从文件读写数据
	C.		BufferedReader和BufferedWriter是节点流，提供缓冲区功能，提升读写效率
	D.		readLine()能够读取一行数据，返回值是字符串类型，简化了操做
22)	InputStreamReader是转换流，能够将字节流转换成字符流，是字符流与字节流之间的桥梁。它的实现使用的设计模式是（ C ）。（选择一项）

	A.		工厂模式
	B.		装饰模式
	C.		适配器模式
	D.		代理模式
23)	如下选项中能够填写到横线处，让代码正确编译和运行的是（ A ）。（选择一项）
	public class Test implements Runnable { public static void main(String[] args) { ___________________________________ t.start(); System.out.println("main"); } public void run() { System.out.println("thread1!"); } }

	A.		Thread t = new Thread(new Test());
	B.		Test t = new Test();
	C.		Thread t = new Test();
	D.		Thread t = new Thread();
24)	在多个线程访问同一个资源时，可使用（ A ）关键字来实现线程同步，保证对资源安全访问。（选择一项）

	A.		synchronized
	B.		transient
	C.		static
	D.		yield
25)	如下说法中关于UDP协议的说法正确的是（ AD ）。（选择二项）

	A.		发送无论对方是否准备好，接收方收到也不确认
	B.		面向链接
	C.		占用系统资源多、效率低
	D.		很是简单的协议，能够广播发送

3、 判断题（共20个题目，总计10分）

一个Java源文件中能够定义多个类，可是至多只能有一个public类。(T )
Java的字节码文件的扩展名是class，是一种平台独立的非二进制文件。( F )
^ 是异或位运算符，运算规则是若是两个操做数相同，结果是0，不然结果是1。( T )
赋值运算符优先级别低于条件运算符，条件运算符优先级别低于算术运算符。( T )
switch选择语句是多分支选择语句，只能处理等值条件判断的状况，表达式能够是int类型、char类型，但不能是double,float类型。( T )
在多重循环中，外层循环变量变化一遍，内层循环变量要变化一次。( F )
程序调用自身的编程技巧称为递归。递归的特色是编程简单而且节省内存。( F )
类能够当作一类对象的模板，对象能够当作该类的一个具体实例。( T )
使用public修饰的成员属性和方法能够被当前项目中全部包的全部类访问。( T )
将子类对象赋给父类引用变量，称为向下转型，将没法访问子类特有的方法。( F )
继承是多态的基础，没有继承就没有多态。( T )
内部类做为外部类成员，权限修饰符和其余成员同样，可声明为private、默认、protected或public。( T )
对于物理链接，好比数据库链接、输入流输出流、Socket链接等，垃圾回收机制无能为力，必须手动关闭才能够。( T )
数组和集合中的元素能够是任何数据类型，包括基本类型和引用类型。( F )
加强的for循环能够遍历数组和集合，语法简单不须要知道数组的长度，不能实现与下标相关的操做。( T )
LinkedHashMap是一种有序的HashMap，查询速度快，便于进行添加删除操做。( T )
Collection类是专门用来操做集合的工具类，提供一系列静态方法实现对各类集合的操做。( F )

Collection是接口类型，存放单值的最大接口；
Collections是操做集合的工具类，就像数组同样，Arrays类是数组工具类。

一个File对象能够表明一个文件或目录，它能够获取文件和目录属性，也能够访问文件内容。F )
进程是线程Thread内部的一个执行单元，它是程序中一个单一顺序控制流程。( F )
Socket是传输层供给应用层的编程接口，是应用层与传输层之间的桥梁。( T )

4、 简答题（共5个题目，总计25分）

方法重载和方法重写（覆盖）的区别。（4分）

	英文	位置不一样	修饰符	返回值	方法名	参数	抛出异常	方法体
重载	overload	同一个类中	无关	无关	相同	不一样	无关	不一样
重写	override	子类和父类间	大于等于	小于等于	相同	相同	小于等于	不一样

　　　　答：

　　　　（1）相同点：

　　　　①方法名称相同。

　　　　②都属于多态机制。

　　　　（2不一样点：位置、参数列表、权限修饰符、返回值类型、抛出异常不一样。

　　　　重载(overload)：发生在同一个类中，方法名相同，参数列表不一样，与权限修饰、返回值类型、抛出异常无关。

　　　　重写(override): 发生在继承类中，方法名和参数列表相同，权限修饰符大于等于父类、返回值类型小于等于父类、抛出异常小于等于父类。

写出java.lang.Object类的六个经常使用方法的声明并说明其做用。（6分）

　　　　1) public boolean equals(java.lang.Object) 比较内容

　　　　2) public native int hashCode() 哈希码

　　　　3) public java.lang.String toString() 变成字符串

　　　　4) public final native java.lang.Class getClass() 获取类结构信息

　　　　5) protected void finalize() throws java.lang.Throwable 垃圾回收前执行的方法

　　　　6) protected native Object clone() throws java.lang.CloneNotSupportedException 克隆

　　　　7) public final void wait() throws java.lang.InterruptedException 多线程中等待功能

　　　　8) public final native void notify() 多线程中唤醒功能

　　　　9) public final native void notifyAll() 多线程中唤醒全部等待线程的功能

接口和抽象类的联系和区别。（5分）

　　　　相同点

抽象类和接口均包含抽象方法，类必须实现全部的抽象方法，不然是抽象类
抽象类和接口都不能实例化，他们位于继承树的顶端，被其余类继承和实现

　　　　二者的区别主要体如今两方面：语法方面和设计理念方面

　　　　语法方面的区别是比较低层次的，非本质的，主要表如今：（2分）

接口中只能定义全局静态常量，不能定义变量。抽象类中能够定义常量和变量。
接口中全部的方法都是全局抽象方法。抽象类中能够有0个、1个或多个，甚至所有都是抽象方法。
抽象类中能够有构造方法，但不能用来实例化，而在子类实例化时执行，完成属于抽象类的初始化操做。接口中不能定义构造方法。
一个类只能有一个直接父类（能够是抽象类），但能够充实实现多个接口。一个类使用extends来继承抽象类，使用implements来实现接口。

　　　　两者的主要区别在设计理念上，决定了某些状况下使用抽象类仍是接口。（2分）

抽象类体现了一种继承关系，目的是复用代码，抽象类定义了各个子类的相同代码，可认为父类是一个实现了部分功能的“中间产品”，而子类是“最终产品”。父类和子类间须存在“is-a”关系，即父类和子类在概念本质上是相同的。

　　　　接口并不要求实现类和接口在概念本质上一致，仅仅是实现了接口定义的约定或能力而已。接口定义了“作什么”，实现类负责完成“怎么作”，体现了功能（规范）和实现分离的原则。接口和实现之间能够认为是一种“has-a的关系

　　　　一、抽象类和接口都不能直接实例化，若是要实例化，抽象类变量必须指向实现全部抽象方法的子类对象，接口变量必须指向实现全部接口方法的类对象。

　　　　二、抽象类要被子类继承，接口要被类实现。

　　　　三、接口只能作方法申明，抽象类中能够作方法申明，也能够作方法实现

　　　　四、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

　　　　五、抽象类里的抽象方法必须所有被子类所实现，若是子类不能所有实现父类抽象方法，那么该子类只能是抽象类。一样，一个实现接口的时候，如不能所有实现接口方法，那么该类也只能为抽象类。

　　　　六、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果

　　　　七、抽象类里能够没有抽象方法

　　　　八、若是一个类里有抽象方法，那么这个类只能是抽象类

　　　　九、抽象方法要被实现，因此不能是静态的，也不能是私有的。

　　　　十、接口可继承接口，并可多继承接口，但类只能单根继承。

Vector和ArrayList、ArrayList和LinkedList的区别和联系。（6分）

　　　　Vector和ArrayList的区别和联系

　　　　实现原理相同，功能相同，都是长度可变的数组结构，不少状况下能够互用（1分）

　　　　二者的主要区别以下

Vector是早期JDK接口，ArrayList是替代Vector的新接口（0.5分）
Vector线程安全，ArrayList重速度轻安全，线程非安全（1分）
3. 长度需增加时，Vector默认增加一倍，ArrayList增加50%（0.5分）

　　　　ArrayList和LinkedList的区别和联系

　　　　ArrayList和LinkedList都是List的实现类，元素具备有序，不惟一特色。（1分）

　　　　ArrayList实现了长度可变的数组，在内存中分配连续空间。遍历元素和随机访问元素的效率比较高；（1分）

　　　　LinkedList采用链表存储方式。插入、删除元素时效率比较高（1分）

面向对象设计原则有哪些。（4分）

　　　　面向对象设计原则是面向对象设计的基石，面向对象设计质量的依据和保障，设计模式是面向对象设计原则的经典应用

单一职责原则SRP
开闭原则OCP
里氏替代原则LSP
依赖注入原则DIP
接口分离原则ISP
迪米特原则LOD
组合/聚合复用原则CARP

开闭原则具备理想主义的色彩，它是面向对象设计的终极目标。其余设计原则均可以看做是开闭原则的实现手段或方法。

  1 1、    编码题（共3个题目，总计20分）
  2 1.    写出饿汉式单例模式、懒汉式单例模式、多线程状况下懒汉式双重判断单例模式的示例代码。（7分）
  3 
  4 public class Student_1 {
  5     //饿汉式
  6     private static Student_1 student = new Student_1();
  7 
  8     public static Student_1 newInstance() {
  9         return student;
 10     }
 11 
 12     public Student_1() {
 13         System.out.println("饿汉式建立对象");
 14     }
 15 
 16 }
 17 
 18 class Student_2 {
 19     //懒汉式
 20     private static Student_2 student2;
 21 
 22     static Student_2 newInstance2() {
 23     //提升效率，若是第一次建立对象成功，后面就不用进入同步当中，直接返回对象便可
 24         if (student2 == null) {
 25             synchronized (Student_1.class) {
 26                 //若是是第一次调用方法，进入if，建立对象
 27                 if (student2 == null) {
 28                     student2 = new Student_2();
 29                 }
 30             }
 31         }
 32         return student2;
 33     }
 34 
 35     public Student_2() {
 36         System.out.println("懒汉式双重检验建立对象");
 37     }
 38     
 39 }
 40 public class Danli_1 {
 41   
 42     public static void main(String[] args) {
 43         Student_1 s =Student_1.newInstance();
 44         
 45         Student_2 s2 =Student_2.newInstance2();
 46         
 47     }
 48 }
 49 
 50 2.    写出使用JDBC访问数据库表t_student中全部数据，并将结果集内容封装成List返回的代码。（6分）
 51 1)    数据库表已经建立，表名称及字段信息以下
 52 表名    t_student    中文表名称    学生信息表
 53 序号    字段名称    字段说明    类型    长度    备注
 54 1    id    学生编号    number    6    主键
 55 2    name    学生姓名    varchar2    8    非空
 56 3    age    学生年龄    number    3    非空
 57 4    score    学生分数    number    5,1    非空
 58 5    enterdate    入学时间    date        非空
 59 2)    实体类Student已经提供，和数据库表字段对应，有id,name,age,score,enterDate五个属性及相应的getter和setter方法，提供了各类参数的构造方法。
 60 3)    使用JDBC访问数据库四个链接参数分别为
 61 a)    driver:oracle.jdbc.driver.OracleDriver
 62 b)    url:jdbc:oracle:thin:@localhost:1521:orcl
 63 c)    username:bjsxt
 64 d)    password:bjsxt                
 65 4)    方法的声明为public List<Student> findAll(){ }，在方法体中书写JDBC代码完成功能便可。
 66 3.    使用TCP网络编程完成用户登陆功能：客户端输入用户名和密码，向服务器发出登陆请求；服务器接收数据并进行判断，若是用户名和密码均是bjsxt，则登陆成功，不然登陆失败，返回相应响应信息；客户端接收响应信息并输出登陆结果。（7分）
 67 1)    用户User类已提供构造方法 public User(String username,String password)。
 68 2)    客户端采用ObjectOutputStream发送封装了用户名和密码的User对象。
 69 3)    服务器端和客户端的类名和方法声明以下所示。
 70 
 71 import java.io.BufferedReader;
 72 import java.io.BufferedWriter;
 73 import java.io.IOException;
 74 import java.io.InputStreamReader;
 75 import java.io.OutputStreamWriter;
 76 import java.net.Socket;
 77 import java.util.Scanner;
 78 
 79 public class UserClint_3 {
 80     static Scanner sc = new Scanner(System.in);
 81     public static void main(String[] args) throws IOException {
 82         //1.建立客户端套接字
 83         Socket s = new Socket("localhost", 152);
 84         //2.建立客户端输出流
 85         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
 86         //3.用户输入用户和密码，并写入输出流
 87         System.out.println("请输入用户名：");
 88         String user = sc.nextLine();
 89         System.out.println("请输入用户密码：");
 90         String password = sc.nextLine();
 91         bw.write(user);
 92         bw.flush();
 93         bw.newLine();
 94         bw.write(password);
 95         bw.flush();
 96         
 97         //4.通知服务端客户端用户信息写入完毕
 98         s.shutdownOutput();
 99         
100         //5.建立输入流来接受服务端响应的信息
101         BufferedReader br=  new BufferedReader(new InputStreamReader(s.getInputStream()));
102         String info = br.readLine();
103         //6.输出响应信息
104         System.out.println(info);
105         //7.关闭套接字
106         s.close();
107     }
108 }
109 
110 import java.io.BufferedReader;
111 import java.io.BufferedWriter;
112 import java.io.FileInputStream;
113 import java.io.IOException;
114 import java.io.InputStreamReader;
115 import java.io.OutputStreamWriter;
116 import java.net.ServerSocket;
117 import java.net.Socket;
118 import java.util.HashMap;
119 import java.util.Map;
120 import java.util.Properties;
121 
122 public class UserServer_3 {
123     public static Map<String, String> User() throws  IOException{
124         //将用户信息存放在User.properties文件中
125         //建立properties类获取用户信息
126         Properties p = new Properties();
127         //经过load()方法读取用户信息
128         p.load(new FileInputStream("User.Properties"));
129         //经过getProperty()方法获取用户信息的键，获得用户信息的值
130         String user = p.getProperty("username");
131         String pwd = p.getProperty("pwd");
132         
133         //建立map集合，将用户信息的键以及对应的值放入集合中
134         Map<String, String> map = new HashMap<>();
135         map.put("username", user);
136         map.put("pwd", pwd);
137         return map;
138     }
139     public static void main(String[] args) throws IOException {
140         //1.建立服务器端套接字
141         ServerSocket ss = new ServerSocket(152);
142         //2.监听客户端套接字
143         Socket s = ss.accept();
144         //3.建立输入流用来读取客户端发送的用户信息
145         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
146         //4.读取客户端发送的用户信息
147         String username = br.readLine();
148         String password = br.readLine();
149         
150         //5.调用map集合，拿到map集合里面的用户信息和客户端发送的信息进行比对
151         Map<String, String> map = User();
152         //6.建立输出流用来响应客户端
153         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
154         //7.进行信息比对
155         if(map.get("username").equals(username)&&map.get("pwd").equals(password)){
156             //8.写入响应信息
157             bw.write("恭喜您，登陆成功！");
158             bw.flush();
159         }else{
160             bw.write("登陆失败，用户或用户密码错误！");
161             bw.flush();
162         }
163         //9.关闭客户端套接字
164         s.close();
165     }
166 }

Java 初级软件工程师 认证考试试卷1

Java 初级软件工程师认证考试试卷1