javeWeb常用快捷键 Junit for changeableargs enumn reflect

2021-11-18 04:10:15

*1 工具常用的快捷键

1) Eclipse和MyEclipse，IBM，2001，Java编写，开源，跨平台跨语言
2）Alt+/快速内容提示
3）Ctrl+1快速修补错误
4）Syso+Alt+/快速显示System.out.println()语句
5）Ctrl+Shift+F快速排版正确代码
6）Ctrl+Shift+X转大写，Ctrl+Shift+Y转小写
7）Ctrl+Shift+O一次性导入多个包
8）Ctrl+/加或减单行注释
9) Ctrl+Shift+/加多行注释，Ctrl+Shift+\取消多行注释
10) 选中行+Alt+上下光标键移动行

*2 使用断点调试程序，使用Junit测试程序

1)通过断点方式调式程序的每个步骤
2)Step over查看代码粗粒度执行过程
3)Step into查看代码细粒度执行过程
4)@Before和@After会在@Test方法执行前后各执行一次
5)@BeforeClass和@AfterClass是在类前后各执行一次

javeWeb常用快捷键 Junit for changeableargs enumn reflect

//Junit单独/同时测试多个方法

public class Demo1 {
    @Test
    public void test1(){
        System.out.println("Junit使用");
    }
    @Test
    public void test2(){
        System.out.println("Junit调式");
    }
}

//Junit测试在方法前后执行
public class Demo2 {
    @Before
    public void setUp() throws Exception {
        System.out.println("文件打开");
    }
    @Test
    public void test1(){
        System.out.println("test1()");
    }
    @Test
    public void test2(){
        System.out.println("test2()");
    }
    @After
    public void tearDown() throws Exception {
        System.out.println("文件关闭");
    }
}

//Junit测试在类加载前后执行
public class Demo3 {
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("setUpBeforeClass()");
    }
    @Test
    public void test1(){
        System.out.println("test1()");
    }
    @Test
    public void test2(){
        System.out.println("test2()");
    }
    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("tearDownAfterClass()");
    }
}

*3 静态导入和自动装拆箱

1）静态导入可以导入对象，属性，方法，*
2）语法：
    import static java.lang.Math.PI;
    import static java.lang.Math.pow;
    import static java.lang.System.out;
3）在JDK5中，编译器自动将基本类型和对应的包装类型，自动转换
    例如：int<->Integer

//List集合加入int型和取出Integer类型数据
public class Demo1 {
    
    @Test
    public void test1(){
        List<String> list = new ArrayList<String>();
        list.add("jack");
        String name = list.get(0);
        System.out.println("name="+name);
    }
    
    @Test
    public void test2(){
        int i = 100;
        List list = new ArrayList();
        list.add(i);
        Integer num = (Integer) list.get(0);
        System.out.println("num="+num);
    }
}

*4 增强for循环

1)循环迭代数组/List/Set/Map集合
2)对Map集合的二种迭代方式：
a)keySet()
b)entrySet()
3)在迭代集合时，一定要动态通知Iterator，而不要动态通知List集合，应选用ListIterator。

public class Demo1 {
    @Test
    public void test1(){
        int[] is = {1,2,3,4,5};
        for(int i=0;i<is.length;i++){
            System.out.println(is[i]);
        }
    }
    @Test
    public void test2(){
        int[] is = {1,2,3,4,5};
        for(int value : is){
            System.out.print(value+"\t");
        }
    }
    @Test
    public void testSet(){
        Set<Integer> set = new HashSet<Integer>();
        set.add(100);
        set.add(200);
        set.add(300);
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            System.out.print(key+"\t");
        }
    }
    @Test
    public void testList(){
        List<String> list = new ArrayList<String>();
        list.add("jack");
        list.add("marry");
        list.add("sisi");
        for(String name : list){
            System.out.print(name+"\t");
        }
    }
    @Test
    public void testMap1(){
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(100,"jack");
        map.put(200,"marry");
        map.put(300,"sisi");
        Set<Integer> set = map.keySet();
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key+"-"+value);
        }
    }
    @Test
    public void testMap2(){
        Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(100,"jack");
        map.put(200,"marry");
        map.put(300,"sisi");
        Set<Entry<Integer,String>> set = map.entrySet();
        Iterator<Entry<Integer,String>> it = set.iterator();
        while(it.hasNext()){
            Entry<Integer,String> entry = it.next();
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"<->"+value);
        }
    }

