这是我在四天内听完陈老师讲的java基础加强后的总结

一、   MyEclipse中的一些常用的快捷键：

ctrl+shift+x 大写

ctrl+shift+y 小写

alt+/ 内容提示

写住方法的时候可以先写main然后按alt+/就可以了

  ctrl+1  快速修复

  ctrl+shift+O  导包

  格式化代码块：ctrl + shift + F

  向前向后：Alt + 方向键

  向前向后复制  ctrl+alt + 方向键

  添加多行注释 Ctrl+Shift+/

除去多行注释 Ctrl+Shift+/

ctrl+shift +T  查看源码

查看所有快捷键的 快捷键：ctrl+shift+L

二、   项目的调试：

在项目的开发过程中经常会遇到一些BUG,所以我们会用一种方式去调试BUG，那就是断点调试；

断点调试可以跟踪程序方便用户观察最终方便的将错误找到从而来进行调错；

在进行调试的准备就是要添加断点，用鼠标双击左边的行符就可以添加断点，然后通过debug as来运行程序，

F5 ：是跳入程序执行；F6：是跳过程序执行；  F7：是跳出程序执行；

三、   装箱与拆箱：

       拆箱是把“引用”类型转换成“值”类型；

     装箱是把“值”类型转换成“引用类型”；

原因是有时某些方法的参数要求使用“引用”类型，而你想把“值”类型的变量通过这个参数传入，就需要使用这个操作。

相关实例：

Integer i = 1000;//装箱

int c =  i;//拆箱

//典型的应用案例

           List list = new ArrayList();

           list.add(12);//装箱

           int temp = (Integer)list.get(0);//拆箱

          

四、   数据类型：

1、基本数据类型

               整型 ：  byte short int long

               浮点型：float double

               字符型：char

               布尔型：boolean  true false

 

           自动类型转换：

                  byte 、short、 int、 long、float、 double

                  、char

           强制类型转换：

这一般就很简单了，在这里就不想说了。

    

                     

2、引用数据类型

                  类

                 接口

                 数组

 

   封装类：

               byte   Byte

               short  Short

               int    Integer

               long   Long

               float  Float

               double Double

               char  Character

               boolean  Boolean

五、   迭代器的使用：

for循环的新特性，只能用于数组、集合、实现Iterable接口的集合；

Integer arr[] = {100,100,18,90,89};

      

       //jdk1.4之前

       for (int i = 0; i

             System.out.print("   "+arr[i]);

       }

      

       //jdk1.5的for增强版

       for(int i:arr){

             System.out.print("   "+i);

            

       }

注：数组中没有length()这个方法，但是数组中有length这个属性。用来表示数组的长度。

      String中有length()这个方法。用来得到字符串的长度。

 

//实现了Iterator接口的集合

       List list = Arrays.asList("12","12","abc","cd");

            

 

       for (int i = 0; i

             String temp = (String)list.get(i);

             System.out.print("   "+ temp);

       }

      

       //采用迭代器输出

       Iterator it = list.iterator();

       while(it.hasNext()){

       String tem= (String)it.next();

       System.out.print(tem+"   " );

       }

      

      

       //jdk 1.5

       for(Object obj:list){

             String str = (String)obj;

             System.out.print("  "+str);

       }

      

 

//map集合

       Map map = new HashMap();

       map.put(1, "aa"); //key  value

       map.put(2, "aac");

       map.put(3, "aacc");

       map.put(4, "aa4");

注：map.put(1, "aat"); //key 不能够重复

      

       //1、迭代map集合的值

       Set set = map.keySet(); //key装到set中

       Iterator it = set.iterator(); //返回set的迭代

器装的key值

       while(it.hasNext()){

             Integer key = (Integer)it.next();

             String value = (String)map.get(key);

             System.out.println(key+"  "+value);

       }

      

      

       //2、迭代map集合的值

       Set entry =  map.entrySet();  //Set

>

      

       it = entry.iterator(); //返回set的迭代器 装

