黑马程序员--java高新技术--

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------详细请查看： 

(1)Eclipse:

建立工程： 点击菜单上的File-- new -- project -- java project -- 写工  程名，天数 -- finish -- yes

 

eclipse创建好的工程路径:

bin -- 存储编译后的class文件的

src -- 存储写的源文件的java文件

 

在工程上，建包  ： 工程上鼠标右键 -- new -- package -- 包名  -- finish

 

建类 ： 包上鼠标右键 -- new -- class -- 写类名 -- finish

 

如何运行，3种方式:

A:点击绿色的箭头

B:在类的代码区域，鼠标右键 --run as -- java Appl

C: 左侧的类Demo.java

 

调整和设置 (个性化):

  代码的字体 ： window -- prefer -- gene -- appera -- color and fonts --java -- java edit text font -- edit

 

  控制台字体 ： window -- prefer -- gene -- appera -- color and fonts -- debug -- console font -- edit

 

  文本文件字体 ： window -- prefer -- gene -- appera -- color and fonts -- basic -- text font -- edit

 

 

  取消代码的悬浮效果 ： window -- prefer -- java -- editor -- hovers -- 勾去第一项

    回看提示框 -- F2

 

  

取消方法中多余的注释 ：winow -- prefer -- code style --  code templates -- code 

 

    删除插件，删除links文件夹，不管用，删除缓存  eclipse -- configuration -- update -- 删除

 

eclipse快捷键:

内容辅助快捷键  Alt + /

配置 Alt + /   window -- prefer -- java -- editor -- templates

单行注释快捷键  Ctrl + /  取消单行注释，再按一次

多行注释快捷键  Ctrl + Shift + /  取消多行注释  Ctrl + shift + \

复制当前行，在上或者下方  Ctrl + Alt + 上或者下箭头

移动当前行，在上或者下方  Alt + 上或者下箭头

意见与提示快捷键 Ctrl + 1  

导入包的快捷键  Ctrl + shift + o;

 

代码的自动生成:

代码区 ： 鼠标右键 -- source

自动调节，代码格式 Ctrl + shift + F

 

 工程的导入:

 包资源管理器 鼠标右键 import -- general -- into workspace

 

 debug调式模式:

 跟随代码运行，逐行代码跟踪调试

 运行过程中，实现变量值的查看，对象地址应用，数组中的内容

 F6 向下运行代码

 F5 进入方法

 

 Eclipse和Myeclipes关系:

 Myeclipes是Eclipes的一个插件.先安装Eclipse,再安装Myeclipes,相当于给Eclipse打个补丁,扩展其功能

 让他可以开发java意义的程序--web项目

 

(2)静态导入：import static 导入一个类中的静态方法或是全部的静态方法。

 

（3）可变参：一个方法接受的参数的个数不固定，这时就可以用可变参数

     可变参数的特点：

     A:只能出现在参数列表最好；

     B: "..."位于变量类型和变量名之间，前后有无空格都可以

     C:调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法中以数组的形式访问

 

