Lambda表達式

Lambda表達式:
Lambda表達式是Java8以後的新特性
Lambda表達式是函數式編程
Java-->面嚮對象語言 block代碼塊(閉包) 函數式編程(接近於面向過程) --> 面向對象
什麼是函數式編程？函數式編程（英語：functional programming）或稱函數程序設計，
又稱泛函編程，是一種編程範型，它將電腦運算視爲數學上的函數(cos sin tan)計算，
而且避免使用程序狀態以及易變對象。函數編程語言最重要的基礎是λ演算（lambda calculus）。
並且λ演算的函數能夠接受函數看成輸入（引數）和輸出（傳出值）。
ps:λ這個符號能夠在搜狗輸入法的符號中顯示

而在面向對象編程中，面向對象程序設計（英語：Object-oriented programming，縮寫：OOP）
是種具備對象概念的程序編程範型，同時也是一種程序開發的方法。它可能包含數據、屬性、代碼與方法。
對象則指的是類的實例。它將對象做爲程序的基本單元，將程序和數據封裝其中，以提升軟件的重用性、
靈活性和擴展性，對象裏的程序能夠訪問及常常修改對象相關連的數據。在面向對象程序編程裏，
計算機程序會被設計成彼此相關的對象。

Lambda表達式能幹什麼
將接口的實現方式重匿名內部類的形式簡化爲了一個函數式表達式方式
簡化接口實現

語法:
(形參參數) -> 表達式 或{方法體};
ps:
Lambds表達式就是實現了當前接口中的方法及簡
void show();
() -> {System.out.println("我是Lambda表達式")};

1.形參列表
形參列表容許省略參數類型,若形參列表中只有一個參數,形參列表的原括號也能夠省略
ps:形參列表 對應的是 接口中所須要實現方法的 形參列表
void show(int a, int b);
void display(int c);
(int a,int b) -> {實現};
(int a) -> {實現};
a -> {實現};

2.箭頭(->)
必須是英文狀態下的符號 減號(-) + 大於號(>) 指向實現代碼塊


3.代碼塊:
若代碼塊只包含一條語句,Lambda表達式容許容許省略花括號
若Lambda表達式中只有一條return,能夠省略return關鍵字
若Lambda表達式中有多條語句(實現方法的邏輯)不能省略大括號

ps:Java中Lambda表達式的結合須要和接口完成
Stream API --> 流式編程
看Lambda包Test類

/**
 * 
 */
package com.qfedu.Day25.Lambda;

import java.util.ArrayList;

