亚洲婷婷国产精品电影人久久,亚洲人成影院在线,久久久久亚洲国产AV麻豆

Java Basic-Java I/O(�?

blovesaga — Sun, 11 Jun 2006 13:27:00 GMT

�~�码�Q�将一个Unicode码�{换�ؓ本地字符表示的过�E��ؓ�~�码�?br /> 解码�Q�将一个字节�{换�ؓ一个字�W�（用Unicode表示�Q�，�q�个�q�程叫解码�?br /> [��单的说去获取一个Unicode码就是解码]
code:

import java.util.*;
import java.nio.charset.*;
class CharsetTest
{
public static void main(String[] args)throws Exception
{
  /*
  Map m=Charset.availableCharsets();
  Set names=m.keySet();
  Iterator it =names.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  Properties pps=System.getProperties();
  //pps.list(System.out);
  pps.put("file.encoding","ISO-8859-1");
  int data;
  byte[] buf=new byte[100];
  int i=0;
  while((data=System.in.read())!='q')
  {
   buf[i]=(byte)data;
   i++;
  }
  String str=new String(buf,0,i);
  //String strGBK=new String(str.getBytes("ISO-8859-1"),"GBK");
  //System.out.println(strGBK);
  System.out.println(str);
}
}

RandomAccessFile

RandomAccessFile�c�d��时实��C��DataInput和DataOutput接口�Q�提供了�Ҏ(gu��)��仉��机存取的功能�Q?br /> 利用�q�个�c�d��以在文�g的�Q何位�|�读取或写入数据�?br /> RandomAccessFile�c�L��供了一个文件指针，用来标志要进行读写操作的下一位数据的位置�?

code:
import java.io.*;
class RandomFileTest
{
public static void main(String[] args)throws Exception
{
  Student s1 = new Student(1,"zhangsan",98.5);
  Student s2 = new Student(2,"lisi",90.5);
  Student s3 = new Student(3,"wangwu",78.5);

  RandomAccessFile rsf=new RandomAccessFile("student.txt","rw"); //存取模式rw
  s1.WriteStudent(rsf);
  s2.WriteStudent(rsf);
  s3.WriteStudent(rsf);

  Student s =new Student();
  rsf.seek(0); //把文件指针移到文仉��
  for(long i=0;i  {
   s.ReadStudent(rsf);
   System.out.println(s.num+":"+s.name+":"+s.score);
  }
  rsf.close();
}
}

class Student
{
int num;
String name;
double score;
Student()
{

}
Student(int num,String name,double score)
{
  this.num=num;
  this.name=name;
  this.score=score;
}
public void WriteStudent(RandomAccessFile raf)throws Exception
{
  raf.writeInt(num);
  raf.writeUTF(name);
  raf.writeDouble(score);
}
public void ReadStudent(RandomAccessFile raf)throws Exception
{
  raf.readInt();
  raf.readUTF();
  raf.readDouble();
}
}

对象序列�?/p>

.��对象�{换�ؓ字节��保存�v来，�q�在日后�q�原�q�个对象�Q�这�U�机制叫做对象序列化�?br /> .��一个对象保存到�怹�存储讑֤�上称为持�l�性�?br /> .一个对象要惌��够实现序列化�Q�必��d��现Serializable接口或Externalizable接口�?br /> .当一个对象被序列化时�Q�只保存对象的非静态成员变量，不能保存��M��的成员变量和静态的
成员变量�?br /> .如果一个对象的成员变量是一个对象，那么�q�个对象的数据成员也会被保存�?br /> .如果一个可序列化的对象包含�Ҏ(gu��)��个不可序列化的对象的引用�Q�那么整个序列化操作��会��p�|�Q?br /> �q�且会抛��Z��个NotSerializableException。我们可以将�q�个引用标记为transient,那么对象
仍然可以序列化�?/p>

code:
import java.io.*;
class ObjectSerialTest
{
public static void main(String[] args)throws Exception
{
  Employee e1 = new Employee("zhangsan",20,2800.50);
  Employee e2 = new Employee("lisi",22,25000.50);
  Employee e3 = new Employee("wangwu",23,12800.50);
  Employee e4 = new Employee("blovesaga",22,3800.50);

  FileOutputStream fos=new FileOutputStream("employee.txt");
  ObjectOutputStream oos=new ObjectOutputStream(fos);
  oos.writeObject(e1);
  oos.writeObject(e2);
  oos.writeObject(e3);
  oos.writeObject(e4);
  oos.close();

  FileInputStream fis = new FileInputStream("employee.txt");
  ObjectInputStream ois =new ObjectInputStream(fis);
  Employee e;
  for(int i=0;i<4;i++)
  {
   e=(Employee)ois.readObject();
   System.out.println(e.name+":"+e.age+":"+e.salary);
  }
  ois.close();
}
}

class Employee implements Serializable
{
String name;
int age;
double salary;
transient Thread t1 =new Thread();
Employee(String name,int age,double salary)
{
  this.name=name;
  this.age=age;
  this.salary=salary;
}
//可以写private void readObject()�Ҏ(gu��)��来控制我们自己想要实现的
private void writeObject(java.io.ObjectOutputStream oos)throws Exception
{
  //例如我们自己写想要显�C�的��序和那些需要显�C?br />  oos.writeInt(age);
  oos.writeUTF(name);
  System.out.println("Write Object");
}
private void readObject(java.io.ObjectInputStream ois)throws Exception
{
  //按照写入的顺序来��d��
  age=ois.readInt();
  name=ois.readUTF();
  System.out.println("Read Object");
}
}

blovesaga 2006-06-11 21:27 发表评论

基础学习�?--Java I/O学习(一)

blovesaga — Sun, 11 Jun 2006 06:18:00 GMT

File�c?/p>

一个File�cȝ��对象�Q�表�C�Z��盘上的文�g或目录�?br /> File�c�L��供了与��^台无关的�Ҏ(gu��)��来对��盘上的文�g或目录进行操作�?/p>

import java.io.*;
class FileTest
{
public static void main(String[] args) throws Exception
{
  //File f = new File("1.txt");
  //f.createNewFile();   创徏文�g
  //f.mkdir(); 创徏文�g�?br />  //File f = new File("F:\\Java Develop\\1.txt");//使用�l�对路径
  //f.createNewFile();
  /*
  *WINDOWS�q�_��下有盘符�Q�LINUX下是没有�?br />  *考虑到JAVA语言的��^台性，所有用分隔�W�seperator/seperatorChar
  */
  /*
  File fDir = new File(File.separator);//创徏了当前的根目�?br />  String strFile = "Java Develop"+File.separator+"1.txt";
  File f = new File(fDir,strFile);
  f.createNewFile();
  //f.delete();
  f.deleteOnExit();
  Thread.sleep(3000);
  */
  /*
  for(int i=0;i<5;i++)
  {
   File.createTempFile("linshi",".tmp");
   f.deleteOnExit();
  }
  Thread.sleep(3000);
  */

  File fDir = new File(File.separator);
  String strFile ="Java Develop"+File.separator;
  File f = new File(fDir,strFile);
  //文�g�q��o�?br />  String[] names = f.list(new FilenameFilter()
  {
   public boolean accept(File dir,String name)
   {
    return name.indexOf(".java")!=-1;
   }
  });
  for(int i=0;i  {
   System.out.println(names[i]);
  }
}
}

��式I/0

��?Stream)是字节的源或目的�?br /> 两种基本的流�? 输入��?Input Stream)和输出流(Output Stream)。从从中��d��一�p�d��字节�?br /> 对象�U�Cؓ输入��。而能向其中写入一�p�d��字节的对象称��出流�?/p>

��的分类

节点��? 从特定的地方��d��的流�c�，例如�Q�磁盘或一块内存区域�?br /> �q��o��? 使用节点作�ؓ输入或输出。过滤流使用的是一个已�l�存在的输入��或输出��连接创建的�?br /> (如下�?

         InputStream(一个抽象的基类)
.三个基本的读写方�?br /> abstract int read(): ��d��一个字节数据，�q�返回到数据�Q�如果返�?1�Q�表�C��C��输入��的
                       末尾�?br /> int read(byte[] b): ��数据读入一个字节数�l�，同时�q�回实际��d��的字节数。如果返�?1�Q?br />                       表示��d��了输入流的末��?br /> int read(byte[] b,int off,int len): ��数据读入一个字节数�l�，同时�q�回是实际读取的�?br />                       节数。如果返�?1�Q�表�C��C��输入��的末尾。off指定在数�l�b中存�?br />                       数据的�v始偏�U�M��|�；len指定��d��的最大字节数�?br /> 其他的方�?br /> long-skip(long n): 在输入流中蟩�q�n个字节，�q�返回实际蟩�q�的字节数�?br /> int available():   �q�回在不发生��d��的情况下�Q�可��d��的字节数�?br /> void close():      关闭输入��，释放和这个流相关的系�l�资源�?br /> void mark(int reqdlimit): 在输入流的当前位�|�放�|�一个标讎ͼ�如果��d��的字节数多余
                     readlimit讄��的��|��则流忽略�q�个标记�?br /> void reset():      �q�回��C��一个标记�?br /> boolean markSupported(): ��试当前是否支持mark和reset�Ҏ(gu��)��。如果支持返回true�Q�反之false�?/p>

java.io包中的InputStream的类层次 (下图)

OutputStream

三个基本的写�Ҏ(gu��)��
abstract void write(int b): 往输出��中写入一个字�?br /> void write(byte[] b): 往输出��中写入数组b中的所有字�?br /> void writte(byte[] b,int off,int len): 往输出��中写入数组b中从偏移量off开始的len�?br /> 字节的数�?br /> 其它�Ҏ(gu��)��
void flush(): ��h��输出��，强制�~�冲��Z��的输出字节被写出
void close(): 关闭输出��，释放和这个流相关的系�l�资�?/p>

java.io包中OutputStream的类层次(如下�?

基本的流�c?/p>

FileInputStream和FileOutputStream
节点��，用于从文件中��d��或往文�g中写入字节流。如果在构造FileOutputStream�Ӟ��文�g已经
存在�Q�则覆盖�q�个文�g�?br />
BufferedInputStream和BufferedOutputStream
�q��o��，需要��用已�l�存在的节点��来构造，提供带缓冲的��d��Q�提高了��d��的效率�?/p>

DataInputStream和DataOutputStream
�q��o��，需要��用已�l�存在的节点��来构�?提供了读写Java中的基本数据�c�d��的功能�?/p>

PipedInputStream和PipedOutputStream
��道��，用于�U�程间的通信。一个线�E�的PipedInputStream对象从另一个线�E�的PipedOutputStream
对象��d��输入。要使管道流有用�Q�必��d��时构造管道输入流和管道输出流�?/p>

code:
import java.io.*;
class StreamTest
{
public static void main(String[] args)throws Exception
{
  /*
  int data;
  while((data=System.in.read())!=-1) //从标准设备读取数�?br />  {
   System.out.write(data);//从标准设备输出数�?br />  }
  */
  //输出��写数据,只需要关闭尾端的��就可以了，因�ؓfos�q�接��C��bos
  FileOutputStream fos = new FileOutputStream("1.txt");
  //fos.write("());
  //fos.close();
  BufferedOutputStream bos = new BufferedOutputStream(fos);
  //bos.write("http//www.baidu.com".getBytes());
  //bos.flush();
  //bos.close();
  DataOutputStream dos=new DataOutputStream(bos); //�q�接��C��bos和fis
  byte b=3;
  int i=78;
  char ch='a';
  float f=4.5f;
  dos.writeByte(b);
  dos.writeInt(i);
  dos.writeChar(ch);
  dos.writeFloat(f);
  dos.close(); //必须调用flush()或者close()不然不会写入��盘

  //输入��读数据
  FileInputStream fis=new FileInputStream("1.txt");
  BufferedInputStream bis = new BufferedInputStream(fis);
  //byte[] buf=new byte[100];
  //int len=fis.read(buf);
  //int len=bis.read(buf);
  //System.out.println(new String(buf,0,len));
  //fis.close();
  //bis.close();
  //注意��d��的顺序要和写的顺序一�?br />  DataInputStream dis = new DataInputStream(bis);
  System.out.println(dis.readByte());
  System.out.println(dis.readInt());
  System.out.println(dis.readChar());
  System.out.println(dis.readFloat());
  dis.close();

}
}

��道输入/输出��?code:
import java.io.*;
class PipedStreamTest
{
public static void main(String[] args)
{
  PipedOutputStream pos=new PipedOutputStream();
  PipedInputStream pis=new PipedInputStream();
  //�q�接
  try
  {
   pos.connect(pis);
   new Producer(pos).start();
   new Consumer(pis).start();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

class Producer extends Thread
{
private PipedOutputStream pos;
public Producer(PipedOutputStream pos)
{
  this.pos=pos;
}
public void run()
{
  try
  {
   pos.write("hello,welcome!".getBytes());
   pos.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

class Consumer extends Thread
{
private PipedInputStream pis;
Consumer(PipedInputStream pis)
{
  this.pis=pis;
}
public void run()
{
  try
  {
   byte[] buf=new byte[100];
   int len=pis.read(buf);
   System.out.println(new String(buf,0,len));
   pis.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

=================================================================================
Java I/O库的设计原则

Java的I/O库提供了一个称做链接的机制�Q�可以将一个流与另一个流首尾相接�Q��Ş成一个流��道的链接�?br /> �q�种机制实际上是一�U�被�U�做为Decorator(装饰)的设计模式的应用�?br />
通过��的链接�Q�可以动态的增加��的功能�Q�而这些功能的增加是通过�l�合一些流的基本功能而动
态获取的�?/p>

我们要获取一个I/O对象�Q�往往需要��生多个I/O对象�Q�这也是Java I/O库不大容易掌握的原因�Q?br /> 但在I/O库中的Decorator模式的运用，�l�我们提供了实现上的灉|��性�?/p>

I/O��的链接�?如下)

Reader和Writer

Java�E�序语言使用Unicode来表�C�字�W�串和字�W��?br /> Reader和Writer�q�两个抽象类主要用来��d��字符��?/p>

java.io包中Reader的类层次(如下�?

java.io包中Writer的类层次(如下�?

code:
import java.io.*;
class StreamTest
{
public static void main(String[] args)throws Exception
{
  /*
  FileOutputStream fos = new FileOutputStream("1.txt");
  OutputStreamWriter osw = new OutputStreamWriter(fos);
  BufferedWriter bw = new BufferedWriter(osw);

  bw.write("  bw.close();

  FileInputStream fis = new FileInputStream("1.txt");
  InputStreamReader isr = new InputStreamReader(fis);
  BufferedReader br = new BufferedReader(isr);
  System.out.println(br.readLine());
  br.close();
  */
  //InputStreamReader/OutputStreamWriter是一个中间过度类,�q�接字符和字�W�串
  InputStreamReader isr = new InputStreamReader(System.in);
  BufferedReader br = new BufferedReader(isr);
  String strLine;
  while((strLine=br.readLine())!=null)
  {
   System.out.println(strLine);
  }
  br.close();
}
}

字符集的�~�码

ASCII(American Standard Code for Information Interchange,��国信息互换标准代码),是基
于常用的英文字符的一套电(sh��)脑编码系�l�。我们知道英文中�l�常使用的字�W�，数字�W�号被计��机
处理旉��是以二进制编码的形式出现(bit)二进制数对应。其最高位�?�Q�相应的十进制数�?-127
如，数字1�Q�有一些制表符和其他符��L��成。ASCII是现金最通用的单字节�~�码�pȝ��?/p>

GB2312�Q?GB2312码是中华人民共和国国家汉字信息交换用�~�码�Q�全�U�《信息交换用汉字�~�码�?br /> �W�集-基本集》。主要用于给每一个中文字�W�指定相应的数字�Q�也��是�q�行�~�码。一个中文字�W?br /> 用两个字节的数字来表�C�，��Z��和ASCII码有所区别�Q�将中文字符每一个字节的最高位�|�都�?
来表�C��?/p>

GBK�Q��ؓ了对更多的字�W�进行编码，国家又发布了新的�~�码�pȝ��GBK�Q�GBK的K是“扩展”的汉语
拼音的第一个字母）。在新的�~�码�pȝ��里，除了完全兼容GB2312外，�q�对�J�体中文�Q�一些不常用
的汉字和许多�W�号�q�行了编码�?/p>

ISO-8859-1�Q�是西方国家所使用的字�W�编码集�Q�是一�U�单字节的字�W�集�Q�而英文实际上只用了其
中数字小�?28的部分�?/p>

Unicode: �q�是一�U�通用的字�W�集�Q�对所有语�a�的文字进行统一�~�码�Q�对每一个字�W�都采用2个字�?br /> 来表�C�，对于英文字符采取前面加�?”字节的�{�略实现�{�长兼容。如"a"的ASCII码�ؓ0x61,
UNICODE��׃ؓ0x00,0x61�?/p>

UTF-8: Elight-bit UCS Transformation Format,(UCS,Universal Character Set,通用字符�?
UCS是所有其他字�W�集标准的一个超�?。一�?位的ASCII码��|��对应的UTF码是一个字节，如果
字符�?x0000�Q�或�?x0080�?x007f之间�Q�对应的UTF码是两个字节�Q�如果字�W�在0x0800�?xffff
之间�Q�对应的UTF码是三个字节�?br />

blovesaga 2006-06-11 14:18 发表评论

集合框架中的接口

blovesaga — Fri, 09 Jun 2006 03:28:00 GMT

     Collection                   Map(和Collection接口没�Q何关�p?
       / \                         |
      /   \                        |
    Set   List                  SortedMap
    /
   /
SortedSet
(接口�?

所谓框架就是一个类库的集合。集合框架就是一个用来表�C�和操作集合的统一框架�Q�包含了实现
集合的接口和�c�R�?br />
集合框架中的接口

.Collection: 集合层次中的�Ҏ(gu��)��口，JDK没有提供�q�个接口直接的实现类�?br /> .Set: 不能包含重复的元素。SortedSet是一个按照升序排列元素的Set�?br /> .List: 是一个有序的集合�Q�可以包含重复的元素。提供了按照索引讉K��的方式�?br /> .Map: 包含了key-value寏V��Map不能包含重复的key。SortedMap是一个按照升序排列key的Map�?br />
集合框架中的实现�c?br />
实线表示�l�承�c�，虚线表示实现�c�R�?br /> (囑֦��?

.ArrayList: 我们可以��其看做是能够自动增长容量的数组�?br /> .利用ArrayList的toArray()�q�回一个数�l��?br /> .Arrays.asList()�q�回一个列表�?br /> .�q�代�?Iterator)�l�我们提供了一�U�通用的方式来讉K��集合中的元素�?/p>

注意: 从集合类中获取一个数�l?toArray(),从数�l�获取列表利用Arrays.asList()
例子:
import java.util.*;
class ArrayListTest
{
public static void printElement(Collection c)
{
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
}
public static void main(String[] args)
{
  ArrayList a = new ArrayList();
  /*
  a.add("abc");
  a.add("def");
  a.add("hjk");
  */

  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));
  /*
  Object[] o;
  o=a.toArray(); //��集合类转换为数�l?br />  for(int i=0;i  {
   System.out.println(o[i]);
  }

  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);

  for(int i=0;i  {
   System.out.println(a.get(i));
  }

  System.out.println(a);
  System.out.println(a);
  */

  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next�Ҏ(gu��)��
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //�q�代器的作用: 提供一�l�通用的访问方�?br />  printElement(a);
}
}

class Point
{
int x, y;
Point(int x, int y)
{
  this.x=x;
  this.y=y;
}
public String toString()
{
  return "x="+x+","+"y="+y;
}
}

Collections�c?/p>

.排序: Collections.sort(); [区别与Arrays.sort()]
(1) 自然排序(natural ordering);
(2) 实现比较�?Comparator)接口�?br /> .取最大和最��的元素: Collections.max(),Collections.min();
.在已排序的List中搜索指定的元素: Collections.binarySearch()�?/p>

代码�C�Z��:
import java.util.*;
class ArrayListTest
{
public static void printElement(Collection c)
{
  Iterator it = c.iterator();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
}
public static void main(String[] args)
{
  /*
  ArrayList a = new ArrayList();

  a.add("abc");
  a.add("def");
  a.add("hjk");


  a.add(new Point(1,1));
  a.add(new Point(2,2));
  a.add(new Point(3,3));

  Object[] o;
  o=a.toArray(); //��集合类转换为数�l?br />  for(int i=0;i  {
   System.out.println(o[i]);
  }

  List b = new ArrayList();
  b=Arrays.asList(o);
  System.out.println(b);

  for(int i=0;i  {
   System.out.println(a.get(i));
  }

  System.out.println(a);
  System.out.println(a);
  */

  /*
  Iterator it = a.iterator();
   如果要删除元素，必须先调用next�Ҏ(gu��)��
  it.next();
  it.remove();
  while(it.hasNext())
  {
   System.out.println(it.next());
  }
  */
  //�q�代器的作用: 提供一�l�通用的访问方�?br />  //printElement(a);

  Student s1 = new Student(1,"zhangsan");
  Student s2 = new Student(2,"lisi");
  Student s3 = new Student(3,"wangwu");
  Student s4 = new Student(3,"blovesaga");

  ArrayList a = new ArrayList();
  a.add(s1);
  a.add(s2);
  a.add(s3);
  a.add(s4);

  //Collections.sort(a);
  Collections.sort(a,new Student.StudentComparator());
  printElement(a);
}
}

class Point
{
int x, y;
Point(int x, int y)
{
  this.x=x;
  this.y=y;
}
public String toString()
{
  return "x="+x+","+"y="+y;
}
}

class Student implements Comparable
{
int num;
String name;
//实现比较器，它��L��和我们的一个类相关,用内部类
static class StudentComparator implements Comparator //��Z��调用方便声明为静态的
{
  public int compare(Object o1,Object o2)
  {
   Student s1 = (Student)o1;
   Student s2 = (Student)o2;
   int result=s1.num > s2.num ? 1: (s1.num==s2.num ? 0 : -1);
   if(result==0)
   {
    return s1.name.compareTo(s2.name);
   }
   return result;
  }
}
Student(int num,String name)
{
  this.num=num;
  this.name=name;
}
public int compareTo(Object o)
{
  Student s=(Student)o;
  return num > s.num ? 1 :( (num==s.num) ? 0 : -1);
}

public String toString()
{
  return +num+":"+name;
}
}

blovesaga 2006-06-09 11:28 发表评论

�U�程学习

blovesaga — Thu, 08 Jun 2006 04:21:00 GMT

多线�E�学�?/p>

* �E�序�Q�进�E�和�U�程
�E�序: 是指计算机指令的集合�Q�它以文件的形式存储在磁盘上�?br />�q�程: 是一个程序在其自�w�的地址�I�间中的一�ơ执行活动�?/p>

�q�程是资源的甌��Q�调度和独立�q�行的单位，因此�Q�它使用�pȝ��中的�q�行资源�Q�而程序不能申�?br />�pȝ��资源�Q�不能被�pȝ��调度�Q�也不能作�ؓ独立�q�行的单位，因此�Q�它不站用系�l�的�q�行资源�?/p>

�U�程: 是进�E�中一个单一的连接控制流�E�。一个进�E�可以有多个�U�程�?/p>

�U�程又称��量��q�程�Q�它和进�E�一��h��有独立的执行控制,由操作系�l�负责调度，区别在于�U�程
没有独立的存储空��_��而是和所属进�E�中的其它线�E�共享一个存储空��_��q��得线�E�间的通信�q?br />较进�E�简单�?br /> * Java对多�U�程的支�?br />Java在语�a��U�提供了对多�U�程�E�序设计的支持�?br />实现�U�程�E�序的两�U�方�?
(1)从Thread�cȝ��承；
(2)实现Runnable接口�?/p>

Java�q�行时系�l�实��C��一个用于调度线�E�执行的�U�程调度器，用于��定某一时刻由哪一个线�E�在
CPU上运行�?br />在java技术中�Q�线�E�通常是抢占式的而不需要时间片分配�q�程(分配�l�每个线�E�相�{�的CPU旉��?br />�q�程)。抢占式调度模型��是许多�U�程处于可以�q�行状态（�{�待状态）�Q�但实际上只有一个线�E�在
�q�行。该�U�程一直运行到它终止进入可�q�行状态（�{�待状态）�Q�或者另一个具有更高优�U�的�U�程
变成可运行状态。在后一�U�情况下�Q�低优先�U�的�U�程被高优先�U�的�U�程抢占�Q�高优先�U�的�U�程获得
�q�行的机会�?br />Java�U�程调度器支持不同优先��U�程的抢占方式，但其本��n不支持相同优先��U�程的时间片轮换�?br />Java�q�行时系�l�所在的操作�pȝ��Q�例�?windows2000�Q�支持时间片的轮换，则线�E�调度器��支�?br />相同优先�U�线�E�的旉��片轮换�?/p>

用多�U�程技术模拟一个售��系�l?br />实现代码如下:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
  new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object o = new Object();
public void run()
{
  while(true)
  {
   /*
    synchronized(o) //同步块在关键字后得加个对�?��L��的对象都可以)
    {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println(Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
    }
    */
    sell();
  }
}
public synchronized void sell() //同步�Ҏ(gu��)��
{
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println(Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
}
}
* �U�程的同�?br /> The code segments within a program that access the same object from separate,concurrent
thread are called "critical sections"�?br /> 同步的两�U�方式：同步块和同步�Ҏ(gu��)��
没一个对象都有一个监视器(monitor),或者叫做琐�?br /> 同步�Ҏ(gu��)��利用的是this所代表的对象的琐�?br /> 每个class也有一个琐�Q�是�q�个class所对应的Class对象的琐�?br />完整�C�Z��:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  /*
   *写一个try{}catch{}块让main()�Ҏ(gu��)��所在的�U�程�?�U?br />   *主要是想要线�E�优先启�?br />  */
  try
  {
   Thread.sleep(1);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  st.b=true;
  new Thread(st).start();
  //new Thread(st).start();
  //new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object obj = new Object();
boolean b=false;
public void run()
{
  if(b==false)
  {
   while(true)
      sell();
  }
  else
  {
     while(true)
   {
    synchronized(this) //同步块在关键字后得加个对�?��L��的对象都可以)
    {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("obj:"+Thread.currentThread().getName()+
          " sell tickets"+tickets);
          tickets--;
     }
    }
   // sell();
  }
  }

}
public synchronized void sell() //同步�Ҏ(gu��)��
{
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("sell():"+Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
}
}

* �U�程的死�?br /> 哲学家进��的问题
一帮哲学家在一赯��，但是每个人都只有1支筷子，大家都在�{�待别�h拿出一支筷子让自己
先吃�Q�然后再把自��q��拿出去，但是大家都不愿意拿出自己的筷子�?br /> �U�程1琐住了对象A的监视器�Q�等待对象B的监视器�Q�线�E?锁住了对象B的监视器�Q�等待对象A�?br /> 监视器，��造成了死琐�?/p>

�C�Z��代码:
class TicketSystem
{
public static void main(String[] args)
{
  SellTicket st = new SellTicket();
  new Thread(st).start();
  /*
   *写一个try{}catch{}块让main()�Ҏ(gu��)��所在的�U�程�?�U?br />   *主要是想要线�E�优先启�?br />  */
  try
  {
   Thread.sleep(1);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  st.b=true;
  new Thread(st).start();
  //new Thread(st).start();
  //new Thread(st).start();
}
}
class SellTicket implements Runnable
{
int tickets=100;
Object obj = new Object();
boolean b=false;
public void run()
{
  if(b==false)
  {
   while(true)
      sell();
  }
  else
  {
     while(true)
   {
    synchronized(obj) //同步块在关键字后得加个对�?��L��的对象都可以)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
      synchronized(this)
      {
            if(tickets>0)
             {
                System.out.println("obj:"+Thread.currentThread().getName()+
                " sell tickets"+tickets);
                tickets--;
              }
      }
      }
    }
  }

}
public synchronized void sell() //同步�Ҏ(gu��)��
{
  synchronized(obj)
  {
     if(tickets>0)
    {
       try
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
        e.printStackTrace();
      }
          System.out.println("sell():"+Thread.currentThread().getName()+
          "sell tickets"+tickets);
          tickets--;
     }
  }
}
}
* wait,notify,notifyAll
每个对象除了有一个琐之外�Q�还有一个等待队�?wait set),当一个对象刚刚创建的时候，�?br /> 的等待队列是�I�的�?br /> 我们应该在当前线�E�锁住对象的琐后�Q�去调用该对象的wait�Ҏ(gu��)��?br /> 当调用对象的notify�Ҏ(gu��)��Ӟ��从该对象的�{�待队列中删除一个�Q意的�U�程�Q�这个线�E�将再次
成�ؓ可运行的�U�程�?br /> 当调用对象的notifyAll�Ҏ(gu��)��Ӟ��从该对象的�{�待队列中删除所有等待的�U�程�Q�这些线�E�将
成�ؓ可运行的�U�程�?br /> wait和notify重要用于producer-consumer�q�种关系中�?br /> 代码�C�Z��:
class Test
{
public static void main(String[] args)
{
  Queque q = new Queque();
  Procedur p = new Procedur(q);
  Consumer c = new Consumer(q);
  p.start();
  c.start();

}
}

class Procedur extends Thread   //生��?br />{
Queque q;
Procedur(Queque q)
{
  this.q=q;
}
public void run()
{
  for(int i=0;i<10;i++)
  {
   q.put(i);
   System.out.println("Procedur put"+ i);
  }
}
}

class Consumer extends Thread   //消费�?br />{
Queque q;
Consumer(Queque q)
{
  this.q=q;
}
public void run()
{
  while(true)
  {
   System.out.println("Consumer get"+q.get());
  }
}
}

class Queque    //攄��数据
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
  if(!bFull)
  {
    value=i;
    bFull=true;
    notify();
  }
  try
  {
   wait();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
public synchronized int get()
{
  if(!bFull)
  {
   try
   {
    wait();
   }
   catch(Exception e)
   {
    e.printStackTrace();
   }
  }
  bFull=false;
  notify();
  return value;
}
}

�U�程的状态图

   |
   | new Thread
   |                   yield      sleep,wait,suspend,I/O��d��
\|/ start                     |------------------------------------>|
New----->Runnable|                                                        |Not Runnable
                            \    |<------------------------------------|        /
                             \     sleep�l�束,notify,resume,I/O操作完成    /
                              \                                                                /
                               \                                                             /
                                \                                                           /
                                 \                                                       /
                                  \ run�Ҏ(gu��)��退出                             �? /
                                   \stop�Ҏ(gu��)��调用                            /
                                    \                                               /
                                     \                                           /
                                      \                                        / stop�Ҏ(gu��)��调用
                                       \                                      /
                                        \                                     /
                                         \                                   /
                                          \                               /
                                           \                             /
                                            \                          /
                                             \ ______ _____/
                                              |    Dead         |
                                              |____________|
�U�程的终�?br />
讄��一个flag变量�?br /> �l�合interrupt()�Ҏ(gu��)��?br /> code:
class TestThread
{
public static void main(String[] args)
{
  Thread1 t1=new Thread1();
  t1.start();
  int index=0;
  while(true)
  {
   if(index++==500)
   {
    t1.stopThread();
    break;
   }
   System.out.println(Thread.currentThread().getName());
  }
}
}

class Thread1 extends Thread
{
private boolean bStop=false;
public void run()
{
  while(!bStop)
  {
   System.out.println(getName());
  }
}
public void stopThread()
{
  bStop=true;
}
}

blovesaga 2006-06-08 12:21 发表评论

blovesaga — Mon, 05 Jun 2006 07:16:00 GMT

摘要: JAVA �E�序员面�? 32 �? �W�一�Q�谈�? final �Q? ... 阅读全文

blovesaga 2006-06-05 15:16 发表评论

blovesaga — Mon, 05 Jun 2006 06:47:00 GMT

>>>>>>>>>>>>>>>>Runtime和Process�c?lt;<<<<<<<<<<<<<<<<<<
1> 每一个Java�E�序都有一个Runtime�cȝ��单一实例�?br />2> 通过Runtime.getRuntime()获取Runtime�cȝ��实例�?br />3> Runtime�c�L��使用单例模式的一个例子�?br />   Runtime没有public的构造方法。我们必��ȝ��Runtime的静态方法getRuntime();我们可以�?br />   Runtime的exec来执行一个外部程序，也可以用来编译一个源文�g(用来做图形界面的�~�译�?�?br />import java.io.*;
class RuntimeTest
{
public static void main(String[] args)
{
  Runtime rt=Runtime.getRuntime();
  //System.out.println(rt.freeMemory());
  try
  {
   //rt.exec("notepad");
   Process p=rt.exec("java ArrayTest");
   InputStream is=p.getInputStream(); //从执行ArrayTest�c�L��得来�?br />   int data;
   while((data=is.read())!=-1)
   {
    System.out.print((char)data);
   }
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
}
}

------------->>设计模式<<-------------
1> 在我们进行程序设计时,逐渐形成了一些典型问题和问题解决�Ҏ(gu��)��,�q�就是��Y件模式�?br />2> 每一个模式描�q�C��一个在我们�E�序设计中经常发生的问题,以及该问题的解决�Ҏ(gu��)��?br />3> 当我们碰到模式所描述的问题，��可以直接用相应的解��x��法去解决�q�个问题,�q�就是设计模式�?br /><$>单例(Singleton)模式
1> 一个类只有一个实例，而且自行实例化�ƈ像整个系�l�提供这个实例，�q�个�cȝ��为单例类�?br />2> 单例�cȝ��一个重要特点就是类的构造方法是�U�有�?从而避免了外部用利用构造方法直接创建多个实例�?br /> �?Runtime�c�R�?/p>

单例�cȝ��实现:(code)
class Singleton
{
private static final Singleton st=new Singleton();
private Singleton()
{

}
public static Singleton getInstance()
{
return st;
}
}

blovesaga 2006-06-05 14:47 发表评论

��装�c?amp;&Class

blovesaga — Sun, 04 Jun 2006 21:59:00 GMT

=============================��装�c?==============
针对八种基本数据�c�d��定义的相应的引用�c�d��-��装�c?包装�c�，包裹�c?
基本数据�c�d��          ��装�c?br /> boolean               Boolean
byte                  Byte
short                 Short
int                   Integer
long                  Long
char                  Character
float                 Float
double                Double
所有的��状�c�都是一个只�ȝ��Q�不能修改的).针对没个基本�c�d��我们只能建立一个这�ȝ��?/p>

class Test
{
public static void main(String[] args)
{
  int i=3;
  Integer in=new Integer(i);
  int j=in.intValue();
  System.out.println(j);
  String str=in.toString(); //把Integer对象转换为String�c�d��
  System.out.println("str="+str);

  String str1="123";
  System.out.println(Integer.valueOf(str1)); //把String�c�d��转换为Integer�c�d��

  boolean b1=false;
  Boolean b=new Boolean(b1);
  String s1=b.toString();
  System.out.println(s1);

  String s2="NO";
  System.out.println(Boolean.valueOf(s2));
}
}

*****************Class*********************
1> 在Java中，每个class都有一个相应的Class对象。也��是��_��当我们编写一个类�Q�编译完成后,在生�?br />   �?class文�g�?��׃��产生一个Class对象�Q�用于表�C��个类的类型信息�?br />2> 获取Class实例的方法有三种:
   <1>利用对象调用getClass()�Ҏ(gu��)��获得该对象的Class实例�?br />   <2>使用Class�cȝ��静态方法forName(),用类的名字获取一个Class的是实例�?br />   <3>�q�用.class的方式来获取Class实例�Q�对于基本数据类型的��装�c�，�q�可以用.TYPE来获取相应的
      基本数据�c�d��的Class实例�?br />   <4>在运行期��_��如果我们要��生某个类的对象，JAVA虚拟�?JVM)会检查该�c�d��的Class对象是否�?br />      加蝲�Q�如果没有加�?JVM会根据类的名�U�找�?class文�g�q�加载它。一旦某个类型的Class对象�?br />      �l�被加蝲到内存，��可以用它来产生该类型所有的对象�?br />   <5>newInstance()调用�c�M��~�省的构造方法�?好处是我们在不知道类的名字的情况下去创造一个实例）
import java.lang.reflect.*;       //子包必须手动导入
class ClassTest
{
public static void main(String[] args)//throws Exception
{
  /*
  Point pt=new Point();
  Class c1=pt.getClass();//利用对象调用getClass()�Ҏ(gu��)��获得该对象的Class实例
  System.out.println(c1.getName());

  Class c2=Class.forName("Point");//使用Class�cȝ��静态方法forName(),用类的名字获取一个Class的是实例
  System.out.println(c2.getName());

  Class c3=Point.class;//�q�用.class的方式来获取Class实例
  System.out.println(c3.getName());

  Class c4=Integer.TYPE;//��装�cȝ��.TYPE来获取相应的基本数据�c�d��的Class实例�?br />  System.out.println(c4.getName());
  */
  /*
  System.out.println("before new Point()");
  new Point();
  System.out.println("after new Point()");
  Class.forName("Line");
  */
  /*
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Point pt=(Point)c.newInstance();
   pt.output();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }
  */
  if(args.length!=1)
  {
   return;
  }
  try
  {
   Class c=Class.forName(args[0]);
   Constructor[] cons=c.getDeclaredConstructors();
   /*
   for(int i=0;i   {
    System.out.println(cons[i]);
   }
   Method[] ms=c.getDeclaredMethods();
   for(int i=0;i   {
    System.out.println(ms[i]);
   }*/
   Class[] params=cons[0].getParameterTypes();
   Object[] paramValues=new Object[params.length];
   for(int i=0;i   {
    if(params[i].isPrimitive())
    {
     paramValues[i]=new Integer(i+3);
    }
   }
   Object o=cons[0].newInstance(paramValues);
   Method[] ms=c.getDeclaredMethods();
   ms[0].invoke(o,null);
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }

}
}

class Point
{
static
{
  System.out.println("Loading Point");
}
int x,y;
void output()
{
  System.out.println("x="+x+","+"y="+y);
}
Point(int x,int y)
{
  this.x=x;
  this.y=y;
}
}

class Line
{
static
{
System.out.println("Loading Line");
}
}

blovesaga 2006-06-05 05:59 发表评论

function transfer in Java

blovesaga — Sun, 04 Jun 2006 20:19:00 GMT

~~~~~~~~~~~~~~~~~~~~~~~~~~函数的调用~~~~~~~~~~~~~~~~~~~~
1> 在java中，传参�Ӟ��都是以传值的形式惊行�?br />2> 对于基本数据�c�d��Q�传递的是数据的拯��Q�对于引用类型，传递的引用的拷贝�?br />3> 当我们在打印一个对象的时候，比如System.out.println(pt);�Q�它会自动调用类的toString()�Ҏ(gu��)��
�Q�所以徏议在所有的子类中重写toString()�Ҏ(gu��)��?br />我们写一个函数用来交换两个变�?x,y)的�?
code:

class StringTest
{
public static void change(int x, int y)
{
  x=x+y;
  y=x-y;
  x=x-y;
}
/*
public static void change(int[] num)
{
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
}
public static void change(Point pt)
{
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
}
*/
public static void main(String[] args)
{
int x=3;
int y=4;
change(3,4);
System.out.println("x="+x+","+"y="+y);
}
我们期望的输出结果是 x=4,y=3 然后你运行后发现�l�果为x=3,y=4,�q�没有达到我们的要求,��Z��么呢?那是因�ؓ对于基本数据�c�d��Q�传递的是数据的拯��Q�对于引用类型，传递的是引�?首地址)的拷贝。看看下面的内存图解应该你就能看出来�?看看引用�c�d��怎么来实�?

code:

class StringTest
{
/*
public static void change(int x, int y)
{
  x=x+y;
  y=x-y;
  x=x-y;
}
*/
public static void change(int[] num)
{
  num[0]=num[0]+num[1];
  num[1]=num[0]-num[1];
  num[0]=num[0]-num[1];
}
public static void change(Point pt)
{
  pt.x=pt.x+pt.y;
  pt.y=pt.x-pt.y;
  pt.x=pt.x-pt.y;
}
public static void main(String[] args)
{
  /*
   int x=3;
   int y=4;
   change(3,4);
   System.out.println("x="+x+","+"y="+y);
   */
   int[] num=new int[]{3,4};
   change(num);
   System.out.println("x="+num[0]+","+"y="+num[1]);

   Point pt=new Point();
   pt.x=3;
   pt.y=4;
   change(pt);
   System.out.println("x="+pt.x+","+"y="+pt.y);
}
class Point
{
int x,y;
}
再看看引用类型的内存变化�?

以上说明了在Java中函数的调用:

a> 在Java中，传参�Ӟ��都是以传值的方式�q�行�?br />b> 对于基本数据�c�d��Q�传递的是数据的拯��Q�对于引用类型，传递的是引�?首地址)的拷贝�?br />

blovesaga 2006-06-05 04:19 发表评论

Object's Clone

blovesaga — Sun, 04 Jun 2006 20:15:00 GMT

^^^^^^^^^^^^^^^对象的克隆^^^^^^^^^^^^^
1> ��Z��获取对象的一份拷贝，我们可以利用Object�cȝ��clone()�Ҏ(gu��)��?br />2> 在派生类中覆盖基�cȝ��clone()�Q��ƈ声明为public�?br />3> 在派生类的clone()�Ҏ(gu��)��中，调用super.clone()�?br />4> 在派生类中实现Cloneable接口�?br />4> 没有抽象�Ҏ(gu��)��的接口叫标识接口�?br />5> ��Z��么我们在�z��c�M��覆盖Object的clone()�Ҏ(gu��)��Ӟ��一定要调用super.clone()�?在运行时�?Object
的clone()�Ҏ(gu��)��能识别出你要复制的是哪一个对象，然后为此对象分配�I�间�Q��ƈ�q�行对象的复�Ӟ��原
始对象的内容一一复制到新的对象空间去�?/p>* ��克隆是针对没有引用�c�d��的变量来克隆。针对引用类型的克隆应该用Deeply Clone�?br />

��克�?

Code:

class FleetClone
{
public static void main(String[] args)
{
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();
   s2.p.name="feifei";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
}
}

class Professor
{
String name;
int age;
Professor(String name,int age)
{
this.name=name;
this.age=age;
}
}

class Student implements Cloneable
{
Professor p;
String name;
int age;
Student(String name, int age,Professor p)
{
  this.name=name;
  this.age=age;
  this.p=p;
}
public Object clone()
{
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
}
}

改变学生s2的教授信息，打印s1教授信息,�l�果�?name=feifei,age=30.产生�q�个�l�果是因为String是一个常量类�?

深克�?/div>

code:

class DeeplyClone
{
public static void main(String[] args)
{
   Professor p=new Professor("feiyang",23);
   Student s1=new Student("zhangshan",18,p);
   Student s2=(Student)s1.clone();

   s2.p.name="Bill.Gates";
   s2.p.age=30;
   System.out.println("name="+s1.p.name+","+"age="+s1.p.age);
}
}

class Professor implements Cloneable
{
String name;
int age;
Professor(String name,int age)
{
  this.name=name;
  this.age=age;
}
public Object clone()
{
  Object o=null;
  try
  {
   o=super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  return o;
}
}

class Student implements Cloneable
{
Professor p;
String name;
int age;
Student(String name, int age,Professor p)
{
  this.name=name;
  this.age=age;
  this.p=p;
}
public Object clone()
{
  //Object o=null;
  Student o=null;
  try
  {
   o=(Student)super.clone();
  }
  catch(CloneNotSupportedException e)
  {
   e.printStackTrace();
  }
  o.p=(Professor)p.clone();
  return o;
}
}

打印�l�果�?name=Bill.Gates,age=30,�q�就是深克隆.

blovesaga 2006-06-05 04:15 发表评论

blovesaga — Sun, 04 Jun 2006 09:30:00 GMT

Java数组的相��x��?/p>

1> 在Java中所有的数组都有一个缺省的属性length�Q�用于获取数�l�元素的个数�?br />2> 数组的复�? System.arraycopy()�?br />3> 数组的排�? Arrays.sort()�?br />4> 在已排序的数�l�中查找某个元素�Q�Arrays.binarySearch()�?br />具体的看看下面的2个例�?
code1:
class ArrayTest
{
public static void main(String[] args)
{
  /*数组的copy
  int[] num1=new int[]{1,2,3};
  int[] num2=new int[3];
  System.arraycopy(num1,0,num2,0,num1.length);
  for(int i=0;i  {
   System.out.println(num2[i]);
  }
  */
  //引用�c�d��的数�l�copy
  Point[] pts1=new Point[]{new Point(1,1),new Point(2,2),new Point(3,3)};
  Point[] pts2=new Point[3];
  System.arraycopy(pts1,0,pts2,0,pts1.length);
  for(int i=0;i  {
   System.out.println("x="+pts2[i].x+","+"y="+pts2[i].y);
  }
  /*
  *因�ؓ引用�c�d��传递的是引用的拯��Q�所以我们修改pts2数组的第二个点的坐标�Q?br />  *当我们打印pts1数组的第一个点的坐标时�Q�它的坐标点已经被修改�ؓ(5,5)�?br />  pts2[1].x=5;
  pts2[1].y=5;
  System.out.println("x="+pts1[1].x+","+"y="+pts1[1].y);
  */
}
}

class Point
{
int x, y;
Point(int x,int y)
{
  this.x=x;
  this.y=y;
}
}

code2:
import java.util.*;
class TestArray
{
public static void main(String[] args)
{
  /*
  int[] num=new int[]{3,2,1};
  Arrays.sort(num);
  for(int i=0;i  {
   System.out.println(num[i]);
  }
  int index=Arrays.binarySearch(num,3);
  System.out.println("index="+index);
  System.out.println("Element="+num[index]);
  */
  Student[] ss=new Student[]{new Student("zhangshan",1),
                            new Student("lisi",2),
                            new Student("wangwu",3),
                            new Student("mybole",3)};
   Arrays.sort(ss);
   for(int i=0;i   {
   System.out.println(ss[i]);
   }
   int index=Arrays.binarySearch(ss,new Student("lisi",2));
   System.out.println("name="+ss[index].name+","+"index="+index);
}
}

class Student implements Comparable
{
String name;
int num;
Student(String name,int num)
{
  this.name=name;
  this.num=num;
}
public String toString()
{
  return "name="+name+","+"number="+num;
}
public int compareTo(Object o) //对于Object[]排序要求实现Comparable接口
{
  Student s=(Student)o;
  //return num>s.num ? 1 :(num==s.num ? 0 : -1);
  int result=num>s.num ? 1 :(num==s.num ? 0 : -1);//按名字排�?br />  if(0==result)
  {
   result=name.compareTo(s.name);
  }
  return result;
}
}

blovesaga 2006-06-04 17:30 发表评论

blovesaga — Sun, 04 Jun 2006 03:40:00 GMT

通过覆盖父类的方法来实现,在运行时�Ҏ(gu��)��传递对象的引用,来调用相应的�Ҏ(gu��)��.
code:
class Animal
{
int height,weight;
Animal()
{
  System.out.println("Animal construct");
}
void eat()
{
  System.out.println("Animal eat!");
}
void sleep()
{
  System.out.println("Animal sleep!");
}
void breathe()
{
  System.out.println("Animal breathe!");
}
}

class Fish extends Animal
{
Fish()
{
  System.out.println("Fish construct");
}
void breathe() //override method breathe()
{
  System.out.println("Fish bubble");
}
}
class DoMain
{
static void fn(Animal an)
{
  an.breathe();
}
public static void main(String[] args)
{
  //Animal an=new Animal();
  Fish fh=new Fish();
  Animal an;
  an=fh;
  DoMain.fn(an);
}
}

blovesaga 2006-06-04 11:40 发表评论

Basic Study--Java extends

blovesaga — Sun, 04 Jun 2006 03:18:00 GMT

   理解�l�承是理解面向对象程序设计的关键.在Java�?通过关键字extends�l�承一个已有的�c?被��承的�cȝ��为父�c?��类�Q�基�c?,新的�cȝ��为子�c?�z��c?.在Java中不允许多��?code:
class Animal
{
int height,weight;
void eat()
{
  System.out.println("Animal eat!");
}
void sleep()
{
  System.out.println("Animal sleep!");
}
void breathe()
{
  System.out.println("Animal breathe!");
}
}
class Fish extends Animal
{

}
class DoMain
{
public static void main(String[] args)
{
  Animal an=new Animal();
  Fish fn=new Fish();

  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
}
}
Result:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Animal breathe!
(�q�说明派生类�l�承了父�cȝ��所有方法和成员变量.)

�Ҏ(gu��)��的覆�?override)
在子�c�M��定义一个与父类同名,�q�回�c�d��,参数�c�d��均相同的一个方�?�U�Cؓ�Ҏ(gu��)��的覆�?�Ҏ(gu��)��的覆盖发生在子类与父�c�M��?
code:
class Animal
{
int height,weight;
void eat()
{
  System.out.println("Animal eat!");
}
void sleep()
{
  System.out.println("Animal sleep!");
}
void breathe()
{
  System.out.println("Animal breathe!");
}
}
class Fish extends Animal
{
int weight,height;   //隐藏了父�cȝ��weight,height;
void breathe() //override method breathe()
{
  super.breathe(); //用super调用父类的构造方�?br />  System.out.println("Fish bubble");
}
}
class DoMain
{
public static void main(String[] args)
{
// Animal an=new Animal();
  Fish fn=new Fish();

  an.breathe();
  fn.breathe();
  fn.height=30;
  fn.weight=20;
}
}
输出�l�果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal breathe!
Fish bubble

�Ҏ(gu��)��变量super
* 使用�Ҏ(gu��)��变量super提供对父�cȝ��讉K��
* 可以使用super讉K��父类被子�c�隐藏的变量或覆盖的�Ҏ(gu��)��
* 每个子类构造方法的�W�一条语句都是隐含的调用super,如果父类没有�q�种形式的构造函数就会报�?
code:
class Animal
{
int height,weight;
Animal()
{
  System.out.println("Animal construct");
}
void eat()
{
  System.out.println("Animal eat!");
}
void sleep()
{
  System.out.println("Animal sleep!");
}
void breathe()
{
  System.out.println("Animal breathe!");
}
}

class Fish extends Animal
{
Fish()
{
  System.out.println("Fish construct");
}
void breathe() //override method breathe()
{
  System.out.println("Fish bubble");
}
}
class DoMain
{
public static void main(String[] args)
{
  //Animal an=new Animal();
  Fish fn=new Fish();

  //an.breathe();
  //fn.breathe();
  //fn.height=30;
  //fn.weight=20;
}
}
输出�l�果:
F:\Java Develop>javac Animal.java

F:\Java Develop>java DoMain
Animal construct
Fish construct

blovesaga 2006-06-04 11:18 发表评论

Fist Course of Java Study

blovesaga — Sun, 04 Jun 2006 02:51:00 GMT

    从今天开始从零学习JAVA,希望可以认识到更多的朋友,可以让自��q��JAVA之�\走得更�ؓ��利一�?��C��几本书来看也听了几接�?觉得JAVA很吸引我,我想我可以走得更�q�的.自信是最重要�?
    OOP(Object Oriented Programming)描述的是对象与对象之间的�怺�作用.听老师��面向过�E�与面向对象的最大区别是: �q�程化程序设计先��定��法,再确定数据结�?再确定运��?面向�q�程�~�程,习惯于先建立数据�l�构存放数据�q�定义方�?函数)来操作数�?而面向对象的则是构徏一个模�?��数据与�Ҏ(gu��)��l�织在一�?
    我们可以把现实世界的事物抽象为对�?对象一般都有两个特�?状�?Status),行�ؓ(Behavior).软�g的对象概忉|��由显�C�Z��界对象抽象而来.把现实世界的状态保存��Y件对象的变量�?现实世界对象的行为通过软�g对象的方�?函数)来实�?
    我们把相似的对象划分成一个类.在��Y件中�c�d��是一个模�?它定义了通用于一个特定种�cȝ��所有对象的状�?变量)和行�?�Ҏ(gu��)��).�c�L��创徏对象的模�?对象是类的实�?
    面向对象�~�程的难点在于思�\的�{�?我们通常习惯与考虑解决问题的方法，而不是抽象成对象再去解决�?
�cȝ��构造方�?br />* 构造方法的名字和类名相�?�q�且没有�q�回�?
* 构造方法主要用于定义类的初始化状�?
* 我们不能直接调用构造方�?必须通过new关键字来自动调用,从而创建类的实�?
* Java的类都要求有构造方�?如果没有定义构造方�?Java�~�译器会提供一个缺省的构造方�?也就是不参数的构造方�?
�Ҏ(gu��)��的重�?overload)
重蝲构成的条�?�Ҏ(gu��)��的名�U�相�?但参数类型或参数个数不同,才能构成�Ҏ(gu��)��的重�?
code:
class Point
{
int x,y;
/*
*带参数的构造方法和不带参数的构造方法就构成了方�?函数)的重�?br /> */
Point(int a,int b)
{
  x=a;
  y=b;
}
Point()
{

}
void output()
{
  System.out.println(x);
  System.out.println(y);
}
public static void main(String[] args)
{
  //调用不带参数的构造方�?br />  //Point p=new Point();
  //pt.x=10;
  //pt.y=20;
  //p.output();
  Point p1=new Point(3,3); //调用带参数的构造方�?br />  p1.output();
}
}
�Ҏ(gu��)��变量this
* this变量代表对象本��n
* 当类中有两个同名变量,一个属于类(�cȝ��成员变量),一个属于某个特定的�Ҏ(gu��)��(�Ҏ(gu��)��中的局部变�?,使用this区分成员变量和局部变�?
* 使用this��化构造函数的调用
code:
class Point
{
int x,y;
/*
*带参数的构造方法和不带参数的构造方法就构成了方�?函数)的重�?br /> */
Point(int a,int b)
{
  x=a;
  y=b;
}
Point()
{
  this(1,1);
}
void output()
{
  System.out.println(x);
  System.out.println(y);
}
/*output()�Ҏ(gu��)��定义的�Ş参与成员变量同名了，
*那么在output()里就看不到成员变量的x,y了，它被隐藏�?
*/
void output(int x, int y)
{
  this.x=x;
  this.y=y;
}
public static void main(String[] args)
{
  Point pt=new Point(3,3);
  pt.output(5,5);
  pt.output();
}
}
一个类所有的实例(对象)调用的成员方法在内存中只有一份拷�?��管在内存中可能有多个对�?而数据成员在内的没个对象中都存在着一份拷�?this变量允许相同的实例方法�ؓ不同的对象工�?每当调用一个实例方法时,this变量被设�|�成引用该实例方法的特定的类的对�?�Ҏ(gu��)��的代码接着会与this所代表的对象的特定数据建立兌��.

blovesaga 2006-06-04 10:51 发表评论