黑马程序员-lesson10 jcjq

各种简写：
IDE:Integrated Development Envirenment
java ee: Java 2 Platform Enterprise Edition，JavaEE的核心是EJB3.0
jms:
jmx:
jndi:


透视图Perspective与视图view。


良好的习惯，每个类都要有包名。
配置快捷键。content Assist。配置、JAVA、模板。


编译环境与运行环境。高版本的可以运行低版本编译的程序。
Add JAR与ADD外部JAR与Addlibrary。


import语句导入一个类或某个包中的所有类。
import static语句导入一个类中的某个静态方法或所有静态方法。
例：
import static java.lang.Math.max;
import static java.lang.Math.*;


overload与override区别：
override（重写） 
1、方法名、参数、返回值相同。
2、子类方法不能缩小父类方法的访问权限。
3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4、存在于父类和子类之间。
5、方法被定义为final不能被重写。
overload（重载）
1、参数类型、个数、顺序至少有一个不相同。  
2、不能重载只有返回值不同的方法名。
3、存在于父类和子类、同类中。


int... arg 可变参数，只能存在与参数列表的最后一和，以数组的方法来访问可变参数。


for循环增强：
for(type 变量名:集合变量名){……}//就是foreach，在JDK5提出泛化的时候加的


基本数据类型的自动装箱与拆箱。
装箱Integer iobj = 3;
拆箱System.out.print(iobj+12);


基本类型的数据如整数装箱-128～127会等于也就是不创建新对象，而超出的则会不等（==）。
当对象很小并且经常使用，享元模式flyweight，内部状态外部状态。



枚举：
13。枚举类
public enum WeekDay{xx,xx,dd,ff,gg}
public enum WeekDay
{
xx(1),xx(0),dd(),ff,gg//跟括号就是指向调用此枚举指向的构造方法。
private WeekDay(){}
private WeekDay(ina day){}
}




public enum Tra
{


xx(30){
public abstract Tra nextLamp()
{
return xx2;
}
},//new子类调用父类的构造方法
xx2(45){
public abstract Tra nextLamp()
{
return dd;
}
},
dd(5){
public abstract Tra nextLamp()
{
return xx;
}
}


public abstract Tra nextLamp();
private int time;
private Tra(int time)(this.time=time;)
}


枚举只有一个成员是就可当作一种单例的实现方式。
/
反射：
反射的基石：一个类，名字Class（c是大写；另，关键字class）。不能直接new，代码内存中一份字节码
内存中每一份字节码都是Class的实例对象。
如何得到各个字节码对应的实例对象：
Class cls1 = Data.class;//字节码1
new p1.getClass();
Class.forName("java.lang.String");//返回字节码，两种返回，虚拟机中存在，直接返回；没有，加载进来。


八个基本数据类型对应八个基本Class实例对象还有void：
基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。 
String不是基本类型而是一个类。
Class.isPrimitive()
总，只要在源程序出现的类型，都各自有Class的实例对象。


反射就是把Java类中那个的各种成分映射成相应的java类。
一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示。


Constructor类：构造方法
得到某个类的所有构造方法
Constructor[] cons = Class.forName("java.lang.String").getConstructors();
得到某一个构造方法
Constructor con = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
识别某构造方法关键看参数类型。
得到构造方法后可以newInstance，新实例对象。
例子：String str2 = (String)con.newInstance(new StringBuffer("abc"));

Field类:字段
Field fieldX = pt1.getClass().getDeclaredField("x");
fieldX.setAccessible(true);
System.out.println(fieldX.get(pt1));//暴力反射


private static void changeStringValue(Object obj) throws Exception {
Field[] fields = obj.getClass().getFields();
for(Field field : fields){
//if(field.getType().equals(String.class)){
if(field.getType() == String.class){
String oldValue = (String)field.get(obj);
String newValue = oldValue.replace('b', 'a');
field.set(obj, newValue);
}
}
}




Method类：成员方法
invoke()方法，如果其第一个参数为null说明该Method对象对应的是一个静态方法。
Method methodCharAt = String.class.getMethod("charAt", int.class);//int.class参数类型
System.out.println(methodCharAt.invoke(str1, 1));
System.out.println(methodCharAt.invoke(str1, new Object[]{2}));//jdk1.4


用反射方式调用某个类中的main方法：




数组的反射：
a1.getClass().getSuperclass().getName();//返回父类为Object类对应的Class的名。
Array.asList()处理int[]与String[]的差异。//Object与基本数据类型


Class clazz = obj.getClass();
if(clazz.isArray()){}




HashCode方法与HashSet类：
在使用HashCode方法后就不要去修改其中的使用的值，否则会造成内存泄漏。


反射的作用——实现框架。
框架和工具的区别：工具类被用户的类调用，而框架则是调用用户提供的类。
在写程序时无法知道要被调用的类名，所以在程序中无法直接new某个类的实例对象，而要使用反射方式来做。


类加载器，一般用来加载class文件字节码。ClassLoader。
例：
InputStream ips = ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/day1/config.properties");
InputStream ips = ReflectTest2.class.getResourceAsStream("resources/config.properties");
InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/day1/resources/config.properties");




