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

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

- 泛型语法 集合 比如 List

* 在泛型里面写是一个对象，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 list = new ArrayList();

list.add("aaa");

list.add("bbb");

list.add("ccc");

//遍历list集合 有几种方式 三种

//普通for循环 迭代器 增强for

//普通for循环

for(int i=0;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 it = list.iterator();

while(it.hasNext()) {

System.out.println(it.next());

}

* 作业1： ArrayList linkedList Vector 这三个区别

* 在set上使用泛型

代码：

//泛型使用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());

}

}

* 在map上面使用泛型

- map结构：key-valu形式

代码：

//在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);

}

}

6、泛型使用在方法上

* 定义一个数组，实现指定位置上数组元素的交换

* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法

* /*

* 使用泛型方法 需要定义一个类型 使用大写字母表示 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;

}

** 作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素

7、泛型在类上的使用（了解）

* 在一个类上定义一个类型，这个类型可以在类里面直接使用

* public class TestDemo04 {

//在类里面可以直接使用T的类型

T aa;

public void test11(T bb) {}

//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用

public static void test12(A cc) {}

}

8、枚举的简介

* 什么是枚举？

** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。

** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个

* 使用一个关键字 enum

** enum Color3 {

RED,GREEN,YELLOW;

}

* 枚举的构造方法也是私有的

* 特殊枚举的操作（了解）

** 在枚举类里面有构造方法

** 构造方法里面有参数，需要在每个实例上面都写参数

** 在枚举类里面有抽象方法

** 在枚举的每个实例里面都重写这个抽象方法

9、枚举的api的操作

** name() ：返回枚举的名称

** ordinal() ：枚举的下标，下标从0开始

** valueOf(Class 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 void reverses(T[] arr1) {

/*

* 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。

* 交换 长度/2

* */

//遍历数组

for(int i=0;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

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基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

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 it = list.iterator();

while(it.hasNext()) {

System.out.println(it.next());

}

* 作业1： ArrayList linkedList Vector 这三个区别

* 在set上使用泛型

代码：

//泛型使用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());

}

}

* 在map上面使用泛型

- map结构：key-valu形式

代码：

//在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);

}

}

6、泛型使用在方法上

* 定义一个数组，实现指定位置上数组元素的交换

* 方法逻辑相同，只是数据类型不同，这个时候使用泛型方法

* /*

* 使用泛型方法 需要定义一个类型 使用大写字母表示 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;

}

** 作业2： 实现一个泛型方法，接受任意一个数组，颠倒数组中所有元素

7、泛型在类上的使用（了解）

* 在一个类上定义一个类型，这个类型可以在类里面直接使用

* public class TestDemo04 {

//在类里面可以直接使用T的类型

T aa;

public void test11(T bb) {}

//写一个静态方法 在类上面定义的泛型，不能再静态方法里面使用

public static void test12(A cc) {}

}

8、枚举的简介

* 什么是枚举？

** 需要在一定的范围内取值，这个值只能是这个范围内中的任意一个。

** 现实场景：交通信号灯，有三种颜色，但是每次只能亮三种颜色里面的任意一个

* 使用一个关键字 enum

** enum Color3 {

RED,GREEN,YELLOW;

}

* 枚举的构造方法也是私有的

* 特殊枚举的操作（了解）

** 在枚举类里面有构造方法

** 构造方法里面有参数，需要在每个实例上面都写参数

** 在枚举类里面有抽象方法

** 在枚举的每个实例里面都重写这个抽象方法

9、枚举的api的操作

** name() ：返回枚举的名称

** ordinal() ：枚举的下标，下标从0开始

** valueOf(Class 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 void reverses(T[] arr1) {

/*

* 基本思想：把第一个元素和最后一个元素交换位置，把第二个元素和倒数第二个元素交换位置。。。。

* 交换 长度/2

* */

//遍历数组

for(int i=0;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

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基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

/*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

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基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

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基础加强版，希望对大家有所帮助，如果大家有任何疑问请给我留言，会及时回复大家的。在此也非常感谢大家对我们网站的支持！

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。