名词解释

1.泛型

允许在定义类、方法、接口时，使用类型形参T，并且在声明变量、创建对象、使用方法时，动态指定实际参数类型，称为类型实参。例如：List\,ArrayList\

2.多态

指编译时类型和运行时类型不一致的现象

编译时类型：声明该变量时，使用的对象类型

运行时类型：程序运行时，实际赋予该变量的对象类型

3.阻塞

当前正在执行的线程进入阻塞状态，允许其他线程获得执行的机会

当阻塞的线程，在sleep时间到、IO方法返回、获得对象锁、收到notify、resume的条件下，可重新进入到就绪状态（并非运行状态）。允许与其他线程竞争CPU资源，等待线程的再次调度

4.封装

封装是面向对象的重要特征之一，封装把对象的属性和操作，作为一个独立的整体，对外隐藏所有的内部实现细节，并且通过受保护的接口访问其他对象

5.继承

在面向对象设计中，继承机制有效组织类的结构，确定类之间的关系

在已有类的基础上，可以定义新的类，达到代码复用、提高开发效率的目的

对象的一个新类可由现有的类派生，称为类的继承。子类允许继承父类的非private方法和实例变量，访问private成员，则需要通过getter、setter方法实现，并且子类可以通过增加和删除新的方法，满足服务需求

6.抽象

抽象是指对象共性的抽取，从正确的角度，展示对象的相关细节

抽象包含两个方面：过程抽象和数据抽象

过程抽象：识别功能语句，并且作为一个工作单元展示的过程

数据抽象：创建复杂的数据类型，只公开与数据类型交互有意义的操作，对外隐藏所有的内部实现细节

简答题

1.什么是可变参数？

在方法定义时，参数类型确定，参数个数不确定，Java把可变参数封装成数组处理

在方法调用时，可传递任意个数的参数，JVM自动把数据封装成数组，交由方法的逻辑进行处理

1	public static void Array(int ... intArray){}

2.JAVA垃圾回收是什么？

垃圾回收是一个自动运行的动态内存管理程序，自动释放不再被引用的对象

使用特定的垃圾回收算法，实现内存资源的动态回收，减轻编程负担

3.什么是初始化数据块？

初始化数据块是仅次于成员变量、方法、构造器的第四种成员，分为静态和非静态初始化数据块

静态初始化数据块：只能初始化static成员

初始化数据块没有名字，不能传入形参，不能通过类、对象调用，总在构造器之前执行

4.JAVA中equals和==之间的区别

equals：是String类从超类Object继承而来的方法，用于比较两个对象，比较两个对象的内容是否相等

==：用于比较基本数据类型和引用类型

比较基本数据类型时，比较数据类型和值，相同返回true

比较引用类型时，比较内存中是否指向同一对象，相同返回true

5.简单给出JAVA中实现线程的两种方式

通过Thread和Runnable两种方式，重写run（）作为线程的执行体

对于Thread，已经继承Thread类，不能再继承其它类，并且是多任务多线程的操作模式

对于Runnable接口，可以继承其它类，并且是多线程处理同一份资源的操作模式

public class ThreadTest extends Thread{
    public void run(){  
        // ...  
    }
    public static void main(String[] args){
        new ThreadTest().start();
    }
}

public class RunnableThread implements Runnable{
    @Override
    public void run(){
        //...
    }
    public static void main(String[] args){
        RunnableThread run = new RunnableThread();
        new Thread(run,"ThreadName").start();
    }
}

6.接口和抽象类的区别

1.接口只能定义静态常量属性，不能定义普通属性；抽象类可以定义两者

2.接口不能定义初始化代码块；抽象类可以定义初始化代码块

3.接口不包含构造器；抽象类可以包含构造器（抽象类的构造不用于创建对象，而是为了让子类调用构造器，完成抽象类的初始化操作）

4.接口不能定义静态方法；抽象类可以定义静态方法

5.接口只能包含抽象方法，不包含已实现的方法；抽象类可以包含普通方法

一个类最多继承一个直接父类，包括抽象类；一个类可以实现多个接口，以弥补JAVA单继承的不足

7.String是基本数据类型吗？基本数据类型有哪些？

String不是基本数据类型，是类代表字符串，是引用类型（类、接口、数组）

基本数据类型：byte，char，boolean，short，int，long，float，double

8.给出ArrayList、Vector、LinkedList的存储性能和特性

ArrayList和Vector都是数组的方式存储数据，数组元素大小大于实际存储的数据，便于插入和增加；允许直接按序号索引元素，但是插入元素涉及内存的操作，索引快，插入慢

Vector使用了Synchronize，性能上较ArrayList差

LinkedList实现双向链表存储，按序号索引需要前向、后向遍历，但是插入时只需要记录本项前后的元素即可，索引慢，插入快

9.&和&&的区别

&是位运算符，对数进行位运算；&&是逻辑运算符，对逻辑进行运算

10.sleep（）和wait（）的区别

sleep是Thread类的静态方法，使调用线程进入睡眠状态，让出执行机会给其他的线程，直到睡眠时间结束；sleep时间到的线程重新进入就绪状态，与其他线程共同竞争CPU资源；由于是静态方法，不释放对象锁

wait是Object类的方法，使得调用线程，释放对象锁，进入到与该对象有关的等待池中，使对象可以给其他线程访问；当等待的线程收到notify时，重新进入到对象锁池中，等待获得对象锁，进入运行状态

11.GC是什么？为什么要有GC？

GC是由JAVA提供的垃圾回收机制，是JAVA中自动运行的动态内存管理程序

因为在编程中，内存处理容易忘记或错误的回收，会导致系统的奔溃；并且JAVA没有提供，释放已分配内存的显式操作方法；GC通过自动检测对象是否超过作用域，实现内存的动态回收，防止内存泄漏的问题

