五里一徘徊孔雀东南飞
五里一徘徊孔雀东南飞

黑马程序员_JAVA基础加强笔记

-------  android培训、 java培训、期待与您交流！ ----------
1.5后新特性：
        静态导入
        增强for循环
        泛型
        基本数据类型的拆箱与装箱，自动数据类型转换
        枚举
        可变参数
        注解
        线程池 Executors
        lock
        出现StringBuilder
1.7新特性，BeanUtils可以设置Map
  //Map map =(name:"zhang"),age:18;
  //BeanUtils.setProperty(map, "name", "zhang");
1、启动eclipse  ，进程中javaw.exe
2、一些java单词缩写
        java ee—— Java  Platform,Enterprise Edition
        ide——itegrity  development   environment,集成开发环境
        jms—— Java消息服务（Java Message Service）
        jmx—— Java Management Extensions，即Java管理扩展
        jndi—— (Java Naming and Directory Interface,Java命名和目录接口  
        Dao——data access object
        crud——对数据库的增删改查
3、IDE开发工具都支持使用工程化方式管理一个项目的程序开发过程，一般来说一个相对独立的项目就是一个工程，一个项目中涉及的多个java文件。资源文件等用一个工程进行管理。在不适用工程管理的情况下，如果一个项目中包括多个java源文件，编程人员需要精心维护这些源文件之间、以及源文件与其他文件的目录关系，需要逐一编译这些源文件，需要手工启动运行编译后的结果。如果将一个程序的所有源文件用一个工程来组织，开发工具能对所有源文件几种管理，记住每个源文件的位置和相互关系。工程中有哪几个源文件、启动类是哪个、启动参数设置等配置信息在工程中都记录。
    一个workspace可以包含多个project，一个workspace保留了eclipse的一套环境选项的配置，例如，锁使用的javac和java命令，等等。如果eclipse再配置一套环境选项，可以再创建一个workspace。package explorer视图窗口中的filters菜单项，可以显示空的父包。
    一个Perspective代表了若干个view的集合，如何显示各种view
4、常用菜单--配置
    window--preferences--Java--Compiler(编译时用的工具，JRE)
    window--preferences--Java--Installed JRE(运行时用的工具,JRE)
    window--preferences--General--keys(配置快捷键)
5、切换workspace
    File--SwitchWorkspace--选择想要的workspace（如果不存在，会创建），重选workspace需要重启eclipse
    perspective透视图   view视图。     
    如何调试？首先打断点——右键-debug as 进入调试视图 ——选中变量右键watch  可以查看变量值——step over键运行下一步，点一下继续往下运行一行——Resume直接运行完毕后面所有程序
    eclipse右上角 有java    debug   点击可以切换透视图
    如果误关了透视图内的小窗口，可以在window--show View中找到
6、高版本的java能运行低版本的javac编译的程序
    低版本的java不能运行高版本的javac编译的程序
    因为：高版本java融入了许多新的特性，这些特性在低版本上运行不了。
    错误提示：java.lang.UnsupportedclassVersinoError:Bad version number in.class file
    因此这里要注意：包的运行环境的jdk版本（工程，右键，properties）要与myeclipse配置的jdk版本一致
7、代码模板，如trycatch   synchronized   等，选中代码右键surrendwith   即可
    自定义模板：如try  finally
            步骤：window--preferences--java-editor-templates-new
                    输入name和Pattern    ，try{   内容： 在这里右键Insert Variable  ,选择 line_selection}finally{光标在这里，右键insert variable 选择cursor}

try
{
${line_selection}
}
finally
{
${cursor}
}

8、导入已有的工程
    左侧栏，右键import--General--Existing Projects into Workspace
    如果导入的工程与现有workspace所用JRE不一致，则可以右键 工程--build path  --configure build path--Libraries  删掉该JRE   然后add Libraries--user Libraries---add jars。（Add jars 只导入一个jar包，而Add libraries 可以导入多个jar包）
9、静态导入
    import语句可以导入一个类或某个包中的所有类，不能导入包中的包中的类
    import static  语句导入一个类中的某个静态方法或所有静态方法。比如类Math中的Max方法
            可以这样：import static java.lang.Math.*;表示导入math类中的静态方法，这样的话，在程序中就可以直接使用max方法了，而不需要Math.Max()这样调用

package day1;
//import static java.lang.Math.max;导入类中的一个静态方法
import static java.lang.Math.*;//导入类中所有的静态方法
public class StaticImport {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int i=1;
  try {
   i++;
  } finally {
   System.out.println(i);
  }
  System.out.println(max(3, 6));//导入后，可以直接用该静态方法了
  System.out.println(Math.abs(3-6));
 }
}
10、可变参数
        问题：一个方法接收的参数个数不固定
        可变参数特点：
                只能出现在参数列表的最后
                ...位于变量类型和变量名之间，前后有无空格都可以
                调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数
        overload重载
        override重写
        练习：可变参数
         package day1;
public class VariableParameter {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(add(1,2,3,4));
 }
 public static int add(int x,int...args)//int...args可变参数只能放在参数列表最后
 {
  int sum = x;
  for(int i = 0;i
  {
   sum =sum+args[i];
  }
  return sum;
 }
}


11、增强for循环
    语法：for(type 变量名:集合变量名){}
    注意：迭代变量必须在（）中定义，集合变量可以是数组或实现了iterable接口的集合类
package day1;
public class VariableParameter {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(add(1,2,3,4));
 }
 public static int add(int x,int...args)//int...args可变参数只能放在参数列表最后
 {
  int sum = x;
  for(int arg:args)
  {
   sum =sum+arg;
  }
  return sum;
 }
}

12、基本数据类型的拆箱与装箱
        Integer intobj = 12;//自动装箱
        System.out.println(intobj+12);//自动拆箱，

        package studybase;

public class HelloWorld3 {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer io = 3;
System.out.println(io+6);
Integer in1 = 3;
Integer in2 = 3;
System.out.println(in1==in2);//true，-128至127之间
String s1 = "abc";
String s2 = "abc";
System.out.println(s1==s2);//true
//数据范围在-128   127之前时，将对象放在缓存中，如果下次生成新对象时，还是使用这个对象，
//因为数据很小，用的频率比较高，没有必要每生成一个对象就生成一个新的对象，节省缓存空间。
//这就是享元设计模式flyweight
//很多小的对象，具有非常多相同的属性，只有少量属性不同，而且这些小对象用的频率非常高，
//那么我们就可以把这些小对象变成一个对象，把那些不得属性定为外部属性或方法参数以示区别。
Integer in11 = 2233;
Integer in22 = 2233;
System.out.println(in11==in22);//false
Integer int1=Integer.valueOf(128);
Integer int2 = Integer.valueOf(128);
System.out.println(int1==int2);//false
Integer int11=Integer.valueOf(127);
Integer int22 = Integer.valueOf(127);
System.out.println(int11==int22);//true
}

}

13、枚举
        为什么要有枚举？
            问题：要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int  weekday=0;
            枚举就是要让 某个类型的变量的取值，只能为若干个固定值中的一个，否则，编译器就会报错， 枚举可以让编译器在编译时就可以控制源程序中填写的非法制，普通变量的方式在开发阶段无法实现这一目标。
        用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能
            私有的构造方法
            每个元素分别用一个public的静态成员变量表示
            可以有若干公有方法或抽象方法，例如，要提供nextDay方法必须是抽象的
        枚举的基本应用
            举例：定义一个Weekday的枚举
            扩展：枚举类的values, valueOf, name ,toString ,ordinal等方法
            总结：枚举是一种特殊的类，其中的每个元素都是该类的一个实例对象

        采用抽象方法定义nextDay（）就将大量的ifelse语句转移成了一个个独立的类
        如果想在一个类中编写完各个枚举类和测试调用类，那么可以将枚举类定义成调用类的内部类
注意：注意：注意：枚举类一被加载，枚举对象就被创建了
用普通方法定义枚举类：
package studybase;

public abstract class WeekDay {
private WeekDay()
{
}

public abstract String toString();//定义抽象方法，让子类实现该方法

public abstract WeekDay nextDay();//定义抽象方法,让子类实现该方法
public final static WeekDay SUN = new WeekDay()
{
//匿名内部类，实现抽象方法
public WeekDay nextDay()
{
return MON;
}
public String toString()
{
return "SUN";
}
};
public final static WeekDay MON = new WeekDay()
{
public WeekDay nextDay()
{
return TUE;
}
public String toString()
{
return "MON";
}
};
public final static WeekDay TUE = new WeekDay()
{
public WeekDay nextDay()
{
return WED;
}
public String toString()
{
return "TUE";
}
};
public final static WeekDay WED = new WeekDay()
{
public WeekDay nextDay()
{
return THU;
}
public String toString()
{
return "WED";
}
};
public final static WeekDay THU = new WeekDay()
{
public WeekDay nextDay()
{
return FRI;
}
public String toString()
{
return "THU";
}
};
public final static WeekDay FRI = new WeekDay()
{
public WeekDay nextDay()
{
return SAT;
}
public String toString()
{
return "FRI";
}
};
public final static WeekDay SAT = new WeekDay()
{
public WeekDay nextDay()
{
return SUN;
}
public String toString()
{
return "SAT";
}
};

}


package studybase;
 class EnumText {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
WeekDay weekday = WeekDay.SUN;
System.out.println(weekday.nextDay());
}

}
枚举就相当于一个类，其中也可以定义构造发方法、成员变量、普通方法和抽象方法
枚举元素必须放在枚举体重的最开始部分，枚举元素列表的后要有逗号与其他成员分离。把枚举中的成员方法或变量等放在枚举元素的前面，编译会出错。
带构造方法的枚举
        构造方法必须定义为private
        如果有多个构造方法，需要在枚举元素后加（）或不加（）以来确定调用哪个构造方法
        枚举元素MON和MON()的效果是一样的，都是调用默认的构造方法
带抽象方法的枚举
        需要在枚举元素后加{实现该抽象方法}，其实就是匿名内部类
枚举只有一个成员时，就可以作为一种单例的实现方式
用关键字enum定义枚举类
package studybase;

public class EnumText {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
WeekDay weekDay = WeekDay.FRI;
System.out.println(weekDay.name());
System.out.println(weekDay);
System.out.println(weekDay.ordinal());//自己的排行，5，
System.out.println(weekDay.getClass());//返回自己所属于的类
System.out.println(WeekDay.valueOf("SUN").toString());//把字符串变成对应的枚举类对象
System.out.println(WeekDay.values().length);//将枚举元素装到数组中，可以对数组进行遍历
}

//枚举中的元素就是该类的一个对象，即下面的SUN,MON,TUE,WED,THU,FRI,SAT都是
//类WeekDay的对象
public enum WeekDay//定义枚举类  关键字enum
{
SUN,MON,TUE,WED,THU,FRI,SAT;
}
}

内部类可以用public private 修饰，外部类只能是public或默认

示例：带参数构造方法，带抽象方法的枚举
package studybase;

