java期末题型复习

一：PATH与CLASSPATH的区别

PATH：作用是指定命令搜索路径，在i命令行下面执行命令如javac编译java程序时，它会到PATH变量所指定的路径中查找看是否能找到相应的命令程序。设置好PATH变量后，就可以在任何目录下执行javac/java等工具了。

CLASSPATH：作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到它们了，JVM就是通过CLASSPATH来寻找类的。

二：辨析JVM、JRE、JDK

三：辨析final关键字分别修饰变量、方法、类的含义

修饰对象	解释说明	备注
类	无子类，不可以被继承,更不可能被重写。	final类中的方法默认是final的
方法	方法不能在子类中被覆盖	类的private方法会隐式地被指定为final方法。final方法不能被子类的方法覆盖，但可以被继承。
变量	称为常量，初始化以后不能改变值。	用final修饰的成员变量表示常量，值一旦给定就无法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

四：equals与==的区别

equals方法在基类Object中进行定义的源码如下：

    public boolean equals(Object anObject) {
     
        if (this == anObject) {
     
            return true;
        }
    }

由equals的源码可以看出这里定义的equals与==是等效的（Object类中的equals没什么区别），不同的原因就在于有些类（像String、Integer等类）对equals进行了重写，但是没有对equals进行重写的类（比如我们自己写的类）就只能从Object类中继承equals方法，其equals方法与==就也是等效的，除非我们在此类中重写equals。

对equals重写需要注意五点：

1. 自反性：对任意引用值X，x.equals(x)的返回值一定为true；
2. 对称性：对于任何引用值x,y,当且仅当y.equals(x)返回值为true时，x.equals(y)的返回值一定为true；
3. 传递性：如果x.equals(y)=true, y.equals(z)=true,则x.equals(z)=true ；
4. 一致性：如果参与比较的对象没任何改变，则对象比较的结果也不应该有任何改变；
5. 非空性：任何非空的引用值X，x.equals(null)的返回值一定为false 。

