JAVA 私塾第十、十一章笔记整理

第十章 AWT

    AWT(Abstract Window Toolkit)用于Java Application 的GUI(Graphical User Interface图形用户界面)编程。
    AWT所涉及的类一般在java.awt包及其子包中。
   【此处有图片，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】

    布局管理器
        FlowLayout  (Panel和Applets的缺省布局管理器)
        对组件逐行定位，行内从左到右，一行排满后换行。默认的对齐方式是居中。
        BorderLayout   (Window, Dialog和Frame的缺省布局管理器)
        将整个容器的布局划分成东西南北中五部分，组件只能被添加到指定区域。每个区域只能加入一个组件，如加入多个，则先前的会被覆盖。
        GridLayout
        将空间划分成规则的矩形网格，每个单元区域大小相等，组件被添加到每个单元各种，先从左到右满一行后换行，再从上到下。
        CardLayout
        GridBagLayout

第十一章Swing和GUI事件处理

    GUI事件监听器接口：

事件类型	相应监听器接口	监听器接口中的方法
Action	ActionListener	actionPerformed(ActionEvent)
Item	ItemListener	itemStateChanged(ItemEvent)
Mouse	MouseListener	mousePressed(MouseEvent) mouseReleased(MouseEvent) mouseEntered(MouseEvent) mouseExited(MouseEvent) mouseClicked(MouseEvent)
Mouse Motion	MouseMotionListener	mouseDragged(MouseEvent) mouseMoved(MouseEvent)
Key	KeyListener	keyPressed(KeyEvent) keyReleased(KeyEvent) keyTyped(KeyEvent)
Focus	FocusListener	focusGained(FocusEvent) focusLost(FocusEvent)
Adjustment	AdjustmentListener	adjustmentValueChanged(AdjustmentEvent)
Component	ComponentListener	componentMoved(ComponentEvent) componentHidden (ComponentEvent) componentResized(ComponentEvent) componentShown(ComponentEvent)
Window	WindowListener	windowClosing(WindowEvent) windowOpened(WindowEvent) windowIconified(WindowEvent) windowDeiconified(WindowEvent) windowClosed(WindowEvent) windowActivated(WindowEvent) windowDeactivated(WindowEvent)
Container	ContainerListener	componentAdded(ContainerEvent) componentRemoved(ContainerEvent)
Text	TextListener	textValueChanged(TextEvent)

    事件适配器：

2. public abstract class WindowAdapter implements WindowListener {
3.    public void windowOpened(WindowEvent e) {}
4.    public void windowClosing(WindowEvent e) {}
5.    public void windowClosed(WindowEvent e) {}
6.    public void windowIconified(WindowEvent e) {}
7.    public void windowDeiconified(WindowEvent e) {}
8.    public void windowActivated(WindowEvent e) {}
9.    public void windowDeactivated(WindowEvent e) {}
10. }

复制代码

内部类

2. import java.awt.*;
3. import java.awt.event.*;
4. public class Test1{
5.    Frame f = new Frame("Java Gui");
6.    public Test1(){
7.       MyInner m = new MyInner();
8.       f.addWindowListener(m);
9.       f.setSize(150,150);
10.       f.setVisible(true);
11.    }
12.    public static void main(String args[]){
13.       new Test1();
14.    }
15.    class MyInner extends WindowAdapter{
16.       public void windowClosing(WindowEvent e){
17.          System.exit(1);
18.       }
19.    }
20. }

复制代码

    匿名内部类

2. import java.awt.*;
3. import java.awt.event.*;
4. public class Test2{
5.    Frame f = new Frame("Java Gui");
6.    public Test2(){
7.       f.addWindowListener(new WindowAdapter(){
8.          public void windowClosing(WindowEvent e){
9.             System.exit(1);
10.          }
11.       });
12.       f.setSize(150,150);
13.       f.setVisible(true);
14.    }
15.    public static void main(String args[]){
16.       new Test2();
17.    }
18. }