/**
 * Description： 實現Lambda表達式語法<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:Test.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class Test {
     public static void main(String[] args) {
         //void show();
        InteFaceB b = () ->{
            System.out.println("B接口中方法的實現");
        };
        b.showB();
        //簡化版本
        InteFaceB b1 = () -> System.out.println("B中接口的實現");
        b1.showB();
        //void show(int a);
        InteFaceC c = (int a) ->{
            System.out.println("接口C中的方法:"+a);
        };
        c.showC(10);
        //簡化版本 Lambda表達式會推斷接口提供方法的數據類型
        InteFaceC c1 = (a) -> System.out.println("接口C中的方法:"+a);
        c1.showC(1);
        //ArrayList<Integer> array = new  ArrayList<>();
        InteFaceC c2 = a -> System.out.println("接口C中方法"+a);
        c2.showC(2);
        //void show(int a,int b)
        InteFaceD d = (int a, int bi) -> {
            System.out.println("接口D中的方法實現"+(a+bi));
        };
        //簡化版本
        InteFaceD d1 = (a,bi) ->{
            System.out.println("接口D中的方法實現"+(a+bi));
        };
        //多參數的()堅定不能省略
        InteFaceD d2 = (a,bi) -> System.out.println("接口D中的方法實現"+(a+bi));
        
        //InteFaceD d3 = (a,bi) -> a+bi; 常常看到
        
    }

}

 

Lambda表達式還能做爲參數傳遞
看Lambda包TestDemo類

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： Lambds表達式做爲參數傳遞<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo {
    public static void showInfosInteFaceB(InteFaceB b) {
        System.out.println("B接口");
        b.showB();
    }
    public static void showInfosInteFaceC(String message,InteFaceC c) {
        System.out.println("C接口"+message);
        c.showC(100);
    }
    public static void showInfosInteFaceD(int a,int b,InteFaceD d) {
        System.out.println("D接口");
        d.showD(a,b);
    }
    public static void main(String[] args) {
        //函數也是一種數據類型 --> 引用數據類型
        //經過一個變量來存當前函數的引用 
        //基本實現
//        showInfosInteFaceB(()->System.out.println("能夠做爲參數傳遞"));
//        showInfosInteFaceC(c -> System.out.println("能夠做爲參數"));
//        showInfosInteFaceD((a,b) -> System.out.println("能夠做爲參數"));
        
        showInfosInteFaceC("接口C的實現方式", c-> System.out.println("實現"));
        showInfosInteFaceD(300,200,(a,b)->System.out.println("實現+"+(a+b)));
    
        
    }

}

 

 

ps:Java8中若這個接口須要使Lambda表達式實現此時咱們須要在這個接口上提供一個註解
@FunctionalInteFace

Lambda表達式引用全局變量和局部變量
看Lambda包TestDemo2類

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： Lambds表達式引用全局變量和局部變量<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo2.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo2 {
     static String ms1 = "Hello";
     String ms2 = "World";
     public static void main(String[] args) {
          VariableTest v = message -> {
              //引用全局變量 在Lambda中能夠直接引用靜態全局變量
              System.out.println(message + ms1);
              //若引用成員變量須要使用對象調用
              System.out.println(message + new TestDemo2().ms2);
              
          };
          v.sayMessage("Lambda表達式:");
          final String ms3 = "Hello World";
           VariableTest  v1  = message ->{
               //能夠在Lambda表達式中直接調用局部變量
               //局部內部類-->引用局部變量時候,這個局部變量須要是final修改
               //匿名內部類是一個特殊的局部內部類
               //Lambda表達式是代替匿名內部類使用以上推斷得出
               //在Lambda表達式中使用局部變量最好使用final修飾
               //雖然Java7以後能夠不寫final只要引用默認修飾,可是仍是建議書寫
              System.out.println(message + ms3);
           };
           
         
         
         
    }
}

 

Lambda式表達式引用構造方法和方法引用

1.引用類方法
在函數式接口中定義的抽象方法,而方法的實現是觸發某個類方法實現此時咱們就能夠經過 :: 形式完成
看Lambda包TestDemo3

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： Lambda表達式引用類方法<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo3.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo3 {
    public static void main(String[] args) {
        //在Lambda表達式中引用靜態方法
        //Lambda表達式中只有一個 return 能夠省略不寫
//        Converter c = (String str) ->{
//            
//            return Integer.valueOf(str);
//        };
        Converter c = str -> Integer.valueOf(str);
        Integer i = c.convert("69");
        System.out.println(i);
        
        //若Lambda不是的調用的是類方法而且參數能夠進行方法傳遞
        // :: --> 須要有返回值 ,方法中有參數並能夠應用到調用該方法,這個方法必須是靜態方法
        Converter c2 = Integer::valueOf;
        Integer i2 = c.convert("72");
        System.out.println(i2);
        

    }

}

 

2.引用實例方法(成員方法)
在函數式接口中定義的抽象方法,而方法的實現是經過觸發某類類建立的來完成時咱們就能夠 經過 :: 形式完成
看Lambda包TestDemo4;

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： Lambda表達式引用成員方法<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo4.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo4 {

    public static void main(String[] args) {
        //在Lambda表達式中引用成員方法
        ClassATest ca = message -> new A().show(message);
        ca.display("45");
        
        //:: --> 沒有返回值, 接口中方法對參數也須要做用於調用方法中 ,當前對象
        ClassATest ca2 = new A()::show;
        ca2.display("17");
        
    }

}

 

版本二:
在函數式接口中定義的抽象方法,而方法上的實現是經過抽象方法中特定的對象參數來完成咱們能夠經過 :: 形式完成
不過 :: 以前是當前對象的數據了類型,而非 new出一個對象
看Lambda包TestDemo5;

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： 版本二引用成員方法<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo5.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo5 {

    public static void main(String[] args) {
        SubString str1 = (str,begin,end) -> str.substring(begin, end);
        String  val  = str1.sub("I LOVE U", 2, 6);
        System.out.println(val);
        //如何將當前上面Lambda轉換爲 :: 
        //由於當前接口中給的你方法使用的是參數做爲對象調用方法
        //此時修改爲 ::形式的時候就不能從新建立對象了,須要使用其對應的數據類型便可
        SubString str2 = String::substring;
        System.out.println(str2.sub("I LOVE U", 2, 6));
        
    }

}

 

3.引用構造方法
在函數式接口中定義的抽閒方法,而該方法的實現是統統過new 來建立對象,此時咱們就可使用 :: 形式來完成
ps:固定形式 構建對象的類型 :: new;
看Lambda包TestDemo6;

/**
 * 
 */
package com.qfedu.Day25.Lambda;

/**
 * Description： Lambda表達式引用構造方法<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo6.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo6 {
     public static void main(String[] args) {
        ClassBTest cb = (name,age) -> new B(name,age);
        B b1 = cb.getInstance("張三", 18);
        System.out.println(b1);
        
        //比較特殊的使用方式 引用的構造方法
        ClassBTest cb1 = B::new;
        B b2 = cb1.getInstance("李四", 20);
        System.out.println(b2);
        
    }
}

 

總結:
在上面兩個案例中使用到了一個全新的形式 類或(對象) :: 靜態方法/成員方法
若在Lambda表達式中引用了靜態方法或成員方法時 只有一句話 ,可使用 :: 形式進行簡化
:: 以前 是這個方法主要的調用發起者 類/對象
:: 以後 靜態方法/成員方法
ps:必定要主要 方法後面千萬不要傳入參數
調用方法的參數,會經過接口中方法的參數進行傳遞

Lambda表達式和匿名內部類的區別
1.匿名內部類能夠爲任意接口建立對象,無論接口中包含多少個抽象方法,只要匿名內部類實現全部方法便可
可是Lambda表達式只能爲函數式接口建立對象(只能實現一個抽象方法)
2.匿名內部類能夠爲抽象類甚至是普通類建立對象
可是Lambda表達式只能爲函數接口建立對象
3.匿名內內部類實現的抽象方法方法體容許調用接口定義默認(default)方法
可是Lambda表達式的實現是不容許調用默認方法的

Lambds的實際引用
看Lambda包TestDemo7;

/**
 * 
 */
