JavaWeb基础教程之Java基础加强版

1、myeclipse的安装和使用

* 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 application
debug as java application

2、debug的调试模式（断点调试模式）

* 使用这种模式，调试程序（看到程序里面数据的变化）
* 使用debug第一步需要设置一个断点（让程序运行停止在这一行）
- 显示出来行号
- 双击左边，出现一个圆点，表示设置了一个断点
* 使用debug as方式，运行程序
- 提示是否进入到调试界面，yes
- 在断点那一个，有一个绿色条，表示程序停止在这一行，没有向下运行
* 可以让程序向下执行，
- 使用 step over 快捷键是 f6（单步执行）
- resume f8：表示调试结束，直接向下运行
** 比如当前的断点之后还有断点，跳到下一个断点，
**　如果当前断点后面没有断点，程序直接运行结束
* debug另外一个用途
** 查看程序的源代码
** f5 step into：进入到方法
** f7 step return :返回

3、myeclipse的快捷键的使用

* 代码提示 alt /
* 快速导包 ctrl shift o
* 单行注释 ctrl /
* 去掉单行注释 ctrl /
* 多行注释 ctrl shift /
* 去掉多行注释 ctrl shift \
* 删除行 ctrl d

4、junit的使用

* 单元测试
* 测试对象是 是一个类中的方法
* juint不是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新特性
jdk 1.1 1.2 1.4 5.0
** 泛型、枚举、静态导入、自动拆装箱、增强for、可变参数
** 反射

5、泛型的简介

* 为什么要使用泛型？
- 一般使用在集合上
** 比如现在把一个字符串类型的值放入到集合里面，这个时候，这个值放入到集合之后，失去本事的类型，只能是object类型，
这个时候，比如想要对这个值进行类型转换，很容易出现类型转换错误，怎么解决这个问题，可以使用泛型来解决
* 在集合上如何使用泛型
- 常用集合 list set map
- 泛型语法 集合<string> 比如 list<string>
* 在泛型里面写是一个对象，string 不能写基本的数据类型 比如int (****)
** 写基本的数据类型对应包装类
byte -- byte
short -- short
int -- integer
long -- long
float -- float
double -- double
char -- character
boolean -- boolean
* 在list上使用泛型
list的三种实现 arraylist linkedlist vector
代码：
@test
public 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("=================");
//使用增强for
for (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集合上
@test
public 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上使用泛型
@test
public 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的关系
//使用第一种方式遍历
//获取所有的key
set<string> 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<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>
* =======表示定义了一个类型 这个类型是 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、泛型在类上的使用（了解）

* 在一个类上定义一个类型，这个类型可以在类里面直接使用
* public class testdemo04<t> {
//在类里面可以直接使用t的类型
t aa;
public void test11(t bb) {}
//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用
public static <a> void test12(a cc) {}
}

8、枚举的简介

* 什么是枚举？
** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。
** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个
* 使用一个关键字 enum
** enum color3 {
red,green,yellow;
}
* 枚举的构造方法也是私有的
* 特殊枚举的操作（了解）
** 在枚举类里面有构造方法
** 构造方法里面有参数，需要在每个实例上面都写参数
** 在枚举类里面有抽象方法
** 在枚举的每个实例里面都重写这个抽象方法

9、枚举的api的操作

** name() ：返回枚举的名称
** ordinal() ：枚举的下标，下标从0开始
** valueof(class<t> enumtype, string name) ：得到枚举的对象
** 还有两个方法，都是这两个方法不在api里面，编译的时候生成两个方法
*** valueof(string name) 转换枚举对象
*** values() 获得所有枚举对象数组
* 练习：枚举对象、枚举对象下标、枚举对象名称表示之间的转换
- //知道枚举的对象，得到枚举名称和下标
@test
public void test1() {
//得到枚举对象
color100 c100 = color100.red;
//枚举名称
string name = c100.name();
//枚举的下标
int idx = c100.ordinal();
system.out.println(name+" "+idx);
}
- //知道枚举的名称，得到枚举的对象和下标
@test
public void test2() {
string name1 = "green";
//得到对象
color100 c1 = color100.valueof(name1);
//枚举下标
int idx1 = c1.ordinal();
system.out.println(idx1);
}
- //知道枚举的下标，得到枚举的对象和名称
@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里面实现拆装箱
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循环（*****）

* 语法 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）练习：实现一个泛型方法，接受任意类型的数组，颠倒数组中所有元素
代码
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、可变参数

* 可变参数可以应用在什么场景：
** 实现两个数的相加，实现三个数的相加 四个数的相加
-- 如果实现的多个方法，这些方法里面逻辑基本相同，唯一不同的是传递的参数的个数，可以使用可变参数
* 可变参数的定义方法 数据类型...数组的名称
* 理解为一个数组，这个数组存储传递过来的参数
- 代码
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、反射的原理（********理解********）

* 应用在一些通用性比较高的代码 中
* 后面学到的框架，大多数都是使用反射来实现的
* 在框架开发中，都是基于配置文件开发
** 在配置文件中配置了类，可以通过反射得到类中的 所有内容，可以让类中的某个方法来执行
* 类中的所有内容：属性、没有参数的构造方法、有参数的构造方法、普通方法
* 画图分析反射的原理
* 首先需要把java文件保存到本地硬盘 .java
* 编译java文件，成.class文件
* 使用jvm，把class文件通过类加载加载到内存中
* 万事万物都是对象，class文件在内存中使用class类表示
* 当使用反射时候，首先需要获取到class类，得到了这个类之后，就可以得到class文件里面的所有内容
- 包含属性 构造方法 普通方法
* 属性通过一个类 filed
* 构造方法通过一个类 constructor
* 普通方法通过一个类 method

16、使用反射操作类里面的无参数的构造方法（**会写**）

* 首先获取到class类
- // 获取class类
class clazz1 = person.class;
class clazz2 = new person().getclass();
class clazz3 = class.forname("cn.itcast.test09.person");
* 比如： 要对一个类进行实例化，可以new，不使用new，怎么获取？
- //得到class
class c3 = class.forname("cn.itcast.test09.person");
//得到person类的实例
person p = (person) c3.newinstance();
* 代码
//操作无参数的构造方法
@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());
}

17、使用反射操作有参数的构造方法（**会写**）

//操作有参数的构造方法
@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());
}

18、使用反射操作属性（**会写**）

* //操作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");
//操作的是私有的属性，不让操作，需要设置可以操作私有属性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、使用泛型操作普通方法（**会写**）

* 使用method类表示普通方法
* 代码
//操作普通方法 ，比如操作 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);
//让setname方法执行 ，执行设置值
//使用invoke(p4, "niuqi");传递两个参数：第一个参数，person实例；第二个参数，设置的值
//执行了invoke方法之后，相当于，执行了setname方法，同时通过这个方法设置了一个值是niuqi
m1.invoke(p4, "niuqi");
system.out.println(p4.getname());
}
* //操作的私有的方法 ，需要设置值是true
* //m1.setaccessible(true);
* 当操作的方法是静态的方法时候，因为静态方法调用方式是 类名.方法名，不需要类的实例
* 使用反射操作静态方式时候，也是不需要实例
* 在invokie方法的第一个参数里面，写一个 null
- m1.invoke(null, "niuqi");

以上所述是小编给大家介绍的javaweb基础教程之java基础加强版，希望对大家有所帮助