凌宇的java之路（2017年1月23日02:05:53）

[TOC]

Junit测试

用junit测试可以不用每次都去写方法，注释方法去测试，提高了效率，
如何测试呢，看代码：
这个是之前的小方法，用于测试

package com.ly.day01;

public class Ly {

    
    public void sayName(){
        System.out.println("this gay is ly");
    }
}

这个是用来进行junit测试的测试类：

package test;

import org.junit.Test;

import com.ly.day01.Ly;

public class testLy {

    
    @Test
    public void testSayLy(){
        new Ly().sayName();
    }
    
}

其实差别就是多加了一个@Test注解，并且在运行的时候选择 run as junitTest。

如果方法没错，那么就会出现绿条：

测试通过

而如果测试失败了，就会出现

测试失败

---

注解@before 和 @after

在主体类中新增一个方法：

package com.ly.day01;

public class Ly {

    
    public void sayName(){
        System.out.println("this gay is ly");
    }
    
    public void setName(String newName){
        System.out.println("gay, your new name is "+newName);
    }
}

同样的 我们在测试类中新增一个测试方法：

    @Test
    public void testSetName(){
        new Ly().setName("lht");
    }

值得注意的是，一个测试类里面如果有多个测试方法，而我们要一起运行的话，我们可以在

方法概览区

点击整个类运行 run as junitTest

但是在运行之前我们新增2个注解方法：

    
    @Before
    public void before(){
        System.out.println("this gay run before the function");
    }
    
    @After
    public void after(){
        System.out.println("this gay run after the function");
    
    }

运行之后 我们会发现：

this gay run before the function
this gay is ly
this gay run after the function
this gay run before the function
gay, your new name is lht
this gay run after the function

注解@Before，@After 在每个运行方法之前都会先运行一次

---

@BeforeClass 和 @AfterClass

同样的 我们在测试类中新增两个测试方法，注意他们要是静态的

@BeforeClass
    public static void beforeClass(){
        System.out.println("before class");
    }
    
    @AfterClass
    public static void afterClass(){
        System.out.println("after class");
    }
    

运行一次，结果为：

before class
this gay run before the function
this gay is ly
this gay run after the function
this gay run before the function
gay, your new name is lht
this gay run after the function
after class

我们可以发现 * @after和@before 在每个测试方法前后都会运行一次，而
@BeforeClass 和 @AfterClass 则是和类挂钩，只运行一次*

而我们注意到，其实我们在上述的每个测试方法里面都会去实例化一个Ly对象，那么其实我们可以抽离出来，如下：

package test;

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

import com.ly.day01.Ly;

public class testLy {

    private static Ly mLy;
    
    @BeforeClass
    public static void beforeClass(){
        System.out.println("before class");
        mLy=new Ly();
    }
    
    @AfterClass
    public static void afterClass(){
        System.out.println("after class");
        mLy=null;
    }
    
    @Before
    public void before(){
        System.out.println("this gay run before the function");
    }
    
    @After
    public void after(){
        System.out.println("this gay run after the function");
    
    }
    @Test
    public void testSayLy(){
        mLy.sayName();
    }
    
    @Test
    public void testSetName(){
        mLy.setName("lht");
    }
    
}

他们的结果是一样，
而在开发中 这两对注解我们可以更加实用的去用。

---

断言 Assert

上面我们只是测了方法是否可以运行，而如果方法是可以运行的，但是我们又不知道方法运行得对不对，那怎么办呢，我们可以用Assert断言来做判断，
首先我们在Ly类中加入方法，返回值为String：

    public String getName(){
        return "Ly";
    }

而在测试类中加入测试方法：

    @Test
    public void testGetName(){
        Assert.assertEquals("Ly", mLy.getName());
    }

我们可以看到Assert.assertEquals中有两个值，一个是我们期望得到的值，一个是方法的返回数据，其实就很像Android中的TextUtils.equals(String str,String str);很显然，两者equals的时候方法通过，绿条；反之黄条。
相应的Assert还有其他的assertXXXX方法，但是用法大同小异。

拿map数据的两种方式：

/**
     * 取map里面的值的方法 传统方法1
     */
    @Test
    public void getMapValue1() {
        /*
         * HashMap是无序的如果我们需要做有序存储，最好用 LinkedHashMap
         */
        Map map = new LinkedHashMap();
        map.put(5, "--1");
        map.put(2, "--2");
        map.put(3, "--3");
        Set set = map.keySet();
        Iterator it = set.iterator();
        while (it.hasNext()) {
            int key = (Integer) it.next();
            String val = (String) map.get(key);
            System.out.println(key + "---" + val);
        }
    }

    /**
     * 取map数据的传统方法2
     */
    @Test
    public void getMapValue2() {
        /*
         * HashMap是无序的如果我们需要做有序存储，最好用 LinkedHashMap
         */
        Map map = new LinkedHashMap();
        map.put(5, "--1");
        map.put(2, "--2");
        map.put(3, "--3");
        Set set = map.entrySet();
        Iterator it = set.iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Entry) it.next();
            int key = (Integer) entry.getKey();
            String val = (String) entry.getValue();
            System.out.println(key + "---" + val);

        }

    }

