Java学习笔记_系列04

1.网络编程：
   网络基础知识
      Mac地址：每个网卡专用地址，也是唯一的。
      端口(port)：应用程序（进程）的标识（网络通信程序）
         OS中可以有65536（2^16）个端口，进程通过端口交换数据。
         端口是一种抽象的软件结构，与协议相关：TCP的23端口和UDT的23端口为两个不同的概念。
         端口应该用1024以上的端口，以下的端口都已经设定功能。
      协议：为了进行网络中的数据交换而建立的约定，协议是为了保证通信的安全，不同层的协议是完全不同的。
         TCP协议：传输层的协议，重发一切错误的信息
         IP协议：保证地址和主机一一对应（ip地址＋网卡地址）
        
   TCP编程：
      TCP是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。
         1) 服务器分配一个端口号，服务器使用accept()方法等待客户端的信号，信号一到打开socket连接，从socket中取得OutputStream和InputStream。
            2) 客户端提供主机地址和端口号使用socket端口建立连接，得到OutputStream和InputStream。

      Server端编码的步骤：
         1、new ServerSocket 打开端口
         2、调ServerSocket的accept()等待客户连接，当连接成功返回交互的Socket。
         3、调用Socket.getInputStream,getOutputStream获得服务器端的IO流
         4、用处理流封装后与客户端交互，记住你读我写，一读一写。
         5、关闭单一客户端调用Socket的close(),关闭服务器调ServerSocket的close();

      Socket端编码步骤：
         1、new Socket(Server ip,Server port)试图连接，如成功才有对象
         2、调用Socket.getInputStream,getOutputStream获得服务器端的IO流
         3、用处理流封装后与客户端交互，记住你读我写，一读一写。
         4、关闭，只有Socket的close()方法。
2.网络编程：
   多线程+网络：
      1、服务器端的等待客户连接代码（ while(true) ），服务器端与单个客户端交互的代码放入线程体（ run ）
      2、客户端如有其他要求，与服务器交互的代码也要放入线程体
      3、ServerSocket和Socket编码基于TCP/IP协议，重发一切错误数据，当网络不好时会使性能很差
      4、Server端
         new ServerSocket启动等待连接线程
         在accept后启动交互线程
      注意：交互时注意对应产生，读写流对应和次数对应
     
   URL：网址，统一资源定位器
      常用的构造器：
         URL(String spec)
            spec  一个完整的网址（协议+网址）
                   根据 String 表示形式创建 URL 对象。
                  
   URLConnection：与网址进行连接
      通过URL的openConnection()方法生成一个URLConnection实例，通过下面两个方法，进行流的操作
         getInputStream()
                   返回从此打开的连接读取的输入流
                getOutputStream()
                   返回写入到此连接的输出流。
                  
   UDP编程：这种信息传输方式相当于传真，信息打包，在接收端准备纸
      特点：
         1、一种无连接协议，速度快
         2、不保证数据的完整，不会进行重发
        
      DatagramSocket和DatagramPacket类：
         DatagramSocket：此类表示用来发送和接收数据报包的套接字。
         DatagramPacket：数据报包，是UDP下进行传输数据的单位，数据存放在字节数组中，其中包括了目标地址和端口以及传送的信息。
            用于接收：  
               DatagramPacket(byte[] buf , int length)
            用于发送：  
               DatagramPacket(byte[] buf , int length , InetAddress address , int port )
              
      UDP发送端：
         1、创建一个DatagramSocket，不需要参数
         2、创建一个DatagramPacket，指明接收方的IP地址和端口号
         3、发送数据send(DatagramPacket p)
         4、关闭DatagramSocket

      UDP接收端：
         1、创建一个DatagramSocket，指定接收方的IP地址和端口号
         2、创建一个DatagramPacket，不需要IP地址和端口号
         3、接收数据receive(DatagramPacket p)
         4、关闭DatagramSocket
3.常用类库：
   java.lang.*:
      System 系统
      Object 对象
         clone()
         equals()
         hashCode()
         toString()
      Class  类        
      String/StringBuffer/StringBuilder  与字符串相关的
      Thread 线程
      所有的封装类

   java.util.*:
      Set--->HashSet,TreeSet     
      List--->ArrayList  
      Map--->HashMap(线程安全，不支持空),HashTable(线程不安全，支持空)
      Collections--->外同步
      Properties
      Date
      观察者-->Observable,接口Observer
      数据结构+工具类

   java.sql.*: 后面马上会讲到，JDBC
  
   java.awt/swing.*：没什么机会用到
     
   java.io.*:  流相当的多
      File/FilenameFilter
      Serializable 对象序列化接口

         注意：写一个类要考虑的事情：1、无参构造器，2、实现序列化接口，3、重写equals,hashCode
     
      FileInputStream
      FileOutputStream
      InputStreamReader
      PrintStream
      BufferedReader
      nio包
  
   java.net.*:  以后JSP,Servlet用的时候这个包都已经写好了
      InetAddress--->IP地址
      URL----------->网址
      URLConnection---->连接
      ServerSocket,Socket----TCP/IP
      DatagramSocket,DatagramPacket----UDP
     
   一些零散的类：
      Comparable（可比较的）,Comparator（比较器）

      java.math.*;数字在商业软件中应用时找这个包
         BigDecimal
     
      与反射相关的：java.lang.reflect:  用的机会比较少
              
      Runtime（运行环境）,Process（进程） ，这两个在java.lang包里，用了这些就不能跨平台了，而且效率低