编程题

1.UDP编程

a.说明JAVA在UDP协议与TCP协议实现中连接和数据传输的不同

UDP：通过端口号区别程序之间的若干通信，数据传输按数据报传输，包的到达先后次序不定；

TCP：通过端口号区别程序之间的若干通信，数据传输按字节流传输，按顺达到达

UDP是不可靠的网络传输，负载小

TCP是可靠的网络传输，负载大，具有建立连接、中断连接、差错检测、流量控制的功能

b.编程举例UDP如何发送数据

public class UDPClient{
    public static void main(String[] args) throws Exception{
        int port = 12345;
        InetAddress address = InetAddress.getByName("localhost");
        String data = "hello";
        byte[] dataToSend = data.getBytes();
        DatagramSocket socket = new DatagramSocket();
        DatagramPakcet sendPacket = new                                                                                      DatagramPacket(dataToSend,dataToSend.length,address,port);
        socket.send(sendPacket);
        socket.close();
    }
}

c.编程举例UDP如何接收数据

public class UDPServer{
    public static void main(String[] args) throws Exception{
        int port = 12345;
        DatagramSocket socket = new DatagramSocket(port);
        DatagramPacket inPacket = new DatagramPacket(new byte[256],256);
        while(true){
            socket.receive(inPacket);
            System.out.println(inPacket.getData().toString());
        }
    }
}

2.理解线程同步的基础上，针对银行账户对象account，编程实现使用同步代码块和同步方法完成多线程正确取钱行为

// 同步代码块
public class DrawThread extends Thread{
    public void run{
        synchronized(account){
            if(account.getBalance() >= drawAmount)
                System.out.println("取钱成功");
            else
                System.out.println("取钱失败");
        }
    }
}

// 同步方法
public class Account{
    public synchronized void draw(double drawAmount){
        if(account.getBalance() >= drawAmount)
            System.out.println("取钱成功");
        else
            System.out.println("取钱失败");
    }
}

3.使用SQL语法和JDBC完成以下任务

1.创建学生表（字段：逻辑主键id，学号studentId，姓名studentName，年龄age，性别sex 0-女，1-男，并给studentName字段创建索引）

DROP DATABASE IF EXISTS studentdb;
CREATE DATABASE studentdb;
USE DATABASE studentdb;
CREATE TABLE student(
	Id int primary key,
    studentId int,
    studentName varchar(20),
    age int,
    sex int COMMENT'0-女 1-男',
    INDEX idx_stuName(studentName)
);

2.使用JDBC完成对数据库（IP-127.0.0.1，PORT-3306，DB-studentdb，用户名-student，密码-student）对student表的访问，输出全部学生的学号和姓名

public class JDBC{
    public static void main(String[] args) throws Exception{
		String URL = "jdbc:mysql://127.0.0.1:3306/studentdb?user=student&password=student";
		Connection con = null;
		Statement stmt = null;
		ResultSet rs = null;
        try{
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection(URL);
            stmt = con.createStatement();
            rs = stmt.executeQuery("select * from student");
            while(rs.next()){
                System.out.println("学号" + rs.getString("studentId") +                                                                              "姓名" + rs.getString("studentName"));
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            rs.close();
            stm.close();
            con.close();
        }
    }
}

4.使用ServerSocket和Socket类完成从客户端发送一行字符串给服务器，服务器接收后再发送同样一行字符串客户端（客户端发送double数据、文件、java对象给服务器）

public class Client{
    public static void main(String[] args) throws Exception{
        Socket socket = new Socket("127.0.0.1",30000);
        // DOUBLE
        DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(socket.getOutputStream()));
        dos.writeDouble(10.123);
        dos.flush();
        // OBJECT
        ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(socket.getOutputStream()));
        oos.writeObject(new Student("studentName",20));
        // FILE
        byte[] buff = new byte[32];
        BufferedInputStream bis = new BufferedInputeStream(new FileInputStream("\tx"));
        bis.read(buff,0,buff.length);
        OutputStream os = socket.getOutputStream();
        os.write(buff,0,buff.length);
        os.flush();socket.close;
    }
}

public class Server{
    public static void main(String[] args) throws Exception{
        ServerSocket socket = new ServerSocket(30000);
        while(true){
            Socket s = socket.accept();
            // DOUBLE
            DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
            Double d = dis.readDouble();       
            // OBJECT
            ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(s.getInputStream()));
            try{
                Student stu = (Student)ois.readObject();
                System.out.println("姓名"+ stu.getName() + "年龄" + stu.getAge());
            }catch(Exception e){
                e.printStackTrace();
            }
            // FILE
            byte[] buff = new byte[32];
            InputStream is = s.getInputStream();
            int byteRead = is.read(buff,0,buff.length);
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/tx"));
            bos.write(buff,0,buff.length);

            bos.flush();
            bos.close();
            s.close();
        }
    }
}

public class Server{
    public static void main(String[] args){
        try{
           ServerSocket ss = new ServerSocket(30000);
           Socket s = ss.accept();
           BufferedReader br =new BufferedReader(new InputStreamReader(s.getInputStream()));
           String msg = br.readLine();
           System.out.println("客户端：" + msg);
           BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
           bw.write("ehco" + msg);
           bw.flush();
        }catch (Exception e){
           e.printStackTrace();
        }
    }
}

public class Client{
    public static void main(String[] args){
        try{
           Socket s = new Socket("127.0.0.1",30000);
           BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
           bw.write("测试消息文本");
           BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));
           String echo = br.readLine();
           System.out.println("服务器：" + echo);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

5.编写单例模式（Singleton）

public class Singleton{
    private Singleton(){}
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

public class Singleton{
    private static Singleton instance = null;
    public static synchronized Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
      	return instance;
    }
}