内省：
JavaBean是特殊的Java类，其方法名符合某种特定的规则。
JDK中提供了对JavaBean进行操作的一些API，这套API就称之为内省。
java.beans.PropertyDescriptor;
内省的应用。
Introspector类。
beanutils包。//PropertyUtils.setProperty();
Map对象。


/
Java的几个注解：在程序中加了注解就等于为程序打上某些标记。
@SuppressWarnings("deprecation")   //压缩警告
@Deprecated //弃用
@Override //覆盖


注解类<——应用的“注解类”的类<——对“应用了注解类的类”进行反射操作的类
@interface A{}
new other Annotation。
元注解。
@Retention(RetentionPolicy.SOURCE)//生存期，java源文件
@Retention(RetentionPolicy.CLASS)//class文件
@Retention(RetentionPolicy.RUNTIME)//内存中的字节码
@Target({ElementType.METHOD,ElementType.TYPE})


java语言规范：java language specification。


///
泛型：
ArrayList<String> collection2 = new ArrayList<String>();//<>内明确说明集合内的类型


Generic Java 程序的语法在表面上与 C++ 中的模板非常类似，但是二者之间有着本质的区别。
首先，Java 语言中的泛型不能接受基本类型作为类型参数――它只能接受引用类型。这意味着可以定义 List<Integer>，但是不可以定义 List<int>。
其次，在 C++ 模板中，编译器使用提供的类型参数来扩充模板，因此，为 List<A> 生成的 C++ 代码不同于为 List<B> 生成的代码，List<A> 和 List<B> 实际上是两个不同的类。而 Java 中的泛型则以不同的方式实现，编译器仅仅对这些类型参数进行擦除和替换。类型 ArrayList<Integer> 和 ArrayList<String> 的对象共享相同的类，并且只存在一个 ArrayList 类。


泛型是提供给javac编译器用的，限定集合中的输入类型，编译后会去掉“类型”信息。对于参数化的泛型类型，getClass()的返回值与原始类型完全一样。
反射可以穿过泛型。
参数化类型不考虑类型参数的继承关系。创建数组实例时，数组的元素不能使用参数化的类型。


泛型中的？通配符：<?>//指向任意类型。
例：public static void printCollection(Collection<?> collection){}//之中不能调用与类型有关的方法


通配符的扩展：
限定通配符的上边界：
Vector<? extends Number>x=new Vector<integer>();
限定通配符的下边界：
Vector<? super integer>x=new Vector<Number>();


Set<Map.Entry<K,V>> entrySet = maps.entrySet();//获得映射关系的Set视图


方法泛型中的类型推断。
泛型的类型不能是基本类型只能是引用类型。
编译器不允许创建类型变量的数组。


41泛型练习。


定义泛型类型：其中静态方法不能使用类名上的泛型，必须自己定义独立的泛型。


getGenericParameterTypes();
getParameterTypes();


Type类。获得原始类型，获得实际参数类型。参数化类型类。


变量是没法得到自己参数的类型，而必须通过调用方法对象来得到泛型参数类型。



类加载器：
系统默认的三个主要加载器：BootStrap、ExtClassLoader、AppClassLoader。
类加载器也是Java类，但第一个加载器BootStrap不是Java类，加载别的类。


System由BootStrap加载器加载。


Java虚拟机中所有类加载器采用父子关系树状结构。B<-E<-A
BootStrap——>JRE/lib/rt.jar
ExtClassLoader——>JRE/lib/ext/*.jar
AppClassLoader——>CLASSPATH中所有jar和目录
委托加载机制。
每个类加载器加载类时，先问头给其上级类加载器，不会使用子加载器去查找。


线程中的上下文加载器。setContextClassLoader(ClassLoader L);


同样可以写自己的类加载器，必须继承ClassLoader类。
ClassLoader类中的LoadClass方法。//LoadClass中的委托加载机制。
一般是要覆盖findClass方法。再调用definClass()//把一个字节数组换成到字节码，一个类对象。


类加载器原理：父类—>Loader—>loadClass()/findClass()的到class文件的转换成字节码—>definClass()


编写对class加密的工具类：获取文件路径。46
编写解密的加载器。47



代理模式。Proxy类
交叉业务的编程问题即为面向方面的编程(Aspect oriented program，AOP)。
其目标就是使交叉业务模块化。代理是实现AOP功能的核心和关键技术。
动态代理技术：JVM在运行期动态生成出类的字节码，往往用作代理类，即动态代理类。
JVM生成的动态类必须实现一个或多个接口。所以JVM生成的动态类只能用作具有相同接口的目标类的代理。
CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理。所以，如果要为一个没有实现接口的类生成动态代理类，可以使用CGLIB库。


StringBuilder与StringBuffer区别：
应用上差不多都是往字符串上动态添加字符。单线程下StringBuilder效率高，多线程StringBuffer考虑了线程安全。


InvocationHandler接口
 创建动态类的实例对象。
newProxyInstance()//类加载器，接口，handler对象


动态生成的类的内部代码。


54****原理


工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换
构造方法接收代表配置文件的输入流对象，配置文件格式：
#xxx=java.util.ArrayList
xxx=cn.itcast.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.MyAdvice


ProxyFactoryBean充当封装生成动态代理的工厂。


getBean方法