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
javeWeb常用快捷键 Junit for changeableargs enumn reflect的更多相关文章
- IntelliJ IDEA 工具常用快捷键
IntelliJ IDEA是java语言开发的集成环境,IntelliJ在业界被公认为最好的java开发工具之一,尤其在智能代码助手.代码自动提示.重构.J2EE支持.各类版本工具(git.svn.g ...
- 十八、IntelliJ IDEA 常用快捷键 之 Windows 版
IntelliJ IDEA(简称 IDEA),是 Java 语言开发的集成环境,IDEA 在业界被公认为最好的 Java 开发工具之一,尤其在智能代码助手.代码自动提示.重构.J2EE 支持.各类版本 ...
- Visaul Studio 常用快捷键的动画演示
从本篇文章开始,我将会陆续介绍提高 VS 开发效率的文章,欢迎大家补充~ 在进行代码开发的时候,我们往往会频繁的使用键盘.鼠标进行协作,但是切换使用两种工具会影响到我们的开发速度,如果所有的操作都可以 ...
- Android Stuido 常用快捷键
Android Stuido 常用快捷键 Ctrl + Z : 撤消 Ctrl + G : 定位行 Ctrl + / : 单行注释 Ctrl + Shift + Z : 恢复 Ctrl + J : 快 ...
- ADT - Eclipse 常用快捷键
ADT - Eclipse 常用快捷键 Alt + / : 自动补全 F3 : 打开类的源码 Ctrl + D : 删除选中行 Ctrl + 1 : 自动弹出修改建议 Ctrl + Shift + J ...
- iOS开发常用快捷键
二. Xcode基本快捷键 新建项目 Shift + CMD + N 项目中新建文件 CMD + N 运行 CMD + R 编译 CMD + B 停止运行 CMD + . 清除缓存 Shift + C ...
- windows常用快捷键
windows常用快捷键 Fn+F1:Windows的支持和帮助 =Windows 徽标+F1 Fn+F2:重命名对象 Fn+F3:查找所有文件 Fn+F4:选择“转到不同的文件夹”框并沿框中的项向下 ...
- Eclipse最常用快捷键
常用快捷键: Ctrl + 1 :快速修复(当编辑器出现红色波浪线时使用此快捷键能快速弹出提示) Ctrl + d :删除当前光标所在的行 Ctrl + z :撤销上一步的操作 Ctrl + y :重 ...
- MyEclipse 常用快捷键
MyEclipse 常用快捷键 编辑: Ctrl+1 快速修复(最经典的快捷键,就不用多说了,可以解决很多问题,比如import类.try catch包围等) Ctrl+Shift+F 格式化当前代码 ...
随机推荐
- 小米2s换了屏幕后不能近距离对焦，拆过后无法对焦?
主要问题就是小米2/2S手机中壳套后摄像头的位置,里面还有一个正方形的黑色塑胶垫片,一般拆机后这个垫片是不会掉出来的,所以一般上盖时也是直接把中壳合上后上螺丝. 这样安装基本会导致塑胶垫片把摄像头顶住 ...
- winfrom LED时钟
public sealed class Clock : PictureBox { public Clock() { SetStyle(ControlStyles.AllPaintingInWmPain ...
- RHEL 7.2 安装Oracle XE-11.2.0
轻量快捷版本,适合开发 0. /etc/hosts 添加 本机hostname # hostnamepromote.cache-dns.local # cat /etc/hosts127.0.0.1 ...
- 使用urllib2的HttpResponse导致内存不回收（内存泄漏）
问题出现环境:python 2.7.1(X)及以下, Windows(或CentOS) 这个问题产生在lib/urllib2.py的line 1174 (python 2.7.1),导致形成了cycl ...
- Flasback数据库(闪回数据库)
数据库闪回原理: 一旦启用了闪回数据库,修改的块映像会不时从数据库缓冲区复制到闪回缓冲区.通过新的后台恢复写入器(Recovery Writer, RVWR)将此闪回缓冲区内容刷新到磁盘和闪回日志接着 ...
- OFBiz进阶之HelloWorld（三）CRUD操作
参考文档 https://cwiki.apache.org/confluence/display/OFBIZ/OFBiz+Tutorial+-+A+Beginners+Development+Guid ...
- 二十、mysql mysqldump备份工具
.备份所有数据库 mysqldump -uroot -p --all-database > c:\all.sql 备份所有数据库到c盘下的all,sql文件 .备份某个数据库 mysqldump ...
- IPHONE开发知识
IPHONE开发知识http://www.cnblogs.com/valensoft/archive/2010/06/09/1754836.htmlhttp://www.cocoachina.com/ ...
- UITableView自定义单元格
随手笔记: RootViewController代码 #import "RootViewController.h" #import "AddressContact.h&q ...
- Linux操作系统
Linux操作系统 linux源码分析(三)-start_kernel 2016-10-26 11:01 by 轩脉刃, 146 阅读, 收藏, 编辑 前置:这里使用的linux版本是4.8,x86体 ...