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

Java 初级软件工程师

认证考试试卷

 

笔试（A卷）

 

考试时间150分钟

总分 100分

 

 

姓    名_______________________

身份证号_______________________

 

 

考试结束后考卷必须收回，否则考试成绩无效

 

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

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

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

二、   
选择题（共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.		非常简单的协议，可以广播发送

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

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

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

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

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

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

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

　　　　答：

　　　　（1）相同点：

　　　　①方法名称相同。

　　　　②都属于多态机制。

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

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

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

1. 写出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() 多线程中唤醒所有等待线程的功能

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

　　　　相同点

• 抽象类和接口均包含抽象方法，类必须实现所有的抽象方法，否则是抽象类
• 抽象类和接口都不能实例化，他们位于继承树的顶端，被其他类继承和实现

　　　　两者的区别主要体现在两方面：语法方面和设计理念方面

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

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

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

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

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

　　　　1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

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

　　　　3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

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

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

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

　　　　7、抽象类里可以没有抽象方法

　　　　8、如果一个类里有抽象方法，那么这个类只能是抽象类

　　　　9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

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

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

　　　　Vector和ArrayList的区别和联系

　　　　实现原理相同，功能相同，都是长度可变的数组结构，很多情况下可以互用（1分）

　　　　两者的主要区别如下

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

　　　　ArrayList和LinkedList的区别和联系

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

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

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

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

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

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

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

 一、    编码题（共3个题目，总计20分）
 1.    写出饿汉式单例模式、懒汉式单例模式、多线程情况下懒汉式双重判断单例模式的示例代码。（7分）

 public class Student_1 {
     //饿汉式
     private static Student_1 student = new Student_1();

     public static Student_1 newInstance() {
         return student;
     }

     public Student_1() {
         System.out.println("饿汉式创建对象");
     }

 }

 class Student_2 {
     //懒汉式
     private static Student_2 student2;

     static Student_2 newInstance2() {
     //提高效率，如果第一次创建对象成功，后面就不用进入同步当中，直接返回对象即可
         if (student2 == null) {
             synchronized (Student_1.class) {
                 //如果是第一次调用方法，进入if，创建对象
                 if (student2 == null) {
                     student2 = new Student_2();
                 }
             }
         }
         return student2;
     }

     public Student_2() {
         System.out.println("懒汉式双重检验创建对象");
     }

 }
 public class Danli_1 {

     public static void main(String[] args) {
         Student_1 s =Student_1.newInstance();

         Student_2 s2 =Student_2.newInstance2();

     }
 }

 2.    写出使用JDBC访问数据库表t_student中所有数据，并将结果集内容封装成List返回的代码。（6分）
 1)    数据库表已经创建，表名称及字段信息如下
 表名    t_student    中文表名称    学生信息表
 序号    字段名称    字段说明    类型    长度    备注
 1    id    学生编号    number    6    主键
 2    name    学生姓名    varchar2    8    非空
 3    age    学生年龄    number    3    非空
 4    score    学生分数    number    5,1    非空
 5    enterdate    入学时间    date        非空
 2)    实体类Student已经提供，和数据库表字段对应，有id,name,age,score,enterDate五个属性及相应的getter和setter方法，提供了各种参数的构造方法。
 3)    使用JDBC访问数据库四个连接参数分别为
 a)    driver:oracle.jdbc.driver.OracleDriver
 b)    url:jdbc:oracle:thin:@localhost:1521:orcl
 c)    username:bjsxt
 d)    password:bjsxt
 4)    方法的声明为public List<Student> findAll(){ }，在方法体中书写JDBC代码完成功能即可。
 3.    使用TCP网络编程完成用户登录功能：客户端输入用户名和密码，向服务器发出登录请求；服务器接收数据并进行判断，如果用户名和密码均是bjsxt，则登录成功，否则登录失败，返回相应响应信息；客户端接收响应信息并输出登录结果。（7分）
 1)    用户User类已提供构造方法 public User(String username,String password)。
 2)    客户端采用ObjectOutputStream发送封装了用户名和密码的User对象。
 3)    服务器端和客户端的类名和方法声明如下所示。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.Socket;
 import java.util.Scanner;

 public class UserClint_3 {
     static Scanner sc = new Scanner(System.in);
     public static void main(String[] args) throws IOException {
         //1.创建客户端套接字
         Socket s = new Socket("localhost", 152);
         //2.创建客户端输出流
         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
         //3.用户输入用户和密码，并写入输出流
         System.out.println("请输入用户名：");
         String user = sc.nextLine();
         System.out.println("请输入用户密码：");
         String password = sc.nextLine();
         bw.write(user);
         bw.flush();
         bw.newLine();
         bw.write(password);
         bw.flush();

         //4.通知服务端客户端用户信息写入完毕
         s.shutdownOutput();

         //5.创建输入流来接受服务端响应的信息
         BufferedReader br=  new BufferedReader(new InputStreamReader(s.getInputStream()));
         String info = br.readLine();
         //6.输出响应信息
         System.out.println(info);
         //7.关闭套接字
         s.close();
     }
 }

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Properties;

 public class UserServer_3 {
     public static Map<String, String> User() throws  IOException{
         //将用户信息存放在User.properties文件中
         //创建properties类获取用户信息
         Properties p = new Properties();
         //通过load()方法读取用户信息
         p.load(new FileInputStream("User.Properties"));
         //通过getProperty()方法获取用户信息的键，得到用户信息的值
         String user = p.getProperty("username");
         String pwd = p.getProperty("pwd");

         //创建map集合，将用户信息的键以及对应的值放入集合中
         Map<String, String> map = new HashMap<>();
         map.put("username", user);
         map.put("pwd", pwd);
         return map;
     }
     public static void main(String[] args) throws IOException {
         //1.创建服务器端套接字
         ServerSocket ss = new ServerSocket(152);
         //2.监听客户端套接字
         Socket s = ss.accept();
         //3.创建输入流用来读取客户端发送的用户信息
         BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
         //4.读取客户端发送的用户信息
         String username = br.readLine();
         String password = br.readLine();

         //5.调用map集合，拿到map集合里面的用户信息和客户端发送的信息进行比对
         Map<String, String> map = User();
         //6.创建输出流用来响应客户端
         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
         //7.进行信息比对
         if(map.get("username").equals(username)&&map.get("pwd").equals(password)){
             //8.写入响应信息
             bw.write("恭喜您，登录成功！");
             bw.flush();
         }else{
             bw.write("登录失败，用户或用户密码错误！");
             bw.flush();
         }
         //9.关闭客户端套接字
         s.close();
     }
 }