黑马程序员->GUI,网编,正则

--------------------android培训、java培训、期待与您交流！ -----------------

1..........................GUI
 GUI : Graphical User Interface (图形用户接口)  ---------- java.Awt    java.Swing
 @java.Awt : Abstract Window ToolKit (抽象窗口工具包)，需要调用本地系统方法实现功能。书重量级控件
 @javax.Swing : 在AWT 的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由 JAVA 实现，
     增强了移植性，属轻量级控件。
         Component (组件，成分)
          |               |
        Container(容器)   |----Button(按钮)
        |   |    |----Label(标签)
      Window(窗口)  Panel(面板)  |----Checkbox(检查框，复选框)
        /        \      |----TextComponent(文本组件)
    Frame(框架)    Dialog(对话)      /             \
          |                TextArea(文本区域)   TextField(文本框)
         FileDialog(文件对话框)

    Container--->为容器，是一个特殊的容器，该组件可以通过 add 方法来添加其他组件进来。
  布局管理器
//      容器中的组件的排列方式，就是布局。   常见的布局管理器：
      FlowLayout(流式布局管理器) ，从左到右的顺序排列。 Panel 默认的布局管理器。
      BorderLayout(边界布局管理器)，东，南，西，北，中  Frame 默认的布局管理器。
      GridLayout(网格布局管理器)， 规则的矩阵。         
      CardLayout(卡片布局管理器)，选项卡。
      GridBagLayout(网格包布局管理器)，非规则的矩阵。
  创建图形化界面
        1.创建 Frame 窗体。
     2.对窗体进行基本设置，比如 大小，位置，布局。
     3.定义组件。
     4.将组件通过窗体的 add 方法添加到窗体中。
     5.让窗体显示，通过 setVisible(true)。
1.2.时间监听机制
       时间监听机制的特点： 1,事件源。//就是AWt包或Swing包中的那些图形界面组件。
         2.事件。//每一个事件源都有自己特有的对应事件和共性事件。
           3.监听器。//将可以触发某个事件的动作都已经封装到了监听器中。
             4.事件处理。
//    以上三者，在java中都已经定义好了，直接获取其对象来用就可以了。
        我们要做的事情是，就是对产生的动作进行处理。
      窗体事件
   1.  添加窗体事件要实现 implements WindowListener ，但是实现本接口要覆盖 7 个抽象的方法。
//    接口都是抽象的，其中所有方法也都是抽象的，必须复写全部抽象方法后(抽象的没有方法体)才可以建立子类对象。
//    如果只用其中一个方法，如关闭，其它的不用，也必须重写。 这样是不方便的。
   2. WindowListener 的子类 WindowAdapter 已经实现了 WindowListener 接口，并覆盖了其中所有方法。
    那么只要继承 WindowAdapter ,然后覆盖需要的方法即可。
   3.   class MyWin implements WindowAdapter
    {
     public void windowClosing(WindowEvent e){
      System.out.println("退出");
      System.exit(0);
     }   //一般使用匿名内部类方法。
    }
  Action 事件
       按钮的事件监听不是 WindowListener ，而是 ActionListener ,该类只用一个actionPerformed();方法。
       but.addActionListener(new ActionListener(){
      public void actionPerformed(ActionEvent e){
       System.exit(0);
      }
       });
  鼠标事件
    鼠标的事件监听为 MouseListener ，该类下有5个方法，单击，进入，离开，点击按下，点击离开
    butEx.addMouseListener(new MouseAdapter(){
      public void mouseEntered(MouseEvent e){
      S.op("鼠标进入");      //鼠标进入和离开是两个动作。
     }
    }); 
    but1.addMouseListener(new MouseAdapter(){
      public void mouseClicked(MouseEvent e){  //鼠标单击按下和单击松开是两个动作。
      S.op("点击一下");
      if (e.getClickCount()==2)//鼠标事件里没有双击，可获取单击次数，单击两下算双击。
       S.op("双击一下")
     }
    });
  键盘事件
    键盘的事件监听是 KeyListener ,适配器为 KeyAdapter ,该类下有3个方法，某键按下，某键松开，输入某键
    f.addKeyListener(new KeyAdapter(){
     public void keyPressed(KeyEvent e){
      S.op(e.getKeyChar()+e.getKeyCode());//获得输入某键的键面字符和对应的键数值。
      S.op(KeyEvent.getKeyText(e.getKeyCode()));//获取该键键值对应的字符串，如 Escape--对应27
     }
    });
    键盘中所有键都有对应的数值关系，可是不好记忆。可写成 如： KeyEvent.VK_ENTER,VK_ESCAPE,VK_A,,,等等。
    if(e.isControlDown()&&e.getKeyCode()==KeyEvent.VK_ENTER)
      //组合键的写法，  Ctrl + Enter ：在Ctrl 按下的同时，输入 Enter 。
    Dialog (对话框) new Dialog(Frame 属于的框架,String 标题,boolean 模式);//模式为true，即操作完本对话框才可操作
         //后面，为false，则相反。 同 Frame 一样，要设置大小，位置，和布局。
    Label (标签) new Label(String 要显示的内容);
    TextField (文本框) new TextField(int 文本框的长度);
    TextArea (文本区域) new TextArea(int 行数,int 列数);
