java，

java，

1. java中的工具命令

javac:java编译器，将java源代码转化为字节码

java:java解释器，解释并执行java应用程序的字节码文件

appletviewer:Applet程序浏览器，用来执行HTML文件上的java小程序

javadoc:根据java源码及说明语句生成HTLML格式的注释文档

jdb:java调试器，可以逐行执行程序，设置断点和检查变量

javap:java反汇编器，显示类文件中的可访问功能和数据，同时显示字节代码含义

2. 类的静态方法直接用类名调用，并且静态方法只能调用同类中的静态成员(包括变量和方法)

3. 内部类在外部类的作用域内定义，它可以直接访问和引用它所属的外部类的所有变量和方法，但内部类的成员却不能被外部类直接访问，更不用说外部类以外的代码。内部类不能声明为static

4. 抽象类不能定义构造函数，抽象方法不能声明为静态的，抽象方法只需声明，无需实现，含有抽象方法的类必须被定义为抽象类。抽象类的子类必须实现抽象类的所有抽象方法，否则这个子类也是抽象类

5. 接口定义了一种完全抽象的，根本不提供任何实现的类；接口中的变量默认为final和static的，即全局静态变量，一旦定义必须立体初始化。实现接口的类中，所有被实现的方法必须都显示的定义为public的；接口和内存无关。

6. final.修饰变量时，变量在定义时或在类的构造函数里初始化，作用域内不能被修改；public static final修饰变量时表示全局常量；修饰方法时，此方法不可以被子类覆盖；修饰类时，该类不能被继承。

7. 进程就是在某种程度上相互隔离的，独立运行着的程序。线程也称轻量级进程，每个线程有它自己的堆栈，自己的程序计数器和自己的局部变量，但进程种的线程之间的独立性要比进程小，它们共享内存，文件句柄和其他每个进程应有的状态。

8. Runable接口中唯一提供run方法

9. Tread.isAlive()用来测试当前线程是否仍处于活动状态；Tread.join()用来等待某个或某些线程结束

10. "Daemon"（守护线程）的作用就是在程序运行期间于后台提供一种“常规”服务，但它并不属于程序的一个基本部分。当非Daemon线程全部结束以后，程序就会终止运行，而不管是否还有Daemon线程的存在。

11. 可以通过共享变量的方法来中断线程的执行，定义static共享变量可以一次中断所有同一个线程类创建的线程。

12.interrupt可以使一个被阻塞的线程抛出一个中断异常。

13. 解决多个线程访问同一共享数据资源时发生冲突的问题的手段是将欲访问的共享资源所在的关键代码封装到一个同步代码块或同步方法中，使所有针对这一共享资源的操作成为互斥操作。同步块或方法作为一个原子操作来实现。原子操作使指计算机在执行指令过程中不可分割的最小指令单元，原子操作使安全的。

14. 线程同步，模拟订票系统

class SaleTickets implements Runnable
{
 private int ticketNo=100750;//车票编号
 private int ticket=100;//共享私有成员，车票数量
 boolean stop=false;//共享变量，用来中断一个线程
 public void run()
 {
  while(!stop)//通过判断stop变量的值来确定是否继续执行线程体
  {
   sale();
  }
  System.out.println(Thread.currentThread().getName()+" stopped");
 }
 public synchronized void sale()
 {
  if(ticket>0){
   System.out.println(Thread.currentThread().getName()+"is saling Ticket"+ticketNo);
   try{//休眠0-100毫秒
    Thread.sleep((int)(Math.random()*100));
   }catch(InterruptedException e){
     e.printStackTrace();
    }
   ticket=ticket-1;//修改车票数据库的信息   
   System.out.println("ticket"+ticketNo+" is saled by "+Thread.currentThread().getName()+",amount rest is:"+ticket);//显示车票的预定情况
   ticketNo=ticketNo-1;//修改车票编号
  }
  else{//车票已经预定完毕
   stop=true;//修改共享变量
   System.out.println(Thread.currentThread().getName()+":Sorry! All Ticket is saled.");
  }
 }
}

public class SynchronizeDemo {
 public static void main(String[] args) {
  System.out.print(5);
  SaleTickets m=new SaleTickets();
  Thread t1=new Thread(m,"System 1");
  Thread t2=new Thread(m,"System 2");
  t1.start();
  t2.start(); 
  //延时
  try{
   Thread.sleep((int)(Math.random()*3000));
   }catch(InterruptedException e){
    e.printStackTrace();
    }
  m.stop=true;//修改共享变量
  t1.interrupt();
  if(t1.isAlive()){//判断线程状态
   System.out.println(t1.getName()+" is alive!");
  }else{
   System.out.println(t1.getName()+" is dead!");
  }
 }
}

15. 线程通信

//CommunicationDemo.java模拟生产消费过程
class SyncStack/**同步堆栈类，可以一次放入多个数据*/
{ 
 private int index=0;/**堆栈指针初始为0*/
 private char[]buffer=new char[10];/**堆栈有10个字符的空间*/
 public synchronized void push(char c)/**入栈同步方法*/
 {
  if(index==buffer.length)/**堆栈已满不能入栈*/
  {
   try{
    this.wait();/**等待出栈线程将数据出栈*/
   }catch(InterruptedException e){}   
  }
  buffer[index]=c;/**数据入栈*/
  index++;/**指针加1，栈内空间减少*/
  this.notify();/**通知其他线程把数据出栈*/
 }
 public synchronized char pop()/**出栈同步方法*/
 {
  if(index==0)/**堆栈无数据，不能出栈*/
  {
   try{
    this.wait();/**等待入栈线程把数据入栈*/
   }catch(InterruptedException e){}
  }
  this.notify();/**通知其他线程入栈*/
  index--;/**指针向下移动*/
  return buffer[index];/**数据出栈*/
 } 
}

 

