黑马程序员————张孝祥老师基础加强学习笔记

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

第一节  基础加强概述

java基础加强
1、JDK5.0介绍
新特性
2、静态导入(了解)
作用：导入类中的静态成员
语法：import static java.lang.System.out;
或者import static java.lang.System.*;

3、自动装箱和拆箱
基本类型---->包装类型：装箱
包装类型---->基本类型：拆箱

高速缓存：true、false、byte、介于~128-->+127间的整数 、介于\u0000到\u007F间的字符
因此这些基本类型的包装类对象，是同一个对象。

4、增强for循环：
设计的本意：抛弃迭代器
增强for循环只能遍历数组和实现了Iteratable接口的对象。
语法：
for(元素的类型 变量名:数组或实现了Iteratable接口的对象){
 System.out.println(变量名);
}

增强for循环的特点：只适合取数据。要想在遍历时改元素的值，请使用传统for循环。

5、可变参数
可变参数就当做是数组即可。
一个方法的参数列表中，只能有一个可变参数，且必须放在最后。

6、枚举
7、反射
反射乃框架设计之灵魂。
必须先得到类的字节码对象：Class clazz = Class.forName(类的完整类名);

如何得到类的字节码：
  Class.forName(类的完整类名);
  对象引用名称.getClass();
  类名.class
在反射方法时，如果方法的参数是一个数组，考虑到向下兼容问题，会按照JDK1.4的语法来对待（JVM会把传递的数组参数拆开，拆开就代表参数的个数不匹配）
解决办法：防止JVM拆开你的数组
 方式一：把数组看做是一个Object对象
 方式二：重新构建一个Object数组，那个参数数组作为唯一的元素存在。
 
8、内省
beanutils内省框架(依赖commons-logging)：apache
www.apache.org

9、泛型

 

第二节  静态导入

第三节 自动拆箱装箱

 

 

package cn.itcast.base;
import java.util.ArrayList;
import java.util.List;
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList();
int i = 10;//Integer 
list.add(new Integer(i));
//5.0的做法
int j = 100;
list.add(j);//实际上编译器把基本类型的j自动调用了new Integer(10)，传递给集合
//遍历
int k = (Integer)list.get(1);//自动拆箱
System.out.println(k);
//注意的问题
// Integer ii = null;
// int l = ii;
// System.out.println(l);
System.out.println("-------------------------");
Boolean b1 = true;
Boolean b2 = true;
System.out.println(b1==b2);
Integer i1 = 100;
Integer i2 = 100;
System.out.println(i1==i2);
Integer i3 = 129;
Integer i4 = 129;
System.out.println(i3==i4);
Float f1 = 0.1f;
Float f2 = 0.1f;
System.out.println(f1==f2);
}
}
 

 

第四节  增强for循环

 

 

 

package cn.itcast.base;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
//增强for循环
public class Demo3 {
//数组
@Test //ctrl+1
public void test1(){
String s[] = {"a","b","c"};
for(int i=0;i<s.length;i++){
System.out.println(s[i]);
}
for(String ss:s){
System.out.println(ss);
}
}
@Test
//List
public void test2(){
List l = new ArrayList();
l.add("aa");
l.add("bb");
l.add("cc");
Iterator it = l.iterator();
while(it.hasNext()){
String s = (String)it.next();
System.out.println(s);
}
for(Object obj:l){
// String s = (String)obj;
// System.out.println(s);
System.out.println(obj);
}
}
//传统方式遍历Map
@Test
public void test3(){
Map map = new LinkedHashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
Set keys = map.keySet();
Iterator it = keys.iterator();
while(it.hasNext()){
String key = (String)it.next();
String value = (String) map.get(key);
System.out.println(key+"="+value);
}
}
@Test//增强for遍历map方式一
public void test31(){
Map map = new LinkedHashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
Set keys = map.keySet();
for(Object obj:keys){
String key = (String)obj;
String value = (String) map.get(key);
System.out.println(key+"="+value);
}
}
//传统方式遍历Map
@Test
public void test4(){
Map map = new LinkedHashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
Set me = map.entrySet();
Iterator it = me.iterator();
while(it.hasNext()){
Map.Entry m = (Map.Entry)it.next();
String key = (String) m.getKey();
String value = (String)m.getValue();
System.out.println(key+"="+value);
}
}
@Test//增强for循环遍历map方式二
public void test41(){
Map map = new LinkedHashMap();
map.put("a", "aaa");
map.put("b", "bbb");
map.put("c", "ccc");
for(Object obj:map.entrySet()){
Map.Entry me = (Map.Entry )obj;
String key = (String) me.getKey();
String value = (String)me.getValue();
System.out.println(key+"="+value);
}
}
@Test//增强for的一些细节
public void test5(){
int arr[] = {1,1,1};
for(int i:arr){
i = 10;
}
//循环时改元素的值必须使用传统方式
// for(int i=0;i<arr.length;i++){
// arr[i] = 100;
// }
System.out.println(arr[0]);
}
@Test
public void test6(){
List list = new ArrayList();
list.add("p");
for(Object obj:list){
obj = "ppp";
}
System.out.println(list.get(0));
}
}
 

 