1.3.菜单
    MenuBar (菜单栏)，将该菜单栏与 Frame 对象关联，调用框架的 setMenuBar 方法。
        add.(Menu 菜单);  
    MenuItem (菜单项)，
    Menu (菜单)，add.(MenuItem 菜单项);//菜单是菜单项的一部分
     菜单事件
     菜单事件同按钮事件一样，都是 ActionListener 复写 actionPerfored 方法，添加处理方式。
     菜单的打开保存功能
        FileDialog (文件对话框)
        public FileDialog(Frame 所属框架,String 标题,int 模式 FileDialog.LOAD & FileDialog.SAVE)
       //不指定模式，默认为打开。
1.4. jar 包双击执行
   jar -cvfm ma.jar 1.txt day77
      |      |     |      |
//      |      |     |      ----将 day77 目录下的所有文件压缩到 ma.jar 包中
      |      |     -将 1.txt 中的写有要执行文件的 清单 写到 ma.jar 包中的 META-INF 中的 MANIFEST.MF 文件中
//      |      -----------------------要打的包名
      ----- -c  创建新的归档文件
      -v  在标准输出中生成详细输出
      -f  指定归档文件名
      -m  包含指定清单文件中的清单信息
'————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
2.0................网络编程
  2.1.网络模型       OSI参考模型        TCP/IP参考模型
     OSI 参考模型  _________________  ______________
     TCP/IP 参考模型     |应用层         |    |             |
          |———————————————|  |      |
          |表示层   |  | 应用层    | http 协议
          |———————————————|    |      | Ftp 协议
          |会话层         |    |      |
//          |———————————————|  |—————————————|
//          | 传输层      |    | 传输层    | TCP /UDP 协议
          |———————————————|  |—————————————|
          | 网络层      |    | 网际层    | IP 协议
//          |———————————————|  |—————————————|
          |     数据链路层|    |      |
          |———————————————|  |主机至网络层 |
          |       物理层|    |      |
          |———————————————|  |—————————————|
  
  2.2.网络三要素----IP , 端口 , 协议
     IP地址： 网络中设别的标示;不易记忆，可用主机名;本地地址：127.0.0.1 主机名：localhost
//     端口号：用于标示进程的逻辑地址，不用进程的标识;有效端口：0~65535，其中0~1024是系统使用或保留端口。
     传输协议：通讯的规则，常见协议，TCP  UDP
   2.2.1.IP
      Java 中把 IP 地址封装成了对象。
     InetAddress i2 = new InetAddress(); Error //该类没有构造函数(构造函数私有化)，不允许新 new 对象。
     InetAddress i = InetAddress.getLocalHost();//用静态方法获得本类对象
     S.op(i.toString());//获得对象后，调用本类非静态方法。
     S.op(i.getHostAddress());//获取本机 Ip 地址。
     S.op(i.getHostName());//获取本机 主机名。
     InetAddress ia = InetAddress.getByName("192.168.56.1");//获取指定 IP 地址的主机对象。
        S.op(ia.getHostAddress());
        S.op(ia.getHostName());
   2.2.2.TCP  UDP
      UDP : 将数据及源和目的封装成数据包中，不需要建立连接。
      每个数据包的大小限制在 64 K内。
      因无连接，是不可靠协议。