package com.qfedu.Day25.Lambda;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 * Description： Lambda表達式的實際應用<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:TestDemo7.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class TestDemo7 {
      public static void main(String[] args) {
        String[] name = {"張三","李四","王五"};
        List<String> players  = Arrays.asList(name);
        //遍歷集合
        for(String str : players) {
            System.out.println(str);
        }
        //就能夠這樣寫 流式編程方法
        players.forEach((player) -> System.out.println(player+";"));
        //最簡版本
        players.forEach(System.out::println);
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                System.out.println("Hello Lambda");
                
            }
        }).start();
        
        new  Thread(()->System.out.println("Hello Lambda")).start();;
        
        Runnable ru = () -> System.out.println("Hello Lambda");
        new Thread(ru).start();
        
       
        //數組排序
        Arrays.sort(name, new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
            
                return o1.compareTo(o2);
            }
        });
        
        //Lambda表達式
        Comparator<String> sortByName  =  (String str1, String str2) ->{
              return str1.compareTo(str2);
            
        };
        Arrays.sort(name, sortByName);
        
        Arrays.sort(name, (str1,str2)->str1.compareTo(str2));
    
    }

}

 

ps:
1.須要記住形式爲了Scala作準備
2.Lambda能夠替換匿名內部類一次實現的方式
Lambda只能實現接口中一個抽方法.

註解:
Java5開始 Java支持對元數據的支持, 就是是Annotation(註解)
元數據: metadata描述數據的數據
註解:標籤 Annotation
全部的Annotation都是java.Lang.annotation.Annotation接口的子接口
全部Annotation是一種特殊的接口

回顧註解:
@Override -->重寫
@Deprecated --> 過期的
@SuppressWarings --> 壓制警告
既能夠放在方法上,放在變量上,放在類或接口上
使用註解須要注意:必須有三個參與纔有意義
1.有註解的自己
2.被放置的位置(類,屬性,方法,接口,參數上,包等等)
3.由第三方程序使用反射的手段賦予註解特殊的功能

Java5以前自帶註解
Java5中提供的

@Override --> 限定子類重寫父類的方法,只能在方法上
@Deprecated --> 標記當前方法已通過時,不推薦使用 只能用在方法上
@SuppressWarings --> 抑制編譯器發出多種警告
@SuppressWarings(value="all") 能夠應用在方法,類,屬性上
Java7中提供了一個
@SafeVarargs 抑制堆污染
當方法使用可變參數和泛型參數,此時就會形成堆污染 Arrays.asList
Java8中提供一個
@FunctionalInteFace 函數式編程 -->所用在接口上

元註解:
描述註解的註解,用來限定註解能夠貼在哪些程序元素上,還能夠指定註解存在的週期
@Retention: 表示註解能夠保存在哪個代碼時期. 保存的時期的值,封裝在RetentionPolicy枚舉類中:
注意:通常的,自定義的註解,使用RUNTIME.(使用反射賦予註解功能)
SOUECE:註解只能存在於源文件中,一旦編譯,在字節碼中就消失了.
CLASS:(缺省),註解能夠存在於源文件和字節碼文件中,一旦加載進JVM,在JVM中就消失了.
RUNTIME:註解能夠存在於源文件,字節碼文件,JVM中.

@Target:表示註解能夠貼在哪些位置(類,方法上,構造器上等等).
位置的常量封裝在ElementType枚舉類中:
ElementType.ANNOTATION_TYPE只能修飾Annotation
ElementType.CONSTRUCTOR只能修飾構造方法
ElementType.FIELD只能修飾字段(屬性),包括枚舉常量
ElementType.LOCAL_VARIABLE只能修飾局部變量
ElementType.METHOD只能修飾方法
ElementType.PACKAGE只能修飾包(極少使用)
ElementType.PARAMETER只能修飾參數
ElementType.TYPE只能修飾類，接口，枚舉

實現本身的註解:
語法格式:
@interface

@Retention(設置註解存儲在的時間)
@Target(設置能夠書寫註解的位置)
public @interface 註解名{
註解中的成員:
抽象方法 --> (屬性)
數據類型 方法名() default 默認值;

}

/**
 * 
 */
package com.qfedu.Day25.Annotation;

/**
 * Description： 描述類<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:Student.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
//若自定註解在註解中聲明抽象方法(屬性),使用註解時就須要給當前註解中的抽象方法(屬性)賦值
//若註解中使用了默認值,能夠修改也能夠不修改
@VIP(Value="A",age=19,favs = {"你好","呵呵"})
public class Student {
    private String name;
    private int age;
    
}

/**
 * 
 */
package com.qfedu.Day25.Annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Description： 註解 <br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:VIP.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
@Retention(RetentionPolicy.RUNTIME)  //註解的聲明週期就是源文件 ,編譯文件和 JVM中
@Target(ElementType.TYPE) //註解能夠書寫的位置 類,方法和接口
public @interface VIP {
    // 抽象方法 --> 屬性看
    //能夠在註解中聲明的數據類型:基本數據類型, String Class 數組,枚舉,Annotation
    //聲明的同時就賦值,此時在外部寫書註解時就不須要賦值
    String  Value();
    int age() default 19;
    String[] favs();

}
/**
 * 
 */
package com.qfedu.Day25.Annotation;

import java.lang.annotation.Annotation;
import java.util.Arrays;