复制代码

    什么是双缓冲？
       在后台进行界面的更新，然后在前台进行界面交换
       功能：双缓冲可以改善一个被频繁改变的组件的外观

    *Swing和AWT的区别？
       Swing提供了更完整的组件，引入了许多新的特性和能力。Swing API是围绕着实现            
       AWT 各个部分的API 构筑的。
       AWT 采用了与特定平台相关的实现，而绝大多数Swing 组件却不是这样做的，因此Swing 的外观和感觉是可客户化和可插的。

JAVA 私塾第十三章笔记整理

第十三章  I/O流

    JDK所提供的所有流类型，都位于java.io包内都分别继承自以下四种抽象流类型：

	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

    节点流和处理流
        节点流可以从一个特定的数据源读写数据。
        处理流是连接在已存在的流之上，通过对数据的处理为程序提供更强大的读        
        写功能。
        【此处有图片，可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

        继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节（8bit）,上图中深色为节点流，浅色为处理流

        InputStream的方法：
             三个read方法
                int read()：读取一个字节，以整数的形式返回，如返回-1，则表示以到输入流的末尾。
                int read(byte[])：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。
                int read(byte[], int, int)：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。Int,int用于定义读取字节数组的范围。

  void close()：关闭流
                skip(long)：跳过n个字节不读，返回实际跳过的字节数。

       继承自OutputStream的流适用于程序输出数据的，且数据的单位为字节（8bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

        void write(int)
        void write(byte[])
        void write(byte[],int,int)
        void close()
        void flush()将缓冲区的数据全部写到目的地。

        继承自InputStream的流都是用于向程序中输入数据的，且数据的单位为字节（16bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

        Reader的方法：
            三个read方法
                int read()：读取一个字节，以整数的形式返回，如返回-1，则表示以到输入流的末尾。
                int read(byte[])：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。
         int read(byte[], int, int)：读取一系列字节，返回读取的字节数，如返回-1，则表示以到输入流的末尾。Int,int用于定义读取字节数组的范围。

                void close()：关闭流
                skip(long)：跳过n个字节不读，返回实际跳过的字节数。

       继承自Writer的流适用于程序输出数据的，且数据的单位为字节（16bit）,上图中深色为节点流，浅色为处理流
       【此处有图片，可以到JAVA 私塾官网下载完整笔记：ww w.javass.cn】

        void write(int)
        void write(byte[])
        void write(byte[],int,int)
        void close()
        void flush()将缓冲区的数据全部写到目的地。

FileInputStream

2. import java.io.*;
3. public class TestFileInputStream {
4.    public static void main(String[] args) {
5.       int b = 0;
6.       FileInputStream in = null;
7.       try {
8.          in = new FileInputStream("e:/TestFileInputStream.java");
9.       } catch (FileNotFoundException e) {
10.          System.out.println("找不到指定文件");
11.          System.exit(-1);
12.       }
13.    
14.       try {
15.          long num = 0;
16.          while((b=in.read())!=-1){
17.             System.out.print((char)b);
18.             num++;
19.          }
20.          in.close();  
21.          System.out.println();
22.          System.out.println("共读取了 "+num+" 个字节");
23.       } catch (IOException e1) {
24.         System.out.println("文件读取错误"); System.exit(-1);
25.       }
26.    }
27. }

复制代码

共读取了 700 个字节

FileOutputStream

2. import java.io.*;
3. public class TestFileOutputStream {
4.    public static void main(String[] args) {
5.       int b = 0;
6.       FileInputStream in = null;
7.       FileOutputStream out = null;
8.       try {
9.          in = new FileInputStream("e:/TestFileInputStream.java");
10.          out = new FileOutputStream("e:/1.java");
11.          while((b=in.read())!=-1){
12.             out.write(b);
13.          }
14.          in.close();
15.          out.close();
16.       } catch (FileNotFoundException e2) {
17.          System.out.println("找不到指定文件"); System.exit(-1);
18.       } catch (IOException e1) {
19.          System.out.println("文件复制错误"); System.exit(-1);
20.       }
21.       System.out.println("文件已复制");
22.    }
23. }

复制代码

FileReader