(4) 增强for

     格式：for(type 变量名：集合变量名){...}     

     注意事项：a:迭代变量必须在"()"定义

               b:集合变量可以是数组或实现了Iterable接口的集合类

      代码描述：

           int arr = {12,14,15,16,17};

           for(int i:arr）{

               System.out.println(i);

           }

　　　　　    

  (5) 基本数据类型的自动装箱与拆箱

      自动装箱： 就是把基本类型转变为引用类型 Integer i = 15;

      自动拆箱： 与之相反 int i = new Integer(15);

代码体现：

public class Test{

        public static void main (String[] args){

        //自动装箱

         int i = 15;

         Integer integer = i;

         //自动拆箱

         int j = intger;

          //装箱

          Integer counter =1;

          //拆箱

          int counter2 = counter;

          While(counter<100){

               System.out.println(“统计”+counter++);

            }

      }

}

 

（6）枚举：

      枚举就是让某个类型的变量的取值只能为若干个固定值中的一个，   否则，编译器就会报错，枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

特点：   

  A:枚举相当于一个类，其中可可以定义构造方法、成本变量、普通方法和抽象方法

  B:枚举元素必须位于枚举体中的最开始部分，枚举元素列表的要有分号与其他成员分隔，把枚举中的成员方法或变量等放在枚举元素的前面，编译器报错

  C:枚举只有一个成员时，就可以作为一种单例的实现方式

 

 注意：

 1：JDK5 新增,是类类型,但不能使用new 

 不能继承其他类,也不能作为超类,即不能扩展.但隐式继承自java.lang.Enum类,可以实现接口.

 2：枚举包括两个预定义方法:

 public static enum-type[] values();

 public static enum-type valueOf(String st); 用于for-each循环遍历枚举常量.

 且可以用”==”来判断两个枚举常量是否相等.

 从Enum继承而来三个方法:

 final int ordinal() ----返回常量顺序值

 final int compareTo(enum-Type e) -----同一枚举中比较顺序值

 final Boolean equals(enum-type e) -----同一枚举中是否相等,相当于”==”

 3：在switch表达示中case语句不需也不能加入枚举的类型,否则会出错.

 4：枚举是类类型,可以定义构造函数,且可以重载,同样也可定义其他的实例方法和变量,这些每一个枚举常量都有自己的一个副本.甚至可以定义静态的成员.可以实现接口.

 代码解析：

 public enum Answer implements DoAnswer{

 Perfect(10),Good(8),Common(5),Bad(2),Terrible;//枚举常量,相当于 public static Answer类型

 public static int type=1; //定义一个静态成员

 private int degree; //定义一个实例成员变量

 private Answer(){ //定义一个不带参数的构造函数,注只能为private的,默认也一样

 degree=-1;

 }

 private Answer(int d){ //定义一个带参数的重载构造函数

 degree=d;

 }

 public String getProblem(){ //实现接口方法

 return DoAnswer.PROBLEM;

 }

 public int getDegree(){ //定义一个实例成员函数

 return degree;

 }

 public Answer getAnswer(){ //定义一个返回自身的成员函数,每一个常量都有自己的副本

 return this;

 }

 }

 

（7）Class类：       

    A：Java程序中各个Java类属于同一类事物，描述这类事物的Java类名就是Class

    B:Class类代表Java类，它的各个实例对象对应各个类在内存中的字节码，一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中 的内容是不同的。

如何得到各个字节码对应的实例对象（Class类型）

       类名.class  例如：System.class

      对象.getClass()  例如：new Date().getClass()

      Class.forName("类名")  例如:Class.forName("java.util.Date")  

      只要在源程序出现的类型，都有各自的Class实例对象，例如： int[],void...

 

 (8)反射：

     就是把Java类中的各种成分映射成相应的java类，例如，一个java类中用一个Class类的对象来表示，一个类中

 组成部分：

      成员变量，方法，构造方法，包等信息也用一个个的java类来表示。表示java类的Class类提供一

     系列的方法来获取变量，方法构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，

    它们是Field、Method、Constructor、Package等

 一个类中每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后    

案例：

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

 

public class ReflectDemo {

public static void main(String[] args) throws ClassNotFoundException,

NoSuchMethodException, SecurityException, InstantiationException,

IllegalAccessException, IllegalArgumentException,

InvocationTargetException {

// 获取字节码文件对象

Class c = Class.forName("cn.itcast_01.Person");

 

// 通过无参构造器创建对象

Constructor con = c.getConstructor();

Object obj = con.newInstance();

 

// 获取的是无参无返回值的方法show

Method m = c.getMethod("show");

// obj.m(); 理解

// public Object invoke(Object obj,Object... args)

m.invoke(obj); // obj对象调用m方法。

 

System.out.println("----------------------------");

 

// function(String name)

Method m2 = c.getMethod("function", String.class);

m2.invoke(obj, "张三");

 

System.out.println("----------------------------");

 

// String getString(String name, int age)

Method m3 = c.getMethod("getString", String.class, int.class);

Object oo = m3.invoke(obj, "java", 20);

System.out.println(oo);

 

System.out.println("----------------------------");

 

// hello()

// NoSuchMethodException -- 由于hello()方法是私有的，必须通过getDeclaredMethod获取。

Method m4 = c.getDeclaredMethod("hello");

// 暴力访问

m4.setAccessible(true);

// 值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查。

m4.invoke(obj);

}

}

 

(9)Constructor类:

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

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

Constructor[]constructor=Class.forName("java.lang.String").getConstructor();

 得到某一个构造方法：

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()方法 

            

    Method类：

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

          例如：MethodcharAt=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对象对应的是一个静态方法

 

(10)数组的反射：

A:具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象

B:代表数组的Class实例对象的getSuperClass()方法返回得到父类为Object类对应的Class

C:基本类型的一维数组可以被当做Object类型使用，不能当做Object[]类型使用；非基本类型的一维数组，即可以当做Object类型使用，又可以当做Object[]类型使用

 

(11)注解的应用： 注解类 @interface A{}

                  应用了注解类的类 @A

                                   Class B{}

                  对应用了注解类的类进行反射操作的类

                                 Class C{

              B.class isAnnotationPresen(

               A.class);

           A a = B.class.getAnnotation(

               A.class);

          }  

 自定义注解：

     A:定义一个简单的注解：public @interace MyAnnotation{}

     B:把它加在某个类上：@MyAnnotation public class AnnotationTest{}

     C:用反射进行测试AnnotationTest的定义是否有@MyAnnotation

根据反射测试的问题，引出@Retention元注解的三中取值：  

 RetetionPolicy.SOURCE

 RetetionPolicy.CLASS 

 RetetionPolicy.RUNTIME   

 分别对应java源文件、class文件、内存中的字节码

 

(12) JavaBean:

     A: JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

     B: JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。

     C:一个符合JavaBean特点的类可以当做普通类一样进行使用，但把它当JavaBean用会有一些额外的好处，如大家都这么使用则增加了代码的可读性和可修改性。JDK中提供了对JavaBean进行操作的一些API，这套API称为内省，用内省的方式操作JavaBean比普通类的方式便捷。

     D: Beanutils工具包提供了更为便捷的读取和设置JavaBean的属性，具体方法参照文档。此方法需要引入Beanutils工具包和logging包。

(13)泛型：

     是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译

     带类型说明的集合时会去除掉类型信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和

     原始类型完全一样，由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其他类型的数据    

     

 ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语

     整个称为ArrayList<E>泛型类型

     ArrayList<E>中的E称为类型变量或类型参数 

   整个称为ArrayList<Integer>称为参数化的类型   

   ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数

代码体现：

 

  public class ArrayListDemo {

public static void main(String[] args) {

ArrayList<String> array = new ArrayList<String>();

 

array.add("hello");

array.add("world");

array.add("java");

Iterator<String> it = array.iterator();

while (it.hasNext()) {

String s = it.next();

System.out.println(s);

 

}

 

}

}

 

（14）类加载器：

    Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类

              BootStrap   ExtClassLoader  AppClassLoader

     

  类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然第一个类加载器是BootStrap

 

  Java虚拟机中的所有类加载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定

     一个父级类装载器对象或者默认采用系统类装载器为其父级类加载   

     

 类加载器之间的父子关系和管辖范围   

    BootStrap -------------->jre/lib/rt.jar

       

    ExtClassLoader---------->jre/lib/ext/*.jar 

 

    AppClassLoader----------->classpath指定的所有jar或目录  

     

     

类加载器的委托机制：

        首先当前线程的类加载器去加载线程中的第一个类，如果类A中引用了类B,Java虚拟机将使用加载类A的类装载器来

        加载类B；还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

        每个类加载器加载类时，又先委托给其上级类加载器，当所有祖宗类加载器没有加载到类，回到发起者类加载器，

  还加载不了，则抛出ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法

代码解析：

package snippet;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

/**

*

* @author Administrator

*自定义类加载器

*/

public class MyClassLoader extends ClassLoader {

// 获取java源文件的二进制码

public byte[] getBytes(String filename){

File file = new File(filename);

InputStream ips=null;

byte[] b = new byte[(int) file.length()];

try {

ips = new FileInputStream(file);

int raw =ips.read(b);

if(raw!=file.length()){

throw new IOException("无法完整读取文件");

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

finally{

if(ips!=null){

try {

ips.close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

return b;

}

public boolean compile(String javaFile){

System.out.println("正在编译");

Process p=null;

try {

//调用系统javac命令

p=Runtime.getRuntime().exec("javac" + javaFile);

try {

p.waitFor();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

int ret = p.exitValue();

return ret==0;

}

protected Class<?> findClass(String name) {

Class<?> clazz=null;

String fileStub = name.replace(".", "/");

String javaFileName = fileStub + ".java";

String classFileName = fileStub + ".class";

File javaFile = new File(javaFileName);

File classFile = new File(classFileName);

//如果java源文件存在并且class文件不存在，或者java源文件比class文件修改的时间晚

if(javaFile.exists()&&(!classFile.exists()||javaFile.lastModified()>classFile.lastModified())){

if(!compile(javaFileName)||!classFile.exists()){

try {

throw new ClassNotFoundException("未发现class文件");

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

//如果class文件已经存在，那么直接生成字节码

if(classFile.exists()){

byte[] b = getBytes(classFileName);

clazz = defineClass(name, b, 0, b.length);

}

//如果为空，标明加载失败

if(clazz==null){

try {

throw new ClassNotFoundException(name);

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

return clazz;

}

}

（14）动态代类：

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

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

     CGLIB库（目前开源，也许将来会加到jdk中）可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。

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

     A：在调用目标方法之前。

     B：在调用目标方法之前。

     C：在调用目标方法前后。

     D：在处理目标方法异常的catch块中。

------- <a  target="blank">android培训</a>、<a  target="blank">java培训</a>、期待与您交流！ ----------详细请查看：http://edu.csdn.net