今天看别人写的代码我感觉好高深，分享下

Question

他创建一个类对象有个属性是集合，反过来又用集合添加了这个类对象，我以为不能这么做呢，结果运行通过了，可是我觉得这和java的抽象哲学相违背啊。就好像人这个类里张三的身高属性又包含了张三这个类对象一样，你们怎么看呢，大家一起讨论下么java

Answer 1

不全对，后边对集合和这个类都做了处理，然后还是不停的循环的。package chat;import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;public class Client implements ActionListener,KeyListener{ /**
 * @param args
 */
private JFrame f;
private JPanel p;
private JTextArea text;
private JScrollPane jsp;
private JLabel jlname;
private JTextField txtname,txt;
private JButton butok;
private Socket client;

private BufferedReader br;
private BufferedWriter bw;


public Client()
{
f = new JFrame("聊天系统_客户端");
p = new JPanel();
text = new JTextArea(30,50);
jsp = new JScrollPane(text);

jlname = new JLabel("姓名:");
txtname = new JTextField(5);
txt = new JTextField(15);
txt.addKeyListener(this);
butok = new JButton("发送");
butok.addActionListener(this);

p.add(jlname);
p.add(txtname);
p.add(txt);
p.add(butok);

f.add(jsp);
f.add(p,BorderLayout.SOUTH);

f.setBounds(100, 100, 400, 500);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.show();
//网络通信
try {
client  = new Socket("127.0.0.1",8000);

//交互信息
br = new BufferedReader(new InputStreamReader(client.getInputStream()));
bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
String line="";
while(true)
{
line = br.readLine();
if(line==null)break;
text.append(line+"\n");
}
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
System.exit(-1);
} catch (IOException e) {
// TODO Auto-generated catch block
System.exit(-1);
}
finally
{
try {
br.close();
bw.close();
client.close();
} catch (IOException e) {
// TODO Auto-generated catch block
System.exit(-1);
}


}

}

public void send()
{
String name = txtname.getText().trim();
String str = txt.getText().trim();
text.append("我说:"+str+"\n");
txt.setText("");

try {
bw.write(name+"说:"+str+"\n");
bw.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
txt.requestFocus();



}


public static void main(String[] args) {
// TODO Auto-generated method stub
        new Client();
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getSource()==butok)
{
  send();
}
}
@Override
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
if(e.getKeyCode()==KeyEvent.VK_ENTER)
{
  send();
}
}
@Override
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub

}
@Override
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub

}}package chat;import java.io.*;
import java.net.Socket;
import java.util.Vector;public class DaiLi implements Runnable { private Socket s;
private Vector v;
private BufferedReader br;
private PrintWriter pw;

public DaiLi(Socket s,Vector v)
{
 this.s = s;
 this.v = v;
 
 try {
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
pw = new PrintWriter(s.getOutputStream(),true);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
 
 
 Thread th = new Thread(this);
 th.start();
}
@Override
public void run() {
// TODO Auto-generated method stub

                
String str ="";
 while(true)
 {
 try {
str=br.readLine();
if(str==null)break;
for(int i=0;i<v.size();i++)
{
DaiLi dl = (DaiLi)v.elementAt(i);

if(dl!=this)
{
      dl.pw.println(str);
}
}
} catch (IOException e) {
// TODO Auto-generated catch block
System.exit(-1);
}
 
 }
 try {
br.close();
pw.close();
s.close();
v.remove(this);

} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}}package chat;import java.io.IOException;
import java.net.*;
import java.util.Vector;public class Server { /**
 * @param args
 */
private ServerSocket server;
private Vector v;

public Server()
{
try {
v = new Vector();
server = new ServerSocket(8000);


while(true)
{
 System.out.println("准备连接");
 Socket s = server.accept();
 System.out.println("连接成功");
 //执行线程，线程处理信息交互
 DaiLi dl = new DaiLi(s,v); 
 v.add(dl);

}

} catch (IOException e) {
// TODO Auto-generated catch block

System.exit(-1);
try {
server.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}

}

public static void main(String[] args) {
// TODO Auto-generated method stub
       new  Server();
}}//执行线程，线程处理信息交互
的下两行他就把类对象付给集合，把集合添加了类对象，我觉得这样不好，但是后边daili里还要关掉v这个集合，我想不出好办法，貌似只能这样了，你有什么好办法么，我的server是这么写的package chat;import java.io.IOException;
import java.net.*;
import java.util.Vector;public class Server { /**
 * @param args
 */
private ServerSocket server;
private Vector v;

public Vector getV() {
return v;
} public void setV(Vector v) {
this.v = v;
} public Server()
{
try {
v = new Vector();
server = new ServerSocket(8000);


while(true)
{
 System.out.println("准备连接");
 Socket s = server.accept();
 System.out.println("连接成功");
 //执行线程，线程处理信息交互
// DaiLi dl = new DaiLi(s,v); 
 //v.add(dl);
 v.add(s);
 new Thread(new DaiLi(s)).start();
 

}

} catch (IOException e) {
// TODO Auto-generated catch block

System.exit(-1);
try {
server.close();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}

}

public static void main(String[] args) {
// TODO Auto-generated method stub
       new  Server();
}}但是到了移除v的时候我就无解了

Answer 2

//v.remove(this);

a.setV(a.getV().remove(this));
本来想把dali改成这样，可是发现返回值是布尔型的，不能放在set里边，我就不会啦

Answer 3

LinkedList是用双向链表实现的，就像火车一样
每一个java.util.LinkedList.Entry对象，就像是一个火车车厢，每一个Entry对象都有前一个Entry的引用，和后一个Entry的引用，每一个Entry通过这两个引用来确定自己的位置。就好象排队的时候，你只要记得前面和后面的人是谁就可以了。
源码如下：private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;

Answer 4

我这里也有类似的聊天程序: http://raysmond.com/article/71

Answer 5

可以是同一个对象：
public class myTest {
ArrayList<myTest> al=new ArrayList<myTest>();
public void showMsg(){ //定义个方法
System.out.println("bbbbbbbbb");
}

public void add(myTest m){ //定义自己增加自己
al.add(m);
m.showMsg();
}
public static void main(String args[]){

myTest m=new myTest();
for(int i=0;i<10;i++){
m.add(m);//使用自己的方法增加自己10遍
}这不就是类对象的方法属性增加自己当前这个对象，但是内存还是一块，我理解就是一个引用多了个壳子句柄而已。

Answer 6

比如说张三，他一个属性是亲戚[]，然后这里面包含了李四、王五、赵六。
但是他们都是People这个类的对象。。

Answer 7

楼主要用过struts2 的VO和标签
你就没必要这么大惊小怪了！！！

Answer 8

JUnit框架中TestSuite有相似的特性,事实上,Chain Of Resposibility的实现基本上也是这种做法。算的上比较常见的。

Answer 9

类对象的属性包含自己的例子很多。但是使用场景给你这个不太一样
java中的'this'。delphi 中的'self'，都是指向自己的

Answer 10

类对象的属性包含自己的例子很多。但是使用场景给你这个不太一样
 java中的'this'。delphi 中的'self'，都是指向自己的 

Answer 11

你认为出现了“死循环”，是么？在实际的Web开发中，确实不能这样做，因为会使Json数据的无限拼装，引起内存溢出。不过从纯Javase的角度讲，这是可以的。
与其说是“他创建一个类对象有个属性是集合，反过来又用集合添加了这个类对象”，不如说是：对象包含一个属性，这个属性是“指针数组”，里边的指针类型是“指向人的指针”，只不过“其中的一个指针指向了张三”。
以下两点，均是出于“面向过程”的思想，但能帮助你深刻理解“面向对象”的思想：
1、Java处处是指针，引用存在于栈内存中，指向堆内存中的对象。
2、引用传递的底层实现依然是值传递。