import java.util.Date;

public class EnumText 
{

/**
 * @param args
 */
public static void main(String[] args) {
new Date(300){};//new子类的实例对象，并调用父类带参数的构造方法
}

//枚举中的元素就是该类的一个对象，即下面的SUN,MON,TUE,WED,THU,FRI,SAT都是
//类WeekDay的对象
public enum WeekDay//定义枚举类  关键字enum
{
SUN,MON,TUE(),WED,THU(),FRI,SAT(3);
//注意：构造方法只能是private
private WeekDay()//创建SUN,MON,TUE,WED，FRI实例时，默认调用该方法
{
}
//带参数的构造方法
private WeekDay(int day)//创建THU(1),SAT(3)时调用该方法
{
}
}
//带参数构造方法，带抽象方法的枚举类
public enum Trafficlamp
{
//用匿名内部类实现该抽象方法
RED(30){
public Trafficlamp nextLamp()
{
return GREEN;
}
},
GREEN(45){
public Trafficlamp nextLamp()
{
return YELLOW;
}
},
YELLOW(5){
public Trafficlamp nextLamp()
{
return RED;
}
};
public abstract Trafficlamp nextLamp();//抽象方法
private int time ;
private Trafficlamp(int time)
{
this.time = time;
}
}
}

14、反射——Class类
    java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例来确定的，不同的实例对象有不同的属性值。java程序中的各个java类，它们是否属于同于类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要助于与小写的class关键字区别。Class类描述了哪些方面的信息？类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表等等。学习反射就要了解Class。
    理解：
    Person p1 = new Person();//首先在硬盘上编译成二进制代码，加载进内存，再用字节码创建出一个个对象
    Person p2 = new Person();
    Date
    Math

    Class cls1 = 字节码1;//每个类的字节码就是Class的对象
    Class cls2 = 字节码2;
第一种得到字节码的方法：jvm中已有的字节码
    Class cls3 = Person.class;
    Class cls4 = Math.class;
第二种得到字节码方法：对象.getClass(),如new Date().getClass();
第三种得到字节码的方法：调用静态方法forName得到jvm中没有的字节码
    Class.forName("java.lang.String");

九个预定义Class实例对象，void  boolean  short  byte  int   long   float  double char
判断这些对象是否属于基本数据类型字节码，用Class 的isPrimitive()方法

数组类型的Class实例对象，判断用isArray();

总之：只要是在源程序中出现的类型，都有各自的Class实例对象，如int[] 、 void等 

15、反射
    反射就是把java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等也是一个个的类。表示java类的Class类显然要提供一些列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是响应类的实例对象来表示，他们是Field/Method /Constructor/package等等
    一个类中的每个成员都可以用响应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用？

16、Constructor类
    Constructor类代表某个类中的一个构造方法
    得到某个类所有的构造方法：
            Constructor[] constructor= 
                    Class.forName("java.lang.String").getConstructors();
    得到某一个构造方法：
            Constructor constructor = 
                    Class.forName("java.lang.String").getConstructor( StringBuffer.class);
            获得方法时要用到类型
    创建实例对象：
            通常方式：String str = new String( new StringBuffer("abc"));
            反射方式：String str = (String)constructor.newInstance( new StringBuffer("abc"));
            创建实例对象时也要用到类型
    Class.newInstance()方法
            例子：String obj = (String)Class.forName("java.lang.String").newInstance();
            该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象
            该方法内部的具体代码是怎么写的？用到了缓存机制来保存默认构造方法的实例对象。

package studybase;

import java.lang.reflect.Constructor;

public class ReflectTest {

/**
 * @param args
 */
public static void main(String[] args) throws Exception
{
// TODO Auto-generated method stub
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
System.out.println(cls1==cls2);//true
System.out.println(cls2==cls3);//true
System.out.println(cls1.isPrimitive());//false，判断是不是基本数据类型字节码
System.out.println(int.class.isPrimitive());//true，判断int字节码是不是基本数据类型字节码
System.out.println(int.class ==Integer.class);//false,二者属于不同类型
      System.out.println(int.class == Integer.TYPE);//true,TYPE表示其基本类型
System.out.println(int[].class.isPrimitive());//false,数组也是一种类型
System.out.println(int[].class.isArray());//true,判断数组字节码是否属于数组
String.class.getConstructor(StringBuffer.class);//表示得到参数为StringBuffer类型的构造方法。
//new String (new StringBuffer("abc"));
//用反射方法写上面的语句
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
}

}


17、Field类
    Field类代表某个类中的一个成员变量
    演示：用eclipse自动生成java类的构造方法
    问题：得到Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，那关联哪个对象呢？所以字段field X代表的是x的定义，而不是具体的x变量
package studybase;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectTest {

/**
 * @param args
 */
public static void main(String[] args) throws Exception
{
ReflectPoint pt1 = new ReflectPoint(3,5);
Field fieldy = pt1.getClass().getField("y");//fieldy不代表y的值
//fieldy不是对象身上的变量，而是类上。要取得y的值，用get方法
System.out.println(fieldy.get(pt1));
//x是private的因此需要用getDeclaredField(),该方法不管你是否private，都能看到
Field fieldx = pt1.getClass().getDeclaredField("x");
//setAccessible(true)表示我能够拿到变量，暴力反射
fieldx.setAccessible(true);
System.out.println(fieldx.get(pt1));
}

}
package studybase;

public class ReflectPoint {

/**
 * @param args
 */
private int x;
public  int y;
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}

}


反射练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的”b"改成"a"

package studybase;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectTest {

/**
 * @param args
 */
public static void main(String[] args) throws Exception
{
// TODO Auto-generated method stub
String str1 = "abc";
Class cls1 = str1.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
System.out.println(cls1==cls2);//true
System.out.println(cls2==cls3);//true
System.out.println(cls1.isPrimitive());//false，判断是不是基本数据类型字节码
System.out.println(int.class.isPrimitive());//true，判断int字节码是不是基本数据类型字节码
System.out.println(int.class ==Integer.class);//false,二者属于不同类型
System.out.println(int[].class.isPrimitive());//false,数组也是一种类型
System.out.println(int[].class.isArray());//true,判断数组字节码是否属于数组
String.class.getConstructor(StringBuffer.class);//表示得到参数为StringBuffer类型的构造方法。
//new String (new StringBuffer("abc"));
//用反射方法写上面的语句
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
ReflectPoint pt1 = new ReflectPoint(3,5);
Field fieldy = pt1.getClass().getField("y");//fieldy不代表y的值
//fieldy不是对象身上的变量，而是类上。要取得y的值，用get方法
System.out.println(fieldy.get(pt1));
//x是private的因此需要用getDeclaredField(),该方法不管你是否private，都能看到
Field fieldx = pt1.getClass().getDeclaredField("x");
//setAccessible(true)表示我能够拿到变量，暴力反射
fieldx.setAccessible(true);
System.out.println(fieldx.get(pt1));
changeStringValue();
}

private static void changeStringValue(Object obj) throws Exception
{
// TODO Auto-generated method stub
//获得obj的所有成员变量
Field[] fields = obj.getClass().getFields();
//对存有成员变量的数组进行遍历
for(Field field:fields)
{
//判断成员变量所属类字节码是否与String相同
if(field.getType() == String.class)
{
//获得变量值
String oldValue = (String)field.get(obj);
//将变量值中‘b' 修改为'a'
String newValue = oldValue.replace('b','a');
//将新值设置到obj中
field.set(obj,newValue);
}
}
}

}

package studybase;

public class ReflectPoint {

/**
 * @param args
 */
private int x;
public  int y;
public String str1 ="ball";
public String str2 ="basketball";
public String str3 ="itcast";
public ReflectPoint(int x, int y) {
super();
this.x = x;
this.y = y;
}

public static void main(String[] args) {
// TODO Auto-generated method stub

}
public String toString()
{
return str1+"...."+str2+"...."+str3;
}
}


18、Method类
    Method类代表某个类中的一个成员方法
    得到类中某一个方法：
            Method charAt = 
                Class.forName("java.lang.String").getMethod("charAt",int.class);
    调用方法：
            通常方式：System.out.println(str.charAt(1));
            反射方式：System.out.println(charAt.invoke(str,1));
                    如果传递给Method对象的 invoke()方法的一个参数为null，说明该Method对象对应的是一个静态方法
    jdk1.4 与 1.5中invoke方法的区别
            1.5：public Object invoke(Object obj,Object...args)
            1.4：public Object invoke(Object obj,Object[] args),即按1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码页可以用jdk1.4改写为
charAt.invoke("str",new Object[]{1})形式

package day1;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectTest {
 /**
  * @param args
  * @throws NoSuchMethodException
  * @throws SecurityException
  * @throws InvocationTargetException
  * @throws IllegalAccessException
  * @throws InstantiationException
  * @throws IllegalArgumentException
  */
 public static void main(String[] args) throws Exception
 {
  Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
  String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
  System.out.println(str2.charAt(2));
 
  ReflectPoint pt1 = new ReflectPoint(3,5);
  Field fieldY = pt1.getClass().getField("y");
  System.out.println(fieldY.get(pt1));
  Field fieldX = pt1.getClass().getDeclaredField("x");
  fieldX.setAccessible(true);
  System.out.println(fieldX.get(pt1));
 
  changeStringValue(pt1);
  System.out.println(pt1);
 
  Method methodCharAt = String.class.getMethod("charAt", int.class);
  System.out.println(methodCharAt.invoke(str2, 1));
  System.out.println(methodCharAt.invoke(null, 1));//这里是null 表示静态方法
 
 }
 
 private static void changeStringValue(Object obj) throws Exception
 {
  Field[] fields = obj.getClass().getFields();
  for(Field field:fields)
  {
   if(field.getType()==(String.class))
   {
    String oldValue = (String)field.get(obj);
    String newValue = oldValue.replace('b', 'a');
    field.set(obj, newValue);
   }
  }
 }
}
19、用反射方式执行某个类中的main 方法
    目标：写一个程序，这个程序能够根据用户提供的类名，去执行该类的main方法
    问题：启动java程序的main方法的参数是一个字符串数组，即public static void main(String[] aargs),通过反射方式来调用这个main方法时，如何为invoke方法传递参数？按jdk1.5的语法，整个数组时一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke时，javac到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按照jdk1.4的语法进行处理，即把数组打散称为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码：mainMethod.invoke(null,new String[]{"xxx"}),javac只把它当做jdk1.4的语法进行理解，而不把它当做jdk1.5的语法理解，因此会出现参数类型不对的问题
    解决办法：
            mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});//把数组打包成一个数组
            mainMethod.invoke(Object)new String[]{"xxx"}),编译器会做特殊处理，编译时不把参数当做数组看待，也就不会把数组打散成若干个参数了