//向List集合并发存取元素引起的问题
public class Demo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("jack");
        list.add("marry");
        list.add("sisi");
        System.out.println("list前长度"+list.size());
        //Iterator<String> it = list.iterator();
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()){
            String key = it.next();
            System.out.print(key+"\t");
            //list.add("qq");
            //动态通知迭代器，加入了新元素，从而迭代器自动通知List集合
            it.add("qq");
        }
        System.out.println("\nlist后长度"+list.size());
        it = list.listIterator();
        while(it.hasNext()){
            String key = it.next();
            System.out.print(key+"\t");
        }
    }
}

*5 可变参数

1）参数的个数不确定的
2）可变参数只能放置在参数的最后，即最右边
3）可变参数最少0个，最多1个
4）编译器将可变参数当作一个一维数组来对待

//可变参数
public class Demo1 {
    public static void main(String[] args) {
        //show1(new String[]{"jack","marry","sisi","soso"});
        //show2("jack","marry","sisi","soso","berry");
        show3("qq","jack","marry","sisi","soso","berry");
        
    }
    public static void show1(String[] arr) {
        for(String a :arr){
            System.out.print(a+"\t");
        }
    }
    public static void show2(String... arr) {
        for(String a :arr){
            System.out.print(a+"\t");
        }
    }
    public static void show3(String qq,String... arr) {
        System.out.println("第一个参数是：" + qq);
        for(String a :arr){
            System.out.print(a+"\t");
        }
    }
    /*
    public static void show4(String... arr1,String... arr2) {
    }
    */
}

*6 枚举

1）当取值是某范围中的之一，这时可以使用枚举
2）当向用户提示严重的错误时，尽可以使用抛异常的方式通知客户端
3）可以对枚举在运行时验证
4）可以对枚举在编译时验证
5）枚举值相当于实例变量
6）枚举类与普通一致，可以继承或实现，如果有抽像方法的话，可以利用每个枚举值以匿名内部类的方式去实现
7）枚举值可以用在switch()语句中
8）枚举类常用方法如下：
    a)name()：显示枚举值
    b)ordinal()：显示枚举值对应的索引，从0开始
    c)values()：取得该枚举类对应的所有枚举值，是一个数组
    d)valueOf()：判段某个字符串是否属性枚举值之一

//自定义算法解决学员分数等级ABCDE(运行验证)
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("jack");
        student.setGrade("E");
        System.out.println("姓名：" + student.getName());
        System.out.println("等级：" + student.getGrade());
    }
}

//学生
public class Student {
    //姓名
    private String name;
    
    //等级
    private String grade;//等级是能是{A,B,C,D,E取值之一}
    
    public Student(){}
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGrade() {
        return grade;
    }
    public void setGrade(String grade) throws Exception {
        //判段
        if(grade!=null && grade.matches("A|B|C|D|E")){
            this.grade = grade;
        }else{
            throw new Exception();
        }
    }
}

//使用模拟枚举类表示学员分数等级ABCDE(编译验证)
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("jack");
        student.setGrade(Grade.B);
        System.out.println("姓名：" + student.getName());
        System.out.println("等级：" + student.getGrade().getTip());
        System.out.println("分数区间：" + student.getGrade().getDesc());
    }
}
//分数类
public class Grade {
    public static Grade A = new Grade("A","90-100");
    public static Grade B = new Grade("B","80-89");
    public static Grade C = new Grade("C","70-79");
    public static Grade D = new Grade("D","60-69");
    public static Grade E = new Grade("E","<60");
    private String tip;
    private String desc;
    private Grade(String tip,String desc){
        this.tip = tip;
        this.desc = desc;
    }
    public String getTip() {
        return tip;
    }
    public String getDesc() {
        return desc;
    }
}

