javeWeb常用快捷键 Junit for changeableargs enumn reflect

*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是在类前后各执行一次

//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
上一篇:JS全部API笔记


下一篇:SuperSocket基础一