package studybase;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectTest {

public static void main(String[] args) throws Exception
{
//通常方法：调用main方法
TestArguments.main(new String[]{"123","434","ede"});
//反射方法：
String startingClassName = args[0];
Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
mainMethod.invoke(null, new Object[]{new String[]{"123","434","ede"}});
//或者下面这条语句
mainMethod.invoke(null, (Object)new String[]{"123","434","ede"});
}
}


class TestArguments
{
public static void main(String[] args)
{
for(String arg:args)
{
System.out.println(arg);
}
}
}

20、数组与Object
    具有相同 维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象
    代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class
    基本类型的一维数组可以被当做Object类型使用，不能当做Object[] 类型使用，非基本类型的一维数组，既可以当做Object类型来使用，又可以当做Object[] 类型使用
    Arrays.asList()方法处理intp[] 和String[] 时的差异
    记住一个类Array（不是Arrays）,该类是用于数组的反射，记住一个方法get（arrayname,arrayindex),用于得到指定数组指定下标的内容，如System.out.println(Array.get(a1, 2));

package studybase;

import java.util.Arrays;

public class ArrayReflectTest {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a1 = new int[]{1,2,3};
int[] a2 = new int[5];
int[][] a3 = new int[3][5];
String[] a4 = new String[]{"a","b","c"};
sop(a1.getClass() == a2.getClass());//true
//sop(a1.getClass() == a3.getClass());//编译不通过
//sop(a1.getClass() == a4.getClass());//编译不通过
sop(a1.getClass().getName());//结果：[I    [表示数组      I表示int
sop(a1.getClass().getSuperclass().getName());
sop(a4.getClass().getSuperclass().getName());
Object aobj1 = a1;//int[] 数组当做对象
Object aobj2 = a4;//可以理解为String[]数组当做一个对象
//Object[] aobj3 = a1;//int不能当做Object来使用
Object[] aobj4 = a3;//数组Objcet[] 中的每个元素是一维数组int[]，因为int[] 是对象
Object[] aobj5 = a4;//数组Object[] 中的每个元素都是String[] 数组中的每个元素
sop(a1);//[I@459189e1
sop(a4);//[Ljava.lang.String;@55f33675
      //用public static List asList( Object[] a)方法将数组转为List
sop(Arrays.asList( a1));//[[I@459189e1],原因asList接收的是Object，而int不是object
sop(Arrays.asList(a4));//[a, b, c]

                 //数组的反射
       // Object obj = null;
//printObject(obj);
                printObject(a1);
                printObject(a4);
}
private static void printObject(Object obj) {
// TODO Auto-generated method stub
Class clazz = obj.getClass();//得到字节码
if(clazz.isArray())//判断是否数组
{
int len = Array.getLength(obj);
for(int i = 0;i
{
sop(Array.get(obj, i));
}
}else
{
sop(obj);
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

获得数组中的元素类型
不能获得aa的类型，但能获得各个元素的类型
Object[] aa = new Object[]{"a",1};
aa[0].getClass().getName();


21、反射的作用---》实现框架功能
框架与框架要解决的核心问题
        我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
        我在写框架时，你这个用户可能还在上小学，还不回写程序，那么我写的框架程序怎么能调用你以后写的类？
        因为在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象，而要用反射方式来做。
综合案例：
        先直接new语句创建ArrayList和HashSet的实例对象，演示用eclipse自动生成ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果差异。
        然后改为采用配置文件加反射的方式创建ArrayList和HashSet的实例对象，比较观察运行结果差异

一般方式：

package studybase;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;

public class ReflectTestf2 {


public static void main(String[] args) {
// TODO Auto-generated method stub
Collection collections = new HashSet();//集合中有三个元素
//hashSet中无序，不能存入相同对象，但是pt1  pt3虽然指向同一个对象，二者hashcode值不同
//用equals比较pt1 pt3时，jvm认为二者不同，因此可以存入hashSet
//如果两个对象相等的话  那就让二者的hashcode也相等（在hashset中）
/*
 当一个对象被存储间HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，
 否则，对象修改后的哈希值与最初存储进HashSet集合中哈希值就不同了，在这种情况下
 即使在contains方法使用该对象的当前引用作为的参数区HashSet集合中检索对象，
 也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，从而造成内存泄露
  
 通常来将，一个类的两个势力对象用equals()方法比较的结果相等时，他们的话细致也必须相等，但反之则不成立
 即equals方法比较结果不相等的对象可以具有相同的哈希值，或者说哈希值相同的两个对象的equals方法比较的结果可以不等
 例如，字符串"BB"和"Aa"的equals方法结果肯定不相等，但他们的hashCode方法返回值却相等
  */
//Collection collections = new ArrayList();//集合中有四个元素
//ArrayList 中元素的存入有序，因此同一个对象可以存多个引用
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
//pt1和pt3,指向同一个对象，但是二者hashcode值不同，因此用equals比较时，不同
//我么可以重写hashcode()方法，让二者值相等，那么equals就相同了
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
//内存泄露   内存溢出
pt1.y = 8;//改变已经存储在collections中的对象的值，改变以后，pt1的hashcode值就改变了
//collections.add(pt1);//集合中三个元素了
//collections.remove(pt1);//无法删除，因为hashcode已变，删除的是现在的哈希值，而原有的哈希值找不到了
System.out.println(collections.size());
}

}

用反射方式：就是说不出现具体类的名字，而是从配置文件中读出来的

package studybase;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Properties;

public class ReflectTestf2 {


public static void main(String[] args) throws Exception
{
/*
                创建配置文件：
                        右键工程名--new--File
                        给文件起名字： config.properties
                        向文件中添加内容： className=java.util.ArrayList
                */
     //方式一：读写配置文件都可以
InputStream ips  = new FileInputStream(" config.properties ");//连接配置文件
      //方式二：用类加载器方式,但只能读配置文件
      //InputStream ips =        //ReflectTest2.class.getClassLoader().getResourceAsStream("javainhance2/day1/config.properties");
  //方式三：用类加载 （其实内部也是用的类加载器）
 // InputStream ips = ReflectTest2.class.getResourceAsStream("config.properties");
  
Properties props = new Properties();
props.load(ips);//将配置文件内容加载到props中
ips.close();
String  className  = props.getProperty(" className ");//读取配置文件中的className值,此值为类名
Collection collections =(Collection)Class.forName( className ).newInstance();
                //根据className创建字节码文件，并根据字节码创建该类对象，并把该类对象转为Collection类型
                //这样就不需要修改代码，直接修改配置文件中的className值就可以了，比如 className=java.util.HashSet


ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);
//pt1和pt3,指向同一个对象，但是二者hashcode值不同，因此用equals比较时，不同
//我么可以重写hashcode()方法，让二者值相等，那么equals就相同了
collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);
//内存泄露   内存溢出
pt1.y = 8;//改变已经存储在collections中的对象的值，改变以后，pt1的hashcode值就改变了
//collections.add(pt1);//集合中三个元素了
//collections.remove(pt1);//无法删除，因为hashcode已变，删除的是现在的哈希值，而原有的哈希值找不到了
System.out.println(collections.size());
}

}

用类加载器方式管理资源和配置文件。
配置文件的访问：
        相对路径：InputStream ips  = new FileInputStream(" config.properties ");//连接配置文件   
在这里的文件路径是相对路径，如果将项目发给用户，那么该相对路径可能出问题，找不到
        绝对路径：如果这里时绝对路径（如D盘),但是用户没有D盘的话，也会出现问题
        getRealPath()方法：此时就用到了一个方法，可以解决这个问题：
getRealPath();得到项目在硬盘上的绝对路径
得到绝对路径后再加上配置文件在项目的相对路径，，这样就成了配置文件的绝对路径
一定要记住用完整的路径，但完整的路径不是硬编码，而是运算出来的。
类加载器：将.class文件加载到内存中，也提供将普通文件（这里是配置文件）加载的功能。


一个知识点：eclipse会自动把源文件(src）中的java文件自动编译成.class文件并放到bin（classpath指定的目录）中，会把src中的非java文件按目录原封不动放到bin（classpath指定的目录）中。用户用的时候是在bin中的文件。而我们操作时只需要操作src中的文件


22、内省（IntroSpector）——JavaBean了解——特殊的java类
    符合特殊规则：
    int getAge()
    void setAge(int age)

一般规则：javabean属性通过get   set来操作
                去掉方法名的get  set  那么剩下的就应该是属性名，要全小写的
                如：getTime--time
                        settime--time
                        getCPU--CPU

class Person
{
        private int age;//不需要向外直接提供访问，private
        public int getAge()//向外界提供得到age的方法
        {
                return age;
        }
        public void setAge(int age)//为javabean属性赋值
        {
                this.age = age;
        }
}

注意：类javabean可以当做普通类来处理，而且符合javabean规则的类也可以当做javabean来处理

JavaBean是一种特殊的java类，主要用于传递数据信息，这种java类中方法主要用于访问私有的字段，且方法名符合某种命名规则
如果要在两个模块之间传递多个信息，可以将这些信息封装到一个javabean中，这种javabean的实例对象通常称之为值对、对象（Value Object    简称VO ），这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些响应的方法来访问，javabean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名getId，至于你把它存到哪个比变量上，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是系哦啊写的，则把剩余部分的字母该成小写的
总之，一个类被当做javabean使用时，其属性是根据方法名推断出来的，它根本看不到java类的内部成员变量。

一个符合javabean特点的类可以当做普通类一样使用，但把它当做javabean来用肯定需要带来一些额外的好处，我们才会去了解和应用javabean，好处如下：
        在java EE开发中，经常要使用到javabean，很多环境就要求按javabean方式进行操作，别人都这么用和要求这么做，那么你就没有挑选的余地
        在JDK中提供了对javabean进行操作的一些API，这套API就称为内省，如果你自己去通过getX方法访问私有的x，怎么做？有一定难度，用内省这套API操作javabean比用普通类的方式更方便


一般方式：
package studybase;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class IntroSpectorTest {

/**
 * @param args
 */
public static void main(String[] args) throws Exception 
{
// TODO Auto-generated method stub
javaBeanTest jbt = new javaBeanTest();
String propertyName = "name";
PropertyDescriptor pd = new PropertyDescriptor(propertyName,jbt.getClass());
//获取值
Method methodGetName = pd.getReadMethod();
Object retVal = methodGetName.invoke(jbt);
System.out.println(retVal);
//设置值
PropertyDescriptor pd2 = new PropertyDescriptor(propertyName,jbt.getClass());
Method methodSetName = pd2.getWriteMethod();
methodSetName.invoke(pd2,"zhangsan");
System.out.println(pd2.getName());
}

}


用beanutils工具包操作javabean
需要导入：commons-beanutils
                  commons-logging
然后add  to buildpath

用beanutils操作的属性，数据类型都会转换成String类型
用PropertyUtils操作的javabean属性，保持属性原来的数据类型

package studybase;

import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.Map;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class IntroSpectorTest {

/**
 * @param args
 */
public static void main(String[] args) throws Exception 
{
// TODO Auto-generated method stub
javaBeanTest jbt = new javaBeanTest();
String propertyName = "name";
BeanUtils.setProperty(jbt,"name","zhangsan");
String obj = BeanUtils.getProperty(jbt,"name");
System.out.println(obj);
//java7新特性
//Map map = {name:"xx",age:23};
//BeanUtils.setProperty(map, "name", "lisi");
//propertyUtils
PropertyUtils.setProperty(jbt, "age", 24);
}

}


package javainhance;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class IntroSpectorTest {

/**
 * @param args
 * @throws IntrospectionException 
 * @throws InvocationTargetException 
 * @throws IllegalAccessException 
 * @throws IllegalArgumentException 
 * @throws NoSuchMethodException 
 */
public static void main(String[] args) throws IntrospectionException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
// TODO Auto-generated method stub
ReflectPoint pt1 = new ReflectPoint(3,5);
String propertyName = "x";
//x-->X-->getX-->MethodGetX
//方式一：
// PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
// Method methodGetX = pd.getReadMethod();
// Object retVal = methodGetX.invoke(pt1);
// System.out.println(retVal);
//
// Method methodSetX = pd.getWriteMethod();
// methodSetX.invoke(pt1,7);
//
// System.out.println(pt1.getX());
//方式二：
PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());
Method methodGetX = pd.getReadMethod();
Object retVal = methodGetX.invoke(pt1);
System.out.println(retVal);
Method methodSetX = pd.getWriteMethod();
methodSetX.invoke(pt1,7);
//BeanUtils使用方法
/*
 下载：commons-beanutils-1.8.3.zip
  解压后将commons-beanutils-1.8.3.jar复制，在工程下new-folder（取名lib），粘贴到此处，然后右键-Build Path--Add to Build Path
 下载：commons-logging-1.1.3.zip
  将诶呀后将commons-logging-1.1.3.jar复制，粘贴到lib中，然后右键-Build Path--Add to Build Path
 */
System.out.println(BeanUtils .getProperty(pt1, "x"));
System.out.println(BeanUtils .getProperty(pt1, "x").getClass().getName());//类型是String
BeanUtils.setProperty(pt1, "x", "9");//beanutils中属性值以字符串形式操作,会自动转换类型
System.out.println(pt1.getX());
BeanUtils.setProperty(pt1, "birthday.time", "111");
System.out.println(BeanUtils.getProperty(pt1, "birthday.time"));
//java7的新特性
//Map map = {name:"zxx",age:18};
//BeanUtils.setProperty(map, "name", "lhm");
//map与javabean之间可以相互转换
//也可以使用PropertyUtils,与BeanUtils的区别在于，set和get时，属性值类型是Integer；BeanUtils是String
//因此二者的使用看需求
PropertyUtils.setProperty(pt1, "x", 10);
System.out.println(PropertyUtils.getProperty(pt1, "x"));
System.out.println(PropertyUtils.getProperty(pt1, "x").getClass().getName());//类型为Integer
}

}