//      不需要建立连接，速度快。
      TCP : 建立连接，形成传输数据的通道。
      在连接中进行大数据量传输。
      通过三次握手完成连接，是可靠协议。
//      必须建立连接，效率会稍低。
   2.2.3.Socket
      Socket 就是为网络服务提供的一种机制。通信两端都有 Socket 。
      网络通信其实就是 Socket 间的通信，数据在两个 Socket 间通过 IO 传输。
      UDP传输
       1.DatagramSocket 与 DatagramPacket  
       2.建立发送端，接受端。
       3.建立数据包   
       4.调用 Socket 的发送接受方法。
       5.关闭 Socket //发送端和接收端是两个独立的运行程序。
     public static void main(String[] args) throws Exception//有Socket异常，未知端口异常，和发送的IO异常，所以要抛出。
      {
       DatagramSocket ds = new DatagramSocket();//定义一个Socket服务。
       byte[] data = "kaca..i am coming".getBytes();//定义byte数组，因为发送的数据包只支持 byte 数组。
       DatagramPacket dp = //定义一个数据包。
        new DatagramPacket(data,data.length,InetAddress.getByName("192.168.56.1"),1008);//数据包构造方法的一种
                  //接收byte数组，指定长度，接收端 IP地址，和端口。
       ds.send(dp);//调用Socket的发送方法，把数据包发送出去。
       ds.close();//关流。
      }
     DatagramSocket ds = new DatagramSocket(1008);//定义一个端点，Socket服务。
      byte[] data = new byte[1024];//定义用于接收数据的数组。
      DatagramPacket dp =
       new DatagramPacket(data,data.length);//定义数据包，用于接收发过来的数据。
      ds.receive(dp);//调用服务的接收方法，把接收的数据存储到数据包中。
      String da = new String(dp.getData(),0,dp.getLength());//调用数据包的方法把接收的数据中的信息部分提出。

      S.op(dp.getAddress().getHostAddress()+"--------"+da+"------"+dp.getPort());//用包的方法获取数据IP和端口。
      ds.close();
   2.2.4.
    键盘录入方式的数据
    BufferedReader bur = new BufferedReader(new InputStreamReader(System.in));
    String line = null;
    while((line=bur.readLine())!=null){
     byte[] buf = line.getBytes();
     DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.1.1.1"),10001);
     ds.send(dp);
    }//键盘录入是把键盘作为源，并封装数据包发送。   接收不变。
   2.2.5.
     用多线程方法，将发送和接收放在同一个窗口中，发送和接收同时运行，既是聊天程序。
   
  2.3...TCP
   2.3.1. Socket 和 ServerSocket
       建立客户端和服务器端
       建立连接后，通过 Socket 中的 IO 流进行数据的传输
       关闭 Socket //同样，客户端和服务端是两个独立的应用程序。

     服务端：
    1.建立服务端的Socket 服务，ServerSocket(); 并监听一个端口。
    2.获取连接过来的客户端对象。通过ServerSocket的 accept 方法。没有连接就会等，阻塞式方法。
    3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。
      Socket s = new Socket("127.1.1.1",10088);
      BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
      PrintWriter out = new PrintWriter(s.getOutputStream(),true);
      BufferedReader buin = new BufferedReader(new InputStreamReader(s.getInputStream()));
      String line = null;
      while((line=bufr.readLine())!=null){
       out.println(line);
       String str = buin.readLine();
       S.op("Server---->"+str);
      }
       bufr.close();
       s.close();
          ServerSocket ss = new ServerSocket(10088);
          Socket s = ss.accept();
          String ip = s.getInetAddress().getHostAddress();
          System.out.println(ip);
          BufferedReader buIn =
           new BufferedReader(new InputStreamReader(s.getInputStream()));
          PrintWriter out = new PrintWriter(s.getOutputStream(),true);
          String line = null;
          while((line=buIn.readLine())!=null){  
           out.println(line.toUpperCase());   
          }
          s.close();
          ss.close();
  2.4.并发访问服务端
   //如要并发向服务端上传数据，那么叫要加入多线程技术。
    服务端获取到连接上的客户端，后只有等待该客户端执行完数据，并断开连接后，才可以 accept 其他连接。
         //因为是阻塞式方法。
    加入多线程，将每个客户端封装到一个单独的线程中，就可以同时处理多个客户端请求。

    将每个客户端要执行的相同的代码封装到 run(); 方法中。
     class picThread implements Runnable{
       private Socket s;
       picThread(Socket s ){
        this.s = s;
       }
      public void run(){
       try{
        String i = s.getInetAddress().getHostAddress();
        System.out.println(i);
        InputStream in = s.getInputStream();
        FileOutputStream fos = new FileOutputStream("obama.jpg");
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=in.read(buf))!=-1){
         fos.write(buf, 0, len);
        }
        OutputStream out = s.getOutputStream();
        out.write("up is over".getBytes());
        fos.close();
        s.close();
       }
       catch(Exception e){}  
      }
      
     }
     public class PicServer {
      public static void main(String[] args) throws Exception{  
       ServerSocket ss = new ServerSocket(10088);
       while(true){
        Socket s = ss.accept();//循环获取每个连接进来的客户端。
        new Thread(new picThread(s)).start();   
       }//while 一直循环，并且不关服务端对象。没有 ss.close();方法。
      }
     }
  2.5. URL
    统一资源定位器(全球资源定位器)（Uniform Resource Locator）
    String getFile();//获取此 URL 的文件名
    String getHost();//获取此 URL 的主机名
    String getPath();//获取此 URL 的路径部分
    int getPort();//获取此 URL 的端口号
    String getProtocol();//获取此 URL 的协议名称
    String getQuery();//获取此 URL 的查询部分
