java复习3.0

简答题
什么是jdk和jre

1. 定义

JRE(Java Runtime
Enviroment)是Java的运行环境。面向Java程序的使用者，而不是开发者。如果你仅下载并安装了JRE，那么你的系统只能运行Java程序。JRE是运行Java程序所必须环境的集合，包含JVM标准实现及Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。
JDK(Java Development Kit)又称J2SDK(Java2 Software Development
Kit)，是Java开发工具包，它提供了Java的开发环境(提供了编译器javac等工具，用于将java文件编译为class文件)和运行环境(提
供了JVM和Runtime辅助包，用于解析class文件使其得到运行)。如果你下载并安装了JDK，那么你不仅可以开发Java程序，也同时拥有了运
行Java程序的平台。JDK是整个Java的核心，包括了Java运行环境(JRE)，一堆Java工具tools.jar和Java标准类库(rt.jar)。

2. 区别

JRE主要包含：java类库的class文件(都在lib目录下打包成了jar)和虚拟机(jvm.dll)；JDK主要包含：java类库的 class文件(都在lib目录下打包成了jar)并自带一个JRE。那么为什么JDK要自带一个JRE呢？而且jdk/jre/bin下的client和server两个文件夹下都包含jvm.dll(说明JDK自带的JRE有两个虚拟机)。
记得在环境变量path中设置jdk/bin路径麽？老师会告诉大家不设置的话javac和java是用不了的。确实jdk/bin目录下包含了所有的命令。可是有没有人想过我们用的java命令并不是jdk/bin目录下的而是jre/bin目录下的呢？不信可以做一个实验，大家可以把jdk
/bin目录下的java.exe剪切到别的地方再运行java程序，发现了什么？一切OK！(JRE中没有javac命令，原因很简单，它不是开发环境)那么有人会问了？我明明没有设置jre/bin目录到环境变量中啊？试想一下如果java为了提供给大多数人使用，他们是不需要jdk做开发的，只需
要jre能让java程序跑起来就可以了，那么每个客户还需要手动去设置环境变量多麻烦啊？所以安装jre的时候安装程序自动帮你把jre的java.exe添加到了系统变量中，验证的方法很简单，去Windows/system32下面去看看吧，发现了什么？有一个java.exe

set和list区别

List的功能方法
实际上有两种List：一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。
List：次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。
ArrayList：由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历 ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。 LinkedList
：对顺序访问进行了优化，向List中间插入与删除的开销并不大。随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。

Set的功能方法

Set具有与Collection完全一样的接口，因此没有任何额外的功能。实际上Set就是Collection,只是行为不同。这是继承与多态思想的典型应用：表现不同的行为。Set不保存重复的元素(至于如何判断元素相同则较为负责)

Set :
存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象的唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。
HashSet：为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。 TreeSet： 保存次序的Set,
底层为树结构。使用它可以从Set中提取有序的序列。

LinkedHashSet：具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

list与Set区别

1、List,Set都是继承自Collection接口 2、List特点：元素有放入顺序，元素可重复
，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set 的Object必须定义equals()方法，另外list支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。）
3.Set和List对比： Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。

什么是多态

概念：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。简单的说:就是用基类的引用指向子类的对象。
多态首先是建立在继承的基础上的，先有继承才能有多态。多态是指不同的子类在继承父类后分别都重写覆盖了父类的方法，即父类同一个方法，在继承的子类中表现出不同的形式。多态成立的另一个条件是在创建子类时候必须使用父类new子类的方式。
多态可以用在方法的参数中和方法的返回类型中。

接口和抽象类区别

程序分析
父类构造函数和子类构造函数执行顺序
（见1.0）
一个string类的equals方法与==区别
（见1.0）
一个try catch finally块的执行
（见1.0）

程序设计题
小球从100米自由落体，落地后弹起是原来一半高度,求10次落地一共走过的路程

<pre name="code" class="java">/*
一球从100米的高度自由落下，每次落地后反跳回原高度的一半，再落下。
求它在第10次落地时，共经过多少米？第10次反弹多高？
*/
 
 
import java.io.*;
 
class Demo
{
	private Demo(){}
 
	private static Demo instance = new Demo();
 
	public void getResults(int n)
	{
		final double H = 100;
		double sum = H;
		//h 是此次弹起了的高度
		double h = H/2;			
	//从第2次开始进入循环，第1次直接输出初始化值。	
		for(int i = 2; i <= n ; i++)
		{
			//当前弹起了的高度*2 +上一次的sum就是本次一共经过的路程。
			sum = sum + h*2;
			//h 的值变成了下一次能弹起来的高度
			h = h/2;
 
		}
 
		System.out.println(n+"次撞地时走过的路程:"+sum+"\n"+n+"次撞地后能弹起来的高度:"+h);
 
	}
 
	public static Demo getInstance()
	{
		return instance;
 
	}
 
}
 
