第一天：JAVA基础加强
u 快捷键的配置
ctrl+/ 注释代码 ,再次输入则表示打开注释
ctrl+shift+/ 是以 /* */
ctrl+shift+\ 打开注释
ctrl+1 这是修复错误的快捷键
atl+/ 配合ctrl+1使用来解决可以修复的错误.
ctrl+shift+o 批量导包
alt+left 回到上一次视图
alt+right回到下一个视图
ctrl+shif+f整理源码格式
如何关联源码!!
F3可以打开相应的源码
在jdk下src.zip文件
u 调试功能
原理图 （执行到一个方法后，就新建一个栈，发现它还在调用其它方法，又新建立了一个栈，如果有新的方法会一直建立新的栈，整个过程其实就是递归，回来的时间也是一层一层的）
f5 跳入
f6 跳过
f7 跳出
watch: 点击某个变量，可以查看当前的值.
terminate: 终止这次调试
删除所有断点:
drop to frame: 回到当前的栈顶，重新执行.
resume: 直接跳到下一个断点.
u Junit
Junit是 sun公司提供的一款专业的做测试的框架 (主要用于单元测试)
1. 如何找到junit
2. junit的测试案例1 TestJunit.java
packagecn.itcast.junit;
importorg.junit.Test;
publicclass TestJunit1 {
//测试cry方法
@Test
publicvoid testCry(){
//1.创建Cat 实例
Cat cat=new Cat();
cat.cry();
}
//测试count方法
@Test
publicvoid testCount(){
Cat cat=new Cat();
cat.count(20);
}
}
3. 案例2
packagecn.itcast.junit;
importorg.junit.After;
importorg.junit.Before;
importorg.junit.Test;
publicclass TestJunit2 {
//setUp函数是用于来初始化一些变量，每次调用一个测试方法时间都会调用一次，是运行期间调用的。
@Before
public void setUp() throws Exception {
System.out.println("setUp....");
}
@Test
public void testCry(){
//1.创建Cat 实例
Cat cat=new Cat();
cat.cry();
}
//测试count方法
@Test
public void testCount(){
Cat cat=new Cat();
cat.count(20);
}
//tearDown是用于回收资源
@After
public void tearDown() throws Exception {
System.out.println("tearDown()...");
}
}
setup.....
45
teardown....
setup.....
cry....
teardown....
4. 案例3
packagecn.itcast.junit;
importorg.junit.AfterClass;
importorg.junit.BeforeClass;
importorg.junit.Test;
publicclass TestJunit3 {
static Cat cat = null;
//该函数只会被调用一次，其二、静态方法不能调用动态引用，所以这个对象必须设置为静态的。整个测试只会调用一次，相当于在类加载之前调用。
@BeforeClass
publicstaticvoid setUpBeforeClass()throws Exception {
cat = new Cat();
System.out.println("setUpBeforeClass..");
}
@Test
publicvoid testCry() {
// 1.创建Cat 实例
cat.cry();
}
// 测试count方法
@Test
publicvoid testCount() {
cat.count(20);
}
@AfterClass
publicstaticvoid tearDownAfterClass() throwsException {
System.out.println("tearDownAfterClass...");
}
}
setUpBeforeClass
45
cry....
tearDownAfterClass
u 包装类
u 自动装箱(autoboxing)：把一个基本数据类型直接赋给对应的包装类变量, 或者赋给 Object 变量
u 自动拆箱：把包装类对象直接赋给一个对应的基本类型变量
int--->Integer float-->Float byte-->Bye boolean -->Boolean
char--->Charaterdouble-->Dobule long-->Long short-->Short
Double d = 12321.23;//自动装箱
double d2 = d;//自动拆箱
//经典应用
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(34);
int c = (Integer)list.get(0);
u 增强for循环
1.对数组的操作:
intarr[]={5,7,9,90};
for(int i:arr){
System.out.println(i);
}
2.对list的操作（是有序的，用链表存放，效率较低）:
Listlist=new ArrayList();
list.add("abc");
list.add("ddd");
//对list用增强for
for(Object obj: list){
System.out.println("增强取:"+obj);
}
3.对set集合的操作（set是无序的，底层用数组存放，直接用索引取，效率高）
Setset=new HashSet();
set.add("aaa");
set.add("bbb");
set.add("ccc");
//set的增强取法
for(Object obj:set ){
System.out.println(obj);
}
5. 对map集合的操作
案例1:
packagecn.itcast.enhance;
importjava.util.HashMap;
importjava.util.Iterator;
importjava.util.LinkedHashMap;
importjava.util.Map;
importjava.util.Set;
importjava.util.Map.Entry;
publicclass Demo02 {
/**map的操作
*@paramargs
*/
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
//map不是有序集合，但是LinkedHashMap是有序的，这样可以使map成为有序的。
Map map=new LinkedHashMap();
map.put("aaa", "111");
map.put("bbb", "宋江");
map.put("ccc", "贾宝玉");
//1.传统取法,用迭代器
//取出key的set
Set set=map.keySet();
//取迭代器
Iterator it=set.iterator();
while(it.hasNext()){
//取出key
String key=(String) it.next();
//取出值
String val=(String) map.get(key);
System.out.println(key+"= "+val );
}
System.out.println("map的第二种传统取法");
//1.取出entrySet
Set set2=map.entrySet();
//2.得到迭代器
Iterator it2=set2.iterator();
//3.取出
while(it2.hasNext()){
Map.Entry me= (Map.Entry)it2.next();
System.out.println(me.getKey()+":"+me.getValue());
}
//map的增强取法
//1.取出entrySet
Set set3=map.entrySet();
for(Object obj: set3){ //obj= (Map.Entry) it2.next();
Map.Entry me=(Map.Entry)obj;
System.out.println(me.getKey()+" ::: "+me.getValue());
}
}
}
//对map
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(1, "aaa");
map.put(2, "bb");
map.put(3, "ccc");
//传统1 其思想可见图表
//1.取出key的set
Set<Integer> set = map.keySet();
//2.遍历key 的set,然后取出相应的value
for(Integer i:set){
System.out.println(map.get(i));
}
//传统2,其思想是把map对象形成一个set集合，但是这个set集合里面的类型是Map.Entry
//然后我们去遍历这个Map.Entry即可。
Set entry = (Set)map.entrySet();
Iterator iterator = entry.iterator();
while(iterator.hasNext()){
Map.Entry<Integer, String> set2 = (Entry<Integer,String>) iterator.next();
System.out.println(set2.getKey()+" "+set2.getValue());
}
//增强
Set<Map.Entry<Integer, String>> set3 =map.entrySet();
for(Map.Entry<Integer, String> maps:set3){
System.out.println(maps.getKey()+":::"+maps.getValue());
}
u 可变参数
1. 可变参数可以接受，多个参数值后当做数组对待.
2. 在Arrays.asList()要注意，只能把对象数组，转成List集合
案例说明：
• 调用可变参数的方法时, 编译器将自动创建一个数组保存传递给方法的可变参数，因此，程序员可以在方法体中以数组的形式访问可变参数
• 可变参数只能处于参数列表的最后, 所以一个方法最多只能有一个长度可变的参数
packagecn.itcast.changeparameters;
publicclass Demo1 {
/**
*@paramargs
*/
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
sum("顺平",new Dog(),1,65,-1);
}
//计算多个数的和
publicstaticvoid sum(String name, Dog g,int ... arr){
//可以把arr当做一个数组
for(inti=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
class Dog{
}
案例2 Arrays.asList用法
String str[]={"aa","bbb","ccc","大哥"};
int [] arr={3,6,8};
List list2=Arrays.asList(str);//这里不能放arr int数组.
System.out.println("asList 后");
for(Objectobj: list2)
{
System.out.println(obj);
}
u 枚举
u 一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，此类问题在JDK5以前采用自定义带有枚举功能的类解决，Java5以后可以直接使用枚举予以解决。
1. 提出问题
比如我们给Person { privatre String sex;} 这是如果你不控制，sex可以为任意值.
2. 解决方法
2.1传统解决方法1
//传统解决方法1
classPerson{
private Stringname;
private Stringsex;
public StringgetName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
public StringgetSex() {
returnsex;
}
publicvoid setSex(String sex) {
//看看sex是不是我需要的,事后诸葛亮.
if(!sex.matches("man|woman")){
//不对
throw newRuntimeException("性别值不对");
}
this.sex = sex;
}
}
2.2 传统解决方法2
//定义一个Sex类,目标是让使用者，不能让其创建Sex 对象
finalclass Sex{
publicstatic Sex man=new Sex("男"); //man->"男"
publicstatic Sex woman=new Sex("女"); //woman->"女";
publicstatic Sex middle=new Sex("ddd");
private Stringval;
public StringgetVal() {
returnval;
}
privateSex(String val){
this.val=val;
}
}
l 枚举类具有如下特性：
• 使用内部类给每个枚举实例编写函数print。
• 枚举类也是一种特殊形式的Java类。
• 枚举类中声明的每一个枚举值代表枚举类的一个实例对象。
• 与java中的普通类一样，在声明枚举类时，也可以声明属性、方法和构造函数，但枚举类的构造函数必须为私有的（这点不难理解）。
• 枚举类也可以实现接口、或继承抽象类。
• JDK5中扩展了swith语句，它除了可以接收int, byte, char, short外，还可以接收一个枚举类型。
• 若枚举类只有一个枚举值，则可以当作单态设计模式使用。
2.3直接使用enum来解决
//直接使用enum类型
enum Sex1{
woman,man;
}
案例:1
//用枚举类型来Grade
enum Grade{
其实它们每一个都是一个Grade的实例，相当于new Grade(“及格”)();这样子，就是
说它现在有五个静态实例，可以供你调用，其实sun就是把上面的代码又简化成了这个样子
如果在实例化对象的时间又在后面加了个大括号就相当于继承这个类，所以要重写这个类的一
些抽象方法即可。
a("优秀"),b("良好"),c("一般"),d("及格"),e("不及格");//构造函数.
private Stringval;
public StringgetVal() {
returnval;
}
privateGrade(String val){
this.val=val;
}
}
在枚举中我们之所以要构造方法和一个get方法就是为了给这个属性赋值，如果你不赋值，只写一个a，那么程序得到的就是一个a。也可以用在某些场合。
案例:2, 通过内部类来实现打印对应信息
enumGrade2{
a{
@Override
public String getInfo() {
// TODO Auto-generatedmethod stub
return"优秀";
}
}
,b{
@Override
public String getInfo() {
// TODOAuto-generated method stub
return"良好";
}
}
,c{
@Override
public String getInfo() {
// TODOAuto-generated method stub
return"一般";
}
}
,d{
@Override
public String getInfo() {
// TODOAuto-generated method stub
return"及格";
}
}
,e{
@Override
public String getInfo() {
// TODOAuto-generated method stub
return"不及格";
}
}
;
//提供一个函数去返回a对应的具体的值.
abstractpublic String getInfo();
}
案例3:把enum如何使用到 switch，其中case里面的只能填写Grade里面已经定义的实例，国灰javac编译器发现它是枚举类型后会自动去找它。
Gradeg=Grade.a;
switch(g){
casea:
System.out.println("aaa");
break;
caseb:
System.out.println("bbb");
break;
}
单态设计模式：在开发需求中我们只需要一个实例存在，例如hibernate中的SessionFactory.
Week.Mon.getVal()：过程详解：Week.Mon它是实例化了这个对象相当于new Week(“
星期一”)，这个构造方法就是对成员变量赋值了，然后再调用getVal()方法，来调用这个给成员变量赋的值，即可得到。其实还是一个类，只不过是特殊的。
枚举的几个常用方法举例:
WeekDaywd=WeekDay.Tue;
//返回其名字和在枚举中的位置（从0开始）。
System.out.println(wd.name()+" "+wd.ordinal());
// valueOf()返回带指定名称的指定枚举类型的枚举常量。
WeekDay wd2=wd.valueOf("Mon");==WeekDay wd2 = WeekDay.Mon;
System.out.println(wd2.getLocaleDate());
//遍历枚举值
WeekDay wds[]=wd.values();
for(WeekDay t: wds){
System.out.println(t.getLocaleDate());
}
u 反射技术
1. 提出一个问题
String classPath=”cn.itcast.Cat”
需求，请把该类的所有方法和属性得到.
2. 提出第二个问题
|
<classes>
<class>
<name>cn.itcast.Cat</name>
<methods>
<method>
<name>cry</name>
<parameters>
<parameter>
<name>username</name>
<type>java.lang.String</type>
<value>刘德华</value>
</parameter>
</parameters>
</method>
</methods>
</class>
</classes>
3. 反射原理图
这个图必须要明白，我们首先获得的就是这个JVM中的Class对象（对象的对象）（三种方法），得到这个后，再得到相应的构造函数（getConstructor(…)）对其进行实例化,然后再实例化
newInstance（…）
4. 使用反射技术得到构造函数，并实例化对象
所有的操作都是对Cat.java
packagecn.itcast.reflection;
importjava.util.List;
publicclass Cat {
public Stringname=”麦当劳”;
privateintage;
private String[]foods;
public Cat(){
// TODO Auto-generated constructor stub
}
publicCat(String []foods){
this.foods=foods;
}
publicvoid show(){
System.out.println("猫猫叫w");
}
//添加一个带有参数的函数
publicvoid show(String name){
System.out.println("猫猫叫"+name);
}
//有两个参数的普通函数
publicvoid show(String name,int age){
System.out.println(name+" 年龄是"+age);
}
//猫猫数数
privatevoid count(List list){
for(Object obj: list)
{
System.out.println(obj);
}
}
publicCat(String name,int age){
this.name=name;
this.age=age;
}
public StringgetName() {
returnname;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
returnage;
}
publicvoid setAge(int age) {
this.age = age;
}
publicString[] getFoods() {
returnfoods;
}
publicvoid setFoods(String[] foods) {
this.foods = foods;
}
}
案例1使用默认的构造函数来实例化对象
//使用默认的构造函数来实例化对象
privatestaticvoid test1() throws InstantiationException,
IllegalAccessException {
// TODO Auto-generated method stub
Class clazz=Cat.class;
//实例化Cat newInstance()返回的object对象，如果加泛型就不用再转了。
它实际上调用的是无参构造方法，如果类有有了有参构造方法会把无参的挤掉，所以我们也必须要把无参的写出来，这其实是javabean的基本规范。
Cat cat=(Cat) clazz.newInstance();
//测试
cat.show();
}
案例2
//用 public Cat(String name,int age)来实例化对象
privatestaticvoid test2() throws NoSuchMethodException,
SecurityException,InstantiationException, IllegalAccessException,
IllegalArgumentException,InvocationTargetException {
Class clazz =Cat.class;
//得到该构造方法,希望得到
Constructorc=clazz.getConstructor(String.class,int.class);
//在创建实例之前必须先确定要实例化哪个类型的对象，所以要先得到自己想要构造函数
Cat cat=(Cat) c.newInstance("小白",2); //相当于 Cat cat=new Cat("小白",2);
System.out.println(cat.getName());
cat.show();
}
案例3
//得到 public Cat(String []foods) 构造函数
privatestaticvoid test3() throws NoSuchMethodException,
SecurityException,InstantiationException, IllegalAccessException,
IllegalArgumentException,InvocationTargetException {
//1.得到Class 对象
Class clazz = Cat.class;
//2.通过clazz得打构造
Constructor c=clazz.getConstructor(String[].class);
//3.通过c 来创建Cat 实例直接写new String[]错误的原因是，它会把它当成两个字符串（出现wrong number of arguments的错误），但是我们得到的构造器是一个字符数组，所以要转化成object，或者写成object数组。
//Cat cat=(Cat) c.newInstance((Object) new String[]{"鱼","老鼠"});//因为newInstance接受可变参数,"鱼"，"老鼠" // newInstance("鱼","老鼠")
Cat cat=(Cat) c.newInstance(new Object[]{ new String[]{"鱼","老鼠"}});//因为newInstance接受可变参数,"鱼"，"老鼠" // newInstance("鱼","老鼠")
cat.show();
}
5. 使用反射技术,得到成员函数，并调用.
案例1
//反射 public void show()，并调用.
privatestaticvoid test1() throws Exception {
//1.得到Class对象
Class clazz = Class.forName("cn.itcast.reflection.Cat");
//2.得到show方法
Method m=clazz.getMethod("show",null);
//3.调用
m.invoke(clazz.newInstance(),null); //同学会不好理解clazz.newInstance().invoke(m,"");
}
案例2
////反射public void show(String name)
privatestaticvoid test2() throws Exception {
//反射public void show(String name)
Class clazz = Class.forName("cn.itcast.reflection.Cat");
//得到show(String name)
Method m=clazz.getMethod("show",String.class);
//调用
m.invoke(clazz.newInstance(), "宋江"); // show("宋江");
}
案例3
//反射 public void show(String name,int age)
privatestaticvoid test3() throws Exception {
Class clazz = Class.forName("cn.itcast.reflection.Cat");
Method m=clazz.getMethod("show", String.class,int.class);
m.invoke(clazz.newInstance(), "贾宝玉",12);
}
案例4（演示的是私有的方法如何获得，至于参数个数的只举例一个）
//反射private voidcount(List list)
privatestaticvoid test4() throws Exception {
Class clazz = Class.forName("cn.itcast.reflection.Cat");
//Method m=clazz.getMethod("count", List.class);//当一个函数是私有的，则不能使用 getMethod
Method m=clazz.getDeclaredMethod("count", List.class);
m.setAccessible(true);//暴力访问.
List al=new ArrayList();
al.add(1);al.add(3);
m.invoke(clazz.newInstance(), al);
}
6. 使用反射得到字段
案例1:
//反射public String name="麦当劳";
privatestaticvoid test1() throws Exception {
//Cat cat=new Cat();
Class clazz=Cat.class;
Field f=clazz.getField("name");
//取得f的值.
String name=(String)f.get(clazz.newInstance()); //cat.get(f); //返回Object就是name的值
System.out.println(name);
}
案例2:
//得到private int age;
privatestaticvoid test2() throws Exception {
Class clazz = Cat.class;
Field f=clazz.getDeclaredField("age");
f.setAccessible(true);
//这是创建猫的实例
Cat cat=(Cat) clazz.newInstance();
//给f字段赋值.cat表示给哪个实例赋值.
f.set(cat, 13);
//取出f.get(cat) 取出cat这个实例的f字符的值
System.out.println(f.get(cat));
}