java的高新技术

eclipse以及IDE开发

1、myeclipse是eclipse的插件，eclipse就是java开发的

2、简写；

Java ee : Java Platform，Enterprise Edition

ide: IDE的英文全称为“IntegratedDrive Electronics”,即“电子集成驱动器

jms: Java消息服务Java Message Servicejmx: Java Management Extensions

JNDI(Java Naming and Directory Interface,Java命名和目录接口

3、包名是域名倒过来写。

4、面试的时候看得的就是卷面整洁，命名准确，单词正取。     

5、配置快捷键：

 

6、视图就是每个小窗口，而透视图就是小窗口的集合。

7、如何调试：[右击]----【debug as】

变量的值：【watch】

如何快速的让选中的代码马上的形成try-catch 

【选中】--【右键】---【surround with】--【try--catch】

8、配置模板：

【windows】--【preferences】---【template】--【这个时候就可以配置模板了】

 

 

 

 

 

反射的基石Class

1、如何得到各个字节码对应的实例对象

l  类名.class 例如：System.class

l  对象.getClass(),例如：P.getClass();

l  Class.forName(类名)；例如：Class.forName(“java.util.Date”);

 

注意：编译器只看变量的定义，不看代码的运行。

 

反射（还是不怎么明白）

1、反射就是把java类中的各种成分映射成为相应的java类。例如：一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法等信息也可以用一个个java类来表示，一个汽车是一个类，汽车中的发动机，变速箱等等也是一个一个的类。

Constructor类

l  Constructor类代表某个类中的一个构造方法。

l  得到某个类中的所有的构造方法：

Constructor constroctor[]=

       Class.forName(“java.lang.String”).getConstructors();

 

l  得到某一个构造方法：

Constructor constructor =

       Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

 

l  创建实例对象：

通常的方式：String str=new String(new StringBuffer(“abc”));

反射的方式：String str=(String)constructor.newInstance(new StringBuffer(“sc”));

 

注意：在eclipse中生成源代码的快捷键是:alt+shift+s ,然后要生成什么看哪个下面划线就单击哪个字母就可以了。

 

Filed类

1、field类代表的是某个类中的一个成员变量。

2、例子：

 

package cn.itcast.day01;

import java.lang.reflect.Field;

public class ReflectTest {

      public static void main(String[] args) throws Exception{

           //定义对象

           ReflectPoint pt1=new ReflectPoint(3,5);

           //通过对象得到对应的字节码文件，通过字节码文件的getField方法得到对象的字段

           Field fieldY=pt1.getClass().getField("y");

           //注意这里的fieldY的值不是5，想要得到具体的值要通过get方法，同时把对象传递进来。      

          

           //得到对应的字段

           //Field fieldX=pt1.getClass().getField("x");

           //这句话会报错 java.lang.NoSuchFieldException,因为x是私有的，那么怎么得到这个字段呢？

           FieldfieldX=pt1.getClass().getDeclaredField("x");

           //System.out.println(fieldX.get(pt1));

           //又出现错误 java.lang.IllegalAccessException，因为x是私有的，即使得到了，也不能够够使用

           //这时候我们采用的方法就是”暴力使用“

           fieldX.setAccessible(true);

           System.out.println(fieldX.get(pt1));

          

       //反射的例子：

      //将任意一个对象中所有的String类型的成员变量所对应的字符串中的“b”改成"a"          

      changeStringValue(pt1);

      System.out.println(pt1);

      }

     

      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);

                            StringnewValue=oldValue.replace('b', 'a');

                            field.set(obj,newValue);

                      }

                     

                 }

      }

}

 

Method类

1、 Method类代表某个类中的一个成员方法

2、 得到类中的某一个方法：

Method charAt =

 Class.forName（“java.lang.String()”）.getMethod(“charAt”,int.class);

//charAt是类的名字，int.class是参数的类型

 

3、调用的方法:

通常的方法：str.charAt(1);

反射的方法：charAt.invoke(str,1);

 