4.国际化：让世界上每个人都能看懂。
   Locale类（java.util包下）：包括所有国家、地区、语言
      存在很多的静态属性，来表示国家、语言
      三种构造方法：
         Locale(String language)
            根据语言代码构造一个语言环境。
         Locale(String language, String country)
            根据语言和国家构造一个语言环境。
         Locale(String language, String country, String variant)
            根据语言、国家和变量构造一个语言环境。
      常用方法：
         Locale getDefault()
                   获得此 Java 虚拟机实例的当前默认语言环境值。
          String getDisplayCountry()
                   返回适合向用户显示的语言环境国家名。
                void setDefault(Locale newLocale)
                   为此 Java 虚拟机实例设置默认语言环境。
         String getLanguage()
                   返回此语言环境的语言代码。
         String getCountry()
                   返回此语言环境的国家/地区代码。
             注意：
                国家会兼容语言，但语言不会兼容国家。
         
   java.text.*：该包下存在许多格式化类
             NumberFormat抽象类：
                常用方法：
                   NumberFormat getInstance()
                      返回当前默认语言环境的通用数字格式。
            NumberFormat getInstance(Locale inLocale)
                      返回指定语言环境的通用数字格式。
                   String format(double number)
                      根据国家，进行格式规范。
                   NumberFormat getCurrencyInstance(Locale inLocale)
                      返回指定语言环境的货币格式。 
                     
             SimpleDateFormat类：
                模式字母：
            y  年 
            M  年中的月份 
            H  一天中的小时数（0-23）
            h  am/pm 中的小时数（1-12）
            m  小时中的分钟数
            s  分钟中的秒数 
         构造器：
            SimpleDateFormat(String pattern)
                      用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
         常用方法：
            String format(Date date) 将一个 Date 格式化为日期/时间字符串。
                注意：
                   看到相应的模式字母，就会进行转换。
        
   实现国际化：
      1、先写各个语言对应的文字类，使其extends ListResourceBundle，然后重写getContents()，返回一个二维数组。
      2、在程序中按照Local和ListResourceBundle的baseName来选择对应的资源，调用getString()/getObject()取得value
         ResourceBundle类：
            ResourceBundle getBundle(String baseName, Locale locale)
               baseName为对应的ListResourceBundle的类名(包名.类名)
               使用指定的基本名称和语言环境，以及调用方的类加载器获取资源包。
      注意：根据key去查找value时，当前没有会去查找默认的，默认的也没有则会抛出异常