24、了解注解及java提供的几个基本注解
    
        注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则等于没有某种标记，以后，javac编译器，开发工具和其他程序可以用反射来了解你的类及各种元素上有无何种标记，看你有什么标记，就去干相对应的事。标记可以加在包、类、字段、方法、方法的参数以及局部变量上。

package studybase_2;

public class AnnotationTest {

//这就是注解，告诉编译器。。。。一些内容
//一个注解其实就是一个类的实例对象
//告诉编译器我已经知道runFinalizersOnExit已过时
@SuppressWarnings("deprecation")
public static void main(String[] args) {
// TODO Auto-generated method stub
System.runFinalizersOnExit(true);
}
//告诉编译器，此方法sayHello已过时，以后再被调用时就会提示
@Deprecated
public static void sayHello()
{
System.out.println("hello");
}

//表示重写
@Override
public static String toString()
{
return "fdf";
}
}


25、注解的应用结构图

        步骤1：注解类
                @interface A
                {
                }
        步骤2：应用了注解类的类
                @A
                Class B
                {

                }
        步骤3：对“应用了注解类的类”进行反射操作的类
                Class C
                {
                        B.class.isAnnotionPresent(A.class);
                        A a = B.class.getAnnotion(A.class);
                }


注解类三个生命周期：
        源文件：@Retention(RetentionPolicy.SOURCE)      
        .class阶段 : @Retention(RetentionPolicy.CLASS)      
        内存运行:@Retention(RetentionPolicy.RUNTIME)
因此在使用时可以明确该注解类的生命周期在哪儿，默认是.class阶段

@Override    SOURCE阶段
@SuppressWarnings      SOURCE阶段
@Deprecated      RUNTIME阶段

@Target()   该注解说明该注解类可以使用在哪儿。


package studybase_2;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//元注解，注解的注解
//元数据
//元信息

//表示一直保留到运行时期
@Retention(RetentionPolicy.RUNTIME)
//表示只能放到方法上
//@Target(ElementType.METHOD)
//如果是多个可以这么写
@Target({ElementType.METHOD,ElementType.TYPE})//参数为ElementType[]
public @interface ItcastAnnotation {

}


26、为注解增加基本属性
    什么是注解的属性，如果一个注解相当于一个胸牌，如果你胸前贴了胸牌，就是传智播客的学生，否则就不是；如果还想区分是哪个班的学生，这时候可以为胸牌再增加一个属性来进行区分。加了属性的标记效果为：@MyAnnotation(olor="red")
    定义基本类型的属性和应用属性
            在注解中增加String color();
            @MyAnnotation(color = "red")
    用反射方式获得注解对应的实例对象后，再通过该对象调用属性对应的方法
            MyAnnotation a = (MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
            System.out.println(a.color());
            可以认为上面这个@MyAnnotation是MyAnnotation类的一个实例对象
    为属性指定缺省值
            String color() default "yellow";
    value 属性
            String value() default "zhx";
            如果注解中有一个名为value的属性，且你指向设置value属性（即其他属性都采用默认值或者只有一个value属性），那么可以省略value=部分，例如：@MyAnnotation("lnm");

27、为注解增加高级属性
    数组类型的属性
            int[] arryAttr() default{1,3,2}；
            @MyAnnotation(arrayAttr={2,3,4});
            如果数组属性中只有一个元素，这时候属性值部分可以省略大括号
    枚举类型的属性
            EnumTest.TrafficLamp();
            @MyAnnotation(lamp=EnumTest.TrafficLamp.GREEN)
    注解类型的属性
            MetaAnnotation annotationAttr()  default @MetaAnnotation('xxxx');
            @MyAnnotation(annotationAttr = @MetaAnnotation('yy'))
            可以认为上面这个恶MyAnnotation是MetaAnnotation类的一个实例对象，同样的道理，可以认为上面这个
            @MetaAnnotation是MetaAnnotation类的一个实例对象
            用代码如下：
            MetaAnnotation   ma = MyAnnotation.annotationAttr();
            System.out.println(ma.value());


示例代码：

package studybase_2;

public @interface MetaAnnotation {
String value();
}


package studybase_2;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//元注解
//元数据
//元信息，注解的注解

//表示一直保留到运行时期
@Retention(RetentionPolicy.RUNTIME)
//表示只能放到方法上
//@Target(ElementType.METHOD)
//如果是多个可以这么写
@Target({ElementType.METHOD,ElementType.TYPE})
public @interface ItcastAnnotation {
String color() default "blue";//是一个属性，在调用该注解时，需要在注解后标出
//使用方法：@ItcastAnnotation(color = "red")
//default "blue"  表示默认值。此时@ItcastAnnotation即可，不用再加color了
String value();
int[] arrayAttr() default {3,4,2};
//EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;
MetaAnnotation annotationAttr() default @MetaAnnotation("vale");
}


package studybase_2;

@ItcastAnnotation(annotationAttr = @MetaAnnotation("fanglixun"),color = "red",value="fdf",arrayAttr={5,6,7})
public class AnnotationTest {

//这就是注解，告诉编译器。。。。一些内容
//一个注解其实就是一个类的实例对象
//告诉编译器我已经知道runFinalizersOnExit已过时
@SuppressWarnings("deprecation")
public static void main(String[] args) {
// TODO Auto-generated method stub
System.runFinalizersOnExit(true);
if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class))
{
ItcastAnnotation annotation = (ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);
System.out.println(annotation);
System.out.println(annotation.color());
System.out.println(annotation.value());
System.out.println(annotation.arrayAttr().length);
//System.out.println(annotation.lamp().nextLamp().name());
System.out.println(annotation.annotationAttr().value());
}
}
//告诉编译器，此方法sayHello已过时，以后再被调用时就会提示
@Deprecated
public static void sayHello()
{
System.out.println("hello");
}
}

另一示例：
package day2;
public @interface MetaAnnotation {
 String value();
}

package day2;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.annotation.ElementType;
//元注解，注解的注解
import day1.EnumTest;
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface ItcastAnnotation {
 String color() default "bule";//设置默认值
 //String color();
 String value();
 
 int[] arrayAttr();//数组类型
 //int[] arrayAttr() default {3,4,5};
 
 //枚举
 EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.RED;
 
 //注解
 MetaAnnotation annotationAttr() default @MetaAnnotation("llj");
}

package day2;
@ItcastAnnotation(annotationAttr=@MetaAnnotation("flx"),color ="red",value="abd",arrayAttr={1,2,3})
public class AnnotationTest {
 /**
  * @param args
  */
 //警告 注解，告诉JVM忽略过时“deprecation”，仍然使用该方法
 @SuppressWarnings("deprecation")
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.runFinalizersOnExit(true);//deprecated,过时的方法
 
  if(AnnotationTest.class.isAnnotationPresent(ItcastAnnotation.class))
  {
   ItcastAnnotation annotation =
     (ItcastAnnotation)AnnotationTest.class.getAnnotation(ItcastAnnotation.class);
   
   System.out.println(annotation);
   System.out.println(annotation.color());
   System.out.println(annotation.value()); 
   System.out.println(annotation.lamp().nextLamp());
   System.out.println(annotation.annotationAttr().value());
   
  }
 }
 //标明该方法过时
 @Deprecated
 public static void sayHello()
 {
  System.out.println("hello");
 }
 
 //标明该方法覆盖父类方法
 @Override
 public String toString()
 {
  return "hello";
 }
}
注解理解：
1、注解就是给类、成员或方法等添加标记，在编译运行时会检查是否有标记，若有就执行相关操作。
2、注解三个生命周期，SOURCE、CLASS和RUNTIME，表示该注解执行到哪一步，然后就不再具有作用了。
3、注解涉及到三个类，注解类A，应用注解类A的类B，对B进行反射操作的类C。
4、注解类可以有属性，且属性需有值，如果在注解类A中设置属性默认值，那么在B中，A就不需要再对属性赋值了，当然如果需要的话，可以修改属性的值；如果不在A中设置属性默认值，那么就必须在B中，A对属性赋值。在C中对B反射可以得到A的实例对象，通过该对象可以获得A实例对象的属性值。注解的属性可以是基本数据类型，数组、字符串、枚举，另外注解也可以是注解类的属性