这是String类源码对equals的重写：

   public boolean equals(Object anObject) {
     
        if (this == anObject) {
     
            return true;
        }
        if (anObject instanceof String) {
     
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
     
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
     
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

五：static的性质与执行顺序

以下是我以前的博客的截图，具体可见：java程序中各成分的执行顺序

六：辨析运行异常与非运行异常

七：将一个字节输入流转换成采用UTF-8编码的字符输入流

import java.io.*;

public class Work1 {
     
    public static void main(String[] args) throws Exception{
     
        InputStream is = new ByteArrayInputStream("hello world".getBytes());

        InputStreamReader inputStreamReader = new InputStreamReader(is, "UTF-8");

        BufferedReader bufferedReader = new BufferedReader(inputStreamReader);

        int value = 0;
        while ((value = bufferedReader.read()) != -1) {
     
            char c = (char) value;
            System.out.println(c);
        }

    }
}

八：java多线程的两种写法

继承Thread类

package test;

public class Demo extends MyThread {
     
    public static void main(String[] args) {
     
        MyThread t = new MyThread();
        t.start();
    }
}

class MyThread extends Thread {
     
    @Override
    public void run() {
       // 重写run方法
        System.out.println(123456);
    }
}

实现runnable接口

package test;

public class Demo implements Runnable {
     
    @Override
    public void run() {
     
        System.out.println(123456);
    }

    public static void main(String[] args) {
     
        Thread t = new Thread(new Demo());
        t.start();
    }
}

九：采用URL类实现网络文件的拷贝

package network.work;

import java.io.*;
import java.net.*;

public class Url {
     
    public static void main(String[] args) {
     
        try {
     
            URL url = new URL("https://cdn.jsdelivr.net/gh/YuJiZhao/picbed/108.jpg");
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

            urlConnection.connect();

            InputStream is = urlConnection.getInputStream();
            FileOutputStream fos = new FileOutputStream("yuanshen.png");

            byte[] buffer = new byte[1024];
            int len;
            while((len = is.read(buffer)) != -1) {
     
                fos.write(buffer, 0, len);
            }

            is.close();
            fos.close();
            urlConnection.disconnect();
        } catch (Exception e) {
     
            e.printStackTrace();
        }
    }
}

十：利用Socket实现客户端与服务端通信

Java中，首先由服务端简历倾听socket，等待并接收连接请求，再由客户端创建socket向服务器发出请求，以此建立连接，就可以开始通信，服务端向客户端发信息利用输入流OutputStream，客户端接收时使用InputStream，客户端向服务端发请求则相反。最后结束通信时由客户端关闭socket及相关资源，再由服务端关闭socket及相关资源。

因此socket通信步骤：
① 创建ServerSocket和Socket
② 打开连接到Socket的输入/输出流
③ 按照协议对Socket进行读/写操作
④ 关闭输入输出流、关闭Socket

代码演示：

服务端：
① 创建ServerSocket对象，绑定监听端口
② 通过accept()方法监听客户端请求
③ 连接建立后，通过输入流读取客户端发送的请求信息
④ 通过输出流向客户端发送乡音信息
⑤ 关闭相关资源

import java.io.*;
import java.net.*;

public class work3_server{
     
    public static void main(String[] args) {
     
        try{
     
            //1、创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口
            ServerSocket serverSocket = new ServerSocket(10086);//1024-65535的某个端口
            //2、调用accept()方法开始监听，等待客户端的连接
            Socket socket = serverSocket.accept();
            //3、获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String info =null;
            while((info=br.readLine()) != null){
     
                System.out.println("我是服务器，客户端说：" + info);
            }
            socket.shutdownInput();//关闭输入流
            //4、获取输出流，响应客户端的请求
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);
            pw.write("欢迎您！");
            pw.flush();

            //5、关闭资源
            pw.close();
            os.close();
            br.close();
            isr.close();
            is.close();
            socket.close();
            serverSocket.close();
        }catch (Exception e) {
     
            e.printStackTrace();
        }
    }
}

客户端：
① 创建Socket对象，指明需要连接的服务器的地址和端口号
② 连接建立后，通过输出流想服务器端发送请求信息
③ 通过输入流获取服务器响应的信息
④ 关闭响应资源

import java.io.*;
import java.net.*;

public class work3_client {
     
    public static void main(String[] args) {
     
        try{
     
            //1、创建客户端Socket，指定服务器地址和端口
            Socket socket = new Socket("localhost",10086);
            //2、获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();//字节输出流
            PrintWriter pw = new PrintWriter(os);//将输出流包装成打印流
            pw.write("用户名：admin；密码：123");
            pw.flush();
            socket.shutdownOutput();
            //3、获取输入流，并读取服务器端的响应信息
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info = null;
            while((info=br.readLine()) != null){
     
                System.out.println("我是客户端，服务器说：" + info);
            }

            //4、关闭资源
            br.close();
            is.close();
            pw.close();
            os.close();
            socket.close();
        } catch (Exception e) {
     
            e.printStackTrace();
        }
    }
}

十一：AWT编程实现按钮监听

package GUI;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class Test6 {
     
    public static void main(String[] args) {
     
        Frame frame = new Frame("demo");
        frame.setSize(300, 200);
        frame.setVisible(true);

        Button btn = new Button("hello");
        frame.add(btn, BorderLayout.CENTER);

        // 绑定事件
        MyActionListener myActionListener = new MyActionListener();
        btn.addActionListener(myActionListener);

        frame.addWindowListener(
                new WindowAdapter() {
     
                    @Override
                    public void windowClosing(WindowEvent e) {
     
                        System.exit(0);
                    }
                }
        );
    }
}

class MyActionListener implements ActionListener {
     
    @Override
    public void actionPerformed(ActionEvent e) {
     
        System.out.println(e.getActionCommand());
    }
}

如果有兴趣了解更多相关内容，欢迎来我的个人网站看看：eyes++的个人空间