java自学笔记之java高新技术

Java高新技术：

import static java.lang.math.*; //静态导入


overload：重载   
override：重写

可变参数： ...；当成数组。

高级for循环：只适合取数据。

自动装箱拆箱：Integer对象在-128 ~ 127之间的对象是相等的。这是一种设计模式，享元模式，flyweight节约内存

枚举： 

public enum WeekDay{
SUN(0),MON(1),TUE(2),WED(3),THT(4),FRI(5),SAT(6)
private WeekDay() {};
private String value;
public WeekDay(value){
this.value = value;


}
public String getValue()
{
return this.value;
}
private WeekDay(int day) {};
}




public enum TrafficLamp{
RED(30){
public TrafficLamp nextLamp()
return GREEN;
}
GREEN(45){
public TrafficLamp nextLamp()
return YELLEO;
}
RED(15){
public TrafficLamp nextLamp()
return RED;
}
public abstract TrafficLamp nextLamp();


private int time;


private TrafficLamp(int time){
this.time = time;
}


}
枚举如果只有一个值就相当于用单台设计模式定义出一个类。

反射的基石 Class类

获得字节码：类名。class  ；对象。getClass ； Class。forName("");
//获得构造方法：
Constructor[] constructors = Class.forName("").getConstructors();
或获取一个 Constructor constructor = Class.forName("").getConstruector(xx.class);
//创建实例对象：
String str = (String) constructor.newInstance(new xx(""));
//跳过构造方法直接获取实例对象：(用缓存保存)
Stirng str = (String)Class.forName("").newInstance();


//获取字段
Field [] fields =  obj.getClass().getFields();
for(Field field : fields)
{
if(field.getType() == String.class())
{
String oldValue = (String)field.get(obj);
String newValue = (String)field.replace('','');
field.set(obj,newValue);
}
}


//获取成员方法
Method method = String.class.getMethod("方法名",参数字节码);
method.invoke(对象,参数);


//反射执行类中的main方法
mainMethod.invok(null,new Object[]{new String[]{"xxx"}});


//数组的反射:


hashCode():哈希算法也称为散列算法，是将数据依特定算法直接指定到一个地址上。hashCode方法实际上返回的就是对象存储的物理地址.


反射实现框架功能：
以前开发的框架可以通过反射调用现在开发的程序。
建一个properties文件。然后读取这个文件的键值对。
InputStream is = new FileInputStream("config.properties");
//properties的加载路径变化
//InputStream is = ReflectTest.class.getClassLoader().getResourceAsStream("com/youxiang/config.properties")
//或者是InputStream is = ReflectTest.class.getResourceAsStream("config.properties");
Properties prop = new Properties();
prop.load(is);
prop.close();
String className = prop.getProperties("className");
Collection collections = (Collection)Class.forName(className);

内省IntorSpector：

主要是对Java Bean属性、方法等的一种处理方法
//PropertyDescriptor来设置和获取值
ReflectPoint rp = new ReflectPoint(3,5);
String propertyName = "x";
PropertyDescriptor pd = new PropertyDescriptor(propertyName,rp.getClass());
Method methodGetX = pd.getReadMethod();
Object retVal = methodGetX.invoke(rp);


//BeanInfo 的 Introspector 来设置和获取值
BeanInfo. beanInfo = Introspector.getBeanInfo(Person.class);
PropertyDescriptors [] pds = beanInfo.getPropertyDescriptors();
for(PropertyDescriptor pd : psd)
{
if(pd.getName().equals(propertyName))
{
Method methodGetX = pd.getReadMethod();
retVal = nethodGetX.invoke(pt);
break;
}
}


//Beanutils工具包来设置和获取值:
需要先将jar包下载导入到工程
BeanUtils.getProperty(rp,"x").getClass().getName();
BeanUtils.setProperty(rp,"x","9");
//操作map
Mao map = new HashMao();
map.put("name","youxiang");
BeanUtils.populate(bean,map);


BeanUtils默认只能转换八种默认数据类型，
如Date类型就不能转换set值。需要注册一个日期转换器，实现Coverter()接口
ConvertUtils.register(new Converter(){
public Object convert(Class type,Object value){
if (value == null) {
return null;
}
if (!(vlaue instanceof String)) {
throw new ConversionException("只支持String类型");
}
String str = (String) value;
if (str.trim().equals("")) {
return null;
}
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
return df.parse(str);
}
},Date.class);


//java7的新特性
Map map={name:"zxx",age:18};
BeanUtils.setProperty(map,"name","1=hm");

注解：annotation

相当于一种标记，Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。
@Deprecated：表示子类要重写（override）父类的对应方法
@Override：表示方法是不建议被使用的。
@SuppressWarnings：表示抑制警告

自定义注解：

 Java中提供了四种元注解，专门负责注解其他的注解
 @Retention元注解，表示需要在什么级别保存该注释信息（生命周期）。可选的RetentionPoicy参数包括：
 RetentionPolicy.SOURCE: 停留在java源文件，编译器被丢掉
 RetentionPolicy.CLASS：停留在class文件中，但会被VM丢弃（默认）
 RetentionPolicy.RUNTIME：内存中的字节码，VM将在运行时也保留注解，因此可以通过反射机制读取注解的信息
 @Target元注解，默认值为任何元素，表示该注解用于什么地方。可用的ElementType参数包括
 ElementType.CONSTRUCTOR: 构造器声明
 ElementType.FIELD: 成员变量、对象、属性（包括enum实例）
 ElementType.LOCAL_VARIABLE: 局部变量声明
 ElementType.METHOD: 方法声明
 ElementType.PACKAGE: 包声明
 ElementType.PARAMETER: 参数声明
 ElementType.TYPE: 类、接口（包括注解类型)或enum声明
 @Documented将注解包含在JavaDoc中
 @Inheried允许子类继承父类中的注解
 