29、泛型，是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时，会去除掉“类型"信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

ArrayList 类定义和ArrayList类引用中涉及如下术语：
        整个称为ArrayList泛型类型
        ArrayList中的E称为类型变量或类型参数
        整个ArrayList称为参数化的类型
        ArrayList中的Integer称为类型参数的实例或实际类型参数
        ArrayList中的<>读作typeof
        ArrayList称为原始类型
参数化类型和原始类型的兼容性
        参数化类型可以引用一个原始类型的对象，编译报告警告，例如
                Collection c = new Vector();
        原始类型可以引用一个参数化类型的对象，编译报告警告，例如
                Collection c = new Vector ();
参数化类型不考虑类型参数的继承关系
        Vector v = new Vector();错误
        Vector v = new Vector(); 错误
在创建数组实例时，数组的元素不能使用参数化类型
        Vector vectorList[]= new Vector[10];错误

判断对错：原因，编译器严格按语法检查，不考虑执行时候
        Vector v = new Vector();   编译通过，原始类型=参数化类型
        Vector v1 = v;编译通过，参数化类型= 原始类型


package studybase_2;

import java.util.ArrayList;
import java.util.Collection;

public class GenericTest {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
ArrayList collection1 = new ArrayList();
collection1.add(1);
collection1.add(1L);
collection1.add("abd");
int i =(Integer)collection1.get(1);//ClassCastException
*/
ArrayList collection2 = new ArrayList();
collection2.add("abd");
collection2.add("zhangshn");
collection2.add("lisi");
String element = collection2.get(1);
System.out.println(element);
}
public static void printCollection(Collection collection)
{
System.out.println(collection.size());
for(Object obj:collection)
{
System.out.println(obj);
}
}
}

另一示例：
package day2;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class GenericTest {
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  //泛型为String的ArrayList内存放Integer数据
  List listStr = new ArrayList();
  listStr.add("a");
  listStr.add("b");
  listStr.add("c");
  ListIterator li = listStr.listIterator();
  while(li.hasNext())
  {
   System.out.println(li.next());
  }
  //通过反射方式得到add方法，调用方法add Integer类型数据
  Method methodList = listStr.getClass().getMethod("add", Object.class);
  methodList.invoke(listStr, 1);
  methodList.invoke(listStr, 2);
  methodList.invoke(listStr, 3);
  methodList.invoke(listStr, 4);
  System.out.println(listStr);
  System.out.println(listStr.get(3));//这里报错，因为方法get(index)返回值为String
 
  //向泛型为Integer的ArrayList添加String类型数据
  List listIn = new ArrayList();
  listIn.add(2);
  System.out.println(listStr.getClass()==listIn.getClass());
  listIn.getClass().getMethod("add", Object.class).invoke(listIn, "ab");
  System.out.println(listIn.get(1));
 }
}

泛型中的？通配符
    问题：定义一个方法，该方法用于打印任意参数化类型的集合中的所有数据
    错误方式：
            public static void printCollection(Collection cols)
            {
                    for(Object obj:cols)
                    {
                            System.out.println(obj);
                    }
                    cols.add("String");//没错，因为是Object  所以可以add  String
                    cols = new HashSet();//错误，上面是Object   下面是Date  不能这样做

    正确方式：
            public static void printCollection(Collection cols)
            {
                    for(Object obj:cols)
                    {
                            System.out.println(obj);
                    }
                    cols.add("String");//错误，因为不知道？是什么类型，不一定匹配String类型
                    cols.size();//正确，此方法与类型参数没有关系
                    cols = new HashSet();//正确
                    //使用?通配符可以引用其他各种参数化的类型，？通配符定义的变量主要用于引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法
            }

            }



泛型中的？通配符的扩展
    限定通配符的上边界：
            正确：Vector x = new Vector();
            错误：Vector x = new Vector();
    限定通配符的下界：
            正确：Vector x = new Vector();
            错误：Vector x = new Vector();
    提示：
            限定通配符总是包括自己。


30、自定义泛型，由C++的模板函数引入自定义泛型
    如下函数的结构很相似，仅类型不同
            int add(int x,int y)
            {
                    return x+y;
            }
            int add(float x,float y)
            {
                    return x+y;
            }
            int add(double x,double y)
            {
                    return x+y;
            }
            
交换数组中的两个元素的位置的泛型方法语法定义如下：
static void swap(E[] a,int i ,int j)
{
        E t = a[i];
        a[i] = a[j];
        a[j] = t;
}

用于防止泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回值类型之前，也就是紧邻返回值之前，按照惯例，类型参数通常用单个大写字母表示。
只有引用类型才能作为泛型方法的实际参数，swap(new int[2]{3,2},1,2),语句会报编译错误
除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如：
        Class.getAnnotation()方法的定义，并且可以用&来指定多个边界，如
         void method(){}
普通方法、构造方法和静态方法中都可以使用泛型
也可以用类型变量来表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch后的（）中
在泛型中可以同时又多个类型参数，在定义他们的<>中用逗号分开，例如：
        public static V getValue(K key){return map.get(key);}

java中的泛型类型类似于c++中的模板，但是这种相似性仅限于表面，java语言中的泛型基本上完全是在编译器中用于编译器执行类型检查和类型推断，然后生成普通的非凡行的字节码，这种实现技术为擦除erasure（编译器使用泛型类型保证类型安全，然后在生成字节码之前将其清除），这是因为扩展虚拟机指令来支持泛型被认为是无法接受的，这回为java厂商升级其jvm造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。

package studybase_2;

import java.util.ArrayList;
import java.util.Collection;

public class GenericTest {

/**
 * @param args
 */
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
ArrayList collection1 = new ArrayList();
collection1.add(1);
collection1.add(1L);
collection1.add("abd");
int i =(Integer)collection1.get(1);//ClassCastException
*/
ArrayList collection2 = new ArrayList();
collection2.add("abd");
collection2.add("zhangshn");
collection2.add("lisi");
String element = collection2.get(1);
System.out.println(element);
//Class
//Class x = Class.forName("java.lang.String");
add(3,5);
      //类型的推断，二者最小公约
Number x = add(3,3.3);//返回值类型为二者最小所在集,int   float ---Number
Object s =add(3,"abc");//int    String------Object
swap(new String[]{"a","fdf","fdfggg"},1,2);
swap(new int[]{1,2,3},1,2);//错误，T应该是引用型类型，必须是对象猜想
}
public static void printCollection(Collection collection)
{
System.out.println(collection.size());
for(Object obj:collection)
{
System.out.println(obj);
}
}
private static T add(T x,T y)
{
return null;
}
private static void swap(T[] a,int i,int j)
{
T tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}


自定义泛型类的应用
如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：
        public class GenericDao
        {
                private T field1;
                public void save(T obj)
                {

                }

                public T getById(int id)
                {

                }
        }

类级别的泛型时根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都课可以
        GenericDao dao = null;
        new GenericDao();
注意：在堆泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型
            当一个变量被声明为泛型时，只能被实例变量和方法调用（还有内嵌类型），而而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类锁共享的，所以静态成员不应该有类级别的类型参数。
         public static void update2()//可以，给该静态方法加泛型
{
}
public static void update(T obj)//错误，这里不能调用泛型参数
{
}
问题：类中只有一个方法需要使用泛型，是使用类级别的翻新还是使用方法级别的泛型？方法级别。


package studybase_2;

import java.util.Set;

public class GenericDao {

/**
 * @param args
 */
public void add(T x)
{
}
public T findById(int id)
{
return null;
}
public void delete(T obj)
{
}
public void delete(int id)
{
}
public void update(T obj)
{
}
public Set findByConditions(String name)
{
return null;
}
public T findByUserName(String name)
{
return null;
}
public static void update2()//可以，给该静态方法加泛型
{
}
public static void update(T obj)//错误，这里不能调用泛型参数
{
}
}

31、通过反射获得泛型的实际类型参
得到参数化类型的方法，通过反射得到该方法的字节码，然后得到该方法中参数的泛型类型
public static void main(String[] args)
{
//通过反射得到泛型实际参数的类型
Method applyMethod = GenericDao.class.getMethod("applyVector",Vector.class);
Type[] type = applyMethod.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType)types[0];
System.out.println(pType.getRawType());//得到  Vector
System.out.println(pType.getActualTypeArguments());//得到Date
}
public static void applyVector(Vector v1)
{
//有个方法可以根据提供的变量获得该变量的泛型的实际参数
}

32、类加载器
        java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap ,ExtClassLoader,AppClassLoader
        类加载器也是java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是java类，这正是BootStrap
        java虚拟机中的所有类加载器采用具有斧子关系的树形结构进行组织，在实例化每个类加载器对象时，需要为其制定一个父级类加载器对象或者默认采用系统类加载器为其父级类加载器。