2. import java.io.*;
3. public class TestFileReader {
4.    public static void main(String[] args) {
5.       FileReader fr = null;
6.       int c = 0;
7.       try {
8.          fr = new FileReader("e:/TestFileReader.java");
9.          int ln = 0;
10.          while ((c = fr.read()) != -1) {
11.             System.out.print((char)c);
12.          }
13.          fr.close();
14.       } catch (FileNotFoundException e) {
15.          System.out.println("找不到指定文件");
16.       } catch (IOException e) {
17.          System.out.println("文件读取错误");
18.       }
19.    }
20. }

复制代码

FileWriter

2. import java.io.*;
3. public class TestFileWriter {
4.    public static void main(String[] args) {
5.       FileWriter fw = null;
6.       try {
7.          fw = new FileWriter("e:/sunicode.dat");
8.          for(int c=0;c<=50000;c++){
9.             fw.write(c);
10.          }
11.          fw.close();
12.       } catch (IOException e1) {
13.      e1.printStackTrace();
14.         System.out.println("文件写入错误");
15.         System.exit(-1);
16.       }
17.    }
18. }

复制代码

BufferedStream

2. import java.io.*;
3. public class TestBufferStream{
4.   public static void main(String[] args) {
5.     try {
6.       BufferedWriter bw = new BufferedWriter(new FileWriter("e:/2.java"));
7.       BufferedReader br = new BufferedReader(
8.              new FileReader("e:/1.java"));
9.       String s = null;
10.       for(int i=1;i<=100;i++){
11.         s = String.valueOf(Math.random());
12.         bw.write(s);
13.         bw.newLine();
14.       }
15.       bw.flush();
16.       while((s=br.readLine())!=null){
17.         System.out.println(s);
18.       }
19.       bw.close();
20.       br.close();
21.     } catch (IOException e) { e.printStackTrace();}
22.   }
23. }

复制代码

简述File类的基本功能
处理文件和获取文件信息,文件或文件夹的管理
除了读写文件内容其他的都可以做

代码示例：如何使用随机文件读写类来读写文件内容
    RW表示文件时可读写的
       读：
  try{
    RandomAccessFile f = new RandomAccessFile("test.txt", "rw");
    long len = 0L;
    long allLen = f.length();
    int i = 0;
    while (len < allLen) {
      String s = f.readLine();
      if (i > 0) {
          col.add(s);
      }
      i++;
      //游标
      len = f.getFilePointer();
    }
  }catch(Exception err){
    err.printStackTrace();
  }
  
  写：
  
  try{
    RandomAccessFile f = new RandomAccessFile("test.txt", "rw");
    StringBuffer buffer = new StringBuffer("n");
    Iterator it = col.iterator();
    while (it.hasNext()) {
      buffer.append(it.next() + "n");
    }
    f.writeUTF(buffer.toString());
  }catch(Exception err){
     err.printStackTrace();
  }

代码示例：如何使用流的基本接口来读写文件内容

2. import java.io.*;
3. public class Test{
4. public static void main(String args[]){
5.    String currentLine;
6.    try{
7.       DataInputStream in = new DataInputStream(new BufferedInputStream(new FileInputStream("Test.java")));
8.       while ((currentLine = in.readLine()) != null)
9.          System.out.println(currentLine);
10.       }catch (IOException e) {
11.          System.err.println("Error: " + e);
12.       } // End of try/catch structure.
13.    } // End of method: main
14. } // End of class

复制代码

JAVA 私塾资料下载

包括初级、中级、高级和项目视频、教材、源代码等学习资料，还有一些常用工具。

ww w.javass.cn/javapeixunzlxz/zlxz.html

JAVA 私塾第十四、十五章笔记整理

第十四章 多线程

    线程的基本概念：
        线程是一个程序内部的顺序控制流。
        进程是正在执行的程序，一个或更多的线程构成了一个进程。

        线程和进程的区别：
    每个进程都有独立的代码和数据空间（进程上下文），进程切换的开销大。
    线程作为轻量级的进程，同一类线程可以共享代码和数据空间，但每个线程有独立的运行栈和数据空间，因此线程切换的开销小。
    多进程—在操作系统中同时运行多个任务（程序），也称多任务。
    多线程—在同一应用程序中多个顺序流同时执行。

    创建线程的2中方式：
      1.定义线程实现Runnable接口

