我在达内上CORE JAVA的笔记

Freon

                                   core java day11 总结
复习：
 AWT,Swing是写用户图形界面的，但实际开发中90%都是用JSP写的。但Swing可以帮助我们理解OOAD的概念
 我们在这个地方讲了两个模式：模式就是A情况下使用B。
  1、观察者模式
    当A发生变化，需要B处理时，可以考虑是否使用。
    Observer-----B（处理者）
    Observable---A
  2、适配器模式
     
概念：
 类：描述现实事物（抽象描述）
 对象：类的个体
 实例：new过的对象（实例化）
 属性:描述这个类的(有用)特征
 方法:行为（大多会操作属性）
 构造：目标是构造对象
 
 面向对象的三大特性：
 封装：private 属性，set时限定，构造时要调用方法，内部类中也要调用set方法。好处是保证了属性的有效、安全。
   封装的体现：集合
 继承：类extends类（是的关系）单继承，
    类implements接口（是的关系）多继承。
    接口extends 接口（是的关系）多继承。
    好处：
     1、代码复用
     2、可维护性、可扩展
     3、支持多态       
 多态：
  1、数字多态
  2、方法多态（重写、重载）
    重写：首先要有继承关系，父类方法不满足子类时需要重写，
      条件：相同的方法名，参数表，返回类型，访问权限不能更小，异常不能抛更大，final的不能重写，静态的方法只能用静态去重写。对抽象方法重写--我们也叫实现
    重载：同一类中（方法重载可以包括继承的方法），方法名同名，不同参数表，返回类型无关但最好相同。重载方便调用。
  3、参数多态（重要使用）
  4、类多态（接口）
  好处：
   1、参数传递更加灵活、方便
   2、多种设计模式依赖多态
   3、面向接口编程依赖多态
   4、多态是由具体到抽象的一个手段
  
  多态的体现：集合、接口 
  
  this:代表本类。
    用法：
      this.;  本类方法、属性（重名时）
      thsi(); 本类构造器第一行。调用本类其它构造器
  super:代表父类，（包括父类的父类）
    用法：
      super();用在本类构造器第一行，表示调用父类构造器
   
  先父后子，先this后super,先语句块后构造器，静态语句块 > 普通语句块
  
  static：静态，类共享
  final:不可改变，不能继承，例System,Math.
     final的属性不能二次赋值
  abstract:用于声明抽象类、抽象方法，可放在接口中。
    
  接口中的属性都是public static final
  接口中的方法都是public abstract
  
  父类方法-->子类重写：调用重写后的方法。
  
  在没有super时，有相同方法时只会调子类的方法，加super时相当于没有多态了。
  
  类库：Object：clone,equals,hashCode,toString,finalize
     String:字符串，不可改变
       indexOf,subString,split,matches,replaceAll
     StringBuffer:
     StringBuilder:
     封装类：转换用.TYPE(简单类型的类对象）
   集合：对象集（可扩容），保存下多个对象。
      数组：包含简单类型
  
    Set:add,remove,Iterator(或for--each),
    List:add,remove,get(或for--each,或Iterator)
    
   反射：
     Class-->类对象
     Field-->属性
     Method--->方法
     Constructor-->构造
  
       作用：动态的生成对象，动态的执行方法
   
  大数值：java.Math.BigDecimal
     参数必须用String类型，商业开发需要精确计算时必须使用这个
     
新课：
 
  线程：
    进程的概念：
      进程是指在同一个操作系统(OS)中执行的子程序。
    多进程：同一个操作系统中执行的多个并行的子程序。
    线程：同一进程中执行的子程序流。
    多线程：同一个进程中执行的多个并行的子程序流。
    
     多进程的好处：提高CPU的使用率。
     多线程的好处：提高CPU的使用率。
     时间片方式（主流）:全称叫CPU时间片，指的是CPU的一段执行时间，时间片分配给进程/线程，时间很短但能做很多事情。
                       有时间片的会抢占CPU，进程与进程抢，线程与线程抢。时间片用完了会再分。不管如何抢占，CPU的使用率也不会调到100%
    并发是针对的时间段。严格来说在一个时间点是无并发的。人所感受到的都是时间段
    
    线程与进程：
      多进程是独立的堆空间，独立的栈空间。进程与进程是互不影响的
      多线程是栈空间独立，堆空间共享。线程与线程是可以影响的。
      线程是由进程内部的一些顺序执行的代码组成的。
      没有进程不会有线程。一个进程可以有多个线程，有一个主线程，其它线程做为附加线程。
      
    JAVA中如何调用进程：（课堂代码：TestWinPro.java , TestLinPro.java)
      进程与操作系统相关，不能跨平台。JAVA中不推荐调进程。
      
      与进程相关的两个类：都在java.lang包中
         Runtime类（运行环境）: exec()调用本地程序。
         rocess:进程类，是exec()的返回类型。
         Runtime.getRuntime();返回与当前 Java 应用程序相关的运行时对象。
      
      线程模型：
        虚拟CPU（CPU时间片）:Thead
        代码和数据由Runnable提供，run()运行代码，数据是子类属性
      
      写线程的方法：（课堂代码：TestThread.java，TestRunnable.java)
           1、继承Thread 类:
               1、extends Thead
               2、重写run()方法
               3、new 本类.start();
             好处：编写简单，可读性好
           2、实现Runnable接口
               1、implements Runnable
               2、重写run()方法
               3、new 本类，new Thread(本类对象）
               4、Thread对象.start();
             好处：保留了类继承，代码和逻辑分离，便于实现多线程。               
       run()和start()是不一样的：
           run()叫线程体方法，自身其实就是普通方法，run（）不会启动线程
           start()叫线程启动的方法，向线程调度来说明当前线程ready（准备好了）。而不是正在执行的状态。
                     
      优先级：1--10，1最小，10最大，在某些操作系统中优先级会失效的。
              小优先级代表时间片小。
             
      守护线程依赖于其它线程
      join使自身加入主线程
      
     线程中几个重要的方法： (课堂代码：TestDaemon.java,TestSleep.java，TestJoin.java)
      Thread.currentThread()取当前线程（实现接口方式有时用这个）
      sleep():暂停线程，本线程不会抢，除非sleep运行完，这个是静态方法。自己让出CPU，其它的来抢。
      yield():暂停线程，给本类或>=本类优先级的。只给优先级高的让，一般优先级低的抢不到
      join():让本线程加入主线程。在线程内部、程序依然是顺序执行的，乱序体现在不同线程。
         tj.start();
        tj.join();要按这个顺序执行，若把join放在前面是无意义的。
      setDaemon(true)后台/守护线程 
      
   线程状态图：
       
    ▲ 初始状态              ▲阻塞状态               ▲终止状态
        \                 /           ┍ 1等待输入     ┓
         \               /sleep时间到    \ 2sleep     /
          \start        /                 \ 3join    /stop
           \           /                   \        /
            ┙       ┕                     \      /
         ▲ 可运行状态  _ _ _ OS选中 _ _ _\   ▲运行状态
          (只缺CPU)    \  CPU到期或调用yield
                    ┍                        /    \
                      \                      /      \wait
                       \        Synchronized/        \
                        \                  /          \
                         \                /            \
                          \              /              \
                           \           ┕               ┙
                             ▲ 锁池状态 ＜－－－－－－ ▲等待队列
                                          notify/notifyall
      
        
        
    
    

Freon

                                              core java day12  笔记

 同一个线程只能用start()启动一次。
 多线程编码多半采用实现接口的方式
 一个线程必须有自己的虚拟cpu
 一个线程可以和其他线程共享代码和数据
 
 synchronized可以加在方法层也可以加在代码块
 当对一个方法或一个代码块加上后，意味着线程在同步代码中必须采用串行访问，不能再并行。
 Synchronized用法
    1．Synchronized修饰代码块（同步代码块），
      public void push(char c){
          synchronized(this)//只有持有当前对象锁标记的线程才能访问这个代码块，this就是对象锁，锁定代码块
         {
           ...
          }
      }

      对括号内的对象加锁，只有拿到锁标记的对象才能执行该代码块
    2．Synchronized修饰方法
        public synchronized void push(char c) {
             ...
        }
       在整个方法里，对当前对象的加锁，只有拿到锁标记的对象才能执行该方法。
      
 对共享数据的读和写要一起同步，一般来说属性表示共享数据。
 同步的问题：串行，大大的降低效率。
 尽可能不要在方法层使用同步，使用synchronized。
 所有的对象都有对象锁，一个钥匙。
 
 池：池就是内存常驻
   常量池、线程池、DB连接池、等待池、同步池、对象池
   好处：快
   坏处：占去了部分内存
 
 同步最怕死锁
 对象锁正在使用的对象不能直接操作。
 
 interrupt()也会从运行状态到阻塞状态
 stop()存在潜在的安全隐患，所以不再用。
 1、对象-->锁--->对立
 2、同步依赖对象锁（对象）、锁对象相同，同步语句串行
 
 避免死锁：要保持顺序锁,不要回调，反向打开
 
 因为线程的死锁，从而引发要多线程的通信
 死锁：每个线程不释放自己拥有的资源，却申请别的线程拥有的资源，会造成死锁问题
       没有获得加锁对象的锁标记的线程,不能访问只有获得该对象所标记才能访问的同步方法,但可以访问这个对象的非同步的方法。

 例：     t1                           t2
     synchronized(o1){              synchronized(o2){
  synchronized(o2){           synchronized(o1){
  }                               }
     }                              }

          t1和t2会形成死锁
 
  Vector,Hashtable,StringBuffer 这些是同步的。
  ArrayList,HashSet,StringBuild 这些是不同步的。
 
  得到一个同步的ArrayList: List list=Collections.synchronizedList(new ArrayList());----外同步
                           List list=new Vector();-----外同步
 
  wait();参数可选，可以是0个，1个，2个。 对象锁，放锁，自己等。
    用 notify(); notifyAll(); 唤醒wait();
   notify()随机唤醒一个，notifyAll()全部唤醒，随机选。
   调用wait()方法表示让正在执行的线程停止执行进入对象的等待队列去等待，同时释放掉对象的锁
   注意：只能对加锁的资源进行wait()和notify()。
  1) wait()：交出锁和CPU的占用;
  2) notify()：将从对象的等待池中移走一个任意的线程，并放到锁池中，那里的对象一直在等待，直到可以获得对象的锁标记。
  3) notifyAll(): 将从等待池中移走所有等待那个对象的线程并放到锁池中，只有锁池中的线程能获取对象的锁标记，锁标记允许线程从上次因调用wait()而中断的地方开始继续运行
   
   怎么用线程？
    1、extends Thread,无共享时使用
    2、implements Runnable,有共享时使用
    
   同步有什么用：
     线程是共享堆、独享栈的，所以有可能发生两个线程同时操作同一块内存。
     同步可以使共同的操作变成单独操作。
     
   同步原理：对象锁+同步
         对象锁是对象所特有的锁，简单类型不是对象，没有锁。
    同步的优缺点：
      为了安全，同步不得不用。缺点就是效率非常低下。
    多线程编码：
      1、实现线程采用Runnable接口。
      2、有共享数据的冲突用同步 
      3、避免死锁（采用顺序锁，不要回调）
      4、若使用wait,notify进行交互时的原则
         （1）用notifyAll代替notify
         （2）wait是在同步语句的内部，用while循环
   
    在什么情况下放锁（交钥匙）：
       1、同步代码执行完毕
       2、异常未处理
       3、wait()方法
       
   