类加载器之间的斧子关系和管辖范围
            BootStrap——JRE/lib/ rt.jar
                    |
            ExtClassLoader——JRE/lib/ ext/*.jar
                    |
System classLoader——AppClassLoader—— CLASSPATH指定的所有jar或目录
                                        /                    \
                            MyClassLoader        ItcastClassLoader——传播智客制定的特殊目录

示例：
package day2;
public class ClassLoaderTest {
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(
    ClassLoaderTest.class.getClassLoader().getClass().getName());
  System.out.println(System.class.getClassLoader()); // null
 
  ClassLoader loader = ClassLoaderTest.class.getClassLoader();
  while(loader != null)
  {
   System.out.println(loader.getClass().getName());
   loader = loader.getParent();
  }
  System.out.println(loader);
 
  System.out.println(System.class.getClassLoader());
  System.out.println(
    ClassLoaderTest.class.getClassLoader().getClass().getName()
    );
 
  ClassLoader loader1 = ClassLoaderTest.class.getClassLoader();
  while(loader1 != null)
  {
   System.out.println(loader1.getClass().getName());
   loader1 = loader1.getParent();
  }
  System.out.println(loader1);
 }
}

33、类加载器的委托机制

当java虚拟机要加载一个类时， 到底派出哪个类加载器去加载？
        首先当前线程的类加载器去加载线程中的第一个类
        如果类A中引用了类B，java虚拟机将使用加载类A的类加载器来加载类B
        还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类
每个类加载器加载类时，又先委托给上级类加载器
        当所有祖宗类加载器没有加载到类（先祖后父再自己），回到发起者来加载器，还加载不了，则抛出ClassNotFoundException，，不是再去找发起者类加载器的子类加载器，因为没有getChild方法。
分析：由发起者父类加载，而不是由发起者子类去加载，原因一：发起者可能有多个子类，那么不确定由哪个子类去加载，而发起者只有一个父类，因此可以确定由父类加载器去加载。原因二：由父类加载器加载那么产生一份字节码文件，而由多个子类加载，有可能出现多份相同字节码，浪费内存空间。
        
34、编写自己的类加载器
    知识讲解：
            自定义的类加载器必须继承ClassLoader
            loadClass方法与findClass方法
            defineClass方法
父类--loadClass/findClass--得到class文件的转换成字节码--definClass（），简单的说就是，继承ClassLoader，覆盖findClass()方法，findClass()中用definClass()方法将字节数组转为字节码。（loadClass作用是逐级委托父类加载器去加载类，因此不用覆盖）
    编程步骤
            编写一个对文件内容进行简单加密的程序。
            编写了一个自己的类加载器，可实现对加密过的类进行装载和解密
            编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以处理使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName
    实验步骤：
            对不带包名的class文件进行加密，加密结果存放到另一个木，例如java MyClassLoader MyTest.class F:\itcast
            运行加载类的程序时，结果能够被正常加载，但打印出来的类加载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
            用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类加载器装载失败
            删除CLASSPATH环境下定的类文件，再执行上一步操作就可以了。

package day2;
import java.util.Date;
public class ClassLoaderAttachment extends Date {
 public String toString()
 {
  return "hello ,itcast";
 }
}


package day2;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class MyClassLoader extends ClassLoader{
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception{
  // TODO Auto-generated method stub
  String srcPath = args[0];//待加密的字节码文件
  String destDir = args[1]; //加密后文件的存放位置
  FileInputStream fis = new FileInputStream(srcPath);
  String destFileName = srcPath.substring(srcPath.lastIndexOf('\\')+1);
  String destPath = destDir+"\\"+destFileName;
  FileOutputStream fos = new FileOutputStream(destPath);
  cypher(fis,fos);
  fis.close();
  fos.close();
 }
 private static void cypher(InputStream ips,OutputStream ops) throws Exception 
 {
  int b = -1;
  while((b=ips.read()) != -1)
  {
   ops.write(b^0xff);
  }
 }
 
 private String classDir;
 @Override
 protected Class findClass(String name) throws ClassNotFoundException
 {
  String classFileName = classDir+"\\"+name+".class";
  FileInputStream fis ;
  try {
   fis = new FileInputStream(classFileName);
   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   try {
    cypher(fis,bos);
    fis.close();
    byte[] bytes = bos.toByteArray();
    return defineClass(bytes,0,bytes.length);
   } catch (Exception e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  } catch (FileNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  return super.findClass(name);
 }
 
 public MyClassLoader(){}
 
 public MyClassLoader(String classDir)
 {
  this.classDir = classDir;
 }
}


package day2;
import java.util.Date;
public class ClassLoaderTest {
 /**
  * @param args
  * @throws ClassNotFoundException
  * @throws IllegalAccessException
  * @throws InstantiationException
  */
 public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
  // TODO Auto-generated method stub
  System.out.println(
    ClassLoaderTest.class.getClassLoader().getClass().getName());
  System.out.println(System.class.getClassLoader()); // null
 
  ClassLoader loader = ClassLoaderTest.class.getClassLoader();
  while(loader != null)
  {
   System.out.println(loader.getClass().getName());
   loader = loader.getParent();
  }
  System.out.println(loader);
 
  System.out.println(System.class.getClassLoader());
  System.out.println(
    ClassLoaderTest.class.getClassLoader().getClass().getName()
    );
 
  ClassLoader loader1 = ClassLoaderTest.class.getClassLoader();
  while(loader1 != null)
  {
   System.out.println(loader1.getClass().getName());
   loader1 = loader1.getParent();
  }
  System.out.println(loader1);
 
  System.out.println(new ClassLoaderAttachment().toString());
 
  Class clazz = new MyClassLoader("itcastlib").loadClass("ClassLoaderAttachment");
  Date d1 = (Date) clazz.newInstance();
  System.out.println(d1);
 
 }
}

35、编写一个能打印出自己的类加载器名称和当前类加载器的斧子结构关系链的MyServlet，正常发布后，看到打印结果为WebAppClassLoader
        把MyServlet.class文件打成jar包，放到ext目录下，重启tomcat，发现找不到HttpServlet错误
        把tomcat中的servlet.jar也放到ext目录中，问题解决，打印结果ExtclassLoader
package cn.itcast1.itcastweb1.web.servlets;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class MyServlet extends HttpServlet {
 /**
  * The doGet method of the servlet.
  *
  * This method is called when a form has its tag value method equals to get.
  *
  * @param request the request send by the client to the server
  * @param response the response send by the server to the client
  * @throws ServletException if an error occurred
  * @throws IOException if an error occurred
  */
 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException { 
  response.setContentType("text/html");
  PrintWriter out = response.getWriter();
  ClassLoader loader = this.getClass().getClassLoader();
  while(loader != null)
  {
   out.println(loader.getClass().getName());
   loader = loader.getParent();
  }
  out.close();
 }
}


36、代理的概念与作用
    程序中的代理
            要为已经存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、、日志、计算方法的运行时间、事务管理等等，该如何做》
            编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码
            如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类还是代理类，这样以后很容易切换，比如，想要日志功能时就配置代理类，否则配置目标类，这样增加系统功能很容易，以后运行一段时间，又想去掉系统功能也很容易。
            AOP   Aspect oriented program    面向方面的编程

动态代理技术
        要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情，写成百上千个代理类
        JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类
        JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
        如果目标类没有实现一个接口，那么CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以便用CGLIB库
        代理类的各个方法中通常除了要调用目标的响应方法和对外返回目标返回的结果，还可以在代理方法中的如下四个位置加上系统功能代码：
                在调用目标方法之前
                在调用目标方法之后
                在调用目标方法前后
                在处理目标方法异常的catch块中

分析JVM动态生成的类
    创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数
    编码列出动态类中的所有构造方法和参数名
    编码列出动态类中所有的方法和参数名
    创建动态类的实例对象
            用反射获得构造方法
            编写一个最简单的invocationHandler类
            调用构造方法创建动态类的实例对象，并将编写的invocationHandler类的实例对象传进去
            打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常
            将创建动态类的实例对象代理该次匿名内部类的形式填写，
    总结思考，让jvm创建动态类及其实例对象，需要给它提供哪些信息
            三个方面：
                    生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知
                    产生的类字节码必须有个一个关联的类加载器对象
                    生成的类中的方法的代码是怎么样的，也得由我们提供，把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码，提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的，在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了
    用Proxy.newInstance方法直接一步就创建出代理对象

猜想分析动态生成的类的内部代码
    动态生成的类实现了Collection接口（可以实现若干接口），生成的类有Collection接口中的所有方法和一个如下接收InvocationHandler参数的构造方法。
    构造方法接收一个InvocationHandler对象，接收对象了要干什么用？该方法内部代码是怎么样实现的？
    
    $Proxy0 implements Collection
{
    InvocationHandler handler;
    public $Proxy0(InvocationHandler handler)
    {
        this.handler = handler;
    }
}
    实现的Collection接口中的各个方法的代码是怎么样的？InvocationHandler接口中定义的invoke方法接收的三个参数是什么意思？
    int size()
    {
        return handler.invoke(this,this.getClass().getMethod("size"),null);
    }
说明：
    Client 程序调用objproxy.add("aaa")方法时，涉及三要素：objProxy对象，add方法，"aaa"参数。
    Class Proxy$
    {
        add(Object object)
        {
            return handler.invoke(Object proxy,Method method,Object[] args),
        }
    } 


示例：
package day3;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
  System.out.println(clazzProxy1.getName());
 
  System.out.println("-----begin constructors list------");
  //$Proxy0()
  //$Proxy0(InvocationHandler,int)
  Constructor[] constructors = clazzProxy1.getConstructors();
  for(Constructor constructor:constructors)
  {
   String name = constructor.getName();
   StringBuilder sBuilder = new StringBuilder(name);
   sBuilder.append('(');
   Class[] clazzParams = constructor.getParameterTypes();
   for(Class clazzParam:clazzParams)
   {
    sBuilder.append(clazzParam.getName()).append(',');
   }
   if((clazzParams!= null)&&clazzParams.length !=0)
    sBuilder.deleteCharAt(sBuilder.length()-1);
   sBuilder.append(')');
   System.out.println(sBuilder.toString());
  }
 
  System.out.println("-----begin methods list------");
  //$Proxy0()
  //$Proxy0(InvocationHandler,int)
  Method[] methods = clazzProxy1.getMethods();
  for(Method method:methods)
  {
   String name = method.getName();
   StringBuilder sBuilder = new StringBuilder(name);
   sBuilder.append('(');
   Class[] clazzParams = method.getParameterTypes();
   for(Class clazzParam:clazzParams)
   {
    sBuilder.append(clazzParam.getName()).append(',');
   }
   if((clazzParams!= null)&&clazzParams.length !=0)
    sBuilder.deleteCharAt(sBuilder.length()-1);
   sBuilder.append(')');
   System.out.println(sBuilder.toString());
   
   
  }
 
 
  System.out.println("-----begin creat instance list------");
  //方式一：用一般方式，类实现InvocationHandler
  Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
  class MyInvocationHandler1 implements InvocationHandler
  {
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
   
  }
  Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler1());
  System.out.println(proxy1);
  System.out.println(proxy1.toString());
 
  proxy1.clear();//清楚集合，返回值为void
  //System.out.println(proxy1.size());//出现问题，空指针异常，方法size()有返回值
  //size()方法返回值类型int，而 invoke方法 return null，不匹配，因此出问题
 
  //方式二：用匿名内部类方式实现
  Collection proxy2 = (Collection) constructor.newInstance(new InvocationHandler(){
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
   
  });
 
  //方式三：用方法newProxyInstance
  Collection proxy3 = (Collection)Proxy.newProxyInstance(
    Collection.class.getClassLoader(),
    new Class[]{Collection.class},
    new InvocationHandler()
    {
     ArrayList target = new ArrayList();
     public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
      //ArrayList target = new ArrayList();
      long beginTime = System.currentTimeMillis();
      Object retVal = method.invoke(target, args);
      long endTime = System.currentTimeMillis();
      System.out.println(method.getName()+"running time of"+(endTime-beginTime));
      return retVal;
      //return method.invoke(proxy3, args);死循环
     }
    }
    );
  proxy3.add("zxx");//每调用一次add方法就调用一次invoke
  proxy3.add("lhm");//每调用一次add方法就调用一次invoke
  proxy3.add("bxd");//每调用一次add方法就调用一次invoke
  System.out.println(proxy3.size());//每调用一次size()方法就调用一次invoke
  //这里size()为0,因为ArrayList target = new ArrayList();在invoke方法内部，每次调用都是单独的，因此size为0
  //将ArrayList target = new ArrayList();挪到方法外就可以了
  System.out.println(proxy3.getClass().getName());
  //Proxy0,因为只有hashCode() equals()和 toString()三个方法委托给InvocationHandler，其他方法有各自的实现
  //上面的add size方法，InvocationHandler对象的invoke方法，用的是toString方法
 }
}


黑马程序员_JAVA基础加强笔记_第1张图片

