java 进阶篇期末考试复习题总结

一.填空

1.（中）迭代器Iterator为集合而生，专门实现集合遍历，该接口有三个方法，分别是____、____、____

hasNext() next() remove()

2. （易）抽象方法只能定义在________中，抽象类和抽象方法必须由关键字________修饰

抽象类 abstract

3. （中）使用关键字________来定义一个接口，接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字________。

Interface implements

4.（中）在java网络通信中服务器端创建________对象，调用________方法来监听端口，当有客户端连接服务器时返回________对象。

ServerSocket accept Socket

5. （中）在java中使用_______关键字来表示继承关系，所有类都是________类的子类。

extends

6. （难）多态存在的三个必要条件一______________、二______________、三______________。

要有继承要有重写父类引用指向子类对象。

7. （难） Java中多态的实现方式______________、______________、______________。

接口实现，继承父类进行方法重写，同一个类中进行方法重载。

8. （中）java中子类能够继承父类的_______和_______成员变量和成员方法，不能够继承父类的_______成员变量和成员方法。

public protected private

9. （中）子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量需要使用_______关键字来进行引用。

super

10. （易）拥有抽象方法的类就是抽象类，抽象类要使用_______关键字声明。抽象方法_______（一定/不一定）要有抽象类。

abstract 不一定

11.（易）一个类实现这个接口必须实现这个接口中定义的_______的抽象方法，一个类可以实现_______接口。

所有多个

12. （中）Throwable类有两个子类: __________类和__________类。

Exception Error

13. （中）在实现多线程的程序时有两种方式，一是通过继承_______类，二是通过实现________接口。

Thread Runnable

14.（易） __________协议是不可靠传输，__________协议是可靠传输。

UDP TCP

15. （中）FileInputStream 是__________流，BufferedWriter 是__________流，ObjectOutputStream 是__________流。

字节字符对象

16. （难）抽象方法不能使用修饰符__________和__________修饰。

final static

17. （易）多种异常处理是通过在一个__________块后声明若干个__________语句（块）来实现的，无论出不出现异常 __________语句（块）都会执行。

try catch finally

18. （难）算术运算异常、下表数组越界异常类都源于__________这个父类

Exception

19. （易）面向对象程序设计的三个基本特征分别是__________、__________、__________。

封装继承多态

20.（易） __________方法用于定义线程的执行体.___________方法用于启动线程。

run（） start（）

二.单选

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

A. sleep是线程类（Thread）的方法，wait是Object类的方法；

B. sleep不释放对象锁，wait放弃对象锁；

C. sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；

D. wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态。

public interface Flyable {

float hight = 10;

}

下面哪一项与以上接口中的第二行不等价？（B）(中)

A．final float hight = 10;

B．private float hight = 10;

C．static float hight =10;

D．public float hight = 10;

提供Java存取数据库能力的包是（A）(中)

A．java.sql

B．java.awt

C．java.lang

D．java.swing

能用来修饰interface的有（B）(易)

A．private

B．public

C．protected

D．static

下列说法正确的有（B）(难)

在类方法中可用this来调用本类的类方法

B．在类方法中调用本类的类方法时可直接调用

C．在类方法中只能调用本类中的类方法

D．在类方法中绝对不能调用实例方法

下面那几个函数是public void method(){̷}的重载函数？（A）(易)

A.public void method( int m){̷}

B.public int method(){̷}

C.public void method2(){̷}

D.public int method(int m，float f ){̷}

有关线程的哪些叙述是错的（C ）(难)

A方法resume()负责恢复，通过调用suspend()方法而停止的线程。

B使用start()方法可以使一个线程成为可运行的，但是它不一定立即开始运行。

C当一个线程因为抢先机制而停止运行，它被放在可运行队列的后面。

D一个线程可能因为不同的原因停止并进入就绪状态。

请问下列类哪些不是定义在java.io包中的抽象类？（C）(易)

A OutputStream

B Reader

C FileOutputStream

D Writer

关于Java语言，下列描述正确的是（C）（中）

List可以通过delete(int index)方法删除某一元素

B. List， Set， Map都继承自Collection接口

C.Set允许包含null元素，不可以重复