/**
 * Description： 如何取出註解中的值<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:VIPDemo.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class VIPDemo {

    public static void main(String[] args) {
        //1.獲取Student上的全部註解(反射)
        Annotation[] as  =   Student.class.getAnnotations();
        for(int i = 0;i<as.length;i++) {
            System.out.println(as[i]);
        }
        //2.獲取Student真正的註解
        //判斷當前類是否存在指定註解
        if(Student.class.isAnnotationPresent(VIP.class)) {
             //獲取註解對象
            VIP vip =  Student.class.getAnnotation(VIP.class);
            String str = vip.Value();
            String[] strs  = vip.favs();
            System.out.println(str);
            System.out.println(Arrays.toString(strs));
            
            
            
        }

    }

}

 

ps:Spring框架中--> 註解最多 --> 動態代理模式 --> 內省模式JavaBean和Map互轉

什麼是測試:
軟件測試: 這是軟件生命週期中的一部分.--->好的軟件都不是開放出來的,都是測試出來的.黑盒測試： 軟件測試工程師.
黑盒測試也稱功能測試，它是經過測試來檢測每一個功能是否都能正常使用。
在測試中，把程序看做一個不能打開的黑盒子，在徹底不考慮程序內部結構和內部特性的狀況下，在程序接口進行測試，它只檢查程序功能是否按照需求規格說明書的規定正常使用，程序是否能適當地接收輸入數據而產生正確的輸出信息。
黑盒測試着眼於程序外部結構，不考慮內部邏輯結構，主要針對軟件界面和軟件功能進行測試。
黑盒測試是以用戶的角度，從輸入數據與輸出數據的對應關係出發進行測試的。
很明顯，若是外部特性自己設計有問題或規格說明的規定有誤，用黑盒測試方法是發現不了的。

做用：
黑盒測試法注重於測試軟件的功能需求，主要試圖發現下列幾類錯誤。
功能不正確或遺漏；
界面錯誤；
輸入和輸出錯誤；
數據庫訪問錯誤；
性能錯誤；
初始化和終止錯誤等。

白盒測試：由軟件開放工程師來測試,只有本身開放的東西本身才知道是怎麼運做的..
又稱結構測試、透明盒測試、邏輯驅動測試或基於代碼的測試。
它是按照程序內部的結構測試程序，經過測試來檢測產品內部動做是否按照設計規格說明書的規定正常進行，
檢驗程序中的每條通路是否都能按預約要求正確工做。 這一方法是把測試對象看做一個打開的盒子，測試人員依據程序內部邏輯結構相關信息，設計或選擇測試用例，對程序全部邏輯路徑進行測試，經過在不一樣點檢查程序的狀態，肯定實際的狀態是否與預期的狀態一致。

白盒測試是一種測試用設計方法，盒子指的是被測試的軟件，白盒指的是盒子是可視的,你清楚盒子內部的東西以及裏面是如何運做的。
"白盒"法全面瞭解程序內部邏輯結構、對全部邏輯路徑進行測試。測試者必須檢查程序的內部結構，從檢查程序的邏輯着手，得出測試數據。

單元測試(junit)屬於白盒測試.
ps:不管哪一種測試,都須要給當前工程添加Junit-->jar

Junit3
Junit3是針對Java5以前的版本,沒有註解,須要按照規範的形式來書寫測試
遵照以下規則:
1.須要先將JUnit3添加到當前項目中
2.定義一個測試類,並讓該測試類繼承於TestCase類,測試的類型XXXTest
看Junit包Junit3Test

/**
 * 
 */
package com.qfedu.Day25.Junit;

import junit.framework.TestCase;

/**
 * Description： 建立測試類<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:Junit3Test.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
//Junit使用的測試類必須繼承TestCase
public class Junit3Test  extends TestCase{
     //定義測試方法
      /*
       *  訪問權限修飾符必須是public
       *  無返回值
       *  必須以test做爲方法名的前綴  testXXX 
       *  由於底層是用過反射來獲取當前方法的
       *  全部異常都不要處理,一概拋出
       *  
       *  若須要執行測試類中的測試代碼
       *  選中方法名 單機鼠標右鍵 選中 run as --> JUnit Test
       *  
       *  在某些時候在測試完成以後
       *  還對資源進行回收
       *  重寫TestCase:
       *  setUp() -->測試方法以前執行
       *  tearDown() --> 測試方法以後以後
       */
        /* (non-Javadoc)
         * @see junit.framework.TestCase#setUp()
         */
        @Override
        protected void setUp() throws Exception {
             System.out.println("是在測試方法以前先執行");
        }
       
        /* (non-Javadoc)
         * @see junit.framework.TestCase#tearDown()
         */
        @Override
        protected void tearDown() throws Exception {
             System.out.println("是在測試方法執行以後執行");
        }
    
    
       //保存
       public void testSave()throws Exception{
           System.out.println("測試代碼的操做了存儲");
       }
       //刪除
       public void testDelete()throws Exception{
           System.out.println("測試代碼的操做了刪除");
       }
    
    
}

 

Junit4
Junit4是針對Java5以後的版本,使用的是註解,推薦
步驟
1.將Junit4添加到工程中
2.定義一個測試類,不在繼承TestCase類,類名必須是XXXTest
3.全部的測試方法使用的註解
看Junit包Junit4Test

/**
 * 
 */
package com.qfedu.Day25.Junit;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

/**
 * Description： Junit4測試類<br/>
 * Copyright (c) , 2018, JK <br/>
 * This program is protected by copyright laws. <br/>
 * Program Name:Junit4Test.java <br/>
 * 
 * @author 千鋒智哥
 * @version : 1.0
 */
public class Junit4Test {
     /*
      * Junit3中方法名必須是 testXXX
      * Junit4中不須要遵照這個規則,可是實際開發中保留這個書寫形式的
      * 公有  無返回值  方法名保持和Junit3一致 testXXX  異常一概拋出
      * ps:由於爲了防止衝突刪除了Junit3這個測試jar包
      *    
      * 釋放資源 -->Junit3中 setUp tearDownJunit4徹底不須要
      * 使用   @Before @After釋放資源
      * before --> 測試代碼  ---> After
      * 若測代碼使用BeforeClass 和 AfterClass 只會執行一次
      * BeforeClass --> before --> 測試方法  --> After --> AfterClass
      *  
      * 
      * 
      */
      //若這是一個測試方法只需在方法的上面添加註解便可
       //這兩註解必須使用靜態方法 只會執行一次 
       @BeforeClass
       public static void staticInit()throws Exception{
           System.out.println("Begin...");
       }
       @AfterClass
       public static void staticFinallzes()throws Exception{
           System.out.println("end...");
       }
       