分析动态代理的工作原理图
怎样将目标类传进去？
    直接在InvocationHandler实现类中创建目标类的实例对象，可以看运行效果和加入日志代码，但没有实际意义。
    为InvocationHandler实现类注入目标类的实例对象，不能采用匿名内部类的形式了。
    让匿名的InvocationHandler实现类访问外面方法中的目标类实例对象的final类型的引用变量。
将创建代理的过程改为一种更优雅的方式，eclipse重构出一个getProxy方法绑定接收目标同时返回代理对象，让调用者更懒惰，更方便，调用者甚至不用接触任何代理的API。
将系统功能代码模块化，即将切面代码页改为通过参数形式提供，怎样把要执行的系统功能代码以参数形式提供？
    把要执行的代码装到一个对象的某个方法里，然后把这个对象作为参数传递，接受者只要调用这个对象的方法，即等于执行了外界提供的代码。
    为bind方法增加一个Advice参数。


package day3;
import java.lang.reflect.Method;
public interface Advice {
 void beforeMethod(Method method);
 void afterMethod(Method method);
}

package day3;
import java.lang.reflect.Method;
public class MyAdvice implements Advice{
 long beginTime = 0;
 @Override
 public void beforeMethod(Method method) {
  // TODO Auto-generated method stub
  System.out.println("study");
  beginTime = System.currentTimeMillis();
 }
 @Override
 public void afterMethod(Method method) {
  // TODO Auto-generated method stub
  System.out.println("work");
  long endTime = System.currentTimeMillis();
  System.out.println(method.getName()+"running time of"+(endTime-beginTime));
 }
 
}


package day3;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
public class ProxyTest {
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
  System.out.println(clazzProxy1.getName());
 
  System.out.println("-----begin constructors list------");
  //$Proxy0()
  //$Proxy0(InvocationHandler,int)
  Constructor[] constructors = clazzProxy1.getConstructors();
  for(Constructor constructor:constructors)
  {
   String name = constructor.getName();
   StringBuilder sBuilder = new StringBuilder(name);
   sBuilder.append('(');
   Class[] clazzParams = constructor.getParameterTypes();
   for(Class clazzParam:clazzParams)
   {
    sBuilder.append(clazzParam.getName()).append(',');
   }
   if((clazzParams!= null)&&clazzParams.length !=0)
    sBuilder.deleteCharAt(sBuilder.length()-1);
   sBuilder.append(')');
   System.out.println(sBuilder.toString());
  }
 
  System.out.println("-----begin methods list------");
  //$Proxy0()
  //$Proxy0(InvocationHandler,int)
  Method[] methods = clazzProxy1.getMethods();
  for(Method method:methods)
  {
   String name = method.getName();
   StringBuilder sBuilder = new StringBuilder(name);
   sBuilder.append('(');
   Class[] clazzParams = method.getParameterTypes();
   for(Class clazzParam:clazzParams)
   {
    sBuilder.append(clazzParam.getName()).append(',');
   }
   if((clazzParams!= null)&&clazzParams.length !=0)
    sBuilder.deleteCharAt(sBuilder.length()-1);
   sBuilder.append(')');
   System.out.println(sBuilder.toString());
   
   
  }
 
 
  System.out.println("-----begin creat instance list------");
  //方式一：用一般方式，类实现InvocationHandler
  Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);
  class MyInvocationHandler1 implements InvocationHandler
  {
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
   
  }
  Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHandler1());
  System.out.println(proxy1);
  System.out.println(proxy1.toString());
 
  proxy1.clear();//清楚集合，返回值为void
  //System.out.println(proxy1.size());//出现问题，空指针异常，方法size()有返回值
  //size()方法返回值类型int，而 invoke方法 return null，不匹配，因此出问题
 
  //方式二：用匿名内部类方式实现
  Collection proxy2 = (Collection) constructor.newInstance(new InvocationHandler(){
   @Override
   public Object invoke(Object proxy, Method method, Object[] args)
     throws Throwable {
    // TODO Auto-generated method stub
    return null;
   }
   
  });
 
// //方式三：用方法newProxyInstance
// Collection proxy3 = (Collection)Proxy.newProxyInstance(
// Collection.class.getClassLoader(),
// new Class[]{Collection.class},
// new InvocationHandler()
// {
// ArrayList target = new ArrayList();
// public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
// //ArrayList target = new ArrayList();
// long beginTime = System.currentTimeMillis();
// Object retVal = method.invoke(target, args);
// long endTime = System.currentTimeMillis();
// System.out.println(method.getName()+"running time of"+(endTime-beginTime));
// return retVal;
// //return method.invoke(proxy3, args);死循环
// }
// }
// );
// proxy3.add("zxx");//每调用一次add方法就调用一次invoke
// proxy3.add("lhm");//每调用一次add方法就调用一次invoke
// proxy3.add("bxd");//每调用一次add方法就调用一次invoke
// System.out.println(proxy3.size());//每调用一次size()方法就调用一次invoke
// //这里size()为0,因为ArrayList target = new ArrayList();在invoke方法内部，每次调用都是单独的，因此size为0
// //将ArrayList target = new ArrayList();挪到方法外就可以了
// System.out.println(proxy3.getClass().getName());
// //Proxy0,因为只有hashCode() equals()和 toString()三个方法委托给InvocationHandler，其他方法有各自的实现
// //上面的add size方法，InvocationHandler对象的invoke方法，用的是toString方法
 
 
  //方式四：框架
  final ArrayList target = new ArrayList();
  Collection proxy3 = (Collection)getProxy(target, new MyAdvice());
  proxy3.add("zxx");//每调用一次add方法就调用一次invoke
  proxy3.add("lhm");//每调用一次add方法就调用一次invoke
  proxy3.add("bxd");//每调用一次add方法就调用一次invoke
  System.out.println(proxy3.size());//每调用一次size()方法就调用一次invoke
  //这里size()为0,因为ArrayList target = new ArrayList();在invoke方法内部，每次调用都是单独的，因此size为0
  //将ArrayList target = new ArrayList();挪到方法外就可以了
  System.out.println(proxy3.getClass().getName());
  //Proxy0,因为只有hashCode() equals()和 toString()三个方法委托给InvocationHandler，其他方法有各自的实现
  //上面的add size方法，InvocationHandler对象的invoke方法，用的是toString方法
 }
 public static Object getProxy(final Object target,final Advice advice) {
  Object proxy3 =Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    //new Class[]{Collection.class},
    target.getClass().getInterfaces(),
    new InvocationHandler()
    {
     
     public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
      //ArrayList target = new ArrayList();
// long beginTime = System.currentTimeMillis();
// Object retVal = method.invoke(target, args);
// long endTime = System.currentTimeMillis();
// System.out.println(method.getName()+"running time of"+(endTime-beginTime));
// return retVal;
      //return method.invoke(proxy3, args);死循环
     
     
      advice.beforeMethod(method);
      Object retVal = method.invoke(target, args);
      advice.afterMethod(method);
     
     
      return retVal;
     }
    }
    );
  return proxy3;
 }
}


实现AOP功能的封装与配置
1、工厂类BeanFactory负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其getBean方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是ProxyFactoryBean，则直接返回该类的实例对象，否则，返回该类实例对象的getProxy方法返回的对象。
2、BeanFactory的构造方法接收代表配置文件的输入流对象，配置文件格式如下：
#xxx = java.util.ArrayList
xxx = cn.itcast.ProxyFactoryBean
xxx.target = java.util.ArrayList
xxx.advice = cn.itcast.MyAdvice
3、ProxyFactoryBean充当封装生成动态代理的工厂，需要为工厂类提供哪些配置参数信息？
目标
通知
4、编写客户端应用：
编写实现Advice接口的类和在配置文件中进行配置
调用BeanFactory获取对象

示例：
package day3;
import java.lang.reflect.Method;
public interface Advice {
 void beforeMethod(Method method);
 void afterMethod(Method method);
}