第五节 可变参数

 

package cn.itcast.base;
import org.junit.Test;
//可变参数
public class Demo4 {
//计算任意数量的整数的和
public int sum(int ...args){//可变参数就当做数组来用
int sum = 0;
for(int i:args){
sum+=i;
}
return sum;
}
@Test//如何使用带有可变参数的方法
public void test1(){
int result = sum(1,2,3,4);
System.out.println(result);
}
@Test
public void test2(){
int values[] = {1,2,3,4,5};
int result = sum(values);
System.out.println(result);
}
public String aa(String s2,String...s1){
return null;
}
}
第六节 枚举
package cn.itcast.base.enumeration;
public class Student {
//不优雅
// private String name;
// private String grade;//成绩，只能是ABCDE
// public String getName() {
// return name;
// }
// public void setName(String name) {
// this.name = name;
// }
// public String getGrade() {
// return grade;
// }
// public void setGrade(String grade) {
// if(!grade.matches("[ABCDE]")){
// throw new RuntimeException("非法数值");
// }
// this.grade = grade;
// }
private String name;
private Grade grade;//成绩，只能是ABCDE
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Grade getGrade() {
return grade;
}
public void setGrade(Grade grade) {
this.grade = grade;
}
}
/*
class Grade{
private Grade(){}
public static Grade A = new Grade();
public static Grade B = new Grade();
public static Grade C = new Grade();
public static Grade D = new Grade();
public static Grade E = new Grade();
}*/
enum Grade{//与上面的代码功能完全一样
A("100~90"){
public String toLocaleString(){
return "优秀";
}
},B("89~80"){
public String toLocaleString(){
return "良好";
}
},C("79~70"){
public String toLocaleString(){
return "一般";
}
},D("69~60"){
public String toLocaleString(){
return "刚及格";
}
},E("59~0"){
public String toLocaleString(){
return "不及格";
}
};//代表着自身的一个个的实例对象
// 字段
private String value;// A 100~90 B 89~80 C 79~70 D 69~60 E 59~0
//构造函数，
private Grade(){}
private Grade(String value){
this.value = value;
}
public String getValue() {
return value;
}
public abstract String toLocaleString();
}
/*
private String value; 
private Grade(String value){
this.value = value;
}
public static Grade A = new Grade("dsfdsf"){
public String toLocaleString(){
return "优秀";
}
};
public static Grade B = new Grade();
public static Grade C = new Grade();
public static Grade D = new Grade();
public static Grade E = new Grade();
*/
 

 

 

 

