1、myeclipse的安装和使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
* eclipse：是一个免费的开发工具* myeclipse：是一个收费的插件，破解myeclipse，** 安装目录的要求： 不能有中文和空格** 安装完成之后，选择一个工作空间 ，这个工作空间不能有中文和空格* 破解myeclipse** 运行run.bat文件，但是运行之前，必须要安装jdk，通过配置环境变量* myeclipse的使用* 创建一个工程 - 类型 java project web project- 选择依赖的jdk，可以使用myeclipse自带的jdk，或者可以使用安装的jdk* 创建包 package- cn.itcast.test XX.XX.XX* 在包里面创建一个类- 类的命名规范：** 首字母要大写比如： TestDemo1 UserManager* 在类里面创建方法public void test1(参数列表) {方法体或者返回值;} - 方法的命名规范首字母小写 比如：addNum()* 定义变量- 变量的命名规范** 首字母小写，第二个单词的首字母要大写 ，比如 userName* 这些命名还有一种方式** 使用汉语拼音命名 yonghuming mima** 不能把汉语拼音和英文字母混合使用userMing* 命名的最基本的原则：看到名字知道是什么含义* 代码需要有缩进* 运行程序 run as java applicationdebug as java application |
2、debug的调试模式（断点调试模式）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
* 使用这种模式，调试程序（看到程序里面数据的变化）* 使用debug第一步需要设置一个断点（让程序运行停止在这一行）- 显示出来行号- 双击左边，出现一个圆点，表示设置了一个断点* 使用debug as方式，运行程序- 提示是否进入到调试界面，yes- 在断点那一个，有一个绿色条，表示程序停止在这一行，没有向下运行* 可以让程序向下执行，- 使用 step over 快捷键是 F6（单步执行）- resume F8：表示调试结束，直接向下运行** 比如当前的断点之后还有断点，跳到下一个断点，** 如果当前断点后面没有断点，程序直接运行结束* debug另外一个用途** 查看程序的源代码** F5 step into：进入到方法** F7 step return :返回 |
3、myeclipse的快捷键的使用
|
1
2
3
4
5
6
7
|
* 代码提示 alt /* 快速导包 ctrl shift o* 单行注释 ctrl /* 去掉单行注释 ctrl /* 多行注释 ctrl shift /* 去掉多行注释 ctrl shift \* 删除行 ctrl d |
4、junit的使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
* 单元测试* 测试对象是 是一个类中的方法* juint不是javase的一部分，想要使用导入jar包** 但是，在myeclipse中自带了junit的jar包* 首先junit版本 3.x 4.x* 单元测试方法时候，方法命名规则 public void 方法名() {}* 使用注解方式运行测试方法, 在方法的上面** @Test：表示方法进行单元测试--- @Testpublic void testAdd1() {TestJunit test01 = new TestJunit();test01.testAdd(2, 3);}- 选中方法名称，右键运行 点击run as --- junit test- 当出现绿色条，表示方法测试通过- 当出现了红棕色条，表示方法测试不通过--- 要运行类中的多个测试方法，点击类中的其他位置，run as --- junit test** @Ignore ：表示这个方法不进行单元测试** @Before: 在每个方法执行运行** @After：在每个方法之后运行** 断言（了解）- Assert.assertEquals("测试期望的值", "方法运行的实际的值")jdk5.0新特性jdk 1.1 1.2 1.4 5.0** 泛型、枚举、静态导入、自动拆装箱、增强for、可变参数** 反射 |
5、泛型的简介
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
* 为什么要使用泛型？- 一般使用在集合上** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决* 在集合上如何使用泛型- 常用集合 list set map- 泛型语法 集合<String> 比如 List<String>* 在泛型里面写是一个对象，String 不能写基本的数据类型 比如int (****)** 写基本的数据类型对应包装类byte -- Byteshort -- Shortint -- Integerlong -- Longfloat -- Floatdouble -- Doublechar -- Characterboolean -- Boolean* 在list上使用泛型list的三种实现 ArrayList linkedList Vector代码：@Testpublic void testList() {List<String> list = new ArrayList<String>();list.add("aaa");list.add("bbb");list.add("ccc");//遍历list集合 有几种方式 三种//普通for循环 迭代器 增强for//普通for循环for(int i=0;i<list.size();i++) {String s = list.get(i);System.out.println(s);}System.out.println("=================");//使用增强forfor (String s1 : list) {System.out.println(s1);}System.out.println("=================");//使用迭代器遍历Iterator<String> it = list.iterator();while(it.hasNext()) {System.out.println(it.next());}* 作业1： ArrayList linkedList Vector 这三个区别* 在set上使用泛型代码：//泛型使用set集合上@Testpublic void testSet() {Set<String> set = new HashSet<String>();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<String> it1 = set.iterator();while(it1.hasNext()) {System.out.println(it1.next());}}* 在map上面使用泛型- map结构：key-valu形式代码：//在map上使用泛型@Testpublic void testMap() {Map<String,String> map = new HashMap<String,String>();map.put("aaa", "111");map.put("bbb", "222");map.put("ccc", "333");//遍历map 有几种遍历方式 两种// 1、获取所有的key，通过key得到value 使用get方法// 2、获取key和value的关系//使用第一种方式遍历//获取所有的keySet<String> sets = map.keySet();//遍历所有key返回的setfor (String key : sets) {//通过key得到valueString value = map.get(key);System.out.println(key+" : "+value);}System.out.println("==============");//得到key和value的关系Set<Entry<String, String>> sets1 = map.entrySet();//遍历sets1for (Entry<String, String> entry : sets1) {//entry是key和value关系String keyv = entry.getKey();String valuev = entry.getValue();System.out.println(keyv+" : "+valuev);}} |
6、泛型使用在方法上
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
* 定义一个数组，实现指定位置上数组元素的交换* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法* /** 使用泛型方法 需要定义一个类型 使用大写字母表示 T :这个T表示任意的类型* 写在返回值之前 void之前 <T>* =======表示定义了一个类型 这个类型是 T* 在下面就可以使用这个类型了 T* */public static <T> void swap1(T[] arr ,int a,int b) {T temp = arr[a];arr[a] = arr[b];arr[b] = temp;}** 作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素 |
7、泛型在类上的使用（了解）
|
1
2
3
4
5
6
7
8
|
* 在一个类上定义一个类型，这个类型可以在类里面直接使用* public class TestDemo04<T> {//在类里面可以直接使用T的类型T aa;public void test11(T bb) {}//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用public static <A> void test12(A cc) {}} |
8、枚举的简介
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
* 什么是枚举？** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个* 使用一个关键字 enum** enum Color3 {RED,GREEN,YELLOW;}* 枚举的构造方法也是私有的* 特殊枚举的操作（了解）** 在枚举类里面有构造方法** 构造方法里面有参数，需要在每个实例上面都写参数** 在枚举类里面有抽象方法** 在枚举的每个实例里面都重写这个抽象方法 |
9、枚举的api的操作
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
** name() ：返回枚举的名称** ordinal() ：枚举的下标，下标从0开始** valueOf(Class<T> enumType, String name) ：得到枚举的对象** 还有两个方法，都是这两个方法不在api里面，编译的时候生成两个方法*** valueof(String name) 转换枚举对象*** values() 获得所有枚举对象数组* 练习：枚举对象、枚举对象下标、枚举对象名称表示之间的转换- //知道枚举的对象，得到枚举名称和下标@Testpublic void test1() {//得到枚举对象Color100 c100 = Color100.RED;//枚举名称String name = c100.name();//枚举的下标int idx = c100.ordinal();System.out.println(name+" "+idx);}- //知道枚举的名称，得到枚举的对象和下标@Testpublic void test2() {String name1 = "GREEN";//得到对象Color100 c1 = Color100.valueOf(name1);//枚举下标int idx1 = c1.ordinal();System.out.println(idx1);}- //知道枚举的下标，得到枚举的对象和名称@Testpublic void test3() {int idx2 = 2;//得到枚举的对象Color100[] cs = Color100.values();//根据下标得到对象Color100 c12 = cs[idx2];//得到枚举的名称String name = c12.name();System.out.println(name);} |
10、静态导入(了解)
|
1
2
3
4
5
|
* 可以在代码里面，直接使用静态导入方式，导入静态方法或者常量* import static XX.XX.xxx* import static java.lang.System.out;import static java.util.Arrays.sort;** 比如现在实现一个计算器 在Math类里面 |
11、自动拆装箱
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
* 装箱** 把基本的数据类型转换成包装类* 拆箱** 把包装类转换成基本的数据类型** //自动装箱Integer i = 10;//自动拆箱int m = i;** 在jdk1.4里面如何实现装箱和拆箱- //在jdk1.4里面实现拆装箱public void test1() {//装箱Integer m = new Integer(10); //拆箱 int a = m.intValue();}** jdk是会向下兼容- 比如 jdk1.4里面写的代码，这个时候到5.0里面也可以运行** 练习：向下兼容== 执行的结果是会调用 doSomething(double m)== 首先在jdk1.4里面肯定调用这个方法，如果调用下面的方法，需要类型转换，但是jdk1.4不能实现自动拆装箱== 由于jdk是向下兼容，所以，在jdk1.4调用这个方法，在jdk5.0里面还是会调用这个方法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.....");}** 记住：八种基本的数据类型对应的包装类* int --- Integer* char--- Character |
12、增强for循环（*****）
|
1
2
3
4
5
6
7
8
9
10
|
* 语法 for(遍历出来的值 : 要遍历的集合) {}- for(String s : list) {System.out.println(s);}* 使用场景： 数组；实现Iterable接口的集合 可以使用增强for循环* 在集合上使用增强for循环遍历list set 实现了Iterator接口，所以可以使用增强for循环map不能使用增强for循环，没有实现Iterator接口，所以不能使用增强for循环* 增强for循环出现目的：为了替代迭代器** 增强for底层就是迭代器实现的 |
13、内容补充
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
（1）泛型擦除* 首先泛型只是出现在源代码阶段，当编译之后泛型不存在了（2）练习：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素代码public static <T> void reverses(T[] arr1) {/** 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。* 交换 长度/2* *///遍历数组for(int i=0;i<arr1.length/2;i++) {/*int temp = arr1[0];arr1[0] = arr1[arr1.length-1];*/T temp = arr1[i];arr1[i] = arr1[arr1.length-i-1];arr1[arr1.length-i-1] = temp;}} |
14、可变参数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
* 可变参数可以应用在什么场景：** 实现两个数的相加，实现三个数的相加 四个数的相加-- 如果实现的多个方法，这些方法里面逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数* 可变参数的定义方法 数据类型...数组的名称* 理解为一个数组，这个数组存储传递过来的参数- 代码public static void add1(int...nums) {//nums理解为一个数组，这个数组存储传递过来的参数//System.out.println(nums.length);int sum = 0;//遍历数组for(int i=0;i<nums.length;i++) {sum += nums[i];}System.out.println(sum);}* 注意的地方（1）可变参数需要写在方法的参数列表中，不能单独定义（2）在方法的参数列表中只能有一个可变参数（3）方法的参数列表中的可变参数，必须放在参数最后- add1(int a,int...nums) |
15、反射的原理（********理解********）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
* 应用在一些通用性比较高的代码 中* 后面学到的框架，大多数都是使用反射来实现的* 在框架开发中，都是基于配置文件开发** 在配置文件中配置了类，可以通过反射得到类中的 所有内容，可以让类中的某个方法来执行* 类中的所有内容：属性、没有参数的构造方法、有参数的构造方法、普通方法* 画图分析反射的原理* 首先需要把java文件保存到本地硬盘 .java* 编译java文件，成.class文件* 使用jvm，把class文件通过类加载加载到内存中* 万事万物都是对象，class文件在内存中使用Class类表示* 当使用反射时候，首先需要获取到Class类，得到了这个类之后，就可以得到class文件里面的所有内容- 包含属性 构造方法 普通方法* 属性通过一个类 Filed* 构造方法通过一个类 Constructor* 普通方法通过一个类 Method |
16、使用反射操作类里面的无参数的构造方法（**会写**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
* 首先获取到Class类- // 获取Class类Class clazz1 = Person.class;Class clazz2 = new Person().getClass();Class clazz3 = Class.forName("cn.itcast.test09.Person");* 比如： 要对一个类进行实例化，可以new，不使用new，怎么获取？- //得到ClassClass c3 = Class.forName("cn.itcast.test09.Person");//得到Person类的实例Person p = (Person) c3.newInstance();* 代码//操作无参数的构造方法@Testpublic void test1() throws Exception {//得到ClassClass c3 = Class.forName("cn.itcast.test09.Person");//得到Person类的实例Person p = (Person) c3.newInstance();//设置值p.setName("zhangsan");System.out.println(p.getName());} |
17、使用反射操作有参数的构造方法（**会写**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//操作有参数的构造方法@Testpublic void test2() throws Exception {//得到ClassClass 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());} |
18、使用反射操作属性（**会写**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
* //操作name属性@Testpublic 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");//操作的是私有的属性，不让操作，需要设置可以操作私有属性setAccessible(true),可以操作私有属性f1.setAccessible(true);//设置name值 set方法，两个参数：第一个参数类的实例，第二个参数是设置的值f1.set(p11, "wangwu"); //相当于 在 p.name = "wangwu";System.out.println(f1.get(p11)); //相当于 p.name}catch(Exception e) {e.printStackTrace();}} |
19、使用泛型操作普通方法（**会写**）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
* 使用Method类表示普通方法* 代码//操作普通方法 ，比如操作 setName@Testpublic 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);//让setName方法执行 ，执行设置值//使用invoke(p4, "niuqi");传递两个参数：第一个参数，person实例；第二个参数，设置的值//执行了invoke方法之后，相当于，执行了setName方法，同时通过这个方法设置了一个值是niuqim1.invoke(p4, "niuqi");System.out.println(p4.getName());}* //操作的私有的方法 ，需要设置值是true* //m1.setAccessible(true);* 当操作的方法是静态的方法时候，因为静态方法调用方式是 类名.方法名，不需要类的实例* 使用反射操作静态方式时候，也是不需要实例* 在invokie方法的第一个参数里面，写一个 null- m1.invoke(null, "niuqi"); |
以上所述是小编给大家介绍的JavaWeb基础教程之Java基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对服务器之家网站的支持！