'___________________________________________________________________________________________________________________________
3.0.....正则表达式
//      符合一定规则的表达式。
    作用：用于专门操作字符串。
//    特点：用于一些特定的符号来表示一些代码操作，这样就简化了书写。
    好处：可以简化对字符串的负责操作。
    弊端：符号定义越多，正则越长，阅读性极差。
            1     字面值转义     \x
            2     分组 [...]
            3     范围 a-z
            4     并集 [a-e][i-u]
            5     交集 [a-z&&[aeiou]]
    [abc] a、b 或 c（简单类）
    [^abc] 任何字符，除了 a、b 或 c（否定）
    [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围）
    [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集）
    [a-z&&[def]] d、e 或 f（交集）
    [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去）
    [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

  3.1.具体操作功能
      1.匹配： boolean matches(String regex);   String 的 matches();方法。
      2.切割： String[] split(String regex);
        (.)\\1//叠词：为了让规则的结果被重用，可以将规则封装成一个组。用（）完成，组都有编号。
           //从1 开始。要使用已有的组可以用 \n(n就是组的编号)的形式来获取。
      3.替换： String replaceAll(String regex,String 要替换的字符);
      4.获取；//将字符串中的符合规则的子串取出。
        需要导入  import java.util.regex.*;
         Pattern p = Pattern.compile(regex);//将规则封装成对象。
         Matcher m = p.matcher(String);//获取匹配器对象。将规则和字符串相关联。
         boolean b = m.matches();//其实String类中的matches方法，用的就是Pattern和Matcher对象
             //来完成的。只是被String封装后，用起来简单，功能单一。
         boolean b1 = m.find();//将规则作用到字符串上，并进行符合规则的子串查找。
         String s = m.group();//用于获取匹配后的结果。

 

-----------------------android培训、java培训、期待与您交流！ --------------------