第七节 内省

 

 
package cn.itcast.base.introspector;
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.ConvertUtils;
import org.apache.commons.beanutils.Converter;
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;
import org.junit.Test;
//内省:操作属性的（类中的getter和setter方法）
public class Demo1 {
//属性名称：getClass,他的属性名称class
//getAbc --->abc
@Test
public void test1() throws Exception{
//得到Student类中的属性，被封装到了BeanInfo中
BeanInfo bi = Introspector.getBeanInfo(Student.class);
//得到类中的所有的属性描述器
PropertyDescriptor[] pds = bi.getPropertyDescriptors();
System.out.println(pds.length);
for(PropertyDescriptor pd:pds){
System.out.println(pd.getName());
}
}
@Test
public void test2() throws Exception{
Student s = new Student();
// Class clazz = Class.forName("cn.itcast.base.introspector.Student");
// Student s = (Student)clazz.newInstance();
PropertyDescriptor pd = new PropertyDescriptor("name", Student.class);
Method m = pd.getReadMethod();//得到getName()方法
String value = (String)m.invoke(s, null);
System.out.println(value);
//改变name的值
Method m1 = pd.getWriteMethod();//得到setName()方法
m1.invoke(s, "王翔云");
System.out.println(s.getName());
}
//利用BeanUtils框架操作属性:实现原理类似test2
@Test
public void test3() throws Exception{
Student s = new Student();
//为什么要返回字符串：用户的所有输入都是字符串
String str = BeanUtils.getProperty(s, "name");//调用getName方法
System.out.println(str);
//设置值
BeanUtils.setProperty(s, "name", "王翔云");
System.out.println(s.getName());
}
@Test//BeanUtils可以进行类型的自动转换，但仅限基本类型：本来需要int型，给个字符串，ok
public void test4() throws Exception{
Student s = new Student();
String str = BeanUtils.getProperty(s, "age");
System.out.println(str);
BeanUtils.setProperty(s, "age", "19");
System.out.println(s.getAge());
}
//非基本类型的属性设置
//用户的输入都是String
//String <----->其他类型间的互相转换
//用户看到的结果都是String
@Test
public void test5() throws Exception{
Student s = new Student();
//给BeanUtils注册类型转换器：自定义的转换器
ConvertUtils.register(new Converter() {
//type:目标类型
//value:当前传入的值
public Object convert(Class type, Object value) {
// if(type.equals(Date.class)){
// //字符串转换为Date
// }else{
// //Date转换为字符串
// }
DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
if(value instanceof String){
//字符串转换为Date
String v = (String)value;
Date d;
try {
d = df.parse(v);
} catch (ParseException e) {
throw new RuntimeException(e);
}
return d;
}else{
//Date转换为字符串
Date d = (Date)value;
return df.format(d);
}
}
}, Date.class);
BeanUtils.setProperty(s, "birthday", "1989-10-09");
System.out.println(s.getBirthday());
}
@Test//转换器原理参考test5
public void test51() throws Exception{
Student s = new Student();
ConvertUtils.register(new DateLocaleConverter(), Date.class);
BeanUtils.setProperty(s, "birthday", "1999-10-09");
System.out.println(s.getBirthday());
}
@Test//转换器原理参考test5
public void test6() throws Exception{
Student s = new Student();
ConvertUtils.register(new DateLocaleConverter(), Date.class);
BeanUtils.setProperty(s, "birthday", "1999-10-09");
System.out.println(s.getBirthday());
}
}

第八节   反射

 

package cn.itcast.base.reflect;
import java.lang.reflect.Constructor;
import org.junit.Test;
public class Demo1 {
//反射：public Person()
@Test
public void test1() throws Exception{
//得到字节码
Class clazz = Class.forName("cn.itcast.base.reflect.Person");//代表Person类在内存中的字节码对象
// Class clazz = p.getClass();
// Class clazz = Person.class;
Constructor c = clazz.getConstructor(null);//得到构造方法干嘛？创建对象
c.newInstance(null);
}
@Test
public void test11() throws Exception{
Class clazz = Class.forName("cn.itcast.base.reflect.Person");
Person p = (Person)clazz.newInstance();//调用默认的构造方法
System.out.println(p.name);
}
//反射：public Person(String name)
@Test
public void test2() throws Exception{
//得到字节码
Class clazz = Class.forName("cn.itcast.base.reflect.Person");//代表Person类在内存中的字节码对象
Constructor c = clazz.getConstructor(String.class);
c.newInstance("朱巧玲");
}
@Test//public Person(String name,int age)
public void test3() throws Exception{
Class clazz = Class.forName("cn.itcast.base.reflect.Person");
Constructor c = clazz.getConstructor(String.class,int.class);
Person p = (Person)c.newInstance("朱巧玲",20);
System.out.println(p.name);
}
@Test//private Person(int age)
public void test4() throws Exception{
Class clazz = Class.forName("cn.itcast.base.reflect.Person");
Constructor c = clazz.getDeclaredConstructor(int.class);//读取私有的构造方法的
c.setAccessible(true);//暴力反射
Person p = (Person)c.newInstance(20);
System.out.println(p.name);
}
@Test//类中的所有构造方法
public void test5() throws Exception{
Class clazz = Class.forName("cn.itcast.base.reflect.Person");
Constructor[] cs = clazz.getDeclaredConstructors();
System.out.println(cs.length);
}
}
ackage cn.itcast.base.reflect;
import java.lang.reflect.Field;
import java.util.Date;
import org.junit.Test;
//反射字段：Field
public class Demo3 {
//public String name="传智播客";
@Test
public void test1() throws Exception{
Class clazz = Person.class;
Person p = (Person)clazz.newInstance();
Field f = clazz.getField("name");
String s = (String)f.get(p);
System.out.println(s);
//更改name的值
f.set(p, "上海传智");
System.out.println(p.name);
}
@Test//private int age = 18;
public void test2() throws Exception{
Class clazz = Person.class;
Person p = (Person)clazz.newInstance();
Field f = clazz.getDeclaredField("age");
f.setAccessible(true);
int age = (Integer)f.get(p);
System.out.println(age);
f.set(p, 28);
age = (Integer)f.get(p);
System.out.println(age);
}
@Test//public static Date time;
public void test3() throws Exception{
Class clazz = Person.class;
Field f = clazz.getField("time");
f.set(null, new Date());
System.out.println(Person.time);
}
}