      @Before
      public void init()throws Exception{
             System.out.println("初始化.....");
      }
      @After
      public void finallzes()throws Exception{
            System.out.println("銷燬....");
      }
    
    
      @Test
      public  void  testSave() throws Exception{
          System.out.println("Junit4下的測試方法");
      }
      @Test
      public  void  testDelete() throws Exception{
          System.out.println("Junit4下的測試方法");
      }
     
    
}

 

使用斷言:
通常而言,使用斷言是用來作單元測試使用
什麼是斷言呢:指望的結果和真實結果是同樣的
指望值: 執行某個方法能夠獲得什麼效果
實際值: 執行某個方法的到的實際效果
斷言成功: 實際值和指望值相同 ,顯示綠色
斷言失敗: 實際值和指望值不一樣 ,顯示紅色

①:Assert.assertEquals(message, expected, actual):比較的值,比較兩個對象值存儲的數據.
三個參數:
message: 斷言失敗的提示信息,斷言成功不會顯示.
expected: 指望值
actual: 真實值
若真實值和指望值想等,則斷言成功.--->綠條
②:Assert.assertSame(message, expected, actual):比較地址,是同一個對象
Assert.assertNotSame(message, expected, actual):斷言不是同一個對象
③:Assert.assertTrue(message, condition):斷言condition應該爲TRUE.
④:Assert.assertFalse(message, condition):斷言condition應該爲FALSE.
⑤:Assert.assertNull(message, object):斷言對象object爲null.
⑥:Assert.assertNotNull(message, object):斷言對象object不爲null.

⑦:@Test(expected=ArithmeticException.class)
指望該方法報錯,報錯ArithmeticException.
⑧:@Test(timeout=400)
指望該方法在400毫秒以內執行完成.

XML
學習到目前爲止咱們所知道的資源文件只有一個Properties文件 鍵值對 而且繼承於Hashtable
XML是一種可擴展標記語言和HTML相似
XML技術是W3C組織(WWW --> World Wide WEb)發佈的目前通用的標準是2000年XML1.0規範
XML便可以做爲一種配置文件存在,也能夠做爲數據傳輸文件

XML是一種通用的數據交換格式,許多系統都配備了XML格式文件
JSP文件檔組件XML格式過分
能夠知道什麼是XML,如何書寫正確的XML --> w3cschool ---> HTML CSS XML 菜鳥教程http://www.runoob.com/
看Info.xml
XML文件的語法:
XML文件的編碼須要正式一致,通常都是UTF-8
一個XML文件必須有一對根節點,節點名須要區分大小寫 節點中是不容許嵌套節點
<?xml version="1.0" encoding="UTF-8"?>
必須出如今文件的第一行而並且必須寫,用來表示文件是XML文件
節點中能夠書寫子節點
標籤<Students>中是能夠添加屬性

XML約束(瞭解)
能夠對XML文件進行約束操做
dtd文件 schema 文件 --> xsd後綴名
XML中節點的建立