2. public class TestThread1 {
3.    public static void main(String args[]) {
4.       Runner1 r = new Runner1();
5.       Thread t = new Thread(r);
6.       t.start();
7.       for(int i=0; i<100; i++) {
8.          System.out.println("Main Thread:------" + i);
9.       }
10.    }
11. }
12. class Runner1 implements Runnable {
13.    public void run() {
14.       for(int i=0; i<100; i++) {
15.          System.out.println("Runner1 :" + i);
16.       }
17.    }
18. }

复制代码

    2.定义一个Thread的子类，并重写其Run()方法

2. public class TestThread1 {
3.    public static void main(String args[]) {
4.       Runner1 r = new Runner1();
5.       r.start();
6.       for(int i=0; i<100; i++) {
7.          System.out.println("Main Thread:------" + i);
8.       }
9.    }
10. }
11. class Runner1 extends Thread {
12.    public void run() {
13.       for(int i=0; i<100; i++) {
14.          System.out.println("Runner1 :" + i);
15.       }
16.    }
17. }

复制代码

     线程状态：
    【此处有图，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】

线程控制基本方法：

方法	功能
isAlive()	判断线程是否还活着，即线程是否还未终止
getPriority()	获得线程的优先级数值
setPriority()	设置线程的优先级数值
Thread.sleep()	将当前线程睡眠，并指定毫秒数
join()	调用某线程的该方法，将当前线程与该线程“合并“，即等待该线程结束，再回复当前线程的运行。
wait()	当前线程进入对象的wait pool
notify()/notifyAll()	唤醒对象的wait pool中的一个/所有等待线程

    线程的优先级：

2. public class TestPriority {
3.    public static void main(String[] args) {
4.       Thread t1 = new Thread(new T1());
5.       Thread t2 = new Thread(new T2());
6.       t1.setPriority(Thread.NORM_PRIORITY + 3);
7.       t1.start();
8.       t2.start();
9.    }
10. }
11. class T1 implements Runnable {
12.    public void run() {
13.       for(int i=0; i<1000; i++) {
14.          System.out.println("T1: " + i);
15.       }
16.    }
17. }
18. class T2 implements Runnable {
19.    public void run() {
20.       for(int i=0; i<1000; i++) {
21.          System.out.println("------T2: " + i);
22.       }
23.    }
24. }

复制代码

    线程同步：
    当某个对象被用synchronized来修饰时，表明该对象某一时刻只能由一个线程访问。

2. public class TestSync implements Runnable {
3.    Timer timer = new Timer();
4.    public static void main(String[] args) {
5.       TestSync test = new TestSync();
6.       Thread t1 = new Thread(test);
7.       Thread t2 = new Thread(test);
8.       t1.setName("t1");
9.       t2.setName("t2");
10.       t1.start();
11.       t2.start();
12.    }
13.    public void run(){
14.       timer.add(Thread.currentThread().getName());
15.    }
16. }
17. class Timer{
18.    private static int num = 0;
19.    public synchronized void add(String name){
20.       synchronized (this) {
21.          num ++;
22.          try {Thread.sleep(1);}
23.          catch (InterruptedException e) {}
24.          System.out.println(name+", 你是第"+num+"个使用timer的线程");
25.        }
26.    }
27. }

复制代码

死锁：

2. public class TestDeadLock implements Runnable {
3.    public int flag = 1;
4.    static Object o1 = new Object(), o2 = new Object();
5.    public void run() {
6.       System.out.println("flag=" + flag);
7.       if(flag == 1) {
8.          synchronized(o1) {
9.             try {
10.                Thread.sleep(500);
11.             }catch (Exception e) {
12.                e.printStackTrace();
13.             }
14.             synchronized(o2) {
15.                System.out.println("1");
16.             }
17.          }
18.       }
19.       if(flag == 0) {
20.          synchronized(o2) {
21.             try {
22.                Thread.sleep(500);
23.             } catch (Exception e) {
24.                e.printStackTrace();
25.             }
26.             synchronized(o1) {
27.                System.out.println("0");
28.             }
29.          }
30.       }
31.    }
32.    public static void main(String[] args) {
33.       TestDeadLock td1 = new TestDeadLock();
34.       TestDeadLock td2 = new TestDeadLock();
35.       td1.flag = 1;
36.       td2.flag = 0;
37.       Thread t1 = new Thread(td1);
38.       Thread t2 = new Thread(td2);
39.       t1.start();
40.       t2.start();
41.   
42.    }
43. }