5.5.0新特性：
   1、自动装箱，自动解箱(简单类型->对象类型)
      小于127的数值在自动装箱时只做一次装箱，做" == "时相等。
      null无法自动解箱。
      先装箱后赋值和先解箱后赋值时，需要注意是否能够匹配。
     
   2、静态import
      用于导入类中的静态属性和静态方法。
      格式：import static 包名.类名.属性/方法/*
      注意：
         必须是静态的成员。
         静态导入时，不允许导入同名方法/属性。
         使用时，可省略" 类名. "就像使用本类方法一样
        
   3、增强for循环：for(  :  )
      方式统一，可以处理数组和集合。     
      不可以同时对两个以上的集合进行操作。
      不支持删除元素。
     
   4、可变长的参数：(...)
      用于取代数组，实际上还是按数组进行处理，允许传递非数组的值（0到n个，中间用逗号分隔）。
      可变长参数只能出现一次，且一定会放在参数列表的最后。
      作参数时，可变长参数可以不传，但数组不可以。
     
   5、格式化输入输出：Scanner类
      了解下就可以，知道有这个类就OK。
  
   6、枚举Enum：本质上也是一个类，具有类所有特性
      格式：
         enum 枚举名{
            枚举值1,
            枚举值2,
            .....
         }
        
      特性：
         显示一些同类型的清单。
         一个枚举值就是一个枚举对象。
         可以有构造器，但不能是public的。
         具有一个私有的默认无参的构造器，显式构造后，默认的构造器会消失。
         属性，方法和类一样。
         枚举是final的(对于外部无法继承)，但在内部可以去实现。
     
      注意：
         清单里的类，会调用匹配的构造器，如无，则会报错。
         在枚举中可以有抽象方法，但在清单中的所有子类都必须实现他。
         如果要写属性和方法，则最后的一个枚举值要以分号结束。
         枚举中的values()方法会返回枚举中的所有枚举值：  Color[] ss = Color.values(); 
     
   7、泛型

   8、元数据（注释），项目中推广度一般
6.5.0新特性：
   泛型：
      泛型的形式：
         <E>
         <E extends 类型>
         <E extends Numner&comparator>  类名&接口，表示E继承Numner类实现comparator接口
         <?>  泛型通配符表示任意类型，仅用于传参
         <? extends 类型>  表示这个类型可以是该类或者该类的子类。
         <? super 类型>  表示这个类型可以是该类或者该类的父类。        
        
      泛型的优点：
         指定泛型后，取出数据时不需要进行强制类型转换，可以直接赋值给相应类型。
         可以限定集合中的元素类型，保证集合中的元素是按照要求放入的。  
         可以增强多态(继承多个接口而无需写继承类)。
         保证参数有效。

      泛型的局限性：        
         不能实例化泛型
            T t = new T(); //error
         数组不可用泛型限定
            List<String>[] list = new List<String>[10];   //错误
            E[] a = new E[10];   //错误
         类的静态变量不能声明为类的泛型类型
            public class GenClass<T> {
                 private static T t;   //编译错误
            }
         静态方法可以是泛型方法(在修饰符和返回值之间写泛型)，但是不可以使用类的泛型。
            static void copyArrayToList(Object[] os,List<T> ls){
                  //错误，T为类的泛型
            }
           
            static <E> void copyArrayToList(E[] os,List<E> ls){
                  //泛型方法，正确的
            }
         泛型不能使用简单类型
            GenList<int> nList = new GenList<int>(); //编译错误  
         泛型类不能是异常类，也就是该泛型类不能继承自Throwable以及其子类
            public class MyExpection<T> extends Exception{ }   //编译错误
         可以抛出（throws）泛型类，但catch的参数不能是泛型类。
     
      注意：
         编译时类型的泛型和运行时类型的泛型一定要一致，没有多态。
         支持泛型的集合，只能存放指定的类型，或者是指定类型的子类型。  

   注释（元数据）：
      描述代码的代码，作用是规范编译器的语法。

      三种内置注释：
         @Deprecated 所标注的程序元素是不推荐使用的
         @Override 检查是否为合法的覆盖父类的方法
         @SuppressWarnings 注释类或方法，忽略其中的某些类型的警告信息
        
      注释的三种类型：
         标记注释：不需要任何参数
            @Override
            @Deprecated
         单值注释：有一个值的注释
            @注释名（值名=值）
            值名一般为value，可以省略的，直接写值就可以
            值的类型是有限制的，只能是以下几种：
               8种基本数据类型
               String
               Class
               Enum
               Annotation
               以及他们的数组
         多值注释：每个值之间用逗号隔开
        
      四种元注释：java.lang.annotation中的类
         元注释：注释注释的注释，用来限定注释的特征
         @Terget   用来限定某个注释的使用范围，可以对什么元素进行注释
         @Retention  用来描述注释的有效范围
         @Inherited  用来描述某注释是否有继承性
         @Documented  用来限定注释的信息是否能够进行文档化
        
      自定义注释：
         在自定义注释时，要用元注释来进行描述。
         如：
            import java.lang.annotation.*;
            @Target({ElementType.METHOD})
            @Inherited
            @Retention(RetentionPolicy.RUNTIME)
            @Documented
            public @interface InProgress {
               String author();   //定义属性
               String limited();
            }
           
      解析注释：利用反射
         1、Class.forName()
         2、getMethod
         3、判断是否有注释
         4、getAnnotation
6.并发线程：
   三个多线程包：
      java.util.concurrent    包含了常用的多线程工具，是新的多线程工具的主体。
      java.util.concurrent.atomic    包含了不用加锁情况下就能改变值的原子变量。
      java.util.concurrent.locks    包含锁定的工具。
     
   Executor接口：
      替代了Thread类，他可以创建定量的、动态的以及周期性的线程池。
   ExecutorService接口：
      线程池，用来存放线程来节省创建和销毁资源的消耗。
     
   Callable和Future接口：
      Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。Callable和Runnable有几点不同：
         Callable规定的方法是call()，而Runnable规定的方法是run().
         Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
         call()方法可抛出异常，而run()方法是不能抛出异常的。
      运行Callable任务可拿到一个Future对象，通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
7.软件开发流程：
   1、可行性分析
   2、需求分析->开发测试
   3、概要设计->分隔模块，定义框架等
   4、详细设计->类设计、接口设计
   5、编码
   6、测试
   7、部署
   8、维护