I/O流
  输入流 InputStream    
    输出流 OutputStream
   
    输入、输出是针对程序而言的。
   
    常用的输入字节流：
     FileInputStream:文件字节流       
     ObjectInputStream:对象字节流    
     BufferedInputStream：缓冲输入流
    常用的输出流：
     FileOutStream：文件输出流
     ObjectOutputTream：对象输出流
     BufferedOutputStream：缓冲输出流
     rintStream:打印流

       
    1）三个基本的read()方法
        a. int read(): 从流里读出的一个字节或者-1; (实际读了多长） 从此输入流中读取一个数据字节。 返回下一个数据字节；如果已到达文件末尾，则返回 -1。
        b. int read(byte[])：将数据读入到字节数组中，并返回所读的字节数; （期望读了多长）从此输入流中将最多 b.length 个字节的数据读入一个字节数组中。 返回：读入缓冲区的字节总数，如果因为已经到达文件末尾而没有更多的数据，则返回 -1。
       c. int read(byte[], int off, int len)：两个int参数指定了所要填入的数组的子范围。 从此输入流中将最多 len 个字节的数据读入一个字节数组中
    2) 其它方法
        a. void close(): 关闭流，如使用过滤器流，关闭最外部的流，会关闭其余的流。 关闭此文件输入流并释放与此流有关的所有系统资源
        b. int available(): 返回可从流中读取的字节数。
        c. skip(long): 丢弃了流中指定数目的字符。(有时候不跳)
        d. boolean markSupported()
        e. void mark(int)
        f. void rese()
        
   1) 三个基本的write()方法
        a. void write():
        b. void write(byte[])：
        c. void write(byte[], int , int)
  2) 其它方法
        a. void close(): 关闭流，如使用过滤器流，关闭最外部的流，会关闭其余的流。
        b. void flush(): 允许你强制执行写操作。
  注意：在流中close()方法由程序员控制。因为输入输出流已经超越了JVM的边界，所以有时可能无法回收资源。
  原则：凡是跨出虚拟机边界的资源都要求程序员自己关闭，不要指望垃圾回收。
  
  
  
  
   
   