Map.entry

      

       while(it.hasNext()){ //迭代

             Map.Entry entity = (Entry) it.next();

//实体Map.entry的对象取出

             Integer key = (Integer)entity.getKey

(); //调用实体对象的getKey()获取key的值

             String value = (String)

entity.getValue(); //调用实体对象的getValue()获取value的值

            

             System.out.println(key+"  "+value);

            

六、   枚举类的声明与使用：

//简单枚举声明：

enum Grade{

A,B,C,D;

   //A  相当于  public static Grade A = new Grade();

   private Grade(){

        

   }

}

//使用：

System.out.println(Grade.name()); //返回名称

System.out.println(Grade.ordinal());//返回序列

System.out.println(Grade.values().length); //返回数组并计算长度

Grade allentities[] =    Grade.values(); //返回一个Grade的数组

         for(Grade entity:allentities){

              System.out.println(entity);

         }

        

         Grade ss = Grade.valueOf(Grade.class, "A");

      System.out.println(ss.ordinal());

七、   另一种方式定义枚举：

class Grade{

  private Grade(){

      

  }

  public static Grade A = new Grade();

  public static Grade B = new Grade();

  public static Grade C = new Grade();

  public static Grade D = new Grade();

 

}

 

八、   Java中反射机制的使用：

Java类反射中所必须的类：
      Java的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。
Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

 

下面是反射应用的具体案例：

 

首先我们来写一个类：
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
class A extends Object implements ActionListener{
private int a = 3;
public Integer b = new Integer(4);
public A(){}
public A(int id,String name){}
public int abc(int id,String name){return 0;}
public void actionPerformed(ActionEvent e){}
}
你可能被我这个类弄糊涂了，你看不出我要做什么，那就不要看这个类了，这个类是用来测试的，你知道知道它继承了Object类，有一个接口是ActionListener，两个属性int和Integer,两个构造方法和两个方法，这就足够了。
下面我们把A这个类作为一个反射类，来过去A类中的一些信息，首先我们先来过去一下反射类中的属性和属性值。
import java.lang.reflect.*;
class B{
public static void main(String args[]){
A r = new A();
Class temp = r.getClass();
try{
         System.out.println("反射类中所有公有的属性");
                         Field[] fb  =temp.getFields();
for(int j=0;jClass cl = fb[j].getType();
System.out.println("fb:"+cl);
}

                        System.out.println("反射类中所有的属性");
Field[] fa = temp.getDeclaredFields();
                        for(int j=0;jClass cl = fa[j].getType();
System.out.println("fa:"+cl);
}
                           System.out.println("反射类中私有属性的值");
Field f = temp.getDeclaredField("a");
f.setAccessible(true);
Integer i = (Integer)f.get(r);
System.out.println(i);
}catch(Exception e){
e.printStackTrace();
}
}

}
这里用到了两个方法，getFields()、getDeclaredFields()，它们分别是用来获取反射类中所有公有属性和反射类中所有的属性的方法。另外还有getField(String)和getDeclaredField(String)方法都是用来过去反射类中指定的属性的方法，要注意的是getField方法只能取到反射类中公有的属性，而getDeclaredField方法都能取到。
这里还用到了Field 类的setAccessible方法，它是用来设置是否有权限访问反射类中的私有属性的，只有设置为true时才可以访问，默认为false。另外Field类还有set(Object AttributeName,Object value)方法，可以改变指定属性的值。

下面我们来看一下如何获取反射类中的构造方法
import java.lang.reflect.*;
public class SampleConstructor {
public static void main(String[] args) {
A r = new A();
printConstructors(r);
}

public static void printConstructors(A r) {
Class c = r.getClass();
//获取指定类的类名
String className = c.getName();
try {
//获取指定类的构造方法
Constructor[] theCOnstructors= c.getConstructors();
for(int i=0; i//获取指定构造方法的参数的集合
Class[] parameterTypes = theConstructors[i].getParameterTypes();

System.out.print(className + "(");

for(int j=0; jSystem.out.print(parameterTypes[j].getName() + " ");

System.out.println(")");

}
}catch(Exception e) {
e.printStackTrace();
}
}
}
这个例子很简单,只是用getConstructors()方法获取了反射类的构造方法的集合，并用Constructor类的getParameterTypes()获取该构造方法的参数。

下面我们再来获取一下反射类的父类（超类）和接口
import java.io.*;
import java.lang.reflect.*;

public class SampleInterface {
public static void main(String[] args) throws Exception {
A raf = new A();
printInterfaceNames(raf);
}

public static void printInterfaceNames(Object o) {
Class c = o.getClass();
//获取反射类的接口
Class[] theInterfaces = c.getInterfaces();
for(int i=0; iSystem.out.println(theInterfaces[i].getName());
//获取反射类的父类（超类）
Class theSuperclass = c.getSuperclass();
System.out.println(theSuperclass.getName());
}
}
这个例子也很简单，只是用Class类的getInterfaces()方法获取反射类的所有接口，由于接口可以有多个，所以它返回一个Class数组。用getSuperclass()方法来获取反射类的父类（超类），由于一个类只能继承自一个类，所以它返回一个Class对象。

下面我们来获取一下反射类的方法
import java.lang.reflect.*;
public class SampleMethod {

public static void main(String[] args) {
A p = new A();
printMethods(p);
}

public static void printMethods(Object o) {
Class c = o.getClass();
String className = c.getName();
Method[] m = c.getMethods();
for(int i=0; i//输出方法的返回类型
System.out.print(m[i].getReturnType().getName());
//输出方法名
System.out.print(" "+m[i].getName()+"(");
//获取方法的参数
Class[] parameterTypes = m[i].getParameterTypes();
for(int j=0; jSystem.out.print(parameterTypes[j].getName());
if(parameterTypes.length>j+1){
System.out.print(",");
}
}

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

}

}
这个例子并不难，它只是获得了反射类的所有方法，包括继承自它父类的方法。然后获取方法的返回类型、方法名和方法参数。

接下来让我们回过头来想一想，我们获取了反射类的属性、构造方法、父类、接口和方法，可这些东西能帮我们做些什么呢！！
下面我写一个比较完整的小例子，来说明Java的反射类能做些什么吧！！
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class LoadMethod {
public Object Load(String cName,String MethodName,String[] type,String[] param){
Object retobj = null;
try {
        //加载指定的Java类
            Class cls = Class.forName(cName);
           
            //获取指定对象的实例
            Constructor ct = cls.getConstructor(null);
            Object obj = ct.newInstance(null);
           
            //构建方法参数的数据类型
            Class partypes[] = this.getMethodClass(type);
           
            //在指定类中获取指定的方法
            Method meth = cls.getMethod(MethodName, partypes);
           
            //构建方法的参数值
            Object arglist[] = this.getMethodObject(type,param);

            //调用指定的方法并获取返回值为Object类型
            retobj= meth.invoke(obj, arglist);

        }
        catch (Throwable e) {
            System.err.println(e);
        }
return retobj;
}

//获取参数类型Class[]的方法
public Class[] getMethodClass(String[] type){
Class[] cs = new Class[type.length];
for (int i = 0; i if(!type[i].trim().equals("")||type[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
cs[i]=Integer.TYPE;
}else if(type[i].equals("float")||type[i].equals("Float")){
cs[i]=Float.TYPE;
}else if(type[i].equals("double")||type[i].equals("Double")){
cs[i]=Double.TYPE;
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
cs[i]=Boolean.TYPE;
}else{
cs[i]=String.class;
}
}
}
return cs;
}

//获取参数Object[]的方法
public Object[] getMethodObject(String[] type,String[] param){
Object[] obj = new Object[param.length];
for (int i = 0; i if(!param[i].trim().equals("")||param[i]!=null){
if(type[i].equals("int")||type[i].equals("Integer")){
obj[i]= new Integer(param[i]);
}else if(type[i].equals("float")||type[i].equals("Float")){
obj[i]= new Float(param[i]);
}else if(type[i].equals("double")||type[i].equals("Double")){
obj[i]= new Double(param[i]);
}else if(type[i].equals("boolean")||type[i].equals("Boolean")){
obj[i]=new Boolean(param[i]);
}else{
obj[i] = param[i];
}
}
}
return obj;
}
}