D.数组和集合中的元素可以是任何数据类型，包括基本类型和引用类型

10.

关于异常(Exception)，下列描述错误的是(D)(中)

A. 异常的基类为Exception，所有异常都必须直接或者间接继承它

B. 异常可以用try{ . . .}catch(Exception e){ . . .}来捕获并进行处理

C. 如果某异常继承RuntimeException，则该异常可以不被声明

D. 异常可以随便处理，而不是抛给外层的程序进行处理

11.

类 Teacher 和 Student 是类 Person 的子类;

Teacher t;

Student s;

// t and s are all non-null.

if (t instanceof Person ){ s=(Student)t; }

最后一条语句的结果是:（D）(中)

A．将构造一个Student 对象;

B．表达式是合法的；

C．表达式是错误的；

D．编译时正确，但运行时错误。

12.

关于线程设计，下列描述正确的是(C)(中)

A. 线程对象必须实现Runnable接口

B. 启动一个线程直接调用线程对象的run()方法

C. Java提供对多线程同步提供语言级的支持

D. 一个线程可以包含多个进程

13.

欲构造ArrayList类得一个实例，此类继承了List接口，下列哪个方法是正确的(B)(中)

A ArrayList myList = new Object();

B List myList = new ArrayList();

C ArraylList myList = new List();

D List myList = new List();

14.

选择下面代码的运行结果：（C）(易)