Freon

                                    core java day13 笔记

什么时候使用线程：
 1、为了提高效率
 2、遇到并发问题（例QQ）
 3、处理while(true) 连接

什么时候使用同步：有共享数据冲突时要用同步。 

I/O流:
 流的概念：
         输出流
  程序----------->文件、网络
  程序<-----------数据来源 
          输入流

 流的分类：

  按处理方式来分：
   字节流：按8位传输
   字符符：按16位传输

  按功能来分：
   节点流：与文件、网络打交道的流，操作数据的来源
   处理流：操作节点流

  如何区分：  
   输入流：以InputStream、Reader结尾的流
   输出流：以OutputStream、Write结尾的流
   
   字节流：以InputStream、OutputStream结尾的流
   字符流：以Reader、Writer结尾的流
   
   节点流：看构造器，参数为数据来源，参数是String或File之类的
   处理流：构造器的参数为其它流

 所有的以InputStream结尾的流都是InputStream的子类:
   
  BufferedInputStream（处理流）
  FileInputStream（文件）  

 所有的以OutputStream结尾的流都是OutputStream的子类:

  BufferedOutputStream, DataOutputStream, FilterOutputStream
 选择流时：
  首先确定是输入还是输出。
  其次确定是字节流还是字符流。
  然后确定是节点流还是处理流。
  
 对某文件一次读一行（课堂代码：ReadLine.java）

  InputStreamReader是字节转字符的桥梁

  所有以Buffered开头的流被称为缓冲流，需要注意的是在关闭BufferedWriter前要先flush一下，因为它有缓冲。

 常用的流：File,Buffered,InputStream之类的。
 
 管道流在JAVA中线程交互的时候使用。（课堂代码:InputThread.java,OutputThread.java）
  输入管道：PipedInputStream
  输出管道：PipedOutputStream
  输入管道与输出管道的连接：PipedInputStream(PipedOutputStream src)或PipedOutputStream(PipedInputStream sink)
 
 键盘输入：（课堂代码：TestKey.java）

  
 java.util.Properties属性类，针对属性文件操作，早期使用。好处是可以在不修改代码的情况下改变相应的需求。（课堂代码：TestProperty.java）

  文件名以.properties结尾的文件称为属性文件

   文件的内容是：名字=值  的形式
   常用方法： 
  public void load(InputStream inStream)throws IOException
  public String getProperty(String key)
  public String getProperty(String key,String defaultValue)
  public void store(OutputStream out,String comments)throws IOException
  public Object setProperty(String key,String value)
  public void load(InputStream inStream) throws IOException

 JAVA编码问题：UTF-8,GBK，gb2312是可以显示中文的。  （课堂代码：TestCode.java）

  提供编码帮助的类：java.nio.charset.Charset

   GBK---中、日、韩，gb2312是GBK的子集
 
  什么时候出现中文编码问题：
   1、用流操作文件时
   2、网页（动态、静态）
   3、网络传递信息时

  String--->乱码（再次转码）
   String temp=p.getProperty("name");
   temp=new String(temp.getBytes("ISO8859-1"),"GBK");  这两处的编码有时需要互换位置
  
 File类   （课堂代码：TestFile.java）

  File(String pathname)
   绝对路径：与平台相关
   相对路径：部分跨平台，目录不能变。不敢说100%跨平台。

   boolean createNewFile()  创建文件
   boolean delete()  删除文件
   boolean mkdir()/mkdirs() 创建目录
   boolean renameTo(File destination)  改名
   boolean canRead()/canWrite()  是否可读可写
   boolean exists() 存在与否
   String[] list()  返回由此抽象路径名所表示的目录中的文件和目录的名称所组成字符串数组。
   long lastModified()  获得最后修改时间
   String getPath()/getAbsolutePath()  获得文件路径
   String getParent()/getName()  取上层文件/取文件名或目录名

 
  文件过滤器：接口--java.io.FilenameFilter
  
 以追加的方式向文件中写入：（课堂代码：TestRamdon.java）

 Serialization：对象序列化接口，没有方法的接口称为标志接口。
   

   
   

