各位大哥 问个非常菜菜的问题，100分想送！

Question

............
    public static void main(String[] args) {
        JChatServer cs = new JChatServer("JChatServer");
        cs.start();
        JChatClient cc = cs.new JChatClient();
        cc.start();
    }
.............
帮忙解释一下好么？这样写有什么好处？拜托了

Answer 1

应该是两个线程，当你创建了两个线程之后，你要用START()方法启动它，此时它就变成了可执行线程，等待cpu调度运行。比如两个线程中当有一个调用了Sleep(int x)之后，另一个线程可能就会得到执行的机会了。线程是比较复杂的，建议看看书吧。

Answer 2

cs.new JChatClient();？
可以这样吗？
new JChatClient();
吧？不知你指的是什么，如果是说code的先后顺序的话，应该没有什么好处不好处的，习惯而已。

Answer 3

一个server
一个client
没啥可比性吧
但是如果不使用线程的话
那么当main函数执行完后，server也就关了

Answer 4

可以看出JChatServer和JChatClient是自定义的两个线程类（继承自Thread类或实现了Runnable接口）JChatServer
从名字看应该是聊天的
JChatServer里应该启动ServerSocked
JChatClient里应该是Sockedstart()方法是启动线程
这个应该是启动两个线程就可以用Socket进行通信了

Answer 5

cs.new JChatClient();？
可以这样吗？
new JChatClient();
吧？兄弟，应该是这样的。很显然JChatClient类是JChatServer类的内部类。
内部类创建对象就的用cs.new JChatClient();

Answer 6

JChatClient类是JChatServer类的内部类。
内部类创建对象就的用cs.new JChatClient();
是两个线程，当你创建了两个线程之后，你要用START()方法启动它，此时它就变成了可执行线程，等待cpu调度运行。比如两个线程中当有一个调用了Sleep(int x)之后，另一个线程可能就会得到执行的机会了。

Answer 7

JChatServer的结构如下:
public class JChatServer implements Runnable {
  //....
     public class JChatClient() implements Runnable {
         public void run(){
             //...
         }
     }
  //....
}
这样在外界调用的时候就可以使用JChatClient cc = cs.new  JChatClient();来调用cs的内部类JChatClient.
不过还是建议使用getter Method来进行此操作也就是修改JChatServer的结构为:
public class JChatServer implements Runnable {
  //....
     //added Method 
     public JChatClient  getJChatClient(){
        return new  JChatClient();
     }
     //end added
     private class JChatClient() implements Runnable {
         public void run(){
             //...
         }
     }
  //....
}
调用的时候使用JChatClient cc = cs.getJChatClient();进行调用

Answer 8

关于为什么使用内部类,最令人信服的理由是:
1.每个内部类能自己进行实做(implements),并且不受限与外部类的implements.从某个角度来看内部类,可以说它实多重继承的完整解决方案.虽然接口可以解决多重继承的一部分问题,但是只有使用内部类才能实现多重实做继承(multiple implements inheritance),也就是说只有使用内部类可以实现继承多个非接口的对象.
例如:
interface A{}
interface B{}
Class X implements A,B{
}
Class Y implements A {
  Class InnerY implents B {
  } 
}
X与Y的实现可能没有什么大的区别,但是如果A,B不是接口,而是抽象类的话,只能使用InnerClass来实现了:
abstract Class A{}
abstract Class B{}
Class Y implements A {
  Class InnerY implents B {
  } 
}
2.相对一个外部类而言,内部类可以有很多个实例,每个实例都是相互独立的,不受外部类的影响.(个人估计这是上面程序用innerClass的原因)

Answer 9

多线程，特点就是start以后并不等执行完，而是直接跳回main