public class Test{

public void method()

{

for(int i = ; i < 3; i++)

{

System.out.print(i);

}

System.out.print(i);

}

A．122

B．123

C．编译错误

D．没有任何输出

15.

下列说法正确的有（C）(中)

A． class中的constructor不可省略

B． constructor必须与class同名，但方法不能与class同名

C． constructor在一个对象被new时执行

D．一个class只能定义一个constructor

16.

栈是一种（A）(中)

A 存取受限的线性结构

B 存取不受限的线性结构

C 存取受限的非线性结构

D 存取不受限的非线性结构

17.

下列哪些语句关于内存回收的说明是正确的（B）(中)

A程序员必须创建一个线程来释放内存

B内存回收程序负责释放无用内存

C内存回收程序允许程序员直接释放内存

D内存回收程序可以在指定的时间释放内存对象

18.

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

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

B. String类是final类故可以继承；

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

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

19.

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

A. Java支持多重继承，一个类可以实现多个接口；

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

C. Java只支持单重继承，一个类只可以实现一个接口；

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

20.

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

A. interface中可以有private方法

B. interface中可以有final方法

C. interface中可以有function实现

D. interface可以继承其他interface

三.程序填空

看程序写结果

(1)

Public class StringTest1 {

public static void main(String[] args) {

String s1="hello";

String s2=new String("hello");

if(s1.equals(s2)){

System.out.println("相等");

}else{

System.out.println("不相等");

}

答案：相等

（2）

public class Father {

String name, address, tel;

int age;

public Father(String name, int age) {

this.name = name;

this.age = age;

}

void out() {

System.out.print("姓名:" + name);

System.out.print(" 年龄:" + age);

}

void outOther() {

System.out.print(" 家庭住址:" + address);

System.out.print(" 电话:" + tel);

}

class Son extends Father{
      String school;
      public son(String name, int age){
                 super(name, age);

}
      void out(){
         super.out();
         super.outOther()();
         System.out.println(" 学校:" + school);

}

public static void main(String[] args) {

Son son=new Son(“Tom”,15);

son.address(“金水区”);

son.school(“九中”);

son.tel(“66123456”);

son.out();

}

答案:姓名:Tom 年龄:15 家庭住址:金水区电话:66123456 学校: 九中

（3）class One{
synchronized void display(int num) {

System.out.println("two " + num);

try {

Thread.sleep(1000)

}catch((InterruptedException e) {

System.out.println(”中断”);

}

System.out.println(” 完成”);

}

class Two implements Runnable {

int number;

One one ;

Thread t;
public Two (0ne one_num,int n){

one=one_num;

number = n;

t = new Thread(this);

t.start();

}

public void run(){

one.display(number);

}

public class Synch {

public static void main(String args[]) throws InterruptedException {

One one = new One();

int digit = 100;

Two s1 = new Two(one,digit);

Two s2 = new Two(one,digit);

Two s3 = new Two(one,digit);

Two s4 = new Two(one,digit);

s1.t.join();

S2.t.join();

S3.t.join();

S4.t.join();

System.out.println("Synch结束!");

}

答案：two 100

完成

two 100

完成

two 100

完成

two 100

完成

Synch结束!

(4) public class Test{

public static void main(String[] args) {

List<String> list = new ArrayList<String>();

list.add("str1");

list.add(2, "str2");

String s = list.get(1);

System.out.println(s);

}

答案：运行时出现异常

(5) public class Text {

public static void main(String[] args) {

ArrayList<String> list = new ArrayList<String>();

list.add("java");

list.add("aaa");

list.add("java");

list.add("bbb");

list.remove("java");

Iterator it=list.iterator();

while(it.hasNext()) {

System.out.print(it.next()+" ");

}

答案:aaa java java bbb

(6)class cT implements Runnable{

@Override

public void run() {

// TODO Auto-generated method stub

while(true) {

System.out.println("土豆炖牛肉.....");

System.out.println("小笼包子.....");

System.out.println("西红柿鸡蛋面....");

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

class MT implements Runnable{

@Override

public void run() {

Thread ct=new Thread(new cT());

ct.setDaemon(true);

ct.start();

try {

Thread.sleep(1500);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

public class z12 {

public static void main(String[] args) {

// TODO Auto-generated method stub

Thread mt=new Thread(new MT());

mt.start();

}

答案：土豆炖牛肉.....

小笼包子.....

西红柿鸡蛋面....

土豆炖牛肉.....

小笼包子.....

西红柿鸡蛋面....

（6）class Animal {

Animal() {

System.out.print ("Animal ");

}

public class Dog extends Animal{

Dog() {

System.out.print ("Dog ”);

}

public static void main(String[] args){

Dog snoppy= new Dog();

}

答案：Animal Dog

（7）public class Father{

int a=100;

public void miner(){

}

class Son extends Father{

int a = 0;

public void plus(){

a++;

}

public int getA() {

return super.a;

}

public static void main(String[] args){

Father x = new Father();

Son y = new Son();

System.out.println(y.a);

System.out.println(y.getA());

y.miner();

System.out.println(y.a);

System.out.println(y.getA());

}

答案: 0

100

（8）public class Example{

String str=new String("good");

char[]ch={'a','b','c'};

public static void main(String args[]){

Example ex=new Example();

ex.change(ex.str,ex.ch);

System.out.print(ex.str+" and ");

Sytem.out.print(ex.ch);

}

public void change(String str,char ch[]){

str="test ok";

ch[0]='g';

}

答案:good and gbc

（9）class A{

class Dog{

private String name;

private int age;

public int step;

Dog(String s,int a) {

name=s;

age=a;

step=0;

}

public void run(Dog fast) {

fast.step++;

}

public static void main (String args[]) {

A a=new A();

Dog d=a.new Dog("Tom",3);

d.step=25;

d.run(d);

System.out.println(d.step);

}

答案:26

(11)

public class A{

public int hashCode(){

return 1；

}

public Boolean equals(Object b){

return true;

}

public static void main(String args[]){

Set set=new HashSet()；

set.add(new A());

System.out.println(set.size());

}

答案：1

(12)import java.io.*;

public class abc {

public static void main(String args [ ]) {

AB s = new AB("Hello!","I love JAVA."); System.out.println(s.toString( ));

}

class AB {

String s1;

String s2;

public AB(String str1, String str2) {

s1 = str1;

s2 = str2;

}

public String toString( ){

return s1+s2;

}

答案:Hello! I love JAVA.

（13）public class Tom {

private float weight;

private static String name;

public void setWeight(float weight) {

this.weight = weight;

}

private void out() {

System.out.println(name + "体重：" + weight + "斤");

}

public static void main(String[] args) {

Tom.name = "汤姆猫";

Tom cat = new Tom();

cat.setWeight(20);

cat.out();

}

答案:汤姆猫体重：20.0斤

（14）public class abc {

public static void main(String args[ ]){

System.out.println("a="+a+"\nb="+b);

}

class SubClass extends SuperClass{

int c;

SubClass(int aa, int bb, int cc) {

super(aa, bb);

c=cc;

}

class SubSubClass extends SubClass{

int a;

SubSubClass(int aa, int bb, int cc){

super(aa, bb, cc);

A = aa+bb+cc;

}

void show(){ System.out.println("a="+a+"\nb="+b+"\nc="+c);

}

答案：a=60

b=20

c=30

（15）import java.io.* ;

public class abc{

public static void main(String args[ ]){

int i, s = 0 ;

int a[ ] = { 10,20,30,40,50,60,70,80,90 }; for ( i = 0 ; i < a.length ; i ++ ) if ( a[i]%3 = = 0 ) s += a[i] ; System.out.println("s="+s);

}

答案:s=180

（16）public class TestArray {

public static void main(String args[ ]){

int i , j ;

int a[ ] = { 5,9,6,8,7};

for ( i = 0 ; i < a.length-1; i ++ ) {

int k = i;

for ( j = i ; j < a.length ; j++ )

if ( a[j]<a[k] )

k = j;

int temp =a[i];

a[i] = a[k];

a[k] = temp;

}

for ( i =0 ; i<a.length; i++ )

System.out.print(a[i]+" "); System.out.println( );

}

答案： 5 6 7 8 9

(17)public class Person {

String name;

int age;

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public static void main(String[] args) {

Person c = new Person("Peter", 17);

System.out.println(c.name + " is " + c.age + " years old!");

}

答案：Peter is 17 years old!

(18)public class Course {

private String cNumber;

private String cName;

private int cUnit;

public Course(String number, String name, int unit) {

cNumber = number;

cName = name;

cUnit = unit;

}

public void printCourseInfo(){

System.out.println("课程号:" + cNumber + " 课程名:" + cName + " 学分:" + cUnit);

}

class CourseTest {

public static void main(String[] args) {

Course c;

c = new Course("101", "ASP", 3);

c.printCourseInfo();

}

答案：课程号:101 课程名:ASP 学分:3

(19)public class MyClass {

int a[] = { 1, 2, 3, 4, 5 };

void out() {

for (int j = 0; j < a.length; j++)

System.out.print(a[j] + "");

}

public static void main(String[] args) {

MyClass my = new MyClass();

my.out();

}

答案：12345

(20)import java.io.*;

public class Test {

public static void main(String args[]) throws IOException { BufferedReader buf=new BufferedReader(newInputStreamReader(System.in)); while(true) {

String str=buf.readLine(); if(str.equals("quit"))

break;

int x=Integer.parseInt(str); System.out.println(x*x);

}

当输入5时，结果__25___;当输入quit时，结果__终止应用程序___;

中等题：1.ArrayList的初始化内容如下：

ArrayList<String> list = new ArrayList<String>();

list.add("java");

list.add("aaa");

list.add("java");

list.add("bbb");

____________________________//添加循环条件，实现删除所有”java”

{

if ("java".equals(list.get(i)))

{

list.remove(i);

}

答案：for (int i = list.size() - 1; i >= 0; i--)

中等题；2.public class ObjectOutputStreamDemo {

public static void main(String[] args) {

// TODO Auto-generated method stub

ArrayList<Student> list = new ArrayList<Student>();

list.add(new Student("student1",21));

list.add(new Student("student2",21));

list.add(new Student("student3",21));

list.add(new Student("student4",21));

list.add(new Student("student5",21));

list.add(new Student("student6",21));

File file=new File("student.txt");

FileOutputStream fos;

try {

fos = new FileOutputStream(file);

ObjectOutputStream oos=new ObjectOutputStream(fos);

if(list!=null&&list.size()>0)

{

for(int i=0;i<list.size();i++) {

_______________________//将list集合中的对象写入"student.txt"文件中

}

oos.close();

} catch (FileNotFoundException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

答案：oos.writeObject(list.get(i));

中等题：3. import java.io.IOException;

import java.net.DatagramPacket;

import java.net.DatagramSocket;

import java.net.InetAddress;

import java.net.SocketException;

public class UDPserver {

public static void main(String[] args) {

// TODO Auto-generated method stub

try {

DatagramSocket ds=new DatagramSocket(8888)

System.out.println("****服务器以启动，等待连接");

byte[] a=new byte[1024];

(1)__________________; //创建数据报，用于就接收客户端发送的数据

ds.receive(dp);

String str=new String(a, 0, dp.getLength());

System.out.println("我是服务器，客户端说："+str);

//服务器响应客户端

InetAddress address=dp.getAddress();

int port=dp.getPort();

//发送的字节数组

byte[] a1="欢迎您！".getBytes();

(2)_______________________________;//向客户端发送数据报做出响应

ds.send(dp2);

ds.close();

} catch (SocketException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

答案：（1）DatagramPacket dp=new DatagramPacket(a, a.length);

（2）DatagramPacket dp2=new DatagramPacket(a1, a1.length, address,port);

中等题：3. 补充代码，使程序能够在控制台上打印“汪汪……”。

public interface Animal {

void voice();

}

class Dog __________________________________{

@Override

public void voice() {

System.out.println("汪汪......");

}

public class Test3 {

public static void main(String[] args) {

Animal animal = ___________________________________;

animal.voice();

}

答案：（1）implements Animal

（2）new Dog();

简单题：4.public class Test3{

public static void main(String [ ] args ){

int num1 = 10;

int num2 = 20;

int sum = sum(num1, num2)

System.out.println(“num1和num2的和为”+);

}

(1)___________________________________{ //定义方法头部,完成两个整型数字求和

(2)____________________________//返回两个数字之和

}

答案：1) public static int sum(int num1, int num2)

(2) return num1+num

中等题：5.下面的程序使用BufferedWiter 类在D:Hello.txt文件中写入10万个数并输出所用的时间，请将程序填
写完整。
import java.io.*;public class Ex4 {
public static void main(String[] args) throws lOException{
long t = System.currentTimeMillis();

BufferedWriter fw =new BufferedWriter（__20___）
for (int i=1;<100000;++}{
(21)__ (i +"\n");

fw.close();
t=System.currentTimeMillis()-t;
System.out.printin("Time elapsed: "+t +"ms");

}}
答案: (20) new Filitrfp:/\Hello.txt")
(21) fwwite
中等题：6.下面的程序定义了一个线程TmeThread, 该线程每隔1秒钟输出显示一次当前系统时间，在main方法中使用TimeThread类创建3个新线程，并启动这些线程，请将下面的程序填写完整。

import java.util.*;
class TmeThread implements___ {

(14)public void run() {
while (true) {
Date currentTime = new Date();

try {

__________________(1);//休眠1秒钟
}
catch (Exception e) {System.out.println(e.tostring0)}
System.out.printn(Thread.currentThread(). getName()+": "+currentTime);

}
}
public class Ex2 {
public static void main(StringU] args)

{
Stringl[] names="irst", "second"," third"

};
TimeThread myThread = new TimeThread();

for(int i=0;i<3;++)[
Thread threadObj= new Thread(myThread,names[i]);
(16)_____________

答案：(14) Runnable
(15) Thread sleep(1000)
(16) threadObj.start

四.编程题

简单

1.在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中

import java.io.File;

import java.io.FileOutputStream;

public class Test5 {

/**

 * 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中

 *

 * 程序分析：文件写入，要用到输出流FileOutputStream

 * */

public static void main(String[] args) {

// 向文件D:/Hello.txt，写入内容

File file = new File("D:/Hello.txt");

try {

// 创建输出流

FileOutputStream fos = new FileOutputStream(file);

//把String类型的字符串转化为byte数组的数据保存在输出流中

fos.write("HelloJavaWorld你好世界".getBytes());

fos.flush();//刷新输出流

fos.close();//关闭输出流

} catch (Exception e) {

e.printStackTrace();

}

}

}

2.编写线程，执行先输出A，后相隔一秒再输出B，相隔1秒在输出1秒一共10次。

package One;

public class zz {

public static void main(String[] args) {

you a=new you();

     Thread q=new Thread(a);

     q.start();

}

}

class you implements Runnable{

     int i;

public void run() {

for(i=0;i<10;i++) {

System.out.println("A");

try {

Thread.sleep(1000);

System.out.println("B");

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

中等

3.实现两个文件Filein与 Fileout，并将Filein的内容复制到Fileout下

 package One;

public static void main(String[] args) throws Exception {

    File  Filein = new File("student.txt");

    File  Fileout=new File("123456789.txt");

    FileInputStream ins = new FileInputStream(Filein);

    FileOutputStream out = new FileOutputStream(Fileout);

     byte[] c = new byte[1024];

      int n=0;

      while((n=ins.read(c))!=-1){

            out.write(c, 0, n);

        }

        ins.close();

        out.close();

    }

3.现在一共有20张不同的卡片分别摆在桌子上，两个人，同时选取卡片

请使用线程模拟

public class Routine {

public static void main(String[] args) {

      nam st=new nam();

     Thread u=new Thread(st,"Windows1");

     Thread a=new Thread(st,"Windows2");

     u.start();

     a.start();

     }


}

 class nam implements Runnable{

  private static int i=10;

  Object object=new Object();

public void run() {

synchronized(Thread.currentThread().getName()) {

while(i>0) {

System.out.println(Thread.currentThread().getName()+" "+i--);

}

}

       }

 }

难

4.统计学生姓名与其相关信息放入其中使用集合Collection，然后输出出来

如姓名年龄，身高，体重，电话号码

小明 12 150 60 122222

小红 14 160 75 121434

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class zz {

private static final String Iterator = null;

public static void main(String[] args) throws IOException {

    HashMap<Integer,Student>a=new HashMap<Integer,Student>();

    Student q=new Student(12,160,70,"xiaoming","1234567");

    Student b=new Student(14,170,76,"xiaohong","6757443");

    a.put(1, q);

    a.put(2,b);

    Set<Map.Entry<Integer,Student>>us=a.entrySet();

    Iterator<Map.Entry<Integer,Student>> zz=us.iterator();

    while(zz.hasNext()) {

     System.out.println(zz.next().getValue().toString());

    }

    }

}

class Student{

private int Age;

private int Heat;

private int weight;

private String name;

private String phone;

public Student(int Age,int Heat,int weight,String name,String phone) {

this.Age=Age;

this.Heat=Heat;

this.weight=weight;

this.name=name;

this.phone=phone;

}

public String toString () {

return name+" "+Heat+" "+weight+" "+phone;

}



}

5.编写客户端和服务端的socket程序，客户端向服务端发送字符串” hello”，服务端将收到字符串再传给客户端并打印

package ALLHomewok;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.net.Socket;

import java.util.Scanner;

public class ANetOne {

public static void main(String[] args) throws IOException {

String host="localhost";

int port=8888;

int i,k=0;

String s;

Scanner sc=new Scanner(System.in);

Socket socket=new Socket(host,port);

DataOutputStream out=new DataOutputStream(socket.getOutputStream());

DataInputStream in=new DataInputStream(socket.getInputStream());

System.out.println("请输入相应数据");

s=sc.nextLine();

byte[] a=new byte[1024];

out.write(s.getBytes());

in.read(a);

System.out.print(new String(a));

in.close();

out.close();

socket.close();

}



}

 

package ALLHomewok;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.io.OutputStream;

import java.net.ServerSocket;

import java.net.Socket;

public class NetOne {

public static void main(String[] args) throws IOException {

int port=8888;

ServerSocket server=new ServerSocket(port);

Socket socket=server.accept();

DataOutputStream out=new DataOutputStream(socket.getOutputStream());

        DataInputStream in=new DataInputStream(socket.getInputStream());

        System.out.println("连接成功");

        byte[] b=new byte[1024];

         in.read(b);

        System.out.println(new String(b));

        out.write(b);

        //out.writeBytes(new String(b).toString());

         //out.writeBytes(new String(b));

       /* in.read(b);

         out.write(b);*/

       in.close();

       out.close();

       socket.close();

        server.close();

}

}

五.简答题

1.（中）请举例说明抽象类和接口的区别有哪些?
接口:使用interface关键字，一个类可以实现多个接口: -个类实现接口、必须实现接口里的所有方法:接口里必须是抽象方法。
抽象类:使用的是abstract关键字、一个类只能继承一次。继承抽象类的话、是可以不全部实现他的所有方法的，抽象方法只需声明，无需实现。抽象类可含有非抽象方法。

2.（中）请举例简要说明JAVA语言的继承机制有何特点?
子类可以使用父类中的成员变量和方法，然后也可以添加自己的属性和方法。如果子类没有构造方法，则编译器首先为子类添加一个无参的构造方法，然后调用父类的默认构造方法，如果子类有构造方法，则先调用父类的默认构造方法，再调用子类的构造方法:如果父类中没有默认构造方法，则出错。

3.（难）说出一些常用的类，包，接口，请各举5个

常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer

常用的包：java.lang java.awt java.io java.util java.sql

常用的接口：Remote List Map Document NodeList

4.（易）请简述什么是封装和继承

封装:就是把数据和行为结合起在一个包中,并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段.

继承:通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得.

5.（中）多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

6.（易）Collection 和 Collections的区别。

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

7.（难）说出数据连接池的工作机制是什么?

J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量由配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

8.（中）sleep() 和 wait() 有什么区别?
答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间（休息），把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复，时间到了会继续运行。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

9.（易）什么叫方法的重载?构造方法可以重载吗?
一个类中可以有多个方法具有相同的名称，但这些犯法的参数必须不同，即或者是参数个数不同，或者是参数的类型不同，或者是参数的顺序不同。
构造方法可以重载，而且构造方法的重载是方法中使用频率最高的一种。

10（难）TCP协议和UDP协议有什么区别？

UDP协议是无连接通信协议，所谓的无连接就是指数据的发送端和接收端不建立逻辑连接。由于UDP协议消耗资源小，通信效率高，通常都会用于音频、视频和普通数据的传输。UDP协议在传输数据时不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议。

TCP协议是面向连接的通信协议，即在传输数据前先在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”。

11（中）Socket类和ServerSocket类各有什么作用？

ServerSocket类用于创建服务端程序，通过调用ServerSocket对象的accept()方法，接收来自客户端的请求。

Socket类用于创建客户端程序，当客户端和服务端的两个Socket建立了专线连接后，连接的一端既能向另一端连续写入字节，也能从另一端读取字节。Socket类中定义了getInputStream()方法返回Socket的输入流对象，定义了getOutputStream()方法返回Socket的输出流对象。只要连接的一端向该输出流对象写入了数据，连接的另一端就能从其输入流对象中读取到。

12．（易）什么是多态。

多态意味着一个对象有着多种形态，可以在特定的情况下，表现不同的状态，从而对应着不同的属性和方法。简单的说，多态就是使用父类类型的变量引用子类对象，根据被引用子类对象的特性，程序会得到不同的运行效果。

13.（易）Person类和Test类的代码如下所示，请指出代码中的错误语句并改正

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("亚亚");

}

person.name = "美美";改为person = new Person("美美");

14.（易）请简述final关键字的特点

final修饰的类不能被继承，final修饰的方法不能再被覆盖，一旦你将引用声明作final，你将不能改变这个引用了

15.（中）抽象类和抽象方法有什么特点

一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类。

抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承。

若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象方法。抽象方法可再与public、protected复合使用，但不能与final、private和static复合使用。

抽象方法只有方法声明，不能有方法体。

16.（易）什么是接口？如何定义接口？

接口是用来定义类间多重继承功能的结构。接口声明的语法：

[public] interface 接口名 [extends 父接口名列表]

17（中）Error与Exception有什么区别?

Error(错误)表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题，比如，内存资源不足等，对于这种错误，程序基本无能为力，除了退出运行外别无选择。

Exception(违例)表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。

18.（易）进程和线程的区别是什么？

进程是执行着的应用程序，而线程是进程内部的一个执行序列。一个进程可以有多个线程。线程又叫做轻量级进程。

19.（中）什么是服务端包含(Server Side Include)？

服务端包含(SSI)是一种简单的解释型服务端脚本语言，大多数时候仅用在Web上，用servlet标签嵌入进来。SSI最常用的场景把一个或多个文件包含到Web服务器的一个Web页面中。当浏览器访问Web页面的时候，Web服务器会用对应的servlet产生的文本来替换Web页面中的servlet标签。

20．（中）Java中的HashMap的工作原理是什么？

Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。