javaWeb--eclipse简介，测试模式，泛型、枚举

一、Myeclipse
1.eclipse 是一个免费的软件
myeclipse是一个收费的插件。

2.debug调试模式（断点调试模式）
在行号那里双击，设置断点，运行后，会在断点那行代码出现绿色条，表示程序停在这一行。step over快捷键是F6,表示单步执行。resume F8,表示调试结束直接向下执行，（如果有断点直接跳到下一个断点，没有断点，直接运行到最后）。
debug的另一种作用是查看源代码
使用F7或者step into。

3.快捷键
Alt+/：代码提示
ctrl+1：代码修复
ctrl+shift+o：快速导包
ctrl+/：单行注释，再使用一次表示取消单行注释
ctrl+shift+/：多行注释
ctrl+shift+\：取消多行注释
ctrl+d：删除一行
ctrl+shift+f：代码的格式化,有时不好使，使用source–format

4.junit的使用（单元测试）
测试对象是一个类中的方法
junit 不是javase的一部分，需要导入jar包
但是在myeclipse 中含有这个jar包，可以直接使用

测试某个方法时，要建一个源代码文件夹，即File–Source Folder,然后再建包，包名和要被测试的方法所在的包名相同，使用单元测试方法时，方法的命名规则：public void 方法名(){};使用注解的方式运行测试的方法，首先在方法前写上@Test（区分大小写），最后双击方法名，Run As—Junit Test.
要是运行多个方法，在该类的任意空白处，右击Run As—Junit Test.

package cn.liqing.junit;

public class TestJunit {
    public static void main(String[] args) {

    }
    public static void testJunit(int a,int b){
        System.out.println(a+b);
    }

}

package cn.liqing.junit;

import org.junit.Test;

public class TestJu {
    @Test
    public void testJu(){
        TestJunit.testJunit(3, 4);
    }

}

如果写的为@Ignore，表示该测试方法不进行单元测试
@Before,@After,表示在运行某一个测试方法时，都运行这两个方法
如果在空白处执行，表示每一个方法之前之后都运行

package cn.liqing.junit;

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

public class TestJu {
    @Before
    public void testBefore(){
        System.out.println("Before...");
    }
    @Test
    public void testJu(){
        TestJunit.testJunit(3, 4);
    }
    @After
    public void testAfter(){
        System.out.println("After...");
    }

}
//输出为
Before...
7
After...

二、有关新特性
1、泛型的简介
为什么要使用泛型？泛型一般用在集合中，我们在往集合中存放数据时，会自动认为是Object类型，而当我们从集合中取出数据时，需要强制类型转换，而此时容易出现错误。当时用泛型后，会直接将存储的值认为是你实现确定的值。
2、集合：list set map
遍历list集合的三种方式，for 增强for 迭代器

for(int i=0;i<list.size();i++){
        String s = list.get(i);
        System.out.println(s);

    }
    for (String s1 : list) {
        System.out.println(s1);
    }
    Iterator<String> it = list.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }

遍历set集合有两种方式，增强for和迭代器
set集合是无序性，而且出现重复元素也只当做一个
在map上使用泛型，map是key–value

public class Testbl {
    @Test
    public void testList(){
    Map<String,String> map = new HashMap<String,String>();
    map.put("111", "aaa");
    map.put("222", "bbb");
    map.put("333", "ccc");
    //1.获取所有的key，通过key来获取到value值
    Set<String> sets = map.keySet();
    for (String key : sets) {
        String s1 = map.get(key);
        System.out.println(key+"---"+s1);
    }
    //2.获取key和value的关系
    Set<Entry<String,String>> set2 = map.entrySet();
    for (Entry<String, String> entry : set2) {
        String s2 = entry.getKey();
        String s3 = entry.getValue();
        System.out.println(s2+"---"+s3);
    }
    }

}

3.在泛型中写入的是一个对象，而不能是基本数据类型，比如int，float。如果写基本数据，需要写对应的包装类
int–Integer char–Character ,其他基本数据类型的包装类是首字母大写如double–Double.
4.泛型使用在方法上
方法的逻辑相同，但是方法的数据类型不同，可以使用泛型方法
使用泛型方法时，需要定义一个类型，使用大写字母T表示，这个字母表示任意类型。要写在返回值前。
定义一个数组，实现指定位置上的数组元素的交换
输出数组的方法是：Arrays.toString("要输出的数组名")