Freon

                                        core java day14 笔记

对象的序列化接口Serializable（课堂代码：Person.java,TestObjectOutput.java,TestObjectInput.java）

 想要在网络中传递对象就必须要序列化。
 Serializable接口没有方法，是标识接口
 serialVersionUID的静态常量，在接受传输的数据时会自动检查该值，保证版本的相同。

 包名、类名、属性可以被序列化
 方法、构造器不会序列化
 所有的静态属性都不会被序列化

 属性会被递归序列化，即一个序列化对象内部属性的对象也需要序列化。若内部属性不支持序列化，就会抛出不能序列化异常。
   
 多态，在序列化时用的是实际的对象。

 加上transient关键字的属性不被序列化，用于保护序列化时的敏感数据。

 
java.nio包  （课堂代码：TestCharBuffer.java）
 
 当有大的文件需要处理的时候，为了不影响性能建议用直接缓冲。
 Buffer有直接缓冲和间接缓冲两种。
 只有ByteBuffer类提供了直接缓冲。使用直接缓冲，不影响程序。其它类想用直接缓冲需要进行转换。

 java.nio.*; 块
 java.nio.channels;通道---读写通道
 java.nio.charset;编码---字符集、编码、解码

 java.nio.Buffer:一种用于特定的基本类型数据的容器
  
 java.nio.ByteBuffer:字节缓冲区，
 java.nio.CharBuffer:字符缓冲区

 java.nio.MappedByteBuffer:是特殊的ByteBuffer。直接字节缓冲区，其内容是文件的内存映射区域

 缓冲--->数组（类型匹配） ，8位，
 容量代表内存开辟部分
 界限代表可用部分
 位置代表当前指针
  
 容量>=界限>=位置
  
 nio称为无阻塞的IO（经过优化的IO）
 
 获得类对象的方式：
  1、new 本类构造                    （看API的构造部分）
  2、new 子类构造（多态）            （API实现子类部分）
  3、本类static方法                  （API方法部分）
  4、用其它类对象调用方法的返回值。  （API另请参见）
 
 flip()相当于截断没有用的空间，然后把指针移向开头
 
  
java.nio.channels:  （课堂代码：TestChannel.java）

 1、先建立IO流（FileInputStream）
    stream.FileOutputStream
   读写流RandomAccessFile
 2、IO流.getChannel()获得通道 
 
 3、创建大小合适的ByteBuffer（用这个allocate(int)） 
 4、通道:read(buffer)---输入
  write(buffer)---输出
 5、关闭所有的流和通道，先关通道，后关流。
 6、如果有多线程并发，可以使用通道.lock()方法，获得FileLock对象用FileLock.release()释放。
 7、当遇到编码问题，使用Charset、CharsetDecoder、CharsetEncoder解决。
    方法（forName,encode,decode).
 
 java.nio.charset.Charset---编码类
 java.nio.charset.CharsetDecoder---解码器
 java.nio.charset.CharsetEncoder---编码器-->行为
 
  
网络编程：

 URL：网址
 OSI网络参考模型（理论性较强的模型）                     
     七层，应用层、表示层、会话层、传输层、网络层、数据链路层、物理层：

  网络层：寻址、路由（指如何到达地址的过程）
  传输层：端口连接
  TCP模型：应用层/传输层/网络层/网络接口
   层与层之间是单向依赖关系，上层依赖于下层，下层不依赖于上层，层与层之间的连接是虚连接。对等层之间建立协议。
  端口是一种抽象的软件结构，与协议相关：TCP23端口和UDT23端口为两个不同的概念。
  端口应该用1024以上的端口，以下的端口都已经设定功能。

 TCP/IP模型

 应用层：Application
   (FTP,HTTP,TELNET,POP3,SMPT)
 传输层：Transport
   (TCP,UDP)
 网络层：Network
   (IP,ICMP,ARP,RARP)
   IP:起名协议
   ARP:地址解析协议
 物理+数据层：Link：
   (Device driver,….) 

 手机短信：点对点式
   
 A类：0--127
 B类：128-191
 C类：192-223
 D类：224--
 
 IP地址是由4个255数字组成。
 
 127.0.0.1是本机地址
 
 端口：由计算机硬件、软件模拟而成，与协议相关，ip+端口才能交互，端口有0--6成多数字，保留端口是0--1023，稳定端口：1024--4万多，动态：4万多---

  保留端口和动态端口不要用。
  
  例：21是FTP的端口，7是ECHO的端口，80是HTTP端口（网页），7001：WebLogic服务器，8080:Oracle Http,Tomcat服务器，1521：Oracle的监听外来连接端口

 TCP：传输层协议

  保证地址、主机一一对应（ip地址+网卡地址）
 

 java.net.InetAddress:IP地址类
  
 创建网络连接：
  ServerSocket等待连接
  Socket()连接上交互
  网络流传递：
   OutputStream
   InputStream

  关闭时两个连接都要关闭
 
 网络流传递时的原则：你读我写，一读一写
 
 socket（套接字）就是ip+port.
 
 Server端编码的步骤：（课堂代码：TestServer.java）
  1、new ServerSocket 打开端口
  2、调ServerSocket的accept()等待客户连接，当连接成功返回交互的Socket。
  3、调用Socket.getInputStream,getOutputStream获得服务器端的IO流
  4、用处理流封装后与客户端交互，记住你读我写，一读一写。
  5、关闭单一客户端调用Socket的close(),关闭服务器调ServerSocket的close();
 
 Socket端编码步骤：（课堂代码：TestClient.java）
  1、new Socket(Server ip,Server port)试图连接，如成功才有对象
  2、其它参照server端的3，4，5步骤
  3、关闭，只有Socket的close()方法。

 
 
 
 
  
       
  

Freon

     core java day15 笔记
IO流：