注意：如果传递给Method对象的invoke()方法的一个参数为null,说明Method对象对应的是一个静态的方法。

 

      //需求：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。

      String startingClassName =args[0];

      Method mainMethod =

                 Class.forName(startingClassName).getMethod("main",String[].class );

      mainMethod.invoke(null, (Object)new String[]{"111","222","444"});

}

 

 

数组的反射

1、   Array工具类可以用于完成对数组的反射操作

反射的作用---实现框架

综合案例：

l  先直接用new语句创建ArrayList和HashSet的实例对象，用eclipse自动生成ReflectPoint类的equals和hashcode方法，比较两个集合的运行结果的差异

l  采用配置文件加上反射的鍽꧋创建ArrayList和HashSet的实例对象，比较观察结果的差异。

 

JavaBean

1、

是一类特殊的类，这个类中的方法由set和get组成，那么它就是JavaBean。

通过set后者get可以推断出这个类中的属性。

 

2、javaBean的简单的应用

 

package cn.itcast.day01;

 

import java.beans.IntrospectionException;

import java.beans.PropertyDescriptor;

import java.lang.reflect.Method;

 

public class IntroSpectorTest {

      public static void main(String[] args) throws Exception{

           ReflectPoint pt1= new ReflectPoint(3,5);

          

           //ReflectPoint中的某个属性

           String propertyName="x";

          

           //使用javaBean中的方法对属性进行操作

          

           //传递进来要修改的属性的名字以及所对应的类

           PropertyDescriptor pd = new PropertyDescriptor(propertyName,pt1.getClass());

           //获取javaBean中自己所需要的方法

           Method methodGetX=pd.getReadMethod();

           //返回自己后去的值,使用内省

           Object retVal =methodGetX.invoke(pt1);

           System.out.println(retVal);

          

          

           //使用javaBean对使用set方法对其属性进行设置         

           String propertyName2 ="y";

           PropertyDescriptor pd2 = new PropertyDescriptor(propertyName2, pt1.getClass());

           Method methodSetY=pd2.getWriteMethod();

           methodSetY.invoke(pt1, 8);

          

           System.out.println(pt1.getY());

          

      }

}

 

注意：使用eclipse导入jar包的方法:【新建一个文件】--【将jar包导入】--【右键】--【build path】--【添加到buildpath中】

 

PropertyUtils：对类型转换就是本身的

BeanUtils：对类型的转换是String的。

 

注解的应用

 

1、JDk1.5的新特性：枚举、注解

2、每个注解都是一个java类

3、java提供的几个基本的注解：

@SuppressWarnings(“deprecation”) :消除了警告，对应source

@Override :为了防止子类在写父类的方法的时候出错，可以写上这个,对应source

@Deprecated :加上这个代表这个类就被删除了，别人再调用的时候就会画上横线。对应的是Runtime

4、java注解周期的三个生命阶段：java源文件-------class文件-----内存中的字节码文件，分别对应的是：@Retention的三个元注解：RetentionPolicy.SOURCE

RetentionPolicy.CLASS 和RetentionPolicy.RUNTIME

 

 

 

 

 

泛型

1、泛型是提供给javac编译器使用的，可以限定集合中输入类型，让编译器挡住源程序中非法输入，编译器编译带类型说明的集合时去掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法返回值和原始类型完全一样。同时，可以跳过编译器，使用反射得到集合然后向集合中加入其他的数据。

 

典型的例子：

package cn.itcast.day02;

import java.lang.reflect.InvocationTargetException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

public class GenericTest {

    public static void main(String[] args) throws Exception {

       Collection<Integer> collection =newArrayList<Integer>();

       collection.getClass().getMethod("add", Object.class).invoke(collection,"agc" );

       System.out.println(collection);

    }

}

 

2、ArrayList<Integer> 中的<>读作typeof

3、使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数无关的方法，不可以调用与参数有关的方法。

举例：

       //泛型的综合例子

       HashMap<String, Integer> maps =newHashMap<String,Integer>();

       maps.put("lili",23);

       maps.put("xiaoming", 10);

      

       Set<Map.Entry<String,Integer>>entrySet = maps.entrySet();

       for(Map.Entry<String,Integer> entry : entrySet){

           System.out.println(entry.getKey()+":"+ entry.getValue());         

       }     

    }

}

 

