ServerSocket:侦听所有的客户端向服务端发送的建立套接字请求，然后返回套接字对象Socket，客户端和服务端的连接建立。

构建一个ServerSocket对象，需要指定一个端口号，侦听到连接请求，获得一个Socket对象，建立Socket---Socket的连接

import java.io.*;

import java.net.*;

public class JabberServer{

　　public static fianl int port=8080;

　　public static void main(String[] args){

　　　　ServerSocket ss=new ServerSocket(port);

　　　　System.out.println(ss);

　　　　try{

　　　　　　Socket s=ss.accept();

　　　　　　System.out.println(s);

　　　　　　try{

　　　　　　　　BufferedReader br=new BufferedReader(

　　　　　　　　　　　　　　　　　　　　new InputStreamReader(

　　　　　　　　　　　　　　　　　　　　　　s.getInputStream()

　　　　　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　　　　　);

　　　　　　　　//建立连接后，向服务器写入输出内容，只有当输入内容缓存每次被刷新，才能通过网络发送下一批消息

　　　　　　　　PrintWriter pw=new PrintWriter(

　　　　　　　　　　　　　　　　　　new BufferedWriter(

　　　　　　　　　　　　　　　　　　　　new OutputStreamWriter(

　　　　　　　　　　　　　　　　　　　　　　s.getOutputStream();

　　　　　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　　　,true);

　　　　　　　　String str=new String();

　　　　　　　　int i=0;

　　　　　　　　while(true){

　　　　　　　　　　str=br.readLine();

　　　　　　　　　　System.out.println(str);

　　　　　　　　　　pw.println(++i+"content from server");

　　　　　　　　　　if(str.equals("END")

　　　　　　　　　　　　break;

　　　　　　　　}

　　　　　　}finally{

　　　　　　　　System.out.println("Socket close");

　　　　　　　　s.close();

　　　　　　}

　　　　}finally{

　　　　　　System.out.println("ServerSocket close");

　　　　　　ss.close();

　　　　}

　　}

}

import java.io.*;

import java.net.*;

public class JabberClient{

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

　　　　InetAddress add=InetAddress.getByName(null);

　　　　//InetAddress add=InetAddress.getByName("localhost");

　　　　//InetAddress add=InetAddress.getByName("127.0.0.1");

　　　　System.out.println(add);

　　　　Socket s=new Socket(add,JabberServer.port);

　　　　System.out.println(s);

　　　　try{

　　　　　　//建立连接后，向服务器写入输出内容，只有当输入内容缓存每次被刷新，才能通过网络发送下一批消息

　　　　　　PrintWriter pw=new PrintWriter(

　　　　　　　　　　　　　　　　new BufferedWriter(

　　　　　　　　　　　　　　　　　　new OutputStreamWriter(

　　　　　　　　　　　　　　　　　　　　s.getOutputStream()

　　　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　,true);

　　　　　　//获得服务器返回的消息

　　　　　　BufferedReader br=new BufferedReader(

　　　　　　　　　　　　　　　　　　new InputStreamReader(

　　　　　　　　　　　　　　　　　　　　s.getInputStream()

　　　　　　　　　　　　　　　　　　)

　　　　　　　　　　　　　　　　);

　　　　　　String str=new String();

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

　　　　　　　　pw.println(i+"content from client");

　　　　　　　　str=br.readLine();

　　　　　　　　System.out.println(str);

　　　　　　}

　　　　　　//告诉服务端，客户端内容写入完毕

　　　　　　pw.println("END");

　　　　}finally{

　　　　　　System.out.println("Socket close");

　　　　　　s.close();

　　　　}

　　}

}

/**--注意--**/

以上代码都是在文本编辑器中写的，可能会有些许纰漏

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

class Ticker extends Thread{

　　private Button t=new Button("toggle");

　　private TextField tf=new TextField(10);

　　//开关控制count的变化

　　private runFlag=true;

　　private int count=0;

　　class Stop implements ActionListener{

　　　　@Override

　　　　public void actionPerformed(ActionEvent e){

　　　　　　runFlag=!runFlag;

　　　　}

　　}

　　public Ticker(Container c){

　　　　t.addActionListener(new Stop());

　　　　//Panel容器

　　　　Panel p=new Panel();

　　　　p.add(t);

　　　　p.add(tf);

　　　　c.add(p); 

　　}

　　@Override

　　public void run(){

　　　　while(true){

　　　　　　try(

　　　　　　　　Thread.currentThread().sleep(200);

　　　　　　}catch(InterruptedException e){

　　　　　　　　e.printStackTrace();

　　　　　　}

　　　　　　if(runFlag)

　　　　　　　　tf.setText(Integer.toString(++count));

　　　　}

　　}

}

public class Counter extends Applet{

　　private Button start=new Button("Start");

　　private boolean started=false;

　　private int size=0;

　　private Ticker[] ts;

　　@Override

　　public void init(){

　　　　start.addActionListener(new Start());

　　　　add(start);

　　　　ts=new Ticker[size];

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

　　　　　　ts[i]=new Ticker(Counter.this);

　　　　}

　　}

　　class Start implements ActionListener{

　　　　@Override

　　　　public void actionPerformed(ActionEvent e){

　　　　　　if(!started){

　　　　　　　　started=true;

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

　　　　　　　　　　ts[i].start();

　　　　　　　　}

　　　　　　}

　　　　}

　　}

　　public static void main(String[] args){

　　　　Counter c=new Counter();

　　　　Frame frame=new Frame("程序片");

　　　　frame.addWindowListener(

　　　　　　new WindowAdapter(){

　　　　　　　　@Override

　　　　　　　　public void windowClosing(WindowEvent e){

　　　　　　　　　　System.exit(0);

　　　　　　　　}

　　　　　　}

　　　　);

　　　　frame.setSize(300,c.size*50);

　　　　frame.add(c,BorderLayout.CENTER);

　　　　c.init();

　　　　c.start();

　　　　frame.setVisible(true);

　　}

}

/**--注意--**/

以上代码都是在文本编辑器中写的，可能会有些许纰漏

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

class StaticTest{

　　//静态全局变量

　　static int count=0;

　　public StaticTest(){

　　　　++count;

　　　　System.out.println("count:"+count);

　　}

}

public class Test extends Applet{

　　private Button btn=new Button("创建");

　　private TextField tf=new TextField(10);

　　//匿名内部类　　

　　class Create implements ActionListener{

　　　　public void actionPerformed(ActionEvent e){

　　　　　　//每次实例化对象时，count的值会一直累加，而不是重新从0开始

　　　　　　StaticTest st=new StaticTest();

　　　　}　　

　　}

　　@Override

　　public void init(){

　　　　add(btn);

　　　　//添加点击事件

　　　　btn.addActionListener(new Create());

　　　　add(tf);

　　}

　　public static void main(String[] args){

　　　　Test t=new Test();

　　　　Frame frame=new Frame();

　　　　//给窗口添加关闭事件

　　　　frame.addWindowListener(

　　　　　　new ActionAdapter(){

　　　　　　　　public void windowClosing(WindowEvent e){

　　　　　　　　　　System.exit(0);

　　　　　　　　}

　　　　　　}

　　　　);

　　　　frame.add(t,BoderLayout.CENTER);

　　　　frame.setSize(300,200);

　　　　//初始化窗口内控件

　　　　t.init();

　　　　t.start();

　　　　//显示程序片窗口

　　　　frame.setVisible(true);

　　}

}

//多线程

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

public class Test extends Applet{

　　private Button start=new Button("开始“),

　　　　　　　　　　stop=new Button("停止");

　　private TextField tf=new TextField(10);

　　private runFlag=true;

　　private static int count=0;

　　private ThreadTest tt=null;

　　//将ThreadTest作为一个匿名内部类

　　private ThreadTest extends Thread{

　　　　//在构造ThreadTest示例对象的时候，启动线程

　　　　public ThreadTest(){

　　　　　　start();

　　　　}

　　　　@Override

　　　　public void run(){

　　　　　　while(true){

　　　　　　　　try{

　　　　　　　　　　Thread.currentThread().sleep(200);

　　　　　　　　}catch(InterruptedException e){

　　　　　　　　　　e.printStackTrace();

　　　　　　　　}

　　　　　　　　if(runFlag){

　　　　　　　　　　tf.setText(Integer.toString(++count));

　　　　　　　　}

　　　　　　}

　　　　}

　　}

　　class Start implements ActionListener{

　　　　@Override

　　　　public void actionPerformed(ActionEvent e){

　　　　　　if(tt==null)

　　　　　　　　tt=new ThreadTest();

　　　　}

　　}

　　class Stop implements ActionListener{

　　　　　@Override

　　　　　public void actionPerformed(ActionEvent e){

　　　　　　　　if(tt!=null)

　　　　　　　　　　runFlag=!runFlag;

　　　　　}

　　}

　　@Override

　　public void init(){

　　　　add(stop);

　　　　stop.addActionListener(new Stop());

　　　　add(start);

　　　　start.addActionListener(new Start());

　　　　add(tf);

　　}

　　public static void main(String[] args){

　　　　Frame frame=new Frame("程序片");

　　　　Test t=new Test();

　　　　frame.addWindowListener(

　　　　　　new WindowAdapter(){

　　　　　　　　@Override

　　　　　　　　public void windowClosing(WindwoEvent e){

　　　　　　　　　　System.exit(0);

　　　　　　　　}

　　　　　　}

　　　　);

　　　　frame.add(t,BorderLayout.CENTER);

　　　　frame.setSize(300,200);

　　　　t.init();

　　　　t.start();

　　　　frame.setVisible(true);

　　}

}

//在主类中合并线程

要将线程与主类合并，必须实现Runnable接口，重写run()方法，但这与从Thread继承的类还是有很大的差别。若要开启一个新的线程，只需将主类作为一个参数传入即可（类型上溯（Runnable））

import java.awt.*;

import java.awt.event.*;

import java.applet.*;

//实现Runnable接口

public class Test extends Applet implements Runnable{

　　private Button start=new Button("Start"),

　　　　　　　　　　stop=new Button("Stop");

　　private TextField tf=new TextField(10);

　　private Thread th=null;

　　private boolean runFlag=true;

　　private static int count=0;

　　//重写run方法

　　@Override

　　public void run(){

　　　　while(true){

　　　　　　try{

　　　　　　　　th.sleep(200);

　　　　　　}catch(InterruptedException e){

　　　　　　　　e.printStackTrace();

　　　　　　}

　　　　　　if(runFlag)

　　　　　　　　tf.setText(Integer.toString(++count));

　　　　}

　　}

　　class Start implements ActionListener{

　　　　@Override

　　　　public void actionPerformed(ActionEvent e){

　　　　　　if(th==null){

　　　　　　　　//传入当前上下文对象，即上溯类型Runnable(因为实现了此接口)

　　　　　　　　th=new Thread(Test.this);

　　　　　　　　th.start();

　　　　　　}

　　　　}

　　}

　　class Stop implements ActionListener{

　　　　@Override

　　　　public void actionPerformed(ActionEvent e){

　　　　　　runFlag=!runFlag;

　　　　}

　　}

　　@Override

　　public void init(){

　　　　add(start);

　　　　start.addActionListener(new Start());

　　　　add(stop);

　　　　stop.addActionListener(new Stop());

　　　　add(tf);

　　}

　　public static void main(String[] args){

　　　　Frame frame=new Frame("程序片");

　　　　Test t=new Test();

　　　　frame.add(t,BorderLayout.CENTER);

　　　　frame.addWindowListener(

　　　　　　　new WindowAdapter(){

　　　　　　　　　@Override

　　　　　　　　　　public void windowClosing(WindwoEvent e){

　　　　　　　　　　　　System.exit(0);

　　　　　　　　　　}

　　　　　　　　}

　　　　);

　　　　frame.setSize(300,200);

　　　　t.init();

　　　　t.start();

　　　　frame.setVisible(true);

　　}

}

//基础知识：在匿名内部类中不能声明静态变量

/**--注意--**/

以上代码都是在文本编辑器中写的，可能会有些许纰漏

java中有一个FilenameFilter的接口，能够过滤得到指定类型的文件或者目录，其中必须重写accept（File file,String path）方法

public class DirFilter implements FilenameFilter{

　　private String type;

　　public DirFilter(String tp){

　　　　this.type=tp;

　　}

　　public boolean accept(File fl,String path) throws Exception{

　　　　　File file=new File(path);

　　　　　String filename=file.getName();

　　　　　return filename.indexOf(type)!=-1;

　　}

}

具体应用方法：File假如是一个Directory，可以通过list()方法得到这个目录下所有的文件和目录的名称数组，list()方法，一种是没有参数，一种是实现FilenameFilter接口的参数，例如要获得一个指定目录下的所有的java文件，就要使用第二种带参数的list()方法

public class Test{

　　public static void main(String[] args){

　　　　try{

　　　　　　//指定目录(“.”表示当前目录)

　　　　　　File dir=new File(".");

　　　　　　String[] names;

　　　　　　//获得所有java文件

　　　　　　DirFilter filter=new DirFilter(".java");

　　　　　　names=dir.list(filter);

　　　　　　//打印所有java文件名称

　　　　　　for(int i=0;i<names.length;i++){

　　　　　　　　System.out.println("i:"+i+" name:"+names[i]);

　　　　　　}

　　　　}catch(Exception e){

　　　　　　e.printStackTrace();

　　　　}

　　}

}

其中这里还可以将DirFilter类作为Test的一个匿名内部类来实现，例如：

public class Test{

　　//type：必须声明为final类型，作为一个匿名内部类，访问的变量都必须声明为final类型

　　public static FilenameFilter filter(final String type) throws Exception{

　　　　return new FilenameFilter(){

　　　　　　public boolean accept(File file,Stirng path){

　　　　　　　　String filename=new File(path).getName();

　　　　　　　　return filename.indexOf(type)!=-1;

　　　　　　　　}　

　　　　　　};　　　

　　}

　　public static void main(String[] args){

　　　　try{　　　　

　　　　　　File file=new File(".");

　　　　　　String names[];

　　　　　　names=file.list(filter(".java");

　　　　　　for(int i=0;i<names.length;i++){

　　　　　　　　System.out.println("i:"+i+" filename:"+names[i]);

　　　　　　}

　　　　catch(Exception e){

　　　　　　e.printStackTrace();

　　　　}

　　}　　

}

//基础知识1：在一个java文件中，有且只能有一个公共类，即类的修饰符为public

//基础知识2：接口中所定义的任何对象默认作用域都为public

//基础知识3：Exception的命名空间为java.lang.Exception

/**--注意--**/

以上代码都是在文本编辑器中写的，可能会有些许纰漏

其实所有的java对象都可以具备克隆能力，只是因为在基础类Object中被设定成了一个保留方法（protected),要想真正拥有克隆的能力，就需要实现Cloneable接口，重写clone方法。通过克隆方法得到的对象得到的是一个本地的副本。

代码示例：

class User implements Cloneable{

　　int age;

　　public User(int age){

　　　　//用this关键字不至于类成员变量与形参混淆

　　　　this.age=age;

　　}

　　//这里可加@Override也可不加，加了会自动提示是否正确

　　@Override

　　public Object clone{

　　　　Object o=null;

　　　　try{

　　　　　　o=super.clone();

　　　　}catch(CloneNotSupportedException e){

　　　　　　e.printStackTrace();

　　　　}

　　}

　　public String toString(){

　　　　return Integer.toString(this.age);

　　}

}

public class Test{

　　//(1)main中只能调用静态方法（2）修改的是传入的User对象

　　static User g(User u){

　　　　u.age++;

　　　　return u;

　　}

　　//在本地产生了一个User对象副本

　　static User f(User u){

　　　　u=(User)u.clone();

　　　　u.age++;

　　　　return u;

　　}

　　public static void main(String[] args){

　　　　User u=new User(23);

　　　　User u2=g(u);

　　　　if(u==u2)

　　　　　　System.out.println("u==u2");

　　　　else

　　　　　　System.out.println("u!=u2");

　　　　//下面会自动调用User对象的toString()方法

　　　　System.out.println("u.age:"+u);

　　　　System.out.println("u2.age:"+u2);

　　　　User u3=new User(23);

　　　　User u4=f(u3);

　　　　if(u3==u4)

　　　　　　System.out.println("u3==u4");

　　　　else

　　　　　　System.out.println("u3!=u4");

　　　　System.out.println("u3.age:"+u3);

　　　　System.out.println("u4.age:"+u4);

　　}

}

//基本知识：要想让对象具有clone方法，只要实现Cloneable接口，重写clone方法即可，但是有两个需要注意的点：（1）调用super.clone()方法（2）定义为public公共方法

/**--注意--**/

以上代码都是在文本编辑器中写的，可能会有些许纰漏