Javaweb学习笔记——(七)——————myexlipse基本使用、jdk5.0新特性及反射讲解
1.debug调试模式:
*使用这种模式,调试程序(看到程序运行停止在这一行)
-显示出来行号
-双击左边,出现一个圆点,表示设置了一个断点
*使用debug as方式,运行程序
-特使是否进入到调试界面,yes
-在断点那里,有一个绿色的条,表示程序停止在这一行,没有向下运行
*可以让程序向下执行:
-使用 step over 快捷键是 F6(单步执行)
-resume F8:表示调试结束,执行直接向下运行
**比如当前的断点之后还有断点,就会跳到下一个断点
**如果当前的断点后面没有断点,程序直接运行结束
*debug另外一个用途
**查看程序的源代码
**F5 step into:进入到方法
**F7 step return:返回
2.myeclipse的快捷键的使用
*代码提示 alt /
*快速导包 ctrl shift o
*单行注释 ctrl /
*去掉单行注释 ctrl /
*多行注释 ctrl shift /
*去掉多行注释 ctrl shift \
*删除行 ctrl d
3.junit的使用
*单元测试
*测试的对象是一个类中的方法
*junit不是Javase的一部分,想要使用导入jar包
**但是,在myeclipse中自带了junit的jar包
*首先junit版本 3.x,4.x
*单元测试方法时候,方法命名规则 public void 方法名() {}
*使用注释方式运行测试方法,在方法的上面
** @Test
-@Test
public 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新特性
jdk1.1、 1.2、 1.4、 5.0 (因为在1.4过后,增加了好多新特性,所以直接没有1.5,直接命名为5.0)
**泛型、 枚举、 静态导入、 自动拆装箱、 增强for循环、 可变参数
**反射
5.泛型的简介
*为什么要使用泛型?
-一般使用在集合上
**比如现在把一个字符串类型的值放入到集合里面,这个时候,这个值放入到集合之后,失去本身的类型,只能是object类型
这个时候,比如想要对这个值进行类型转换,很容易出现类型转换错误,可以通过泛型解决
*在集合上如何使用泛型
-常用集合 list set map
-泛型语法 集合<String> 集合名称 = new 集合<String>();
*在泛型里面写是一个对象,String 不能写基本的数据类型 比如int
**写基本的数据类型对应包装类
byte -- Byte
short -- Short
int -- Integer
long -- Long
float -- Float
double -- Double
char -- Character
boolean Boolean
*在list上使用泛型
List的三种实现方式:ArrayList linkedList Vector
代码
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
// 比如吧aaa值取出来,类型转换,转换成int类型,会类型转换的错误。.
// 遍历list集合 有三种方式 三种
// 普通for循环,增强for,迭代器
// 普通for循环
for (int i = 0; i < list.size(); i++) {
String listStr = list.get(i);
System.out.println(listStr);
}
// 增强for
for (String listStr : list) {
System.out.println(listStr);
}
// 迭代器
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
*在set上使用泛型
*代码
//泛型在set上的使用(唯一性,无序性)
public void testSet() {
Set<String> set = new HashSet<String>();
set.add("www");
set.add("aaa");
set.add("bbb");
set.add("zzz");
set.add("zzz");
//遍历set,有两种方式
//迭代器,增强for
//使用增强for遍历
for (String string : set) {
System.out.println(string);
}
//使用迭代器遍历
Iterator<String> iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
*在map上面使用泛型
-map结构:key-value形式
代码:
Map<String, String> map = new HashMap<String, String>();
map.put("001", "aaa");
map.put("002", "bbb");
map.put("003", "ccc");
//遍历map,有两种遍历方式
//1.获取所有的key,通过key来得到value,使用get方法
//2.获取key和value的关系
//使用第一种方式遍历
//获取所有的key
Set<String> sets = map.keySet();
//遍历所有的key返回的set
for (String key : sets) {
//通过得到的key得到value
String value = map.get(key);
System.out.println(key+" "+value);
}
//使用第二种方式遍历
//得到key和value的关系
Set<Entry<String, String>> sets1 = map.entrySet();
//遍历sets1
for (Entry<String, String> entry : sets1) {
//entry是key和value的关系
String keyv = entry.getKey();
String valuev = entry.getValue();
System.out.println(keyv+" "+valuev);
}.
6.泛型使用在方法上
*定义一个数组,实现指定位置上的数组元素的交换
*方法逻辑相同,只是数据类型不同,这个时候使用泛型方法
* /*
* 使用泛型方法需要定义一个类型 使用大写字母表示T:这个T表示任意的类型 写在返回值之前 void之前 ========表示定义了一个类型
* 这个类型就是T 在下面就可以使用这个类型了
*/
public static <T> void swap1(T[] arr, int a, int b) {
T temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
7.泛型在类上的使用
*在一个类上定义了一个类型,这个类型可以在类里面直接使用
//在类里面就可以直接使用T类型
T aa;
public void test11(T bb){
}
//写一个静态方法,在类上定义的泛型,不能在静态方法中使用
public static void test22(T cc){
}
8.枚举的简介
*什么的枚举
**需要在一定范围内取值,这个值只能是这个范围内中的任意一个。
**现实场景:交通信号灯,有三种颜色,但是每次只能亮里面的任意一个
*使用一个关键字enum :
**代码:
enum Color3 {
RED, GREEN, YELLOW;
}
*枚举的构造方法也是私有的
*特殊枚举的操作
**在枚举类里面有构造方法
**构造方法里面有参数,需要在每个实例上面都写参数
**在枚举类里面有抽象方法
**在枚举的每一个实例里面都重写这个抽象方法
9.枚举的api的操作
** name():返回枚举的名称
** ordinal():枚举的下标
** valueOf(Class<T> enumType, String name):得到枚举的对象
** 还有两个方法,这个两个方法不在api 里面,编译的时候生成两个方法
***valueOf(String name) 转换枚举对象
***values() 获取所有的枚举对象数组
*练习:
1.// 知道枚举的对象,得到枚举的名称和下标
@Test
public void test1() {
// 得到枚举对象
Color100 c100 = Color100.RED;
// 枚举名称
String name = c100.name();
// 枚举下标
int idx = c100.ordinal();
System.out.println(name + " " + idx);
}
2.// 知道枚举的名称,得到枚举的对象和下标
@Test
public void test2() {
String name1 = "GREEN";
// 得到对象
Color100 c1 = Color100.valueOf(name1);
// 枚举下标
int idx1 = c1.ordinal();
System.out.println(idx1);
}
3.// 知道枚举的下标,得到枚举的对象和名称
@Test
public void test3() {
int idx2 = 2;
// 得到枚举的对象
Color100[] cs = Color100.values();
// 根据下标得到对象
Color100 c12 = cs[idx2];
// 得到枚举的名称
String name = c12.name();
System.out.println(name);
}
10.静态导入
*可以再代码里面,直接使用静态导入方式,导入静态方法或者常量
*import static XX.XX.xxx
*import static java.lang.System.out;
*import static java.util.Arrays.sort;
**比如实现一个计算器 在Math类里面
11.自动拆装箱
*装箱:
**把基本的数据类型转换成包装类
*拆箱:
**把包装类转换成基本的数据类型
** //自动装箱
Integer i = 10;
//自动拆箱
int m = i;
**在jdk1.4里面如何实现装箱和拆箱
//在jdk1.4里面实现拆装箱
private void test() {
//装箱
Integer i = new Integer(10);
//拆箱
int i2 = i.intValue();
}
**jdk是向下兼容
比如子jdk1.4里面写的代码,到5.0里面也可以运行
练习:
==执行的结果会调用 doSomething(double d)
==首先在jdk1.4里面是调用这个方法,如果需要调用doSomething(Integer i)这个方法,则需要类型转换,但是jdk1.4不能实现自动拆装箱
==由于jdk是向下兼容的,所以,在jdk1.4调用这个方法,在jdk5.0还是会调用相同的方法
public static void main(String[] args) {
doSomething(1);
}
public static void doSomething(double d) {
System.out.println(1.0);
}
public static void doSomething(Integer i) {
System.out.println(1);
}
** 八种基本的数据类型对应的包装类
*int -- Integer
*char -- Character
12.增强for循环
*语法:for(遍历出来的值 : 要遍历的集合) {}
for (String string : list) {
System.out.println(string);
}
*实现Iterable接口可以使用增强for循环
*在集合上使用增强for循环遍历
list set 实现了Iterator接口,所以可以使用增强for循环
map不能使用增强for循环,没有实现Iterator接口,所以不能使用只增强for循环
*增强for循环出现目的:为了替代迭代器
**增强for底层就是迭代器
13.内容补充
(1).泛型擦除
*首先泛型知识出现在源代码阶段,当编译之后泛型就不存在了
(2).练习:实现一个泛型方法,接受任意类型元素,颠倒数组
*代码:
private static <T> void reverses2(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.可变参数(指数量上的可变)
*可变参数应用场景:
**实现两个数的相加,实现三个数的相加,实现四个数的相加...
--如果实现的多个方法,这些方法里面逻辑基本相同,唯一不同的是传递的参数的个数,可以使用可变参数
*可变参数的定义方法 数据类型...数组的名称
*理解为一个数组, 这个数组存储传递过来的参数
-代码
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)方法的参数列表中的可变参数,必须放在参数的列表之后
-add(int a, int...nums)
15.反射的原理
*应用在一些通用性比较高的代码中
*在后期中的框架中,大多数都是使用反射来实现的
*在框架开发中,都是基于配置文件开发
**在配置文件中配置了类,可以通过反射得到类中的所有内容,可以让类中的某个方法来执行
*类中的所有内容:属性、没有参数的构造方法,有参数的构造方法、普通方法
**反射的原理:
*首先需要把java文件保存到本地硬盘 .java
*编译java文件,成 .class文件
*使用jvm,把class文件通过类加载加载到内存中
*万事万物皆对象,class文件到内存中使用Class类表示
*当使用反射时候,首先需要获取到Class类,得到这个类之后,就可以得到clss文件里面的所有内容了
-包含属性 构造方法 普通方法
*属性通过一个类:Filed
*构造方法通过一个类:Constructor
*普通方法通过一个类:Method
16.使用反射操作类里面的无参数的构造方法
*首先获取到Class类
// 获取class类
Class class1 = Person.class;
Class class2 = new Person().getClass();
Class class3 = Class.forName("com.changeyd.test09.Person");
*比如:对一个类型进行实例化,可以new,如果不使用new,如何获取?
//得到class类
Class class1 = Class.forName("com.changeyd.test09.Person");
//得到Person类的实例
Person person = (Person) class1.newInstance();
-代码:
//操作无参数的构造方法
@Test
public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
//得到class类
Class class1 = Class.forName("com.changeyd.test09.Person");
//得到Person类的实例
Person person = (Person) class1.newInstance();
//设置值
person.setName("Wangji");
System.out.println(person.getName());
}
17.使用反射操作有参数的构造方法
//操作有参数的构造方法
@Test
public void test2() throws NoSuchMethodException, SecurityException, ClassNotFoundException, InstantiationException,
IllegalAccessException, IllegalArgumentException, InvocationTargetException {
// 得到class类
Class class1 = Class.forName("com.changeyd.test09.Person");
// 使用有参数的构造方法
// class1.getConstructors();//获取所有的构造方法
Constructor cs = class1.getConstructor(String.class, String.class);
// 通过有参数的构造方法设置值
// 通过有参数的构造方法来创建Person实例
Person person = (Person) cs.newInstance("lisi", "100");
System.out.println(person.getId() + " " + person.getName());
}
18.使用反射来操作属性
* @Test
public void test3() throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException,
SecurityException, InstantiationException {
try {
// 得到class类
Class class1 = Class.forName("com.changeyd.test09.Person");
// 得到name属性
// class1.getDeclaredFields();//表示得到所有的属性
// 得到Person类的实例
Person person = (Person) class1.newInstance();
//通过这个方法得到属性,参数是属性的名称
Field field = class1.getDeclaredField("name");
//操作的是私有的属性,不让操作,需要设置可以操作私有属性setAccessible(true),可以操作私有属性
field.setAccessible(true);
// 设置name值 set方法,两个参数:第一个参数类的实例,第二个参数是设置的值
field.set(person, "wangwu");// 相当于在p.name = "wangwu";
System.out.println(field.get(person)); // 相当于p.name;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
19.使用泛型来操作普通方法
*使用Method来表示普通方法
*代码
// 普通方法,比如操作 setName
@Test
public void test4() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException,
NoSuchMethodException, SecurityException, InstantiationException, ClassNotFoundException {
// 得到Class类
Class class1 = Class.forName("com.changeyd.test09.Person");
// 得到Person的实例
Person person = (Person) class1.newInstance();
// 得到普通方法
// class1.getDeclaredFields();//得到所有的普通方法
//传递两个参数:第一个参数,方法名称;第二个参数,通过方法设置的值
Method method = class1.getDeclaredMethod("setName", String.class);
// 让setName方法执行,执行设置值
//使用invoke(person, "niuqi");传递两个参数;第一个参数,person实例;第二个参数,设置的值
//执行了invoke方法之后,相当于,执行了setName方法,同事通过这个方法设置了一个值是niuqi。
method.invoke(person, "niuqi");
System.out.println(person.getName());
}
//如果操作的是私有的方法,需要设置值为true
method.setAccessible(true);
*当操作的方法是静态的方法时候,因为静态方法调用的方式是 类名.方法名,不需要类的实例
*使用反射操作静态方法的时候,也是不需要实例
*在invoke方法的第一个参数里面,写一个null
-method.invoke(null, "wangji");
Javaweb学习笔记——(七)——————myexlipse基本使用、jdk5.0新特性及反射讲解的更多相关文章
- Day07 jdk5.0新特性&Junit&反射
day07总结 今日内容 MyEclipse安装与使用 JUnit使用 泛型 1.5新特性 自动装箱拆箱 增强for 静态导入 可变参数方法 枚举 反射 MyEclipse安装与使用(yes) 安装M ...
- JavaSE 学习笔记之Jdk5.0新特性(十九)
Jdk5.0新特性: Collection在jdk1.5以后,有了一个父接口Iterable,这个接口的出现的将iterator方法进行抽取,提高了扩展性. --------------------- ...
- Java基础和JDK5.0新特性
Java基础 JDK5.0新特性 PS: JDK:Java Development KitsJRE: Java Runtime EvironmentJRE = JVM + ClassLibary JV ...
- Java JDK5.0新特性
JDK5.0新特性 虽然JDK已经到了1.8 但是1.5(5.0)的变化是最大的 1. 增强for循环 foreach语句 foreach简化了迭代器 作用: 对存储对象的容器进行迭代 (数组, co ...
- JDK5.0新特性 (Day_07)
JDK5.0新特性 目录 静态导入 自动装箱/拆箱 for-each循环 可变参数 枚举 JDK 5.0 新特性简介 JDK 5.0 的一个重要主题就是通过新增一些特性来简化开发,这些特性包括 ...
- JDK5.0新特性1
目录 静态导入 自动装箱/拆箱 for-each循环 可变参数 枚举 JDK 5.0 新特性简介 JDK 5.0 的一个重要主题就是通过新增一些特性来简化开发,这些特性包括: 静态导入 自动装箱/拆箱 ...
- Jdk5.0新特性
增强for循环:foreach语句,foreach简化了迭代器. 格式:// 增强for循环括号里写两个参数,第一个是声明一个变量,第二个就是需要迭代的容器 for( 元素类型 变量名 : Colle ...
- JDK5.0新特性(静态导入、自动装箱/拆箱、增强for循环、可变参数、枚举、泛形)
JDK5中新增了很多新的java特性,利用这些新语法可以帮助开发人员编写出更加高效.清晰,安全的代码. 这些新特性主要有:1.静态导入2.自动装箱/拆箱3.增强for循环4.可变参数5.枚举6.泛型7 ...
- JavaWeb学习笔记七 事务
什么是事务?一件事情有n个组成单元 ,要么这n个组成单元同时成功,要么n个单元就同时失败.就是将n个组成单元放到一个事务中. mysql的事务 默认的事务:一条sql语句就是一个事务,默认就开启事务并 ...
随机推荐
- CRM模块
- Python装饰器的深入理解
装饰器 #装饰器:本质上是函数,(装饰其他函数)就是为其他函数添加附加功能 #原则: 1.不能修改被装饰的函数的源代码 # 2.不能修改被装饰的函数的调用方式 #实现装饰器知识储备 #1.函数即变量 ...
- hive启动方式
- 使用DataContext和ItemsSource将数据源绑定到ListView上的区别
在最近的一个项目中,将DataView类型的数据源绑定到ListView控件时,发现当DataView的内容发生变化时,前台的ListView控件的内容并没有发生改变,在这里我先贴出前台要绑定数据源的 ...
- Dapper 介绍
转载:http://***/html/itweb/20130918/125194_125199_125210.htm .NET 轻量级 ORM 框架 - Dapper 介绍 Dapper简单介绍: D ...
- TCP的三次握手与四次挥手过程,各个状态名称与含义
三次握手 第一次握手:主机A发送位码为syn=1,随机产生seq number=10001的数据包到服务器,主机B由SYN=1知道,A要求建立联机,此时状态为SYN_SENT: 第二次握手:主机B收到 ...
- Harmonic Number (II) LightOJ - 1245 (找规律?。。。)
题意: 求前n项的n/i 的和 只取整数部分 暴力肯定超时...然后 ...现在的人真聪明...我真蠢 觉得还是别人的题意比较清晰 比如n=100的话,i=4时n/i等于25,i=5时n/i等于20 ...
- 【转载】LCT
原标题:LCT(Link-Cut Tree)详解(蒟蒻自留地) 出处:https://blog.csdn.net/saramanda/article/details/55253627 如果你还没有接触 ...
- Leetcode 191.位1的个数 By Python
编写一个函数,输入是一个无符号整数,返回其二进制表达式中数字位数为 '1' 的个数(也被称为汉明重量). 示例 : 输入: 11 输出: 3 解释: 整数 11 的二进制表示为 00000000000 ...
- 【POJ3613】Cow Relays 离散化+倍增+矩阵乘法
题目大意:给定一个 N 个顶点,M 条边的无向图,求从起点到终点恰好经过 K 个点的最短路. 题解:设 \(d[1][i][j]\) 表示恰好经过一条边 i,j 两点的最短路,那么有 \(d[r+m] ...