其实上面的方法还可以用foreach的方法再改进

---

枚举

package com.ly.day02;

public enum Grade {
    // A, B, C;
    // A("good"), B("just so so"), C("bad");
    A("good") {
        @Override
        public void attitude() {
            System.out.println("表扬");

        }
    },
    B("just so so") {
        @Override
        public void attitude() {
            System.out.println("冷漠脸");

        }
    },
    C("bad") {
        @Override
        public void attitude() {
            System.out.println("批评");

        }
    };
    // 其实枚举就类似于：
    // public static final Grade A=new Grade();

    // 所以枚举类其实就是一个类，我们可以在方法里面加字段，加构造方法：
    private String Evaluation;

    private Grade(String evaluation) {
        Evaluation = evaluation;
    }

    public String getEvaluation() {
        return Evaluation;
    }

    public void setEvaluation(String evaluation) {
        Evaluation = evaluation;
    }

    /**
     * 加入了上述构造方法和getset后，我们之前定义的枚举ABCD爆红了，为什么？ 因为他们其实就是public static final Grade
     * A=new Grade(); 我们加了构造方法，替换了之前的无参构造方法，所以就爆红了，我们可以修改为： A("good"),
     * B("just so so"), C("bad");
     */

    /**
     * 如果每个枚举都要做不同的事情的时候，那么我们可以定义一个抽象方法，比如： 而加入了抽象方法之后，我们每个枚举类型都要进行实现： A("good")
     * {
     * 
     * @Override public void attitude() { System.out.println("表扬");
     * 
     *           } }, B("just so so"){
     * @Override public void attitude() { System.out.println("冷漠脸");
     * 
     *           } }, C("bad"){
     * @Override public void attitude() { System.out.println("批评");
     * 
     *           } };
     */

    public abstract void attitude();
}

---

反射技术

拿到反射class 的三种方法：

package com.ly.day02.reflect;

public class PersonReflect {

    
    public static void main(String[] args) throws ClassNotFoundException {
        
        
//      1
        Class clazz=Class.forName("com.ly.day02.reflect.Person");
        
//      2
        Class clazz1=new Person().getClass();
        
//      3
        Class clazz2=Person.class;
    }
}

拿到类的构造方法（public）

package com.ly.day02.reflect;

public class Person {

    public String name="this is the name";
    public String pass="this is the pass";

    
    


    



    public Person(){
        super();
    }

    public Person(String name, String pass) {
        super();
        this.name = name;
        this.pass = pass;
    }



}

我们可以这么拿Person类的构造方法：

1. 这里拿的是无参的构造方法：

    @Test
    public void TestDef() throws Exception {
        Class clazz = Class.forName("com.ly.day02.reflect.Person");
        Constructor constructor = clazz.getConstructor(null);
        Person person = (Person) constructor.newInstance(null);
        System.out.println(person.name);
        System.out.println(person.pass);
    }

2. 这里拿的是有参的构造方法：

@Test
    public void test() throws Exception  {
        Class clazz = Class.forName("com.ly.day02.reflect.Person");
        Constructor constructor = clazz.getConstructor(String.class,
                String.class);
        Person person = (Person) constructor.newInstance("Ly", "password");

        System.out.println(person.name);
        System.out.println(person.pass);

    }

输出结果分别为：

输出结果

访问私有的：

getDeclaredConstructor可以返回指定参数的构造函数，而getConstructor只能放回指定参数的public的构造函数区别只是后者只可以返回公有的构造函数

@Test
    public void test() throws Exception  {
        Class clazz = Class.forName("com.ly.day02.reflect.Person");
        
//      用这个方法来获取非public的构造方法
        Constructor constructor = clazz.getDeclaredConstructor(String.class,
                String.class);
//      暴力破解
        constructor.setAccessible(true);
        Person person = (Person) constructor.newInstance("Ly", "password");

        System.out.println(person.name);
        System.out.println(person.pass);

    }

另外一种获取类的方法，需要对象类里面有一个无参的构造方法：

@Test
    public void testAgain() throws Exception {
        Class clazz = Class.forName("com.ly.day02.reflect.Person");
        Person person = (Person) clazz.newInstance();
        System.out.println(person.toString());
    }

Servlet

微信截图_20170423233705.png

Paste_Image.png