package day3.aopframework;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import day3.Advice;
public class BeanFactory {
 Properties props = new Properties();
 public BeanFactory(InputStream ips)
 {
  try {
   props.load(ips);
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 public Object getBean(String name) throws InstantiationException, IllegalAccessException
 {
  String className = props.getProperty(name);
  Object bean = null;
  try {
   Class clazz = Class.forName(className);
   bean = clazz.newInstance();
   
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 
  if(bean instanceof ProxyFactoryBean)
   {
    Object proxy = null;
    ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean)bean;
    Object target;
    try {
     Advice advice = (Advice)Class.forName(props.getProperty(name+".advice")).newInstance();
   
     target = Class.forName(props.getProperty(name+".target")).newInstance();
     
     proxyFactoryBean.setAdvice(advice);
     proxyFactoryBean.setTarget(target);
     proxy = ((ProxyFactoryBean)bean).getProxy();
    } catch (Exception e) {
     // TODO Auto-generated catch block 
     e.printStackTrace();
    }
   
    return proxy;
   }
  return bean;
 }
}


package day3.aopframework;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import day3.Advice;
public class ProxyFactoryBean {
 private Advice advice;
 public Advice getAdvice() {
  return advice;
 }
 public void setAdvice(Advice advice) {
  this.advice = advice;
 }
 public Object getTarget() {
  return target;
 }
 public void setTarget(Object target) {
  this.target = target;
 }
 private Object target;
 public Object getProxy() {
  // TODO Auto-generated method stub
  Object proxy3 =Proxy.newProxyInstance(
    target.getClass().getClassLoader(),
    //new Class[]{Collection.class},
    target.getClass().getInterfaces(),
    new InvocationHandler()
    {
     public Object invoke(Object proxy,Method method,Object[] args)throws Throwable{
     
      advice.beforeMethod(method);
      Object retVal = method.invoke(target, args);
      advice.afterMethod(method);
      return retVal;
     }
    }
    );
  return proxy3;
 }
}

配置文件：config.properties
xxx=java.util.ArrayList
#xxx=day3.aopframework.ProxyFactoryBean
xxx.advice=day3.MyAdvice
xxx.target=java.util.ArrayList


测试类：
package day3.aopframework;
import java.io.InputStream;
public class AopFrameWorkTest {
 /**
  * @param args
  */
 public static void main(String[] args) throws Exception {
  // TODO Auto-generated method stub
  InputStream ips = AopFrameWorkTest.class.getResourceAsStream("config.properties");
  Object bean = new BeanFactory(ips).getBean("xxx");
  System.out.println(bean.getClass().getName());
 }
}


你可能感兴趣的:(JAVA基础加强笔记)

  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day17笔记-高阶函数 ~在杰难逃~ Python笔记python开发语言pycharm数据分析
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
    为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 基于Python给出的PDF文档转Markdown文档的方法 程序媛了了 pythonpdf开发语言
    注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
  • Spring的注解积累 yijiesuifeng spring注解
    用注解来向Spring容器注册Bean。   需要在applicationContext.xml中注册： <context:component-scan base-package=”pagkage1[,pagkage2,…,pagkageN]”/>。 如：在base-package指明一个包    <context:component-sc
  • 传感器 百合不是茶 android传感器
    android传感器的作用主要就是来获取数据,根据得到的数据来触发某种事件   下面就以重力传感器为例;   1,在onCreate中获得传感器服务   private SensorManager sm;// 获得系统的服务 private Sensor sensor;// 创建传感器实例 @Override protected void
  • [光磁与探测]金吕玉衣的意义 comsci
          这是一个古代人的秘密:现在告诉大家       信不信由你们:       穿上金律玉衣的人,如果处于灵魂出窍的状态,可以飞到宇宙中去看星星       这就是为什么古代
  • 精简的反序打印某个数 沐刃青蛟 打印
    以前看到一些让求反序打印某个数的程序。 比如：输入123，输出321。   记得以前是告诉你是几位数的，当时就抓耳挠腮，完全没有思路。   似乎最后是用到%和/方法解决的。   而今突然想到一个简短的方法，就可以实现任意位数的反序打印（但是如果是首位数或者尾位数为0时就没有打印出来了）   代码如下： long num, num1=0;
  • PHP：6种方法获取文件的扩展名 IT独行者 PHP扩展名
      PHP：6种方法获取文件的扩展名   1、字符串查找和截取的方法   1 $extension = substr ( strrchr ( $file ,  '.' ), 1); 2、字符串查找和截取的方法二   1 $extension = substr
  • 面试111 文强chu 面试
    1事务隔离级别有那些 ，事务特性是什么（问到一次） 2 spring aop 如何管理事务的，如何实现的。动态代理如何实现，jdk怎么实现动态代理的，ioc是怎么实现的，spring是单例还是多例，有那些初始化bean的方式，各有什么区别（经常问） 3 struts默认提供了那些拦截器 （一次） 4 过滤器和拦截器的区别 （频率也挺高） 5 final，finally final
  • XML的四种解析方式 小桔子 domjdomdom4jsax
    在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 　　预 备 　　测试环境： 　　AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server
  • wordpress中常见的操作 aichenglong 中文注册wordpress移除菜单
    1 wordpress中使用中文名注册解决办法   1)使用插件   2)修改wp源代码      进入到wp-include/formatting.php文件中找到       function sanitize_user( $username, $strict = false
  • 小飞飞学管理-1 alafqq 管理
    项目管理的下午题，其实就在提出问题（挑刺），分析问题，解决问题。 今天我随意看下10年上半年的第一题。主要就是项目经理的提拨和培养。 结合我自己经历写下心得 对于公司选拔和培养项目经理的制度有什么毛病呢？ 1，公司考察，选拔项目经理，只关注技术能力，而很少或没有关注管理方面的经验，能力。 2，公司对项目经理缺乏必要的项目管理知识和技能方面的培训。 3，公司对项目经理的工作缺乏进行指
  • IO输入输出部分探讨 百合不是茶 IO
     //文件处理  在处理文件输入输出时要引入java.IO这个包； /* 1，运用File类对文件目录和属性进行操作 2，理解流，理解输入输出流的概念 3，使用字节/符流对文件进行读/写操作 4，了解标准的I/O 5，了解对象序列化 */   //1，运用File类对文件目录和属性进行操作   //在工程中线创建一个text.txt
  • getElementById的用法 bijian1013 element
            getElementById是通过Id来设置/返回HTML标签的属性及调用其事件与方法。用这个方法基本上可以控制页面所有标签，条件很简单，就是给每个标签分配一个ID号。        返回具有指定ID属性值的第一个对象的一个引用。        语法： &n
  • 励志经典语录 bijian1013 励志人生
    经典语录1:   哈佛有一个著名的理论：人的差别在于业余时间，而一个人的命运决定于晚上8点到10点之间。每晚抽出2个小时的时间用来阅读、进修、思考或参加有意的演讲、讨论，你会发现，你的人生正在发生改变，坚持数年之后，成功会向你招手。不要每天抱着QQ/MSN/游戏/电影/肥皂剧……奋斗到12点都舍不得休息，看就看一些励志的影视或者文章，不要当作消遣；学会思考人生，学会感悟人生
  • [MongoDB学习笔记三]MongoDB分片 bit1129 mongodb
    MongoDB的副本集(Replica Set)一方面解决了数据的备份和数据的可靠性问题，另一方面也提升了数据的读写性能。MongoDB分片(Sharding)则解决了数据的扩容问题，MongoDB作为云计算时代的分布式数据库，大容量数据存储，高效并发的数据存取，自动容错等是MongoDB的关键指标。 本篇介绍MongoDB的切片(Sharding)   1.何时需要分片 &nbs
  • 【Spark八十三】BlockManager在Spark中的使用场景 bit1129 manager
    1. Broadcast变量的存储，在HttpBroadcast类中可以知道 2. RDD通过CacheManager存储RDD中的数据，CacheManager也是通过BlockManager进行存储的 3. ShuffleMapTask得到的结果数据，是通过FileShuffleBlockManager进行管理的，而FileShuffleBlockManager最终也是使用BlockMan
  • yum方式部署zabbix ronin47 yum方式部署zabbix
    安装网络yum库#rpm -ivh http://repo.zabbix.com/zabbix/2.4/rhel/6/x86_64/zabbix-release-2.4-1.el6.noarch.rpm 通过yum装mysql和zabbix调用的插件还有agent代理#yum install zabbix-server-mysql zabbix-web-mysql mysql-
  • Hibernate4和MySQL5.5自动创建表失败问题解决方法 byalias J2EEHibernate4
    今天初学Hibernate4，了解了使用Hibernate的过程。大体分为4个步骤： ①创建hibernate.cfg.xml文件 ②创建持久化对象 ③创建*.hbm.xml映射文件 ④编写hibernate相应代码 在第四步中，进行了单元测试，测试预期结果是hibernate自动帮助在数据库中创建数据表，结果JUnit单元测试没有问题，在控制台打印了创建数据表的SQL语句，但在数据库中
  • Netty源码学习-FrameDecoder bylijinnan javanetty
    Netty 3.x的user guide里FrameDecoder的例子，有几个疑问： 1.文档说：FrameDecoder calls decode method with an internally maintained cumulative buffer whenever new data is received. 为什么每次有新数据到达时，都会调用decode方法？ 2.Dec
  • SQL行列转换方法 chicony 行列转换
    create table tb(终端名称 varchar(10) , CEI分值 varchar(10) , 终端数量 int) insert into tb values('三星' , '0-5' , 74) insert into tb values('三星' , '10-15' , 83) insert into tb values('苹果' , '0-5' , 93)
  • 中文编码测试 ctrain 编码
    循环打印转换编码 String[] codes = { "iso-8859-1", "utf-8", "gbk", "unicode" }; for (int i = 0; i < codes.length; i++) { for (int j
  • hive 客户端查询报堆内存溢出解决方法 daizj hive堆内存溢出
    hive> select * from t_test where ds=20150323 limit 2; OK Exception in thread "main" java.lang.OutOfMemoryError: Java heap space   问题原因： hive堆内存默认为256M   这个问题的解决方法为： 修改/us
  • 人有多大懒，才有多大闲 (评论『卓有成效的程序员』) dcj3sjt126com 程序员
      卓有成效的程序员给我的震撼很大，程序员作为特殊的群体，有的人可以这么懒，  懒到事情都交给机器去做 ，而有的人又可以那么勤奋，每天都孜孜不倦得做着重复单调的工作。   在看这本书之前，我属于勤奋的人，而看完这本书以后，我要努力变成懒惰的人。 不要在去庞大的开始菜单里面一项一项搜索自己的应用程序，也不要在自己的桌面上放置眼花缭乱的快捷图标
  • Eclipse简单有用的配置 dcj3sjt126com eclipse
    1、显示行号  Window -- Prefences -- General -- Editors -- Text Editors -- show line numbers   2、代码提示字符 Window ->Perferences，并依次展开 Java -> Editor -> Content Assist，最下面一栏 auto-Activation
  • 在tomcat上面安装solr4.8.0全过程 eksliang Solrsolr4.0后的版本安装solr4.8.0安装
    转载请出自出处： http://eksliang.iteye.com/blog/2096478       首先solr是一个基于java的web的应用，所以安装solr之前必须先安装JDK和tomcat，我这里就先省略安装tomcat和jdk了         第一步：当然是下载去官网上下载最新的solr版本，下载地址
  • Android APP通用型拒绝服务、漏洞分析报告 gg163 漏洞androidAPP分析
    点评：记得曾经有段时间很多SRC平台被刷了大量APP本地拒绝服务漏洞，移动安全团队爱内测（ineice.com）发现了一个安卓客户端的通用型拒绝服务漏洞，来看看他们的详细分析吧。  0xr0ot和Xbalien交流所有可能导致应用拒绝服务的异常类型时，发现了一处通用的本地拒绝服务漏洞。该通用型本地拒绝服务可以造成大面积的app拒绝服务。  针对序列化对象而出现的拒绝服务主要
  • HoverTree项目已经实现分层 hvt 编程.netWebC#ASP.ENT
    HoverTree项目已经初步实现分层，源代码已经上传到 http://hovertree.codeplex.com请到SOURCE CODE查看。在本地用SQL Server 2008 数据库测试成功。数据库和表请参考：http://keleyi.com/a/bjae/ue6stb42.htmHoverTree是一个ASP.NET 开源项目，希望对你学习ASP.NET或者C#语言有帮助，如果你对
  • Google Maps API v3: Remove Markers 移除标记 天梯梦 google maps api
    Simply do the following:   I. Declare a global variable: var markersArray = [];   II. Define a function: function clearOverlays() { for (var i = 0; i < markersArray.length; i++ )
  • jQuery选择器总结 lq38366 jquery选择器
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
  • 基础数据结构和算法六：Quick sort sunwinner AlgorithmQuicksort
    Quick sort is probably used more widely than any other. It is popular because it is not difficult to implement, works well for a variety of different kinds of input data, and is substantially faster t
  • 如何让Flash不遮挡HTML div元素的技巧_HTML/Xhtml_网页制作 刘星宇 htmlWeb
    今天在写一个flash广告代码的时候，因为flash自带的链接，容易被当成弹出广告，所以做了一个div层放到flash上面，这样链接都是a触发的不会被拦截，但发现flash一直处于div层上面，原来flash需要加个参数才可以。 让flash置于DIV层之下的方法，让flash不挡住飘浮层或下拉菜单，让Flash不档住浮动对象或层的关键参数：wmode=opaque。 方法如下：
  • Mybatis实用Mapper SQL汇总示例 wdmcygah sqlmysqlmybatis实用
    Mybatis作为一个非常好用的持久层框架，相关资料真的是少得可怜，所幸的是官方文档还算详细。本博文主要列举一些个人感觉比较常用的场景及相应的Mapper SQL写法，希望能够对大家有所帮助。 不少持久层框架对动态SQL的支持不足，在SQL需要动态拼接时非常苦恼，而Mybatis很好地解决了这个问题，算是框架的一大亮点。对于常见的场景，例如：批量插入/更新/删除，模糊查询，多条件查询，联表查询，