5、dao :dataaccess object --àcrud 数据访问对象。

 

类加载器

1、java虚拟机中可以安装多个类加载器，系统默认的主要有三个：BootStrap,ExtClassLoader,AppClassLoader

 

2、类加载器之间的父子关系以及管辖的范围：
---BootStrap  ————》jre/lib/rt.jar

--ExtClassLoader ————》jre/lib/ext/*.jar

--AppClassLoader ————》classpath指定的所有jar或者目录

 

3、类加载器的委托机制：每个类加载器在加载类的时候，又先委托给其上级的类加载器进行加载。

 

代理(??)

1、AOP（Aspectoriented program,简称AOP）面向方面的编程。

2、系统中存在交叉业务，一个交叉业务就是要切入到系统中的一个面，例如：安全，日志

3、动态代理的技术：

l  JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往作为代理类，即动态代理类。

l  JVM生成的动态类必须实现一个或者多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。

l  CGBL库可以动态的生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类动态生成代理类，可以使用CGBL库

l  代理类的各个方法中通常除了要调用目标的I型昂应的方法和对外的目标的返回的结果外，还可以在代理的方法中如下四个位置上加上系统功能代码：

²  在调用目标方法之前

²  在调用目标方法之后

²  在调用目标方法前后

²  在调用目标方法的catch块中

 

 

 

 

 

 

 

多线程

1、定义：

 

package cn.itcast.day04;

 

public class TraditionalThread {

    public static void main(String[] args){

      

       Thread thread =new Thread(){

           @Override

           public void run(){

              while(true){

                  try {

                     Thread.sleep(500);

                  } catch (InterruptedException e) {

                     // TODO Auto-generatedcatch block

                     e.printStackTrace();

                  }

                  System.out.println("1:"+Thread.currentThread().getName()); 

                  System.out.println("2:"+this.getName()); 

              }            

           }

       };

       thread.start();

      

       Thread thread2= new Thread(new Runnable() {

          

           @Override

           public void run() {

              System.out.println("1:"+Thread.currentThread().getName());           

           }

       });

       thread2.start();

      

       new Thread(

              new Runnable() {

                 

                  @Override

                  public void run() {

                     while(true){

                         try {

                            Thread.sleep(500);

                         } catch(InterruptedException e) {

                            // TODO Auto-generated catch block

                            e.printStackTrace();

                         }

                         System.out.println("runnable"+Thread.currentThread().getName());  

                     }  

                    

                  }

              }

              ){

           public void run(){

              while(true){

                  try {

                     Thread.sleep(500);

                  } catch (InterruptedException e) {

                     // TODO Auto-generatedcatch block

                     e.printStackTrace();

                  }

                  System.out.println("thread:"+Thread.currentThread().getName());   

              }  

                           

           }

       }.start();

    }

}

 

2、定时器：

 

package cn.itcast.day04;

 

import java.util.Date;

import java.util.Timer;

import java.util.TimerTask;

 

public class TraditionalTimerTest {

      private static int count =0;       //这就变成了类的了。

     

      public static void main(String[] args){

     

           class MyTimerTask extends TimerTask {

 

                 @Override

                 public void run() {

                      count=(count+1)%2;

                      System.out.println("bombing!");

                      new Timer().schedule(/*new TimerTask() {

                           

                            @Override

                            public void run() {

                                  System.out.println("bombing!2.......");

                                 

                            }

                      }*/new MyTimerTask(), 2000+2000*count );

                 }

           }

          

           new Timer().schedule(new MyTimerTask(), 2000);//调度

          

           while(true){

                 System.out.println(new Date().getSeconds());

                 try {

                      Thread.sleep(1000);

                 } catch (InterruptedException e) {

                      // TODO Auto-generated catch block

                      e.printStackTrace();

                 }               

           }

      }

}

 

3、线程的安全问题可以用银行转账来解释

4、要用到共同的数据（包括同步锁）或者共同的算法的若干个方法应该归在同一个类中，这种设计正好体现了高类聚和程序的健壮性。

5、单例设计模式

6、Java5中的线程并发库、线程池

7、Ctrl+7  :看有什么实现类