java基础1

 1、在eclipse中调试程序，可以先在行的前面设置一个断点，然后右键debug as转换到Debug透视图；这时若需要看某个变量的值可以右键watch；

 2、JavaRuntimeEnvironment只能向下兼容，不能向上兼容。如用1.5的运行坏境运行1.6编译出来的程序就会出错；

 

3、在eclipse中可以在首选项->java->Editor->Templates中配置模板。

 

4、在eclipse中导入一个工程的方法：File->Import->选择工程所在的目录，若导入工程后安装的JDK目录与工程的JDK目录不一致可在工程上点击右键->Build path->Configure

Build path->配置相关参数。

 

5、用import static 包名.类名.方法名；可以静态导入一些静态的方法。

 

6、如果方法中需要使用的参数不定，可以使用可以变参数，用法是在方法中的最后一个参数使用"参数类型 ... 变量名"，如在一个累加方法中：
public int add(int a,int... args){
 int sum=a;
 for(int i=0;i<args.length;i++){
 sum+=args[i];
 } 
 return sum;
}

 

7、for循环增强，使用方法：for(变量类型 变量名：集合变量名){...} 例如：
public static int add(int a,int... nums){
   int sum=a;
   for(int num : nums){
   sum+=num;
   } 
   return sum;
 }
其中的nums必须先在方法add()中定义，集合变量可以是数组或者实现了Iterable接口的集合类；

 

8、自动装箱：当把一个数直接付给一个Integer对象时叫自动装箱，如 Integer i1=15；如有Integer i1=15;Integer i2=15;System.out.println(i1==i2);输入值为ture(因为该

类运用了“享元设计模式”，当数字在-128~127时，多个引用指向一个数字对象)；

 

9、享元设计模式：当有很多个对象拥有很多共同的属性时，可以把这些对象的共通属性整合为一个对象，称之为内部状态；把这些对象的不同属性作为方法的参数传入，称之为

外部状态；

 

10、若自定义了一个枚举类，把构造函数设为private,在运用该类时只能使用该类中已经创建的对象，而不能自行创建该类的对象。定义枚举的方法：public enum 枚举名{枚举

变量}；一个枚举相当于一个类，每个枚举变量都相当于这个类中的一个对象；调用枚举变量的ordinal()方法可得到该变量在枚举中的排位；
“枚举类”中的valueOf("String")方法可以将String转换成相应的枚举对象；value()方法可以返回一个数组，该数组中包含了所有的枚举变量；
当给枚举定义构造方法时，构造方法必须放在元素列表的后面并且构造方法必须设置为private；如:
public enum WeekDay{
SUN,MON,TUE,WED,THI,FRI,SAT;
private WeekDay(){

}
}

 

11、类编译之后变成字节码，得到字节码的方式有三种：1、调用对象的getClass()方法可以得到该类的字节码；2、在程序中用类名.class的方式；3、用Class.forName("java.

包名.类名")的方法；用Class.isPrimitive方法可以判定一个类的实例对象是不是基本数据类型，Int.class==Integer.TYPE的结果是ture,因为Integer.TYPE将该类包装的原始数

据体现出来了；数组实例对象的判定方法是用Class.isArray();

 

12、JAVA反射就是将每个JAVA类中的各种组成部分映射成相应的JAVA类。Constructor类代表某个类中的一个构造方法，得到某个类的所有构造方法：
Constructor [] constructor = Class.forName("该类的包名.类名").getConstructors();
得到某个类的某一个构造方法：Constructor constructor = Class.forName("该类的包名.类名").getConstructor(该构造方法构造出来的类型,如：StringBuffer.class);通过

得到的构造方法可以实例化一个对象，例如：
 Constructor constructor=String.class.getConstructor(StringBuffer.class);
 String str=(String)constructor.newInstance(new StringBuffer("abc"));//由于每个类都有构造方法，编译器不知道constructor是哪个类的构造方法，所以需要强

制类型转换；使用newInstance(参数)时，参数类型必须跟使用getConstructor(参数)时的参数类型一致。如以上语句中若将String str=(String)constructor.newInstance(new

StringBuffer("abc"))改成String str=(String)constructor.newInstance("abc")则会出现错误，因为constructor是一个StringBuffer类型的构造函数，而传递的是一个String

类型的参数"abc".

 

13、Field类可以获得字节码里面的变量，具体应用如下：
import java.lang.reflect.Field;
class Position{
  private int x;
  private int y;
 
public Position(int x, int y) {
 super();
 this.x = x;
 this.y = y;
}
 
}

class Testing{
 public static void main(String [] args) throws Exception{
  Position pt= new Position(3,5);
  Field fieldx = pt.getClass().getDeclaredField("x");//getDeclaredField()方法可以获得类中所有声明过的变量
  //fieldx不是对象上的变量，而是类上的，需要要它去取某个对象上的变量的值
  fieldx.setAccessible(true);//设置私有变量X为可读取，又称为暴力反射；
  System.out.println(fieldx.get(pt));//取出对象pt中的X的值
  
 }
}

 

14、将一个已知字符串中的'b'改成'a'，具体实现如下：
import java.lang.reflect.Field;
class Position{
 
  public String str1 = "public";
  public String str2 = "ball";
 

 
}

class Testing{
 public static void main(String [] args) throws Exception{
  Position pt= new Position();
  changeStringvalue(pt);
  System.out.println(pt.str1);
  System.out.println(pt.str2);
 }

 private static void changeStringvalue(Object obj) throws Exception{
  // TODO Auto-generated method stub
  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);
   }
  }
 }
}

 

15、不用for循环打印出一个数组中的元素列表，具体实现如下：
对于String类型的数组或者对象数组：System.out.println(Arrays.asList(String类型的数组或对象数组));

 