class MainClass 
{
	public static void main(String[] args) throws Exception
	{
		Demo d = Demo.getInstance();
		BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
		String reg = "[1-9]+\\d*";
		String str = null;
		int n = 0; 
		System.out.println("输入一个1到N的数字:");
		for(str = buf.readLine().trim();true; str = buf.readLine().trim())
		{
			if(str.isEmpty() == true)
				continue;
 
			if(str.equals("quit") == true)
				System.exit(0);
 
			if(str.matches(reg) == true)
			{
				n = Integer.parseInt(str);
				
				d.getResults(n);
			}
			else
			{
				System.out.println("非法数字！输入一个1到N的数字:");
			}
		}
	}
}
/*
*/

一个多线程卖火车票，每个窗口随机卖1-5张，共卖掉500张后输出每个窗口卖出的张数

class Ticket implements Runnable{

    private int num;
    private int init = 1;
    private String lock;

    public Ticket(int num,String lock){
        this.num = num;
        this.lock = lock;
    }

    @Override
     public void run() {
        while (true){
            synchronized (lock) {
                if (init > num) {
                    System.out.println(Thread.currentThread().getName()+": 火车票已经卖完了");
                    return;
                }
                try {
                    //模拟出票过程，否则因为执行太快，大部分被一个线程执行完了
                    lock.wait(30);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (init > num) {
                    System.out.println(Thread.currentThread().getName()+": 火车票已经卖完了");
                    return;
                }
                System.out.println(Thread.currentThread().getName() + "售出火车票：" + init++);
            }
        }
    }
    }
}

public static void main(String[] args) throws InterruptedException {
        String  str = "lock";
        Ticket ticket = new Ticket(100,str);
        new Thread(ticket,"窗口A").start();
        new Thread(ticket,"窗口B").start();
        new Thread(ticket,"窗口C").start();
        new Thread(ticket,"窗口D").start();
    }

一个socket网络编程,发送一个数字，接收端接受后输出这个数的全部因数

/**
 * 
 */
package socketTest2;
 
 
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
 
public class Server {
    public static final int PORT = 12345;//监听的端口号   
    
    public static void main(String[] args) {  
        System.out.println("服务器启动...\n");  
        Server server = new Server();  
        server.init();  
    }  
  
    public void init() {  
        try {  
            ServerSocket serverSocket = new ServerSocket(PORT);  
            while (true) {  
                // 一旦有堵塞, 则表示服务器与客户端获得了连接  
                Socket client = serverSocket.accept();  
                // 处理这次连接  
                new HandlerThread(client);  
            }  
        } catch (Exception e) {  
            System.out.println("服务器异常: " + e.getMessage());  
        }  
    }  
  
    private class HandlerThread implements Runnable {  
        private Socket socket;  
        public HandlerThread(Socket client) {  
            socket = client;  
            new Thread(this).start();  
        }  
  
        public void run() {  
                // 读取客户端数据  
                DataInputStream input = new DataInputStream(socket.getInputStream());
                String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
                // 处理客户端数据  
                System.out.println("客户端发过来的内容:" + clientInputStr);  
  
                 if(int n = Integer.parseInt(str)){
                 		//输入一个数，输出这个数的所有因子，并返回因子的个数      
    				int count = 0; 
    				if(n == 0)  {}
    				else {   
    	    			System.out.print(1+" ");    
       				 	for(int i = 2; i <= Math.sqrt(n); i++){  
            			if(n % i == 0){  
                			System.out.print(i+" ");  
                			System.out.print(n/i+" ");    
            			}  
   			 		}  
                }  
            } 
        }  
}  

一个根据框架图写程序，主要考继承

一个读取文件，统计字母,数字和其他字符个数并输出到文件的题

@Test
public void test() {
    FileReader fileReader = null;
    BufferedReader bufferedReader = null;
    int count = 0;
    try {
    	//创建文件输入流
        fileReader = new FileReader("hello.txt");
        PrintStream ps = new PrintStream("hello.txt");
        //创建文件缓冲流
        bufferedReader = new BufferedReader(fileReader);
        String str;
        //定义count记录数字个数
        count = 0;
        //循环每次读取一行
        while ((str = bufferedReader.readLine()) != null){
            char[] chars = str.toCharArray();
            //循环判断每一行中的数字的个数
            for (int i = 0; i < chars.length; i++) {
                for (int i = 0; i < str.length(); i++) {
			        char c = str.charAt(i);
			        if(c<='z'&&c>='a'||c<='Z'&&c>='A') {
			            letterCount++;
			        }else if(c<='9'&&c>='0'){
			            numberCount++;
			        }else if(c==' '){ 
			            spaceCount++;
			        }else{
			            otherCount++;
			        }
			
			    }
			    System.setOut(ps);//把创建的打印输出流赋给系统。即系统下次向 ps输出
			    System.out.println("字母有"+letterCount+"个");
			    System.out.println("数字有"+numberCount+"个");
			    System.out.println("空格有"+spaceCount+"个");
			    System.out.println("其它有"+otherCount+"个");
			    
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if(bufferedReader != null){
                bufferedReader.close();
            }
            if(fileReader != null){
                fileReader.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}