class Producer implements Runnable/**生产者类*/
{
 SyncStack s;/**生产者类生成的字母都保存到同步堆栈中*/
 public Producer(SyncStack s)
 {
  this.s=s;
 }
 public void run()
 {
  char ch;
  for(int i=0;i<10;i++)
  {
   try{
    Thread.sleep((int)(Math.random()*1000));
   }catch(InterruptedException e){}
   ch=(char)(Math.random()*26+'A');/**随机产生5个字符*/
   s.push(ch);/**把字符入栈*/
   System.out.println(Thread.currentThread().getName()+" Push "+ch+" in Stack");/**打印字符入栈*/
  }
 }
}

class Consumer implements Runnable/**消费者类*/
{
 SyncStack s;/**消费者类获得字符都来自同步者堆栈*/
 public Consumer(SyncStack s)
 {
  this.s=s;
 }
 public void run()
 {
  char ch;
  for(int i=0;i<5;i++)
  {
   try{
    Thread.sleep((int)(Math.random()*3000));
   }catch(InterruptedException e){}
   ch=s.pop();/**从堆栈中读取字符*/
   System.out.println(Thread.currentThread().getName()+" Pop "+ch+" from Stack");/**打印字符出栈*/
  }
 }
}
public class CommunicationDemo
{
 public static void main(String[]args)
 {
  SyncStack stack=new SyncStack();
  /**下面的消费者类和生产者类对象所操作的是同一个同步堆栈对象*/
  Thread t1=new Thread(new Producer(stack),"Producer wangzhongbo");/**线程实例化*/
  //consumer1=new Consumer(stack);
  Thread t2=new Thread(new Consumer(stack),"Consumer sunlei");/**线程实例化*/
  Thread t3=new Thread(new Consumer(stack),"Consumer zhangchao");/**线程实例化*/
  t2.start();/**线程启动*/
  t3.start();//线程启动
  t1.start();/**线程启动*/
 }
}

16. 目录操作

//ListAllFiles.java 显示指定目录下的所有文件

import java.io.*;
class ListAllFiles
{
 public void listPath(File path)
 {
  File files[]=path.listFiles();//获得当前目录对象下的所有文件
  for(int i=0;i<files.length;i++)
  {
   if(files[i].isFile())
   {
    System.out.println(files[i].getPath());
   }
   else if(files[i].isDirectory())
   {
    System.out.println(files[i].getPath());
    listPath(files[i]);//递归调用listPath方法
   }
  }
 }
 public static void main(String args[])
 {
  File dir=new File(args[0]);
  ListAllFiles list=new ListAllFiles();//定义一个目录对象
  list.listPath(dir);
 }
}

17. 对象序列化：要想序列化一个对象，声明该对象的类必须实现了Serializable接口。此外还必须与一定的对象输入/输出流联系起来，这样才可以通过对象输出流将对象状态保存起来，再通过对象输入流将对象状态恢复。声明为transient的变量是不被保存的。

18. 对象序列化实例

//ExternalizableDemo.java

import java.io.*;
class ExternalizableDemo implements Externalizable
{
 int i;//声明两个变量
 String s;
 public ExternalizableDemo()//类的无参构造函数
 {
  System.out.println("Externalizable's Constructor");
 }
 public ExternalizableDemo(String s,int i)//类的初始化构造函数
 {
  System.out.println("ExternalizableDemo(String s,int i)");
  this.s=s;
  this.i=i;
 }
 public String toString(){return s+i;}
 //在序列化时自动调用，可以用来指定序列化哪些内容
 public void writeExternal(ObjectOutput out) throws IOException
 {
  System.out.println("ExternalizableDemo.writeExternal");
  out.writeObject(s);//将字符串对象写入对象流
  out.writeInt(i);//将整型变量写入对象流
 }
 //在反序列化时自动调用，可以用来指定反序列哪些内容
 public void readExternal(ObjectInput in) throws IOException,ClassNotFoundException
 {
  System.out.println("ExternalizableDemo.readExternal");
  s=(String)in.readObject();//将字符串对象从对象流中恢复
  i=in.readInt();//将整型变量从对象流中恢复
 }
 public static void main(String []args)
 {
  System.out.println("Constructing objects:");
  ExternalizableDemo ed=new ExternalizableDemo("String ",50);
  System.out.println(ed.toString());//输出对象的变量
  try{
   ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("data.ext"));
   System.out.println("Saving object:");
   out.writeObject(ed);
   out.close();
   ObjectInputStream in=new ObjectInputStream(new FileInputStream("data.ext"));
   System.out.println("Recovering from data.ext:");
   ed=(ExternalizableDemo)in.readObject();
   System.out.println(ed.toString());//输出反序列化后的对象变量
  }catch(Exception e){
   e.printStackTrace();
  }
 }
}

19. Applet下载执行过程

 

 

 

 

 

 

 

 

20. Internet网络通信中主要使用的协议有三种：

适用于网络层的IP协议，它用来规定数据通过IP地址被投递到正确的计算机上

适用于传输层的TCP、UDP协议，这两个协议规定了通过端口号Port将数据投递给正确的应用程序

适用于应用层的HTTP、FTP、SMTP、SNMP协议，它们规定了如何来对数据的内容进行解释

21. 应用程序通过套接字发送和接收数据的过程

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

22. 利用套接字建立连接的过程