复制代码

    wait和sleep的区别
        wait时，别的线程可以访问锁定对象。
        sleep时，别的线程不可以访问锁定对象。

第十五章：网络编程

    什么是url？基本的格式是？
        URL（统一资源定位器，Uniform Resource Locator）用于表示Internet 上资源的地址。这里所说的资源，可以是文件、目录或更为复杂的对象的引用。
        ht tp://home.netscape.com/home/welcome.html

    IP,Port,TCP的基本功能
        IP代表网络位置
        Port代表端口号
        TCP可保证不同厂家生产的计算机能在共同网络环境下运行，解决异构网通信问题，是 目前网络通信的基本协议

    Java网络模型的基本功能
        描述服务端和客户端的连接过程
        【此处有图，可以到JAVA 私塾官网下载完整笔记：w ww.javass.cn】

    Java网络编程究竟做些什么？如何做？
        1.建立连接
        2.准备输出的数据，流式输出
        3.流式输入，编程业务需要的格式
        4.关闭连接

    服务器分配一个端口号。如果客户请求一个连接，服务器使用accept()方法打开socket 连接。
    客户在host的port端口建立连接。
    服务器和客户使用InputStream和OutputStream进行通信。

    基于Socket编程

2. import java.net.*;
3. import java.io.*;
4. public class TestServer {
5.    public static void main(String args[]) {
6.       try {
7.          ServerSocket s = new ServerSocket(8888);
8.          while (true) {
9.             Socket s1 = s.accept();
10.             OutputStream os = s1.getOutputStream();
11.             DataOutputStream dos =
12.             new DataOutputStream(os);
13.             dos.writeUTF("Hello," +s1.getInetAddress() + "port#" +s1.getPort() + "nb   ye!");
14.             dos.close();
15.             s1.close();
16.          }
17.       }catch (IOException e) {
18.          System.out.println("程序运行出错:" + e);
19.       }
20.    }
21. }

复制代码

    TCP和UDP区别
        TCP能保证传输内容的完整和准确，UDP不能保证。

java 私塾经典入门视频

全套Java视频教程是完全真实课堂录制，初级入门部分实际学习时间为十一天，深入剖析重点知识点的理论。

第一天
Java的一些学习方法、Java入门，构建Java开发环境、学习写第一个HelloWorld的程序

第二天
Java的基础语法，Java代码的基本知识、运算符、表达式，Java分支语句和循环语句

第三天
面向对象初步，，Java中如何表达对象，根据前面的抽象来具体的讲述，如何使用一个类，深入理解Java类的基本运行顺序

第四天
理解面向对象的三大特性、引用类型、按值传递和按引用传递、熟练使用内存分配示意图、包装类、类型转换、继承、讲递归

第五天
方法的覆盖和重载的知识点和规则，Java中多态的知识点，static修饰符的规则和应用，final修饰符的规则和应用，内部类的基本知识，深入理解Java的内存分配

第六天
数组，多维数组，基本的排序算法，枚举的基础知识

第七天
Object类的基础知识，再次学习如何使用JDK文档，String类的常用方法

第八天
正则表达式的基础知识，常用类的知识和使用

第九天
抽象类、接口、异常

第十天
开始模拟银行系统的小项目

第十一天
项目收尾工作，示范如何给项目添加基本的权限控制

在线学习地址：ww w.javass.cn/javapeixunzlxz/zlxzchujizaixian.html

java 私塾JDBC笔记整理

一.JDBC是什么？
Java DataBase Connection(类似于IO).

二.JDBC怎样实现传输？
    JDBC利用Driver来连接不同的数据库。如Oracle, SQL Server, MySql , DB2.
    Driver(驱动):本质上是一个程序
    1.它是JDBC技术的实现。
    2.总的来说与数据库相关(因为java部分是固定的，而数据库有很多种需要不同的驱动去适应它)
    3.Driver类型： A:JDBC-ODBC桥
                   B:纯本地实现
                   C:部分JAVA实现
                   D:纯JAVA实现