//学生
public class Student {
    
    //姓名
    private String name;
    
    //分数类
    private Grade grade;
    
    public Student(){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
    
}

//使用枚举类
public class Demo1 {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("marry");
        student.setGrade(Grade.B);
        System.out.println("姓名：" + student.getName());
        System.out.println("等级：" + student.getGrade().getTip());

        System.out.println("分数区间：" + student.getGrade().getDesc());

    }
}
//分数枚举类
public enum Grade {
    A("A","90-100"),
    B("B","80-89"),
    C("C","70-79"),
    D("D","60-69"),
    E("E","<60");
    private String tip;
    private String desc;
    private Grade(String tip,String desc){
        this.tip = tip;
        this.desc = desc;
    }
    public String getTip() {
        return tip;
    }
    public String getDesc() {
        return desc;
    }
}

//学生
public class Student {
    
    //姓名
    private String name;
    
    //分数类
    private Grade grade;
    
    public Student(){}

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }
    
}

//带抽象方法的枚举
public class Demo1 {
    public static void main(String[] args) {
        Season season = Season.SPRING;
        //System.out.println(season.name());
        //System.out.println(season.ordinal());
        //Season[] seasons = season.values();
        //for(Season s : seasons){
        //    System.out.println(s.name());
        //}
        
        Season.valueOf(Season.class,"SPRING");
        
        
        /*season.show();
        String msg = null;
        switch(season){
            case SPRING:
                msg = "1";break;    
            case SUMMER:
                msg = "2";break;    
            case AUTOMN:
                msg = "3";break;    
            case WINNTER:
                msg = "4";break;    
        }
        System.out.println(msg);*/
    }
}

//季节枚举类
public enum Season{
    SPRING{
        public void show(){
            System.out.println("春天");
        }
    },SUMMER{
        public void show(){
            System.out.println("夏天");
        }
    },AUTOMN{
        public void show(){
            System.out.println("秋天");
        }
    },WINNTER{
        public void show(){
            System.out.println("冬天");
        }
    };
    //抽像方法
    public abstract void show();
}

package cn.itcast.java.model;
//单例/态/值设计模式[单线程情况下]
public class Singleton {
    // NO1
    private Singleton() {
    }
    // NO2
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    // NO3
    private static Singleton instance;
}
package cn.itcast.java.model;

public class Demo1 {
    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            Singleton s = Singleton.getInstance();
            System.out.println(s.hashCode());
        }
    }
}

*7 反射

1)解析一个类的各个部分，形成一个对象。
2)外存中的类，加载到内存中，会形成该对象的Class类，例如：String类，加载到内存中，就是StringClass对象。
3)使用不同的方式，取得同一个类型的字节码对象Class是相同的。
4)通过getXxxxx()只能取得该类public的类型
    通过getDeclaredXxxxxx()可以取得该类非public的类型
    设置非public类型的可访问性，默认为false，不可访问
    c.setAccessible(true);
5)反射可以反射private/public的构造方法，字段，普通方法
6)在反射main方法时，编译器会将数组自动拆分，取第一个值
    解决方案：
    //m.invoke(null,(Object)new String[]{"A","B","C","D"});，将数组当作对象，此时编译器不进行拆分
    m.invoke(null,new Object[]{new String[]{"A1","B1","C1","D1"}});在数组中嵌入另一个数组

//Class对象的比较使用==号或!=号
public class Demo1 {
    public static void main(String[] args) throws Exception {

        //类名.class
        Class c1 = String.class;
        
        //对象.getClass()
        Class c2 = new String().getClass();
        
        //Class.forName()
        Class c3 = Class.forName("java.lang.String");
        
        if(c2==c3){
            System.out.println("c2==c3");
        }else{
            System.out.println("c2!=c3");
        }
    }
}