16、hashCode方法的作用：将哈希集合分成若干个存储区域，每个对象可以算出一个hashCode,按照这种hashCode将对象分别存储在对应的区域内以便提高检索的效率；

 

17、反射的作用，实现框架的开发；利用类加载器加载非Class文件：类名.class.getClassLoader().getResourceAsStream("绝对路径")；

 

18、JavaBean是一个特殊的Java类，类中方法的名字必须符合某种特定的命名规则，必须有get和set方法。若一个类有get和set方法，则可将之视作为一个JavaBean来使用；

JavaBean中若有一个getTime()的方法，则该JavaBean中必有一个叫做time的属性。

 

19、用内省的方式读取JavaBean对象的age属性,具体实现如下：
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class TestJavaBean {
 private int age;

 public TestJavaBean(int age) {
  super();
  this.age = age;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }
 
}

class IntroSpectorTest{
 public static void main(String [] args) throws Exception{
  TestJavaBean tjb = new TestJavaBean(23);
  String propertyName ="age";
  PropertyDescriptor pd = new PropertyDescriptor(propertyName,tjb.getClass());
  Method methodgetAge = pd.getReadMethod();//获得getAge方法
  Object retVal = methodgetAge.invoke(tjb);//调用getAge方法后返回的值存在retVal中
  System.out.println(retVal);
  
  
  Method methodsetAge = pd.getWriteMethod();//获得setAge方法
  methodsetAge.invoke(tjb,24);//调用setAge方法将age的值设置为24
  System.out.println(tjb.getAge());
 }
}

 

20、当需要把某些代码抽取为一个方法时，可以选中该段代码，然后右键-->Refactor-->Extract Method;

 

21、Map和JavaBean很相似，Map的key相当于JavaBean的属性，并且Map和JavaBean之间可以相互转换，而BeanUtils提供了这种转换的方法；

 

22、注解：相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，标记可以加在包、类、方法、成员变量、局部变量等上面；@Deprecated //注明当前方法已过时 

@SuppressWarnings("某个警告") //注明跳过某个警告  @Override //注明是覆盖父类的方法

 

 23、注解相当于一个写好的特殊的类，在定义注解时，用@Retention注解可以声明注解的生命周期，@Retention(RetentionPolicy.SOURCE)表示生命周期在java源文件阶段结束；

@Retention(RetentionPolicy.CLASS)表示生命周期到class文件阶段结束;@Retention(RetentionPolicy.RUNTIME)表示生命周期直到运行完之后才结束，也就是内存中的字节码中

都还有该注解；

 

24、反射中，类名.class得到的是字节码，也就是内存中的二进制码。

 

25、在注解中定义属性的方法如下：
public @interface MyAnnotation{
 String color() default "red";//指定了默认值，使用注解时可以不用传递值
 String value();//没有默认值，在使用注解时需要传递一个string类型的值
 int [] array() default{1,2};
}

 

26、使用注解时，若数组属性中只有一个元素，则可省略大括号；如上例中使用注解时可以写成@MyAnnotation (color="blue",value="asd",array=3)，注解的返回值可以是基本

数据类型、String、数组、枚举、class、注解;

 

27、泛型的定义，在类名之后跟上<类型>，如ArrayList<String> collection = new ArrayList<String>();泛型内只能装指定类型的数据，如上例就只能装String类型的数据；

只有在JDK的api中，说明了一个类是泛型类型，该类才能使用泛型；使用泛型可以省去强制类型转换的麻烦；泛型是提供给编译器使用的，编译之后的字节码中不会在有泛型的类

型信息，所以可以利用反射的方法向编译后的泛型中添加不同类型的数据；

 

28、泛型的使用中，Class<?>y=Class<String>x //正确，Class<String>x=Class<?>y //错误

 

29、定义一个方法交换一个数组中两个元素的位置：
 public <T> void swap(T [] array, int i,int j){
  //<T>声明了一个任意类型的变量
  T temp= array[i];
  array[i]=array[j];
  array[j]=temp;
 }

 

30、写一个泛型方法，自动将Object类型的对象转换成其他类型：
public <T> T autoConvert(Object obj){
 return (T) obj;
}

 

31、定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象：
public <T> void fillArray(T [] array,T obj){
 for(int i=0;i<array.length;i++){
  array[i]=obj;
 }
}

 

32、采用自定义泛型方法的方式打印出任意参数化类型的集合中的所有内容：
public <T> void printCollection(Conlection<T> collection){
 for(Object obj : collection){
  System.out.println(obj);
 }
}

 

33、若想让一个类的两个泛型方法中的泛型参数一致，则可以将该参数放在类上，如想在如下代码中让两个方法的<T>一致：
public class GenericDao{
public <T> void add(T x){

}
public <T> T findById(int id){
 return null;
}
}
可以将代码改为：
public class GenericDao<T>{
public void add(T x){

}
public T findById(int id){
 return null;
}
}

 

34、类中的静态方法不能使用泛型类型；

 

35、 Java虚拟机中可以安装多个类加载器，系统默认的有三个类加载器，分别 是：BootStrap,ExtClassLoader,AppClassLoader,每个类加载器负责加载特定位置的类；类加载器也是Java类，所 以它本身也需要被加载，它是由嵌套在JVM内核中的BootStrap加载的，BootStrap不是java类，它是由C++编写的一段二进制代码；

 

 36、JVM生成的动态类必须实现接口，该动态类只能用作实现了相同接口的目标类的代理；若目标类没有实现接口，而需要实现它的代理类则可使用CGLIB库；

 

37、变量名带有clazz的，说明该变量指向一份字节码；单线程的情况下StringBuilder效率比StringBuffer效率高，多线程的情况下则相反