三.JDBC可以用一套固定的接口去跟不同的数据库进行交互
   需要掌握如下接口：Driver, Connection, Statement, PreparedStatement, ResultSet。
   实现：跟IO类似，一边Out，一边In。
   不同的是输出的不是流，而是SQL语句。

   思路：
   JAVA——>数据库
   1.建立跟数据库的连接
      1.1装在驱动  class.forName(“驱动名称”)
      1.2打开连接  Connection conn = DriverManeger.getConnection(URL,用户名,密码);
   2.执行SQl语句
      2.1得到执行SQL语句的接口
          Statement stmt = conn.createStatement();
          或 PreparedStatement pstmt = conn.PreparedStatement(String sql);
      2.2执行SQL语句
          stmt.executeUpdate(sql);
          或 pstmt.setString(1,值);
          pstmt.executeUpdate();
      2.3 关闭连接
          conn.close();
          stmt.close();
          pstmt.close();

   数据库——>JAVA
   1.建立跟数据库的连接
       1.1装在驱动  class.forName(“驱动名称”)
       1.2打开连接  Connection conn = DriverManeger.getConnection(URL,用户名,密码);
   2.执行SQL语句
       2.1得到执行SQL语句的接口
        Statement stmt = conn.createStatement();
        或 PreparedStatement pstmt = conn.PreparedStatement(String sql);
       2.2执行取值，获得从数据库返回的结果集
   3.从ResultSet中获取数据(rs相当于游标)
       while(rs.next())
           a.按名称取值 rs.getString(“字段名”)；
           b.按索引取值 rs.getString(索引下标)；
       两种方法都是对照ResultSet的。
   4.关闭连接
       conn.close();
       rs.close();
       stmt.close();
       pstmt.close();

   *用preparedStatment是指预编译的SQL语句，是静态的。
       String sql = “…………(?,?,?,?)”
    将字段名用?代替
       pstmt.setString(索引,值);
       pstmt.setInt(索引,值);
       pstmt.executeUpdate();
     而Statement是动态的。

四.事务:
    保证数据库正确
    A.原子性：事务的内部操作为一个整体，要么都成功，要么都失败。
    B.一致性：数据操作前后要满足相同的规则。
    C.隔离性：事物内部数据对外的可见性和可操作性。
    D.稳定性：无论发生任何事情，事务都要保证数据能正确保存到数据库中。
  默认情况下，JDBC将一条数据库语句是为一个完整的事务。
  可以关掉默认事务管理： conn.setAutoCommit(false);
  在执行完事务后应提交事务：conn.commit();
                            conn.rollback();
  需要时可以取消事务：conn.close();

五.批量操作
   Statement stmt = conn.createStatement();

   stmt.addBatch(sql); //将多个sql打包
   stmt.executeBatch();//批量执行

可以到java 私塾官网下载完整笔记：w ww.javass.cn

JAVA 私塾经典视频，看完毕业设计绝对没问题

JAVA 私塾课堂实录，从初级到项目，绝对是毕业设计的好资料，看完毕业设计、答辩完全不在话下、毕业设计做好了，对找工作帮助是很大很大的。

下载、在线都有：ww w.javass.cn/javapeixunzlxz/zlxz.html

大力推荐清华出版社的《研磨设计模式》，JAVA设计模式中的宝典啊

《研磨设计模式》看了没？最初是在JavaEye上chjavach兄的博客中看到的，写作风格轻松有趣，问题说的很透彻，堪称设计模式中的宝典。现在这本经典的书出也出版了，很值得买回去研究学习。据chjavach兄说《研磨设计模式》的版权已经输出到台湾。听说这位牛人还是JAVA 私塾培训机构的老师，他的讲课风格跟写作风格一样轻松有趣，通俗易懂。不管谁写的吧，好书就是好书，实力确实很强悍啊，只是不知道这个chjavach兄啥时候能开办个业余班的设计模式班让大家能去学习一下。不想买书朋友可以先到chjavach兄的博客上学习，呵呵~~~~~

博客地址：ht tp://chjavach.javaeye.com/

学习了

先看看再说

东西挺多

买手机是不是一定要买这种有JAVA的手机呢