1、对文件操作用：FileInputStream
2、读行：BufferedReader
3、写一个字符串：DataOutputStream,PrintStream,

read(byte[] b)--->InputStream
read(char[] c)--->Reader

write(byte[] b)--->OutputStream
write(char[] c)--->rintWriter

文件分割器：

 1、界面--->JFrame 1个，JButton 3个--3个Action，JTextField 2个，FileDialog 1个，JLabel

 2、事件处理

     1)打开文件:
    a 显示文件对话
    b 如果选择，setText();

     2)分割
    大---->小（n个）
    FileInput --->1个
    FileOutput--->n个

            3)合并
   n--->1个
   Input---->1个文件对应1个，n-->n
   Output--->1wh

网络编程 
 InetAddress---IP地址
 ServerSocket---服务套接字，主要是用来等客户连接
 Socket----套接字，用来通信

 引入一种输入方式（客户端），Swing图形界面，System.in键盘流
 
 
多线程+网络：

 1、服务器端的（1）等待客户连接的代码while(true)
       （2）服务器端与单个客户端交互的代码，放入线程体（run）
 
 2、客户端如有其它要求，与服务器交互代码也要放入线程体
 
 3、ServerSocket,Socket编码基于TCP/IP协议，重发一切错误数据，对性能有影响
 
 4、Server:
  1、new ServerSocket,启动等待连接的线程（while(true){accept();}）
  2、在accept后启动交互线程，与客户端用流交互。
  3、交互时注意对应关系：读写流对应，次数对应。

java.net.URL:网址--->统一资源定位器，
java.net.URLConnection:与网址相接、交互
 
 1、new URL
 2、openConnection,得到URL Connection
 3、getInputStream()-->InputStreamReader---BufferedReader

UDP用户数据报，无连接，不重发，不保证数据完整，速度快，客户间无影响。
 TCP/IP----像挂号信一样，不允许丢。
 UDP-----平信，丢就丢了
 
 UDP的实现类：
  DatagramSocket（邮递员-->连接 ）,DatagramPacket（信--->数据）
  