泛型:

是提供給javac编译器使用的，用于限定输入的类型。
用泛型时，如果两边都是用到泛型，两边必须要一样的泛型。
Map<Integer,String> map = new HashMap<Integer,String>();
map.put(1, "aa");
map.put(2, "bb");
map.put(3, "cc");
Set<Map.Entry<Integer, String>> set1 = map.entrySet();
for(Map.Entry<Integer, String> entry: set1){
Integer key = entry.getKey();
String value = entry.getValue();
System.out.println(key+".."+value);
}

1，整个ArrayList<E>称为泛型类型
2，ArrayList<E>中的E称为类型变量或类型参数3，整个ArrayList<Integer>称为参数化的类型
4，ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数。
5，ArrayList<Integer>中的<>念着typeof
6，ArrayList称为原始类型


参数化类型和原始类型是具有兼容性的：Vector<String> c = new Vector();
原始类型可以引用一个参数化类型的对象：Vector c = new Vector<String>();
参数化类型不考虑继承关系。错误：Vector<String> v = new Vector<Object>();
编译器不允许创建参数化类型数组。错误：Vector <Integer> v[] = new Vector<Integer>[20];
通配符：'?'只能对变量进行引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
向上限定：？extends Number：？或者？的子类；
向下限定：？super Integer ：？的父类或者？。

自定泛型：

在方法上定义一个泛型，格式是在返回值前加上“<泛型变量名称>”；public static <T> void doxx(T t);
只有引用类型才能作为泛型方法的实际参数,如String Integer等，基本数据类型如int等不能
泛型也可以使用在异常中。
类型推断：定义的泛型方法代表返回两者的最大公约数：
静态方法使用的泛型只能是定义在方法上的。
//编写一个泛型方法，实现指定位置上的数组元素的交换。
public <T> void swap(T arr[],int pos1,int pos2){
T temp = arr[pos1];
arr[pos1] = arr[pos2];
arr[pos2] = temp;
}
//编写一个泛型方法，接受一个任意数组，颠倒数组输出。
public <T>void reverse(T arr[]){
int  start = 0;
int  end = arr.length-1;


while(true){
if (start>=end) {
break
}
T temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;


start++;
end--;
}
}


如何通过反射获得泛型的参数化类型：
Method generMethod = GenericTest.class.getMethod("genericTypeApp", ArrayList.class);
Type[] genericType = generMethod.getGenericParameterTypes();
System.out.println(genericType[0]);
System.out.println(generMethod.getParameterTypes()[0]);
public static void genericTypeApp(ArrayList<String> a){}

类加载器：ClassLoader

类加载器负责把类加载到Java虚拟机（JVM）中。指定类的名称，类加载器就会定位这个类的定义，每一个Java类必须由类加载器加载。
启动JVM的时候，可以使用三个类加载器：引导（bootstrap）类加载器（第一个加载器它不是java类）、扩展（extensions）类加载器、应用程序（application）类加载器。
得到类加载名称：类.class.getClassLoader().getClass().getName();
当处理类加载器时，父委托模式是一个需要理解的关键概念。它规定：类加载器在加载自己的类之前，可以委托先加载父类。
父类加载器可以是客户化的类加载器或者引导类加载器。但是有一点很重要，类加载器只能委托自己的父类加载器，而不能是子类加载器（只能向上不能向下）。

全盘负责 委托机制

classloader 加载类用的是全盘负责委托机制。
全盘负责：即是当一个classloader加载一个Class的时候，这个Class所依赖的和引用的其它Class通常也由这个classloader负责载入。
委托机制：先让parent（父）类加载器寻找，只有在parent找不到的时候才从自己的类路径中去寻找。
类加载还采用了cache机制：如果cache中保存了这个Class就直接返回它，如果没有才从文件中读取和转换成Class，并存入cache，这就是为什么修改了Class但是必须重新启动JVM才能生效,并且类只加载一次的原因。

自定义类加载器：

1、 自定义的类加载器必须继承ClassLoader。
2、 ClassLoader中有loadClass()和findclass()两个方法，loadClass()方法实现了委托机制，findClass()方法辅负责自己加载类，因此我们只需重写findClass()方法
3、 defineClass()方法。通过findClass()得到class文件中的二进制数据后，用findClass()方法将其转换为字节码。

代理和动态代理：

动态代理: JVM可以在运行期动态生成类的字节码,这种动态生成往往被用作代理类,即为动态代理.
jvm生成的动态类必须实现一个或多个接口，所以，jvm生成的动态类只能用作具有相同接口的目标类的代理。
其实动态代理机制最核心的就是InvocationHandler(调用处理器)这个接口InvocationHandler 是代理实例的调用处理程序 实现的接口。
代理对象：代理类所生成的对象。
目标对象：代理类所代理的那个类生成的对象。