Java语言知识点

1.数据类型

    整型：(Short)( 占 2 个字节 ) 、整数 (Int)( 占 4 个字节 ) 与长整数 (Long)( 占 8 个字节 )

   浮点数： 单精度浮点数 (Float)( 占 4 个字节 ) 与双精度浮点数 (Double)( 占 8 个字节 , 带小数点的数字默认是double型)

    字符： Java 的字符采用 Unicode 编码， 每个字符数据类型占 2 个字节，可存储的字符范围从 /u0000 到 /uFFFF 。 一个中文字与一个英文字母在 Java 中同样都是用一个字符来表示。

    布尔：占内存 1 个字节，可存储 True 与 False 两个数值

 

移位操作要注意的问题是高（低）位是补0还是补1和对char, byte, short型的操作：
（1）<< : (left-shift), 最低位补0
（2）>> : （signed right-shift), 右移过程使用符号位扩展（sign extension)，即如果符号为为1则高位补1， 是0则补0，也就是逻辑右移
（3）>>> : (unsigned right-shit),右移过程使用零扩展（zero extension),即最高位一律补0，也就是算术右移
（4） 移位操作的数据类型可以是byte, char, short, int, long型，但是对byte, char, short进行操作时会先把它们变成一个int型，最后得到一个int型的结果，对long型操作时得到一个long型结果，不可以对boolean型进 行操作。
（5）移位操作符可以和＝合并起来，即 <<= 、 >>= 和 >>>=。例如 a >>= 2; 表示将a右移两位后的值重新赋给a。

 

 

2. overload和override的区别
override（重写）
   (1)、方法名、参数、返回值相同。    (2)、子类方法不能缩小父类方法的访问权限。  (3)、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
overload（重载）
   (1)、参数类型、个数、顺序至少有一个不相同。 (2)、不能重载只有返回值不同的方法名。(3)、存在于父类和子类、同类中。

   * 设两个父子类Parent  Child

 overload方法： fun(Parent p)    fun(Child c)

 在主程序中:

    a) Parent p=new Child();

         fun(p)  是调用fun(Parent p)方法

    b) Child p =new Child();

         fun(p)  是调用fun(Child c)方法. 如果无fun(Child c)，则会调用fun(Parent p)方法

 

  * 再加两个父子类Upper，Lower

    Upper upper=new Lower();

    Child p=new Child();

    则调用upper.fun(p)时，系统首先寻找顺序为：Lower类中的fun(Child c) --> Upper类中的fun(Child c) --> Lower类中的fun(Parent p) --> Upper类中的fun(Parent p)

 

    * 上例中如果第二句为Parent p=new Child();则寻找的顺序：Lower类中的fun(Parent p) --> Upper类中的fun(Parent p)

 

  *总结：子对象在override和overload中可以代替父对象。但override优先选择new对象类型中的方法， overload优先选择指针的定义的类型。

 

    属性是不会override的。故Parent和Child都有public int i;时，当Parent p =new Child()时，p.i是指Parnet类中的i

    在方法中使用属性是优先使用本实例中的属性，如果没有，则寻找父类中的属性。

 

2. try catch后面接finally{},如果在try{ return },返回后仍然会执行finally{}语句。再接下来执行调用此函数的下一句。

 

 

 

3.异常
Throwable
  +-- Exception
  +     +-- RuntimeException  (如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理)
  +     +--checked exception( 除RE的异常)  如IOException、SQLException等以及用户自定义的Exception异常，必须要处理
  +-- Error(可不处理，因为这表示java运行环境中的内部错误或者硬件问题，比如，内存资源不足等)

 

 

4.hashcode()与equals()
java.lnag.Object中对hashCode的约定：
   1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。
   2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。
   3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。
不改写hashCode导致使用hashMap不能出现预期结果.

 

4.子父类对象创建时代码顺序

  父对象： arrtibute=value;  (1)  分配内存

             {  }  (2)

             construction(){}  (3)

  子对象： attribute=value;   (4)

              {  }  (5)

             construction(){}  (6) 

 

5.性能(1>2)

   1.1 synchronized(this) {

                  for()  { ...  }

        }

   1.2  for(){

                  synchronized(this) { ... }

          }

   2.1  try{

             synchronized(this)  {  ... }

          }catch{  ...}

 

   2.2 synchronized(this){

             try{...} catch{...}

         }

 

 

5.内部类

    1)成员内部类

public class OuterClass{                                              //外部类

     private class InnerClass{                                   //内部类

            //...

    }

}

  * 外部使用方法：

OuterClass outerClass=new OuterClass ();

InnerClass innerClass= outerClass .new InnerClass ();

  * 不能在成员类中定义static字段、方法和类（static final形式的常量定义除外）如果方法和变量要成为静态，内部类必须被声明为静态。

   * 成员类内部获得其所属外部类实例呢:OuterClass.this

   * 成员类能访问它的外部类实例的任意字段与方法。方便一个类对外提供一个公共接口的实现。

       以JDK Collection类库为例，每种Collection类必须提供一个与其对应的Iterator实现以便客户端能以统一的方式遍历任一 Collection实例。每种Collection类的Iterator实现就被定义为该Collection类的成员类。例如JDK中 AbstractList类的代码片断：