public class TestFan {
    public static void main(String[] args) {
        Integer[] a ={1,2,3,4,5};
        System.out.println(Arrays.toString(a));
        test1(a,1,3);
        System.out.println(Arrays.toString(a));
    }
    public static<T> void test1(T[] arr,int a,int b){
        T temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

}

5.在类上使用泛型
但是不能够使用在静态方法中，因为静态方法在创对象之前已经加载

public class TestU<T> {
//可以定义变量
    T aa;
    //可以用在方法中
    public void teT(T b){

    }

}

6.枚举的简介
需要在一定范围内取值，这个值只能是这个范围的任意一个
应用：现实场景：交通信号灯，有三种颜色，每次只能亮三种颜色中的一个。
使用一个关键字enum
创建枚举的格式，使用逗号隔开
enum 枚举类型名称{枚举对象1名称，枚举对象2名称}
枚举的构造方法是需要私有的

public class Meiju {
    private Color3 color;//类型要和枚举的一致
    public void test(){
        this.color = Color3.RED;
    }

}
enum Color3{
    RED,GREEN,YELLOW;
}

特殊枚举的操作
枚举的类里面，有构造方法或者抽象方法
当有构造方法时

enum Color3{
    RED("red"),GREEN("green"),YELLOW("yellow");
    private Color3(String name){

    }
}

当有抽象方法时
当在枚举里有抽象方法时，需要在每一个实例上都进行实现抽象方法，每个实例之间用逗号隔开

enum Color3{
    enum Color3{
    RED("red"){
        @Override
        public void print1() {
            System.out.println("red");          
        }

    },

    GREEN("green"){

        @Override
        public void print1() {
            System.out.println("green");

        }

    };
    private Color3(String name){

    }
    public abstract void print1();

}

7、枚举的api的使用
name(),返回枚举的名称
ordinal()，枚举的下标，下标从0开始
valueOf(class<T> enumType,String name),得到枚举对象
还有两个方法，不在api文档中，但是在编译的时候生成两个方法
valueof(String name),转换枚举对象
values();获取所有枚举对象数组
枚举对象，枚举下标，枚举名称之间的转换

package cn.liqing.junit;

import org.junit.Test;

public class Tm {
    @Test
    public void test1(){
        //1.知道枚举对象，获取枚举名称和下标
        Colors c1 = Colors.RED;
        String name1 = c1.name();
        int idx1 = c1.ordinal();
        System.out.println(name1+"--"+idx1);
    }
    @Test
    public void test2(){
        //2.知道枚举的名称，获得枚举对象以及下标
        String name2 = "GREEN";
        Colors c2 = Colors.valueOf(name2);
        int idx2 = c2.ordinal();
        System.out.println(idx2);
    }
    @Test
    public void test3(){
        //3.知道枚举的下标，获取枚举对象和枚举名称
        int idx3 = 2;
        //得到数组对象
        Colors[] c33 = Colors.values();
        //得到枚举对象
        Colors c3 = c33[idx3];
        //得到枚举的下标
        String name3 = c3.name();
        System.out.println(name3);
    }

}
enum Colors{
    RED,GREEN,YELLOW;
}

8、静态导入（用的少，导入不好会出错）
可以在代码里使用静态导入的方式，导入静态方法或者常量
写法：import static 方法或者常量所在路径
比如用在计算器中，将Math中的方法导入，就可以不用使Math点方法了，可以直接使用方法。

package cn.liqing.junit;
import static java.lang.System.out;
import static java.util.Arrays.sort;
import java.util.Arrays;
public class Jd {
    public static void main(String[] args) {
        System.out.println("Hello!");
        //当导入之后，可以直接写
        out.println("Jack");

        int[] a = {1,8,6,9,48,57};
        //Arrays.sort(a);
        sort(a);
        out.print(Arrays.toString(a));
    }

}

9、自动拆装箱
装箱：把基本的数据类型转换对应包装类
拆箱：把包装类转换成对应的基本数据类型

//自动装箱
        Integer i = 10;
//自动拆箱
        int m=i;

jdk 的向下兼容
在1.4中不能自动实现拆装箱，所以一定是调用doSomething(double d)，由于jdk是向下兼容，所以在5.0的时候，仍然调用该方法。

public class Testcz {
    public static void main(String[] args) {
        doSomething(10);
    }
    public static void doSomething(double d){
        System.out.println("Double.....");
    }
    public static void doSomething(Integer d){
        System.out.println("Integer.....");
    }
//输出的是Double.....
}

10、增强fo循环
语法：for（遍历出来的值：要遍历的集合）
使用的地方：数组，还有实现了Iterable接口的集合
List Set都是实现了Iterable接口的。而Map没有，所以不能使用增强for循环进行遍历
增强for循环出现目的：为了替代迭代器，因为增强for的底层就是迭代器