//含有构造方法，字段，成员方法，main方法的类
public class Person {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    /*    
    public Person(){
        System.out.println("public Person()");
    }
    public Person(String name,int age){
        System.out.println("public Person(String name,int age)");
    }
    private Person(){
        System.out.println("private Person()");
    }
    protected Person(){
        System.out.println("protected Person()");
    }
    */
    public void show(){
        System.out.println("public void show()");
    }
    public void show(String[] likes,double salary){
        System.out.println("public void show(String[] likes,double salary)");
    }
    private void haha(){
        System.out.println("private void haha()");
    }
    private void xixi(){
        System.out.println("private void xixi()");
    }
    private String goodbye(){
        System.out.println("private String goodbye()");
        return "thanks";
    }
    public static void main(String[] args) {
        System.out.println("public static void main(String[] args)");
    }
}

//通过反射解析构造方法
public class Demo2 {
    public static void main(String[] args) throws Exception {
        
        //取得Person类对应的字节码对象Class
        Class clazz = Class.forName("cn.itcast.java.reflect.Person");
        
        //取得该类的唯一构造方法
        //Constructor c  = clazz.getConstructor(null);
        //Constructor c = clazz.getConstructor(String.class,int.class);
        Constructor c = clazz.getDeclaredConstructor(null);
        
        //创建实例
        //Person p = (Person) c.newInstance(null);
        //Person p = (Person) c.newInstance("berry",10);
        
        //设置非public成员的访问性，默认false即不可访问性
        c.setAccessible(true);
        
        Person p = (Person) c.newInstance(null);
        
        //执行方法
        p.show();
        
    }
}

//通过反射解析字段
public class Demo3 {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        Class c = Class.forName("cn.itcast.java.reflect.Person");
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(p,"杰克");//p.setName("杰克")
        System.out.println("用户名：" + p.getName());
    }
}

//通过反射解析成员方法
public class Demo4 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.itcast.java.reflect.Person");
        Constructor con = c.getConstructor(null);
        Person p = (Person) con.newInstance(null);
        Method m = c.getDeclaredMethod("goodbye",null);
        m.setAccessible(true);
        String returnValue = (String) m.invoke(p,null);
        System.out.println(returnValue);
        
        //Method m = c.getMethod("show",String[].class,double.class);
        //m.invoke(p,new String[]{"sing","dance"},5000);//new Person().show()
    }
}

//通过反射解析main方法 
public class Demo5 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.itcast.java.reflect.Person");
        //获取main方法
        Method m = c.getMethod("main",String[].class);
        //m.invoke(null,(Object)new String[]{"A","B","C","D"});
        m.invoke(null,new Object[]{new String[]{"A1","B1","C1","D1"}});
        
        
    }
}

public class ReflectDemo {

    public static void main(String[] args) throws IOException,
            ClassNotFoundException, InstantiationException,
            IllegalAccessException {
        @SuppressWarnings("resource")
        BufferedReader reader = new BufferedReader(new FileReader("config.txt"));
        String line = reader.readLine();
        Class clazz = Class.forName(line);
        //Class clazz = Class.forName("com.Jordon.Reflect.MyinterImplement");
        Myinter myinter = (Myinter) clazz.newInstance();
        myinter.show();
    }
}

这部分代码反映了reflect的可扩展性，通过读取配置文件就能方便的更改所读取的类文件。

package cn.itcast.java.reflect;

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo6 {
    public static void main(String[] args) throws Exception {
        
        //加载属性文件，取得类名的方法名
        Properties props = new Properties();
        InputStream is = new FileInputStream("src/cn/itcast/java/reflect/class.properties");
        props.load(is);
        String className = props.getProperty("className").trim();
        String methodName = props.getProperty("methodName").trim();
        
        //通过反射，执行该类的方法
        Class c = Class.forName(className);
        Constructor con = c.getConstructor(null);
        Method m = c.getDeclaredMethod(methodName,null);
        m.setAccessible(true);
        m.invoke(con.newInstance(null),null);
        
    }
}
//-------------------------------------------------------------------
className=cn.itcast.java.reflect.Person
methodName=xixi