UDP编程步骤
        send()
 发送--->DatagramSocket(可以无参）-------------->DatagramPacket(需要IP，port)

         receive()
 接收-->DatagramSocket（需要port）--------------> DatagramPacket（不需要IP）
  
 
常用类库：
 java.lang.*:
  System 系统
  Object 对象
   clone()
   equals()
   hashCode()
   toString()
  Class  类   
  String/StringBuffer/StringBuilder  与字符串相关的
  Thread 线程
  所有的封装类

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

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

   注意：写一个类要考虑的事情：1、无参构造器，2、实现序列化接口，3、重写equals,hashCode
  
  FileInputStream
  FileOutputStream
  InputStreamReader
  rintStream
  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包里，用了这些就不能跨平台了，而且效率低
  
    
  
  
  
  
 
  
  
 
   

Freon

                                     core java day16 笔记

国际化：
 即如何让全世界的人都能用一盘棋

 1、java.util.Locale类：（课堂代码：TestLocale.java）

    代表国家、地区、语言

  Locale lc=Locale.CHINA; 推荐使用这种方式获得一个Locale对象

 
 2、java.text.*  格式类
  
  数字：java.text.NumberFormat  （课堂代码：TestNumber.java）

   货币：（课堂代码：TestCur.java）
    public static NumberFormat getCurrencyInstance(Locale inLocale)返回指定语言环境的货币格式。

  日期: 关于Date的类有很多
   Date + Calendar = 日期
   
   Date和Calendar是一个时间点，参照美国海军总局，以毫秒为单位，Calendar支持年月日

        java.util.Date ：（课堂代码：TestDate.java）

    在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式：

    年份 y 由整数 y - 1900 表示。
    月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。
    日期（一月中的某天）按通常方式由整数 1 至 31 表示。
    小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。
    分钟按通常方式由 0 至 59 的整数表示。
    秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。
     于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

    public Date()： 返回相对1970年1月1日0时0分0秒的当前时间
    
    new Date()：返回当前时间。

    public long getTime(): 取时间差，自 1970 年 1 月 1 日 00:00:00 GMT 以来此日期表示的毫秒数。
       
        java.util.Calendar：
    
    new Calendar()--->getTime()---->返回指定日期

         java.util.GregorianCalendar 是java.util.Calendar的子类 
   
    月份是从0开始的，会顺延的。

   java.text.DateFormat

   java.text.SimpleDateFormat : （课堂代码：TestDateFormat.java）
    
    y--->年，M--->月，d--->日，H----->小时（24小时制）,h---->（12小时制），S----->毫秒数  s----->分钟内的秒数
  
 3、java.util.ResourceBundle：（课堂代码：MyResource.java，MyResource_zh_CN.java,TestNotePad.java）

  1、先写各个语言对象文字类，extends ListResoureBundle--->重写getContexts---->返回对象数组（二维：key--value）
  2、在程序中按照Locale（本地）ResourceBundle的Name(String)来选择对应的资源，调用getString/getObject取得value
  
  所有语言文字（不可能）

    默认（default）---->不带后缀
    中文---->默认名+_zh+_CN  ,zh是语言，CN是国家

   java.util.ListResourceBundle

  若都是字符文件可以使用属性文件

java 5.0的新特性：

 JAVA的发展史：
  1.0    JAVA产生（Bug多）
  1.2    成功
  1.3    区别不大
  1.4    nio--->无阻塞、反射、断言
  5.0    Sun--->历经九年--->又名Tiger
 
 1、自动封箱、自动解箱
 2、静态导入  
 3、for--each 循环    
 4、枚举(5.0的关键字enum，相当于interface，class)
 5、泛型（重点）
 6、自增参数(...) 自增数组+自增参数（0--n）
 7、元数据（注释） EJB 3.0中使用，项目中推广度一般
 8、Scanner (格式化IO)

 一、自动封箱、自动解箱 （课堂代码：AutoBox.java）

  简单类型---->封装类

  自动装箱时，小于127的数字==是成立的。
  null无法自动解箱，null与0是两个概念 
  Long l2=23;先装箱，后赋值,Long不能是Integer
  long l3=new Integer(23);先解箱，后赋值 

 二、for-each循环 （课堂代码：AutoBox.java）

  优点：(1)简单(2)只读时首选(3)方式统一（可以处理集合，数组）
  缺点：(1)不能同时操作两个或者以上的集合
        (2)不支持修改、删除

  不能在循环内构造Iterator,否则死循环：（课堂代码：TestIterator.java）

 三、可变参数 （课堂代码：TestV.java）

  用于取代数组，形式为：类型...

  按数组处理，允许传递非数组的值（0--n个，中间用逗号分隔）

  一个方法中，可变参数只允许出现一次(0--1),若出现则必须出现在最后一个参数的位置（位置固定在最后）
  
 四、静态导入 （课堂代码：TestStatic.java）
  
  (1)用于导入类中的静态属性和静态方法。

  (2)格式：import static 包名.类名.属性名/方法名, 也可以用*代表所有的静态属性和静态方法，非静态的不行 
  
  (3)静态导入时，不允许导入同名的方法或属性。（不可重复）
  
  (4)使用时可省略 类名.  ,就像本类方法一样调用
 
  不建议使用,使代码的可读性降低

 五、格式化IO  （课堂代码：TestScanner.java）
   
  java.util.Scanner

 六、枚举(enum)  （课堂代码：AllColor.java,TestEnum.java）
  和interface class同一级别。

  列表、清单，可以用class/interface替代，但一般不替代，是一个特殊类。
 
  (1)显示一些同类型的清单（例:Color）
  (2)构造器可以有，但不能是public的。
  (3)有私有的默认无参构造器，显示定义后会消失（和类一样）。
  (4)属性、方法和类一样
  (5)枚举是final的（对于外部来说无法继承），但是在枚举的内部可以去实现(Color)。
   
  在enum中可以有抽象方法，但在清单中所有类都必须实现此抽象方法。
  

  

Freon

                                  core java day17 笔记

5.0的新特性：

 泛型：

      形式：<这里的内容不确定>

      优点：

  1、类--->不想限定某属性的类型，泛型可实现     （类一级的泛型：课堂代码：TestG.java）
   
   变量泛型==变量类型可变

  2、泛型不需要Cast（强制类型转换）：增强了java的类型安全，可以在编译期间对容器内的对象进行类型检查，在运行期不必进行类型的转换。
 

      注意：1、泛型不支持直接去new对象
     2、泛型不支持多态，既不支持左右边的多态，左边右边必须类型一致
     3、静态属性不能是泛型的，静态方法不能直接使用泛型。
 
  方法级的泛型   （课堂代码：TestMethodG.java）
   
   public static <E> void test(E e){
       //与下面代码不一样的是这里不是多态，不需要强制类型转换
    System.out.println(e);
   }
   //在编译时，此方法与上边的方法被认为是一样的，所以不能同时存在。但若使用这个方法，则在运行时是需要强制类型转换的
   public static void test(Object e){
   }
     方法级的泛型可以在静态中使用
  
     泛型的通配： （课堂代码: TestAllG.java）

    (1)<?> 代表所有类，仅用于传参,                 <E>     可用于其它地方
    (2)<? extends 类>  代表本类以及子类，         <E extends 类> 可用于其它地方
    (3)<? super 类>  代表本类及本类的父类，?支持super,              E无对应的,E不支持super

  注意：多重继承可以这样使用  public static <E extends Number & Serializable> void test(E e){}
        （课堂代码：MyClass.java）
   
   //可以用泛型整合多个接口/类的方法（增强了多态）
   public static <E extends In1&In2> void test(E e){
    e.test1();
    e.test2();
   }
   
 泛型与异常：

  (1)泛型可以extends Exception，但异常类却不支持泛型。   （课堂代码：TestExceptionG.java,MyException.java）
  (2)泛型可以throws,但不支持catch
  
 好处：(1)不需要cast（强制类型转换）
       (2)可以限定集合中元素类型
       (3)可以增强多态（继承多于接口而无需写继承类）
       (4)保证参数有效
      
 不可用：
  (1)catch的括号中是不可用的
  (2)new (不可用); 不能new一个泛型
  (3)数组不可用泛型限定。例：E[] e=new E[10];//数组不能使用，无法初始化。
  (4)static属性不能用泛型，静态的方法在返回值前可以用泛型，其它地方不可以用泛型。
  (5)异常的子类中不可用（Throwable的子类）
  (6)简单类型不可用。例：List<int> list;这是错误的
  
元数据（注释）：

 用于描述数据的数据  
 java.lang.annotation.Annotation 接口

 java.lang.annotation.* +反射机制=元数据机制
  (1)可以帮助编译器更好的工作
  (2)完成参数配置（xml文件）
 
 元数据与类代码一体，不需要再导入其它东西
 xml配置，使代码分离，比较复杂的配置多用xml配置
 
 元数据是在2004.9推出，xml是在1998年推出的，EJB3.0-->2005年
 元数据的应用（会用）
 三个sun公司内嵌的元数据：
  @Override  方法覆盖    (课堂代码：TestStu.java)
  @SuppressWarnings(String) 取消警告
  @Deprecated  过时方法 

 自定义注释，说明（元数据） java.lang.annotation.Target
 
  
 1.标记注释（使用时不需要传值）
 @Override 用在覆盖方法前
 @Deprecated 用在方法声明前，声明此方法已过期

 2.单值注释（使用此注释时要传一个值）值可以是基本数据类型，String，枚举，以及它们的数组
 
 @注释名（prameter=10）
 int parameter
 特例:
 @注释名 (value “134” )

 @SuppressWarnings(value={“ddd”,”aaa”,”ccc”})
 @SuppressWarnings(value={"unchecked"})  //value可以省略，忽略警告
 3.普通注释（多值注释）
 (key1=value,……)

 4.自定义注释
 public  @interface Test{
 }

  (1)new @interface(注释)可以有属性，类型为简单
 在自定义注释时，要用注释来注释（描述）注释。有四种元注释即注释的注释

 @Target()，用来描述（注释）注释所能够注释的程序员元素，描述这个注释将来用来注释什么。想使用Target必须导包java.lang.annotation.ElementType

 @Retention(),描述（注释）注释要保留多久。定义一个注释的信息会保留到什么时候
  SOURCE 被编译器丢弃的注释，自定义的注释不该写SOURCE
  CLASS 存在.class文件中，但在类加载时丢掉
  RUNTIME注释存进.class中，并在加载时也保留，一般情况下，自己写的注释，一定是RUNTIME
 
 @Inherited指示注释被自动继承,是一个标记注释

 @Documented 指示某一类型的注释将通过 javadoc 和类似的默认工具进行文档化。

 注释

 (1)new @interface(注释)：可以有属性
  注释的属性类型可以是
   8种基本类型
   String
   Enum
   Annotation 注释对象，注释=接口
   以及它们的数组
 (2)为注释写注释：@Target,@Retertion(结合ElementType，RetentionPolicy）
 (3)注释的使用：@名字（属性...）
 (4)解析注释（用反射）
  Class.forName()
  getMethods(看情况）
  做是否有了判断(isAnnotationPresent)
  getAnnotation

并发线程池
 
 java.util.concurrent  并发
 java.util.concurrent.atomic  原子性（同步）
 java.util.concurrent.locks  锁
 
 线程池--->池--->空间（池所用）---->内存

 重要的：java.util.concurrent包中
   public interface Executor 
   public interface ExecutorService extends Executor  可以终止线程，可以提供线程池
   public interface ScheduledExecutorService extends ExecutorService  可以计划做任务

   public class Executors extends Object
   
   Callable---->Runnable
   call()----->run()
 增强之处：
  1、可获取信息：run()无返回值
            call可返回任何对象
  2、run()不可抛出异常，call()可抛任何异常

 线程池编程：  
   Executors（入口）
   newFixedThreadPool(个数)
   得到ExecutorService(线程池)
   submit(Callable c) ,得到Future---->get,cancel

 java.util.concurrent.FutureTask<V>：在后台工作的类
 
 java.util.concurrent.Semaphore：用于计数的类
 
 java.util.concurrent.CountDownLatch：等待计数器。一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
 
 
 原子性：当A改变时，B会被锁定
 
 java.util.concurrent.locks.Lock
 java.util.concurrent.locks.ReentrantLock 读写锁 

 
core java 要掌握的：

 1、基本编码能力（调错，API,编程的思路）
 2、概念：
  面向对象三大特性：
   封装：私有化属性，提供公开的方法，在构造器中也要调用set方法，保证属性的有效和完整
   继承：类与类、类与接口单继承，接口与接口多继承
   多态：参数多态，类多态（父类可以指向自身，也可以指向子类）
   
          重写：父类方法不能满足子类需要时重写
   重载：
          
   super:  父类
   this: 本类 
  
 3、类库：
  国际化
  泛型
  

Freon

                                  core java day18 笔记

软件测试：

 开发人员也要写测试代码。
 网上流行的----XP开发（极限开发）

 本章要点：
  软件测试概述
  软件测试分类
  几种单元测试方法------程序员
  组织软件测试-----测试人员
  软件测试文档----90%是测试人员写，但也有程序员写的

  
  软件测试的定义（1983，IEEE）：
  
  “使用人工或自动手段来进行或测定某个系统的过程，其目的在于检验它是否满足规定的需求或是否弄清预期结果与实际结果之间的差别。
    软件测试以检验是否满足需求为目标”

  软件开发流程：
    1、可行性分析
    2、需求分析------>开发、测试，（与客户沟通，了解系统需要），一般由项目经理（PM）完成
    3、概要设计------>分模块，定框架
    4、详细设计------>类设计，接口设计
    5、coding------->程序员
    6、测试
    7、部署
    8、维护

    一般把3，4合起来统称为设计，这部分可由项目经理、架构师或高级程序员来做

   软件质量保证和软件测试不同-----测试只是一种手段
 
  测试的目的：
   寻找缺陷----找Bug(臭虫)
   发现新的缺陷----换方法继续测
   任何系统都不能保证没有缺陷，Bug永远存在，我们所能克服的Bug是致命Bug（严重Bug）
   
   比如XP系统的RPC，冲击波和震荡波这两大病毒就是针对RPC的缺陷去攻击的。
  
  软件测试的原则：

   追溯根源
   计划在先------测试计划（文档）
   从小到大
   不能穷举

  正确认识软件测试：
   
   软件测试不是程序测试-------
   测试心态----开发（创建），测试（破坏）
   测试的分量----大公司测试==开发，国内的小公司测试=0

   规范（标准）针对整个行业，产品（比如XP），项目（比如一个聊天项目）

  软件缺陷的来源：
   编程错误------逻辑错误
   软件复杂度
   沟通
   不断变更的需求
   时间的压力
   人员风险意识
   缺乏文档
   软件开发工具

  总体分类：
   静态测试（检查作业）：
    代码审查
    代码分析
    文档检查
   动态测试（真正的测试）：
    结构测试（白盒） 
    功能测试（黑盒）
   
  工程分类：
   单元测试------程序员
   集成测试------程序员或测试人员
   系统测试------测试人员
   用户测试------用户
 
   几种单元测试方法：
    边界值分析-----if,for循环临界点
    语句覆盖------程序中的每一条语句都要运行到
    判定覆盖-----比如>=,=<等，
    条件覆盖
    判定-条件覆盖
    路径覆盖-------所有的分支都要运行到
  
  用TestCase测试一个类-----根类
  TestRunner  ------运行类
  TestSuite原理-----测试的一个套件

  JUnit是什么？
   开源的------ 模块
   单元测试框架------*.java类
   xUnit-----------HttpUnit---->网页
   JUnit 的特点-------简单，开源，已成为测试的标准
   www.JUnit.org-----老版本
 
  junit.awtui.*: 提供了以AWT方式运行的JUnit的支持;
  junit.textui;提供了以文本方式运行junit的支持
  下面四个包为常用包
真正支持| junit.extensions：提供了junit的一些扩展功能（例如对exception测试的支持）；
测试的包| junit.framework：junit的核心包，提供了对单元测试的核心支持；
  junit.runner：用于启动junit测试的包；
  junit.swingui：提供了以SWING方式运行junit的支持； 

  TestRunner是用来启动JUnit的，显示界面,选用swing版本
测试类中的所有方法都采用test开头(必须是test开头,并且返回void)
  TestCase：这是一个测试类，要写自己的测试类可以extends TestCase
   1、setUp()（初始化方法） 这是生命周期里最先调用的方法，
   2、然后执行每个以“test”开头的方法
   3、在执行完所有测试方法之后执行 tearDown() 方法，结束方法
  TestSuite套嵌类:

  addTestSuite方法--------加测试类，组成一个套件
  addTest(Test)方法
  run(TestResult)方法

Junit提供了如下几种主要的断言方法:
assertEquals  比较两件食物是否相等(基本类型或对象类型)(equals)
assertTrue  对布尔值求值,看它是否为True
assertFalse 对布尔值求值,看它是否为False
assertNull 检查对象是否为null
assertNotNull 检查对象是否不为null
assertSame 检查两个对象是否为同一实例(==)
assertNotSame 检查两个对象是否不为同一实例

 写单元测试的步骤：
  1、针对要测试的每一个类写一个测试用例（TestCase），在setUp方法中初始化要测试的类（new 要测试类的对象）。
           在tearDown方法中把要测试的类的对象置为null。

  2、逐一编写以"test"开头的方法（复杂过程）
  3、新建套件类，再把所有的测试用例（TestCase）加入套件类。（eclipse加或手工加）

 Ant对项目的整合
 JUnit用来测试
 

Ant的使用
主要用于对项目的整体构建\修改\部署等操作
完全自定义的make和build方式
主流的开发工具,如JBuilder\eclipse其实都是使用的ant

在eclipse目录下的plugins文件夹里可以找到Ant

ANT_HOME=
PATH=%ANT_HOME%\bin;
ClassPath=%ANT_HOME%\lib;

写build.xml文件
<?xml version = "1.0" encoding="GB2312" ?>
<!--一个项目，可包含很多任务组(target)-->
<project default="main" basedir=".">
 <!--属性部分，可以写类似的全局变量-->
 <property name="src" value="src\test" />

 <!--项目中的一个任务组，可包含很多任务(task:javac,java....)-->
 <target name="main" description="beginbuild">
  <mkdir dir="classes" />
  <!--编译-->
  <javac srcdir="${src};src" destdir=".\classes" />
  <!--运行-->
  <java classname="test.Test">
   <classpath>
    <pathelement path=".\classes" />
   </classpath>
  </java>
 </target>
 <!--清除所有的class-->
 <target name="clean" description="begin clean">
  <delete dir="classes" />
 </target>
 <!--重新建立项目-->
 <target name="all" depends="clean,main" description="begin all">
 </target>
</project>

liunx下弄build.xml,尝试
 1.testant目录下的东西copy导ant/bin,要求ant和build.xml在同一目录下
 2.进入到ant对应目录,可以看导build.xml.
 3.chmod 777 ant
 4.ant
 5.替换下自己写的build.xml
 6.ant

2.写build.xml,ant解析
3.ant配置环境变量
4.运行

如何制作可运行文件
 1、先建起一个空文件夹
 2、把所有的源文件拷贝到空文件夹
 3、javac -d . *    编译此文件夹下源文件(先进入文件夹)
 4、删除源文件（rm）
 5、jar -cvf test.jar * 完成第一次打包
 6、jar -xvf test.jar   解压
 7、删除test.jar
 8、改META_INF中的文件，加上Main-Class: MenuFrame （注意中间有空格），保存
 9、jar -cvfM test.jar * 
 10、java -jar test.jar 可以运行
 
 
 testant/src
 选属性，作改名----右键refactor--->Rename
 选属性，作封装
 把new ActionListener提取成了private

  
重构--是指在不改变软件任何功能的前提下对代码进行修改,调整其结构,提高其可理解性,降低其修改的成本.
重构的基本思想就是集中精力使设计简化,并且在新的需求出现时提供一个持续发展(而非扩展)的环境.
重构是一项功能强大的技术,但需以微小的步伐修改程序才行.因为在重构时可能在你不经意之间引入了一些错误,尤其是我们在手工进行时更是如此.

重构的优点
1.可以改进软件的设计.
2.可以使你的代码看起来更易理解.
3.可以找出潜伏的臭虫.
4.可以帮助你提高变成的速度---在一次次的迭代过程中阻止系统腐败变质,减少在调试中所花的时间.
5.这个工具有太多太多的好处,它可以使我们更快速的开发软件,甚至还可以提高我们的设计质量.

利用eclipse重构代码(Refactor)
1.Encapsulate field(封装属性)--在类中存在一个public值域.将它声明为private,并提供相应的访问函数.
2.Pull Up Method(方法上移）－－有些方法，在各个subClass中产生完全相同的结果.将该方法移至superClass.
3.Extract InterFace(提炼接口)--若个客户使用class接口中的同一子集.或者两个classes的接口有部分相同.将相同的子集提炼导一个独立的接口中.

jiandanaiboy

没基础估计看了没感觉，继续帮顶

ahstu11

好东西，继续！