*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