public   abstract   class  AbstractList < E >   extends  AbstractCollection < E >   implements  List < E >  {
     private   class  Itr  implements  Iterator < E >  {
         ………;
    }

      public  Iterator < E >  iterator() {
         return   new  Itr();
     }
}

    试想，如果没有成员类机制，只有在AbastractList源码之外定义一个实现Iterator的类Itr，该类有一个AbstractList实例 成员list，为了Itr能获取list的内部信息以便实现遍历，AbstractList必然要向Itr开放额外的访问接口。

 

  2)静态内部类

 引用方法： OuterClass.InnerClass， 其它和外部类一样。

B为A的辅助类，且只为A所用时，可将B定义为A的静态成员类。例如JDK中的LinkedList类就有Entry静态成员类：

public  class  LinkedList < E >  extends  AbstractSequentialList < E >  
   …;
    private  static  class  Entry < E >  {
    E element;
    Entry < E >  next;
    Entry < E >  previous;

    Entry(E element, Entry < E >  next, Entry < E >  previous) {
         this .element  =  element;
         this .next  =  next;
         this .previous  =  previous;
    }
    }
    …;
}

  

    3) 匿名内部类

        new ClassName(){
...//内部类体
};

    内部类体可override这个类的方法

 

   4)局部内部类

public class OuterClass {

public OutInterface doit(final String x) {                                     //doit()方法参数为final类型

           class InnerClass implements OutInterface {              //在doit()方法中定义一个内部类

                    InnerClass(String s) {

                             s = x;

                             System.out.println(s);

                    }

           }

           return new InnerClass("doit");

}

}

 

 

 

 

6.reflection

    (1)      java xxx.class--->寻找JRE/bin/clinet目录中jvm.dll--->启动JVM

           BootstrapLoader (由C编写,搜索sun.boot.class.path路径下的class文件,默认为JRE/classes)      

          ExtClassLoader 

          Extended Loader(,由java编写，搜索java.ext.dirs中指定的类，默认是JRE/lib/ext/classes目录下的class文件 或 lib/ext目录下的jar文件)

          AppClassLoader

         System Loader(, java.class.path中指定的位置的类，也就是classpath所指定的路径

 

   每个类加载器会先将加载类的任务交给其parent,如果parent找不到，再由自己找。

     bootstrapLoader<----getParent()----ExtClassLoader<------getParent()--------AppClassLoader <-----getClassLoader()-----SomeClass<------getClass()-------Someclass实例

 

  (2)生成实例

     1)Class c=Class.forName("包名.类名"); /相当于Class.forName("包名.类名",true, loader); 执行static初始化代码

     2) Class c=Class.forName("包名.类名",false, loader); //jdk1.4前未执行static初始化代码，不过静态变量还是初始化

     3) ClassLoader loader=main.class.getClassLoader(); //如果是实例，可用this.getClass().getClassLoader(), 还可用Thread.currentThread().getClass().getClassLoader();
         Class c=loader.loadClass("包名.类名");

    * 然后为c.newInstance();生成实例

 

    (3)

    自定义ClassLoader类装载，鼓励用 ClassLoader 的子类重写 findClass(String) ，而不是重载Class loadClass(string)方法。重载Class findClass(String name)

       byte[] bytes = 从name类名中取得字节流;
       Class theClass = defineClass(name, bytes, 0, bytes.length);

   (4) 方法

     public class RefTest { public static void main(String[] args) throws Exception { ITest t = new Test1(); System.out.println(ITest.class == t.getClass()); System.out.println("类.class方式调用方法"); Method md = ITest.class.getMethod("test", new Class[] { java.lang.String.class }); System.out.println(md.invoke(t, "你好")); System.out.println("实例.getClass()方式调用方法"); Method md1 = t.getClass().getMethod("method", new Class[] { java.lang.String.class }); System.out.println(md1.invoke(t, "你好")); System.out.println("Class.forName方式调用方法"); Method md2 = Class.forName("reflectiontest.ITest").getMethod("test", new Class[] { java.lang.String.class }); System.out.println(md2.invoke(t, "你好")); Method md3 = Class.forName("reflectiontest.Test1").getMethod("test", new Class[] { java.lang.String.class }); System.out.println(md3.invoke(t, "你好")); } } interface ITest { public String test(String str); } class Test1 implements ITest { Test1() { } public boolean method(String str) { return "aaa".equals(str) ? true : false; } public String test(String str) { return "reflectiontest:" + str; } }

 

 

7性能
    1) java的一些类中，比如是集合类，会默认分配其空间大小，如果编程时能预知其大小，可在创建其对象时指定创建时分配的大小。

    2) StringBuilder