dtd約束文件:
<!ELEMENT contacts (linkman+)> contacts中必須有一個Linkeman節點 至少要有1個
+ 和 正則表達式是通用 ? 0或1 * 最少0個以上 :是一個1
<!ELEMENT linkman (name,email,address,group)> 在LinkeMan下須要出現以節點只能出現1個
<!ELEMENT name (#PCDATA)> p -> parse(解析) c-->Character(字符) --->解析字符串數據 只能傳入字符串
<!ELEMENT email (#PCDATA)>
<!ELEMENT address (#PCDATA)>
<!ELEMENT group (#PCDATA)>
看content2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 最後一個位置是路徑 由於文件已經在當前工程下了因此直接使用 -->
<!DOCTYPE contacts SYSTEM "constactsDtd.dtd">
<contacts>
   <!-- 節點中是能夠書寫屬性 -->
    <linkman>
        <name>Jack</name>
        <email>ijack@sina.cn</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman> 
    <linkman>
        <name>Sparrow</name>
        <email>sparrow@qq.com</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman>
    <linkman>
        <name>Lily</name>
        <email>lily@163.com</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman>
</contacts>

 

schema 文件 --> xsd後綴名
看content.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<!--xmlns 約束來源
    xmlns:xs 約束的依據
    xs:schemaLocation 約束的位置 -->
<contacts xmlns="http://qfedu.com"  
    xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
    xs:schemaLocation="http://qfedu.com contactsSchema.xsd">
    <linkman id="1" >
        <name>Jack</name>
        <email>ijack@sina.cn</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman> 
    <linkman id="2">
        <name>Sparrow</name>
        <email>sparrow@qq.com</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman>
    <linkman id="3">
        <name>Lily</name>
        <email>lily@163.com</email>
        <address>北京</address>
        <group>千鋒教育</group>
    </linkman>
</contacts>

 

 

Web概述:
原始年代1990-1992:
1990年，HTML標記語言的出現標誌Web開發時代的到來.
B/S架構開始在以後的歲月中不斷的發展壯大，攻城略地蠶食傳統C/S的領域。
如同全部的新生事物同樣，在web的史前歲月，web的開發 技術在在html標記誕生後，
不管是在服務端還客戶端都緩慢的發展着，在至關長的一個時間內，它並未像今天這樣輝煌，
甚至於只是靜態的文本標識.
關鍵字：HTML
技術特性：靜態文本顯示，表現力和交互能力不足。(hao123)
封建諸侯年代1993-1996:
1993年，NCSA提出了CGI1.0草案。Web開發終於迎來了它的第二次重大飛躍，伴隨着CGI，
帶來Web的動態處理能力，CGI就是這個時代的國王。(服務器端動態生成內容)
1994年，PHP
1996年，ASP
關鍵字：CGI(Common Gateway Interface )(Perl&&C&&Python)
技術特性：實現了客戶端和服務器端的動態交互， 在程序代碼中寫html標記，
是面向過程的開發方式，用多進程運行
注：CGI是Web服務器端組件，都能產生Web動態頁面輸出
工業文明1996-1999:
1997年，Sun公司推出了Servlet規範。Java陣營終於迎來了本身的web英雄。
1998年JSP技術誕生，Servlet和JSP再加上JavaBean，
讓JavaWeb開發者同時擁有了相似CGI程序的集中處理功能和相似於PHP 的HTML嵌入功能，
此外，Java的運行編譯技術也大提升了Servlet和JSP的執行效率
1998年，Sun發佈了EJB1.0標準
1999年，Sun正式發佈了J2EE的第一個版本，緊接着，遵循J2EE，
爲企業級應用提供支持平臺的各種應用服務器爭先恐後的涌現出來（WebSphere，WebLogic，JBoss），
（同時2001微軟發佈了ASP.NET技術）

 

 

 

查看HTTP數據規範格式:
請求消息的結構：
一個請求行、若干請求頭、以及實體內容，其中的一些請求頭和實體內容都是可選的，請求頭和實體內容之間要用空行隔開。
Request:
常見的請求頭:
<1>、Accept：瀏覽器可接受的MIME類型（Tomcat安裝目錄/conf/web.xml中查找）
MIME的英文全稱是"Multipurpose Internet Mail Extensions" 多用途互聯網郵件擴展，它是一個互聯網標準，在1992年最先應用於電子郵件系統，但後來也應用到瀏覽器。服務器會將它們發送的多媒體數據的類型告訴瀏覽器， 文件內容的類型:
MIME類型就是設定某種擴展名的文件用一種應用程序來打開的方式類型

<2>、Accept-Charset：告知服務器，客戶端支持哪一種字符集
<3>、Accept-Encoding：瀏覽器可以進行解碼的數據編碼方式
<4>、Accept-Language：瀏覽器支持的語言。
<5>、Referer：當前頁面由哪一個頁面訪問過來的。
<6>、Content-Type：通知服務器，請求正文的MIME類型。
取值：application/x-www-form-urlencoded默認值
對應的是form表單的enctype屬性
<7>、Content-Length：請求正文的長度
<8>、If-Modified-Since:通知服務器，緩存的文件的最後修改時間。
<9>、User-Agent:通知服務器，瀏覽器類型.
<10>、Connection:表示是否須要持久鏈接。若是服務器看到這裏的值爲「Keep -Alive」，或者看到請求使用的是HTTP 1.1（HTTP 1.1默認進行持久鏈接
<11>、Cookie:這是最重要的請求頭信息之一（會話有關）

響應消息的結構：
一個狀態行、若干響應頭、以及實體內容 ，其中的一些消息頭和實體內容都是可選的，響應頭和實體內容之間要用空行隔開。
Response:
常見的響應頭:
<1>、Location：制定轉發的地址。需與302/307響應碼一同使用
<2>、Server：告知客戶端服務器使用的容器類型
<3>、Content-Encoding：告知客戶端服務器發送的數據所採用的壓縮格式
<4>、Content-Length：告知客戶端正文的長度
<5>、Content-Type：告知客戶端正文的MIME類型
Conent-Type:text/html;charset=UTF-8
<6>、Refresh：按期刷新。還能夠刷新到其餘資源
Refresh:3;URL=otherurl
3秒後刷新到otherurl這個頁面
<7>、Content-Disposition：指示客戶端如下載的方式保存文件。
Content-Disposition：attachment;filename=2.jpg
<8>、Expires：網頁的有效時間。單位是毫秒(等於-1時表示頁面當即過時)
Cache-Control：no-cache
Pragma：no-cache
控制客戶端不要緩存
<9>、Set-Cookie:SS=Q0=5Lb_nQ; path=/search服務器端發送的Cookie（會話有關)

 

 

Get和Post
總結:
1.本質
Get是向服務器發索取數據的一種請求，而Post是向服務器提交數據的一種請求

2.服務器端獲取值的方法
get方式提交的數據，服務器端使用request.QueryString獲取變量的值
post方式提交的數據，服務器端使用request.Form獲取數據

3.安全性
get方式安全性低，post方式較安全。可是post方式執行效率要比get方式差一些。

4.機制
get是把參數數據隊列加到提交表單的action屬性所指的URL中，
如：http://www.xxx.com?sessonid=db23434&name=hongten&age=20。
在URl中，值和表單南日各個字段一一對應，而且這些在URl中對用戶來講是可見的，
即用戶時能夠看到的。如：name=hongten。
post是經過HTTP post機制，
將表單內各個字段與其內容放置在HTML HEADER內一塊兒傳送到action屬性所指的URL地址，
對於用戶來講，這是透明的。

5.大小
URL不存在參數上限的問題，HTTP協議規範沒有對URL長度進行限制。這個限制是特定的瀏覽器及服務器對它的限制。IE對URL長度的限制是2083字節(2K+35)。對於其餘瀏覽器，如Netscape、FireFox等，理論上沒有長度限制，其限制取決於操做系統的支持。
理論上講，POST是沒有大小限制的，HTTP協議規範也沒有進行大小限制，說「POST數據量存在80K/100K的大小限制」是不許確的，POST數據是沒有限制的，起限制做用的是服務器的處理程序的處理能力。

get方式的安全性較post方式要差一些，因此，包含一些重要的信息的話，簡易使用post數據提交方式
在作查詢統計的時候，使用get方式要更好一些；而在作數據的添加，修改或刪除操做時，建議使用post數據提交方式

 

 

後記:
Java web中用到的技術
HTML:
超文本標記語言，標準通用標記語言下的一個應用。
「超文本」就是指頁面內能夠包含圖片、連接，甚至音樂、程序等非文字元素。
超文本標記語言的結構包括「頭」部分（英語：Head）、和「主體」部分（英語：Body），
其中「頭」部提供關於網頁的信息，「主體」部分提供網頁的具體內容。
ps:靜態網頁 的組成

CSS:
層疊樣式表(英文全稱：Cascading Style Sheets)是一種用來表現HTML（標準通用標記語言的一個應用）
或XML（標準通用標記語言的一個子集）等文件樣式的計算機語言。CSS不只能夠靜態地修飾網頁，
還能夠配合各類腳本語言動態地對網頁各元素進行格式化。 
CSS 可以對網頁中元素位置的排版進行像素級精確控制，支持幾乎全部的字體字號樣式，擁有對網頁對象和模型樣式編輯的能力。
ps:對靜態或動態網頁裝飾用的

JavaScript
JavaScript一種直譯式腳本語言，是一種動態類型、弱類型、基於原型的語言，內置支持類型。
它的解釋器被稱爲JavaScript引擎，爲瀏覽器的一部分，普遍用於客戶端的腳本語言，
最先是在HTML（標準通用標記語言下的一個應用）網頁上使用，用來給HTML網頁增長動態功能
ps:添加特效

Servlet
Servlet（Server Applet）是Java Servlet的簡稱，稱爲小服務程序或服務鏈接器，
用Java編寫的服務器端程序，主要功能在於交互式地瀏覽和修改數據，生成動態Web內容。
ps:讓網頁與服務器之間具有傳輸數據的能力

JSP
JSP全名爲Java Server Pages，中文名叫java服務器頁面，其根本是一個簡化的Servlet設計
它是由Sun Microsystems公司倡導、許多公司參與一塊兒創建的一種動態網頁技術標準。
JSP技術有點相似ASP技術，它是在傳統的網頁HTML（標準通用標記語言的子集）
文件(*.htm,*.html)中插入Java程序段(Scriptlet)和JSP標記(tag)，從而造成JSP文件，後綴名爲(*.jsp)。
用JSP開發的Web應用是跨平臺的，既能在Linux下運行，也能在其餘操做系統上運行
ps:一種讓Servlet簡化的語言

AJAX
是一種用於建立更好更快以及交互性更強的Web應用程序的技術
ps:能夠提升網頁和服務器之間的鏈接效率

JQuery
JQuery是一個快速、簡潔的JavaScript框架，是繼Prototype以後又一個優秀的JavaScript代碼庫（或JavaScript框架）。
jQuery設計的宗旨是「write Less，Do More」，即倡導寫更少的代碼，作更多的事情。它封裝JavaScript經常使用的功能代碼，
提供一種簡便的JavaScript設計模式，優化HTML文檔操做、事件處理、動畫設計和Ajax交互。
ps:增強版JavaScript

Bootstrap
Bootstrap是美國Twitter公司基於HTML、CSS、JavaScript 開發的簡潔、直觀、強悍的前端開發框架，使得 Web 開發更加快捷。
ps:讓HTML、CSS、JavaScript 更加便捷

框架（Framework）是整個或部分系統的可重用設計，表現爲一組抽象構件及構件實例間交互的方法;
另外一種定義認爲，框架是可被應用開發者定製的應用骨架。前者是從應用方面然後者是從目的方面給出的定義。
　　能夠說，一個框架是一個可複用的設計構件，它規定了應用的體系結構，闡明瞭整個設計、協做構件之間的依賴關係、
責任分配和控制流程，表現爲一組抽象類以及其實例之間協做的方法，它爲構件複用提供了上下文(Context)關係。
所以構件庫的大規模重用也須要框架。
　　應用框架指的是實現了某應用領域通用完備功能（除去特殊應用的部分）的底層服務。
使用這種框架的編程人員能夠在一個通用功能已經實現的基礎上開始具體的系統開發。
框架提供了全部應用指望的默認行爲的類集合。具體的應用經過重寫子類(該子類屬於框架的默認行爲)或組裝對象來支持應用專用的行爲。
　　應用框架強調的是軟件的設計重用性和系統的可擴充性，以縮短大型應用軟件系統的開發週期，提升開發質量。
與傳統的基於類庫的面向對象重用技術比較，應用框架更注重於面向專業領域的軟件重用。應用框架具備領域相關性，
構件根據框架進行復合而生成可運行的系統。框架的粒度越大，其中包含的領域知識就更加完整。
　　框架，即framework。其實就是某種應用的半成品，就是一組組件，供你選用完成你本身的系統。
簡單說就是使用別人搭好的舞臺，你來作表演。並且，框架通常是成熟的，不斷升級的軟件。

框架（Framework）是整個或部分系統的可重用設計，表現爲一組抽象構件及構件實例間交互的方法;
另外一種定義認爲，框架是可被應用開發者定製的應用骨架。前者是從應用方面然後者是從目的方面給出的定義。
　　能夠說，一個框架是一個可複用的設計構件，它規定了應用的體系結構，闡明瞭整個設計、協做構件之間的依賴關係、責任分配和控制流程，
表現爲一組抽象類以及其實例之間協做的方法，它爲構件複用提供了上下文(Context)關係。所以構件庫的大規模重用也須要框架。
　　應用框架指的是實現了某應用領域通用完備功能（除去特殊應用的部分）的底層服務。
使用這種框架的編程人員能夠在一個通用功能已經實現的基礎上開始具體的系統開發。
框架提供了全部應用指望的默認行爲的類集合。
具體的應用經過重寫子類(該子類屬於框架的默認行爲)或組裝對象來支持應用專用的行爲。
　　應用框架強調的是軟件的設計重用性和系統的可擴充性，以縮短大型應用軟件系統的開發週期，
提升開發質量。與傳統的基於類庫的面向對象重用技術比較，應用框架更注重於面向專業領域的軟件重用。
應用框架具備領域相關性，構件根據框架進行復合而生成可運行的系統。框架的粒度越大，其中包含的領域知識就更加完整。

框架，即framework。其實就是某種應用的半成品，就是一組組件，供你選用完成你本身的系統。簡單說就是使用別人搭好的舞臺，你來作表演。並且，框架通常是成熟的，不斷升級的軟件。

SSH 爲 struts+spring+hibernate 的一個集成框架，是目前較流行的一種JAVA Web應用程序開源框架

Struts
Struts是一個基於Sun J2EE平臺的MVC框架，主要是採用Servlet和JSP技術來實現的。
因爲Struts能充分知足應用開發的需求，簡單易用，敏捷迅速，在過去的一年中頗受關注。
Struts把Servlet、JSP、自定義標籤和信息資源(message resources)整合到一個統一的框架中，
開發人員利用其進行開發時不用再本身編碼實現全套MVC模式，極大的節省了時間，因此說Struts是一個很是不錯的應用框架。

Spring　　 Spring是一個解決了許多在JavaEE開發中常見的問題的強大框架。 Spring提供了管理業務對象的一致方法而且鼓勵了注入對接口編程而不是對類編程的良好習慣。 Spring的架構基礎是基於使用JavaBean屬性的Inversion of Control容器。 然而，這僅僅是完整圖景中的一部分：Spring在使用IOC容器做爲構建完關注全部架構層的完整解決方案方面是獨一無二的。 Spring提供了惟一的數據訪問抽象，包括簡單和有效率的JDBC框架，極大的改進了效率而且減小了可能的錯誤。 Spring的數據訪問架構還集成了Hibernate和其餘O/R mapping解決方案。 Spring還提供了惟一的事務管理抽象，它可以在各類底層事務管理技術，例如JTA或者JDBC事務提供一個一致的編程模型。 Spring提供了一個用標準Java語言編寫的AOP框架，它給POJOs提供了聲明式的事務管理和其餘企業事務--若是你須要--還能實現你本身的aspects。 這個框架足夠強大，使得應用程序可以拋開EJB的複雜性，同時享受着和傳統EJB相關的關鍵服務。 Spring還提供了能夠和IoC容器集成的強大而靈活的MVC Web框架。 Hibernate　　Hibernate是一個開放源代碼的對象關係映射框架，它對JDBC進行了很是輕量級的對象封裝， 使得Java程序員能夠爲所欲爲的使用對象編程思惟來操縱數據庫。 Hibernate能夠應用在任何使用JDBC的場合， 既能夠在Java的客戶端程序實用，也能夠在Servlet/JSP的Web應用中使用，最具革命意義的是， Hibernate能夠在應用EJB的JavaEE架構中取代CMP，完成數據持久化的重任。 SSM爲 Spring+SpringMVC+MyBatis的一個集成框架，是目前較流行的一種JAVA Web應用程序開源框架Spring     Spring是一個開源框架，Spring是於2003 年興起的一個輕量級的Java 開發框架， 由Rod Johnson 在其著做Expert One-On-One JavaEE Development and Design中闡述的部分理念和原型衍生而來。 它是爲了解決企業應用開發的複雜性而建立的。Spring使用基本的JavaBean來完成之前只可能由EJB完成的事情。 然而，Spring的用途不只限於服務器端的開發。從簡單性、可測試性和鬆耦合的角度而言，任何Java應用均可以從Spring中受益。  簡單來講，Spring是一個輕量級的控制反轉（IoC）和麪向切面（AOP）的容器框架。SpringMVC         Spring MVC屬於SpringFrameWork的後續產品，已經融合在Spring Web Flow裏面。 Spring MVC 分離了控制器、模型對象、分派器以及處理程序對象的角色，這種分離讓它們更容易進行定製。MyBatis   MyBatis 本是apache的一個開源項目iBatis, 2010年這個項目由apache software foundation 遷移到了google code，而且更名爲MyBatis 。 MyBatis是一個基於Java的持久層框架。iBATIS提供的持久層框架包括SQL Maps和Data Access Objects（DAO）MyBatis  消除了幾乎全部的JDBC代碼和參數的手工設置以及結果集的檢索。MyBatis 使用簡單的 XML或註解用於配置和原始映射， 將接口和 Java 的POJOs（Plain Old Java Objects，普通的 Java對象）映射成數據庫中的記錄。