1、myeclipse的安装和使用
2、debug的调试模式(断点调试模式)
package cn.itcast.test;
import java.util.Arrays;
public class TestDemo3 {
/**
* @param args
*/
public static void main(String[] args) {
int[] arr1 = {10,2,5,30,20,11,25};
//debug查看源代码
Arrays.sort(arr1);
System.out.println(Arrays.toString(arr1));
}
}
Alt + / 代码引导
Ctrl + T 在方法上按此键可进入实现类
Ctrl + 鼠标左键 在方法上按此键可进入接口
Ctrl + Alt + H 在方法上按此键可进入调用此方法的上一级方法
Ctrl + O 显示当前类中所有方法的列表
Ctrl + Shift + O 导入缺少的包
Ctrl + Shift + R 根据文件名搜索文件
Ctrl + Shift + I 进入断点在参数上按此键显示具体内容
Ctrl + H 根据内容搜索文件
Ctrl + F 根据内容搜索当前文件
Ctrl + K 根据内容向下搜索当前文件
Ctrl + Shift + K 根据内容向上搜索当前文件
Ctrl + Alt + 上或下 复制选中文本
Alt + 上或下 移动选中文本
Ctrl + Alt + / 拼写自动补全
Ctrl + Shift + F 格式化文本
F6 断点单步运行
F8 按一次执行一个断点
Ctrl + o 在编辑器中打开类结构,适用在编辑框最大化的时候,跳转函数用...
Ctrl + t 也是在编辑器中使用,打开选择的元素的继承树,可以迅速定位父类的方法在子类中的覆盖位置
Alt + <-(左右箭头): 编辑器的回退,就是著名的BACK!
Ctrl + F6 : 切换编辑编辑器,我改成了Table+ctrl
ctrl+/:注释
ctrl+\:取消注释
package cn.itcast.test;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
/**
* java的常用的快捷键
*
* @author asus
*
*/
public class TestDemo4 {
public static void main(String[] args) throws Exception {
// 代码提示 alt /
new FileOutputStream("");
// 代码修复 ctrl 1
// 快速导包 ctrl shift o
List list = new ArrayList();
// 单行注释 ctrl /
// 取消单行注释 ctrl /
// int sum = 0;
// 多行注释 ctrl shift /
// 取消多行注释 ctrl shift \
/*
* int a = 1; int b = 2;
*/
// 删除行 ctrl d
int aa = 10;
// 代码的格式化 ctrl shift F 有时候不好使,点击Source-- Format
//有缩进的效果
}
}
package cn.itcast.test02;
public class TestJunit {
public void testAdd(int a,int b) {
System.out.println(a+b);
}
public void test11() {
System.out.println("test11.....");
}
}
package cn.itcast.test02;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
public class TestDemo {
@Before
public void testBefore() {
System.out.println("before....");
}
@Test
public void testAdd1() {
TestJunit test01 = new TestJunit();
test01.testAdd(2, 3);
//int m = 10/0;
}
@Test
public void test12() {
System.out.println("test12");
}
@Ignore
public void tests11() {
TestJunit test01 = new TestJunit();
test01.test11();
}
@After
public void testAfter() {
System.out.println("after.....");
}
}
package cn.itcast.test02;
import junit.framework.Assert;
import org.junit.Test;
public class TestDemo2 {
@Test
public void test02() {
int a = 3;
int b = 5;
int sum = a+b;
//使用断言
//Assert.assertEquals("测试期望的值", "方法运行的实际的值")
Assert.assertEquals(80, sum);
}
}
package cn.itcast.test03;
import java.util.ArrayList;
import java.util.List;
public class TestDemo1 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
//如果不用泛型,比如把aaa值取出来,类型转换,转换int类型,会类型转换的错误
}
}
package cn.itcast.test03;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.junit.Test;
/**
* 泛型在集合上的使用
* @author asus
*
*/
public class TestDemo02 {
//在map上使用泛型
@Test
public void testMap() {
Map map = new HashMap();
map.put("aaa", "111");
map.put("bbb", "222");
map.put("ccc", "333");
//遍历map 有几种遍历方式 两种
// 1、获取所有的key,通过key得到value 使用get方法
// 2、获取key和value的关系
//使用第一种方式遍历
//获取所有的key
Set sets = map.keySet();
//遍历所有key返回的set
for (String key : sets) {
//通过key得到value
String value = map.get(key);
System.out.println(key+" : "+value);
}
System.out.println("==============");
//得到key和value的关系
Set> sets1 = map.entrySet();
//遍历sets1
for (Entry entry : sets1) {
//entry是key和value关系
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+" : "+valuev);
}
}
//泛型使用set集合上
@Test
public void testSet() {
Set set = new HashSet();
set.add("www");
set.add("qqq");
set.add("zzz");
//set.add("qqq");
//遍历set 有几种方式 两种
//迭代器 增强for
//使用增强for遍历
for (String s2 : set) {
System.out.println(s2);
}
System.out.println("=================");
//使用迭代器遍历
Iterator it1 = set.iterator();
while(it1.hasNext()) {
System.out.println(it1.next());
}
}
//泛型在list上的使用
@Test
public void testList() {
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
list.add("ccc");
//遍历list集合 有几种方式 三种
//普通for循环 迭代器 增强for
//普通for循环
for(int i=0;i it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
package cn.itcast.test03;
import java.util.Arrays;
/**
* 定义一个数组,实现指定位置上数组元素的交换
* @author asus
*
*/
public class TestDemo03 {
public static void main(String[] args) {
//创建一个数组 实现11和13位置交换
Integer[] arr1 = {10,11,12,13,14};
System.out.println(Arrays.toString(arr1));
swap1(arr1,1,3);
System.out.println(Arrays.toString(arr1));
System.out.println("=========================");
//创建一个string类型的数组 实现 bb和dd位置交换
String[] arr2 = {"aa","bb","cc","dd","ff"};
System.out.println(Arrays.toString(arr2));
swap1(arr2,1,3);
System.out.println(Arrays.toString(arr2));
}
/*
* 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型
* 写在返回值之前 void之前
* =======表示定义了一个类型 这个类型是 T
* 在下面就可以使用这个类型了 T
* */
public static void swap1(T[] arr ,int a,int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/*private static void swap1(String[] arr2, int i, int j) {
String temp1 = arr2[i];
arr2[i] = arr2[j];
arr2[j] = temp1;
}
private static void swap1(int[] arr1, int i, int j) {
//定义一个中间变量
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}*/
}
package cn.itcast.test03;
public class TestDemo04 {
//在类里面可以直接使用T的类型
T aa;
public void test11(T bb) {}
//写一个静态方法 在类上面定义的泛型,不能再静态方法里面使用
public static void test12(A cc) {}
}
package cn.itcast.test04;
public class TestEnum1 {
//传统的方式
private int color;
//第二种方式
private Color2 color1;
//第三种方式 jdk5.0新特性 使用枚举
private Color3 color3;
public void test() {
this.color = 1000;//Color1.RED;
this.color1 = Color2.RED;
this.color3 = Color3.GREEN;
}
}
//使用枚举实现
enum Color3 {
RED,GREEN,YELLOW;
}
class Color2 {
//构造方法私有化
private Color2(String name){}
public static final Color2 RED = new Color2("");
public static final Color2 GREEN = new Color2("");
public static final Color2 YELLOW = new Color2("");
}
class Color1 {
public static final int RED = 1;
public static final int GREEN = 2;
public static final int YELLOW = 3;
}
package cn.itcast.test04;
public class TestEnum2 {
}
enum Color11 {
RED("red"){
@Override
public void print1() {
System.out.println("red");
}
},GREEN("green"){
@Override
public void print1() {
System.out.println("green");
}
},YELLOW("yellow") {
@Override
public void print1() {
System.out.println("yellow");
}
};
private Color11(String name) {}
//抽象方法
//当在枚举里面写了抽象方法之后,需要在每个实例上面都实现抽象方法
public abstract void print1();
}
9、枚举的api的操作
package cn.itcast.test04;
import org.junit.Test;
public class TestEnum3 {
//知道枚举的下标,得到枚举的对象和名称
@Test
public void test3() {
int idx2 = 2;
//得到枚举的对象
Color100[] cs = Color100.values();
//根据下标得到对象
Color100 c12 = cs[idx2];
//得到枚举的名称
String name = c12.name();
System.out.println(name);
}
//知道枚举的名称,得到枚举的对象和下标
@Test
public void test2() {
String name1 = "GREEN";
//得到对象
Color100 c1 = Color100.valueOf(name1);
//枚举下标
int idx1 = c1.ordinal();
System.out.println(idx1);
}
//知道枚举的对象,得到枚举名称和下标
@Test
public void test1() {
//得到枚举对象
Color100 c100 = Color100.RED;
//枚举名称
String name = c100.name();
//枚举的下标
int idx = c100.ordinal();
System.out.println(name+" "+idx);
}
}
enum Color100 {
RED,GREEN,YELLOW;
}
package cn.itcast.test05;
/**
* 演示静态导入
* @author asus
*
*/
import static java.lang.System.out;
import static java.util.Arrays.sort;
import static java.util.Arrays.toString;
public class TestDemo1 {
public static void main(String[] args) {
out.println("hello");
int[] arr1 = {10,1,3,20,15};
sort(arr1);
//System.out.println(toString(arr1));//会出错
}
}
package cn.itcast.test06;
public class TestDemo1 {
public static void main(String[] args) {
//自动装箱
Integer i = 10;
//自动拆箱
int m = i;
}
//在jdk1.4里面实现拆装箱
public void test1() {
//装箱
Integer m = new Integer(10);
//拆箱
int a = m.intValue();
}
}
package cn.itcast.test06;
public class TestDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
doSomething(10);
}
public static void doSomething(double m) {
System.out.println("double......");
}
public static void doSomething(Integer a){
System.out.println("integer.....");
}
}
package cn.itcast.test07;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class TestDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
//创建list
List list = new ArrayList();
list.add("aaa");
list.add("bbb");
//使用增强for循环
for(String s : list) {
System.out.println(s);
}
System.out.println("==============================");
//使用迭代器实现
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
package cn.itcast.test07;
import java.util.Arrays;
/**
* 实现一个泛型方法,接受任意类型的数组,颠倒数组中所有元素
* @author asus
*
*/
public class TestDemo2 {
public static void main(String[] args) {
Integer[] arr1 = {10,12,13,14,20};
System.out.println(Arrays.toString(arr1));
//写方法实现颠倒
reverses(arr1);
System.out.println(Arrays.toString(arr1));
System.out.println("====================");
String[] arr2 = {"aa","bb","cc","dd","ff"};
System.out.println(Arrays.toString(arr2));
reverses(arr2);
System.out.println(Arrays.toString(arr2));
}
public static void reverses(T[] arr1) {
/*
* 基本思想:把第一个元素和最后一个元素交换位置,把第二个元素和倒数第二个元素交换位置。。。。
* 交换 长度/2
* */
//遍历数组
for(int i=0;i
package cn.itcast.test08;
/**
* 演示可变参数
* @author asus
*
*/
public class TestDemo1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//int..num;
add1(10,20);
add1(10,20,30);
add1(10,20,30,40);
}
public static void add1(int a,int...nums) {
//nums理解为一个数组,这个数组存储传递过来的参数
//System.out.println(nums.length);
int sum = 0;
//遍历数组
for(int i=0;i
15、反射的原理(理解)
16、使用反射操作类里面的无参数的构造方法(会写)
17、使用反射操作有参数的构造方法(会写)
18、使用反射操作属性(会写)
19、使用泛型操作普通方法(会写)
package cn.itcast.test09;
public class Person {
//属性
private String name;
private String id;
//没有参数的构造方法
public Person() {}
//有参数的构造
public Person(String name, String id) {
this.name = name;
this.id = id;
}
//普通方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
package cn.itcast.test09;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import org.junit.Test;
public class TestDemo1 {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
// 获取Class类
Class clazz1 = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("cn.itcast.test09.Person");
}
//操作普通方法 ,比如操作 setName
@Test
public void test4() throws Exception {
//得到Class类
Class c4 = Class.forName("cn.itcast.test09.Person");
//得到Person实例
Person p4 = (Person) c4.newInstance();
//得到普通方法
//c4.getDeclaredMethods();//得到所有的普通方法
Method m1 = c4.getDeclaredMethod("setName", String.class);
//操作的私有的方法 ,需要设置值是true
//m1.setAccessible(true);
//让setName方法执行 ,执行设置值
m1.invoke(p4, "niuqi");
System.out.println(p4.getName());
}
//操作name属性
@Test
public void test3() {
try {
//得到Class类
Class c2 = Class.forName("cn.itcast.test09.Person");
//得到name属性
//c2.getDeclaredFields();//表示得到所有的属性
//得到Person类的实例
Person p11 = (Person) c2.newInstance();
Field f1 = c2.getDeclaredField("name");
//设置可以操作私有属性
f1.setAccessible(true);
//设置name值
f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";
System.out.println(f1.get(p11)); //相当于 p.name
}catch(Exception e) {
e.printStackTrace();
}
}
//操作有参数的构造方法
@Test
public void test2() throws Exception {
//得到Class
Class c1 = Class.forName("cn.itcast.test09.Person");
//使用有参数的构造方法
//c1.getConstructors();//获取所有的构造方法
//传递是有参数的构造方法里面参数类型,类型使用class形式传递
Constructor cs = c1.getConstructor(String.class,String.class);
//通过有参数的构造方法设置值
//通过有参数的构造方法创建Person实例
Person p1 = (Person) cs.newInstance("lisi","100");
System.out.println(p1.getId()+" "+p1.getName());
}
//操作无参数的构造方法
@Test
public void test1() throws Exception {
//得到Class
Class c3 = Class.forName("cn.itcast.test09.Person");
//得到Person类的实例
Person p = (Person) c3.newInstance();
//设置值
p.setName("zhangsan");
System.out.println(p.getName());
}
}