Java 基础(汇总)

----------------------------------------------基础补充----------------------------------------------------------
使用匿名内部类,隐式调用外部变量,外部变量需要final修饰。
原因：因为生命周期的原因。方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向
一个对象。
首先,内部类和外部类其实是处于同一级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。
问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被
GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到了.如果定义为final类型会将
这个变量复制一份作为成员变量内置于内部类中,这样的话,由于final所修饰的值始终无法改变,所以这个变量所指
向的内存区域就不会变。

Java内部类
分四种：成员内部类.局部内部类,静态内部类和匿名内部类
1、成员内部类：即作为外部类的一个成员存在,与外部类的属性、方法并列。
注意：成员内部类中不能定义静态变量，但可以访问外部类的所有成员。

在类中除了接口和抽象类不能被实例化之外,普通类如果构造方法是私有的话,也不能进行实例化。

将字符串转换成JSON格式类型
1、引入json-lib-jdk.jar
2、代码使用
   String str = "";
   JSONObject json = JSONObject.formObject(str);

将String类的显示是XML格式的字符串当作XML文件内容进行解析成对象
1、需要下载dom4j.jar压缩包
2、代码解析
   //需要解析的字符串
   String content="<?xml version= '1.0' encoding='gb2312'?><weighData>"+
   "<weighTime>2012-12-2 12:23:12</weighTime><cardNum>2</cardNum><cfid>123</cfid></weighData>";
   //将字符串转换为XML对象
   Document document = DocumentHelper.parseTest(content);
   //获取文档的根节点
   Element element   = document.getRootElement();
   //遍历根节点所有的子节点
   Iterator<?> iterator = element.elementIterator();
   //利用反射机制,调用对象的set方法
   Class<?> c = Class.forName("对象路径");
   //创建实体类(返回对象类型)
   TestClass ts =(TestClass)c.newInstance();
   while(iterator.hasNext()){
        Element ele = (Element)iterator.next();
    Filed filed = c.getDeclaredField(element.getName());
    Method method = c.getDeclaredMethod("set"+element.getName(),filed.getType());
    method.invoke(msg,element.getText());
   }

InputStreamReader是不同于BufferedReader的.它主要是字符流和字节流的转换类,通过它可以很同意实现两者
之间的互换。
BufferedReader从字符输入流中读取文本,缓冲各个字符,从而提供字符，数组和行的高效读取。
可以指定缓冲区的大小,或者可使用默认的大小.大多数情况下,默认值就足够大了。
通常Reader所作的每个读取请求都回到值对基础字符或字节流进行相应的读取请求,因此建议用BufferedReader
包装所有其read()操作可能开销很高的Reader(FileReader和InputStreamReader)。
例如,
BufferedReader in = new BufferedReader(new FileReader("foo.in"));
将换从指定文件的输入。如果没有缓冲,则每次调用read()或readLine()都会到值从文件中读取字节,并将其转换为
字符后返回,而这是极其低效的.

final,finally,finalize有什么区别?
1) final用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖和类不可被继承(不能再派生出新的子类)。
   final属性：被final修饰的变量不可变.由于不可变有两重含义：一是引用不可变；二是对象不可变；
   例举一下例子进行说明:
   public static void main(String[] args){
      final StringBuffer s = new StringBuffer("hello");
      s.append("world");
      System.out.println(s);==================结果hello world
   }

   public static void main(String[] args){
      final StringBuffer s = new StringBuffer("hello");
      s = new StringBuffer("hello world");==============结果编译期间错误
   }
   从以上例子可以看出,final指的是引用的不可变性,即它只能指向初始化时指向的那个对象,而不关心指向对象内容的变化
   所以,被final修饰的变量必须被初始化。

   一般可以通过以下几种方式进行初始化:
   1) 在定义的时候初始化；
   2) final成员变量可以在初始化块中初始化,但不可在静态初始化块中初始化。
   3) 静态final成员变量可以在静态初始化块中初始化,但不可在初始化块中初始化。
   4) 在类的构造器中初始化,但静态final成员变量不可以在构造函数中初始化。

   final方法:当一个方法声明为final时,该方法不允许任何子类重写这个方法,但子类仍然可以使用这个方法.
   final参数:用来表示这个参数在这个函数内部不允许被修改。
   final类:当一个类被声明为final时,此类不能被继承,所有方法都不能被重写。但这并不表示final类的成员变量也是不可
   改变的,要想做到final类的成员变量不可改变,必须给成员变量增加final修饰.值得注意的是,一个类不能即被声明为
   abstract，又被声明为final.
2) finally作为异常处理的一部分,它只能用在try/catch语句中,并且附带一个语句块,表示这段语句最终一个被执行,经常
被用在需要释放资源的情况下。
3) finalize是Object类的一个方法,在垃圾回收执行时会调用被回收对象的finalize()方法,可以覆盖此方法来实现对其他资
源的回收,例如关闭文件等。

break,continue,return有什么区别？
1) break用于直接强行跳出当前循环,不再执行剩余代码.
2) continue用于停止当次循环,回到循环起始处,进入下一次循环操作。
3) return语句是一个跳转语句,用来从一个方法返回(返回一个值或其他复杂类型),可以使程序控制返回到调用该方法的地方



JAVA UUID 生成
GUID是一个128位长的数字,一般用16进制表示。算法的核心是结合机器的网卡,当地时间,以恶随机数来生成GUID。从理论
上讲,如果一台机器每秒产生10000000个GUID,则可以保证(概率意义上)3240年不重复。
public class Test{
   public static void main(String[] args){
      UUID uuid = UUID.randomUUID();
      System.out.println(uuid);
   }
}

UUID是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的。通常平台会提供生成UUID的API。
UUID按照开放软件基金会(OSF)制定的标准计算，用到了以太网卡地址、纳秒级时间、芯片ID码和许多可能的数字。
由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，过几秒又生成
一个UUID，则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，
没有网卡以其他方式获得），UUID的唯一缺陷在于生成的结果串会比较长。关于UUID这个标准使用最普遍的是微软
的GUID(Globals Unique Identifiers)。

UUID由一下及部分的组合：
1) 当前日期和时间,UUID的第一个部分与时间有关,如果你在生成一个UUID之后,过几秒又生成一个UUID,则第一个部分不同,
其余相同。
2) 时钟序列
3) 全局唯一的IEEE机器识别号,如果有网卡,从网卡MAC地址获得,没有网卡以其他方式获得
UUID的唯一缺陷在于生成的结果串会比较长.关于UUID这个标准使用最普遍的是微软的GUID.其格式为:
xxxxxxxx-xxxx- xxxx-xxxxxxxxxxxxxxxx(8-4-4-16),其中每个x是0-9或a-f范围内的一个十六进制的数字,而标准的UUID
格式:xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxx (8-4-4-4-12).

静态变量和实例变量的区别
在语法定义上的区别：静态变量前要加static关键字,而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才被分配空间,才能使用这个
实例变量。静态变量则可以直接使用类名来引用。


==：使用该运算符比较两个对象的引用(变量),则实质上是比较两个变量是否引用了相同的的对象.所谓相同的对象是指
是否在堆栈(Heap)中开辟的同一块内存单元中存放的对象。

Jquery和DOM对象相互转换之前,先约定好定义变量的风格.如果获取的对象是JQuery对象，那么在变量面前加上$,例如：
      var $variable = jQuery对象;
      如果获取的是DOM对象，则定义如下;
      var variable  = DOM对象;
 jQuery对象转换成DOM对象
  jQuery没有封装想要的方法，不得不使用DOM对象的时候,有以下两种处理方法.
  1) jQuery对象是一个数组对象,可以通过[index]的方法得到相应的DOM对象。
     jquery代码如下:
     var $cr = $("#cr");
     var cr  = $cr[0];
  2) 另一种方法是jQuery本身提供的,通过get(index)方法得到相应的DOM对象。
     jQuery代码如下:
     var $cr = $("#cr");
     var cr  = $cr.get(0);
 DOM对象转换成jQuery对象
 对于一个DOM对象,只需要用$()把DOM对象包装起来,就可以获得一个jQuery对象;
 jQuery代码如下:
     var cr  = document.getElementById("Id");
     var $cr = $(cr);

java 序列化和反序列化
进行序列化的主要原因是实现对象持久化和进行网络传输。
序列化是将对象转换为可保持或传输的格式的过程.与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来
可以轻松地存储和传输数据。

transient变量和static变量不被序列化。

----------transient Java语言关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,
transient型变量的值不包括在串行化的表示中,然而非transient型的变量是被包括进去的。

----------ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

----------控制对象的序列化和反序列化
例如：将对象转换成文件进行保存导出到本地
  //-----首先创建一个要输出保存的对象------//
  public Person implements Serialable{
     private String name;
     private int age;

     public Person(String name,int age){
        System.out.println("Inside Person's Constructor");
    this.name = name;
    this.age = age;
     }

     public void setName(String name){
        this.name = name;
     }

     public String getName(){
        return name;
     }

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

     public int getAge(){
        return age;
     }
  }

  //序列化、反序列化为一般的文件
  public class Test{
    public static void main(String[] args){
       Test t = new Test();
       t.savePerson();//对象状态转换为可保持或传输的格式的过程
       t.restorePerson();//流转换为对象
    }

    public void savePerson(){
      Person p = new Person("liwy",23);
      try {
        FileOutputStream fos = new FileOutputStream("D://test.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        System.out.println("test.name:" + test.getName());
        System.out.println("test.age:" + test.getAge());

        oos.writeObject(test);
        oos.flush();
        oos.close();

    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    }

    public void restoreTest() {
        try {
            FileInputStream fis = new FileInputStream("D://test.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);

            Test test = (Test) ois.readObject();
            
            System.out.println("test.name:" + test.getName());
            System.out.println("test.age:" + test.getAge());
    
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
  }
  序列化、反序列化为XML文件，我使用了XStream来序列化，需要引入xstream-1.3.1.jar包的支持；
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;

    import com.thoughtworks.xstream.*;

    public class Serialize {
        public static void main(String[] args) {
        Serialize ser = new Serialize();
        ser.serializeToXml();
        ser.deSerializeFromXml();
        }
       
    public void serializeToXml(){
        Person[] myPerson = new Person[2];
        myPerson[0] = new Person("Jay",24);
        myPerson[1] = new Person("Tom",23);
           
        XStream xstream = new XStream();
        try {
            FileOutputStream fos = new FileOutputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
             xstream.toXML(myPerson,fos);
             } catch (FileNotFoundException ex) {
             ex.printStackTrace();
             }      
        System.out.println(xstream.toXML(myPerson));
        }
        public void deSerializeFromXml(){
         XStream xs = new XStream();
         Person[] myPerson = null;

         try {
         FileInputStream fis = new FileInputStream("E:\\workspace\\2010_03\\src\\myPerson.xml");
         myPerson=(Person[])xs.fromXML(fis);
         if (myPerson != null)
         {
             int len = myPerson.length;
             for (int i=0;i<len;i++)
             {
             System.out.println(myPerson[i].getName());
             System.out.println(myPerson[i].getAge());
             }

         }
         } catch (FileNotFoundException ex) {
         ex.printStackTrace();
         }
        }
    }
    运行结果为（console输出），当然可以查看到myPerson.xml文件已经生成：
    Inside Person's Constructor
    Inside Person's Constructor
    <Person-array>
      <Person>
        <name>Jay</name>
        <age>24</age>
      </Person>
      <Person>
        <name>Tom</name>
        <age>23</age>
      </Person>
    </Person-array>
    Jay
    24
    Tom
    23

在java中一共有8种基本数据类型,其中有4种整型,2中浮点类型,一种用于表示Unicode编码的字符单元的字符类型和一种
用于表示真值的boolean类型(一个字节等于8个bit)
1.整型
类型       存储需求(字节长度)        bit数    取值范围            默认值          包装类
long         8字节             8*8     -2^63 ~(2^63)-1        0L或0l         Long
int          4字节             4*8     -2^31 ~(2^31)-1        0           Integer
short        2字节                   2*8     -2^15 ~(2^15)-1        0           Short
byte         1字节                   1*8     -2^7 ~2^7-1        0           Byte


2.浮点型
类型       存储需求        bit数    取值范围             包装类            备注
double       8字节       8*8      64位IEEE754双精度范围       Double  没有后缀F的浮点数值(如3.14)默认为double
float        4字节         4*8      32位IEEE754单精度范围    Float          float类型的数值有一个后缀F

3.char类型
类型       存储需求        bit数    取值范围             默认值       包装类             备注
char         2字节       2*8       Unicode[0,65535]      u0000          Character          

4.boolean类型
类型       存储需求        bit数    取值范围          默认值           包装类            备注
boolean      1字节         1*8         ture和false       false           Boolean

java中查看源代码
  1)点击"window"->"Preferences"->"Java"->"Installed JRES";
  2)此时"Installed JRES"右边是列表窗格,列出了系统中的JRE环境,选择你的JRE,然后点边上的"Edit..",会出现一个窗口
  (Edit JRE)
  3)选中rt.jar文件这一项:"C:\Java\jdk1.5.0_04\jre\lib\rt.jar"点左边的"+"号展开它;
  4)展开后,可以看到"Source Attachment:(none)",这一项,点右边的按钮"Source Attachment.."选择你的JDK目录下的
  src.zip;
  5)点击OK结束;

变量名,函数名,数组名统称为标识符；
   标识符的命名规则:
     只能由字母(a~z,A~Z),数字(0~9),下划线(_)或$组成。
     并且标识符的第一个字符必须是字母,下划线或$.
     此外，标识符也不能包含空白字符(换行符,空格和制表符)

访问权限
作用域与可见性    当前类    同一package    子类    其他package
public              √           √           √        √

protected        √           √           √        ×

default             √           √           ×        ×  

private             √           ×           ×        ×

接口中的方法只能用public和abstract修饰;
接口中的属性默认是public static final;
(使用final修饰代表该属性是常量,常量必须有初始化值)

instanceOf判断这个对象是否是特定类或者是它的子类的一个实例,返回值是boolean布尔类型

java程序运行从上到下的环境次序是
    先编写程序,然后编译成二进制代码,给系统发送信息,然后操作具体的硬件运行
    ：java程序-->JRE/JVM-->操作系统-->硬件

do{
  循环体语句区块
}while(布尔表达式);
=====先执行一次循环体语句区块,然后再判断布尔表达式的值,若为false则跳出do--while循环。

jquery对象转DOM对象的方法
var $test = $("#test");===jquery对象
     ||
转成DOM对象 $test[0]

DOM对象.complete====这个属性可返回浏览器是否已经完成对图像的加载，如果加载完成，则返回true,否则返回false。
DOM对象.onload  ====当图像装载完毕时调用的时间句柄。

----------------------------------------------面向对象-------------------------------------------------------------
面向对象的特征
1) 抽象
2) 继承
3) 封装
4) 多态

通过继承，子类可以使用父类中的一些成员变量与方法，从而能够提高代码的复用性
继承有如下几个特性：
1) java语言不支持多重继承，也就是说，子类至多只能有一个父类，但是可以通过是想多个接口来达到多重继承的目的。
2) 子类只能继承父类的非私有(public与protected)成员变量与方法。
3) 当子类中定义的成员变量和父类中定义的成员变量同名时，子类中的成员变量会覆盖父类的成员变量，而不会继承。
4) 当子类中的方法与父类中的方法有相同的函数签名(相同的方法名，相同的参数个数与类型时)，子类将会覆盖父类的方法，
而不会继承。

组合和继承的区别
组合和继承是面向对象中两种代码复用的方式。
组合是指在新类里面创建原有类的对象，重复利于已有类的功能/

    继承                        组合
class Verhicle{}            class Tire{}

class car extends Verhicle{}            class Car entends Verhicle{
                       private Tire t = new Tire();
                    }
由于Java语言只支持单继承，如果想同时继承两个类或者多个类，在java中是无法直接实现的。同时，在java语言中，如果继
承使用太多，也会让一个class里面的内容变得臃肿不堪。所以能使用组合就尽量不要使用继承。

多态的实现机制
有如下两种实现方式：
1) 方法的重载。重载是指同一个类中有多个同名的方法，但这些方法有着不同的参数。
2) 方法的覆盖。子类的方法和父类的方法相同，子类会覆盖父类的方法，执行自己本身的方法。

此外，只有类中的方法才有多态的概念，类中成员变量没有多态的概念。
class A{
  public int i = 1;
}
class B extends A{
  public int i = 2;
}
public test{
  public static void main(String[] args){
     A a = new B();
     System.out.println(a.i);===========结果是1
  }
}

内部类有哪些?
静态内部类:被申明为static的内部类;
成员内部类:
局部内部类:定义在一个代码块里的类;
匿名内部类:没有类名的内部类;
  使用匿名内部类需要牢记以下原则：
  1) 匿名内部类不能有构造函数。
  2) 匿名内部类不能定义静态成员。
  3) 匿名内部类不能是public,protected,private,static。
  4) 只能创建匿名内部类的一个实例。
  5) 一个匿名内部类一定是在new的后面，这个匿名类必须继承一个父类或实现一个接口。
  6) 因为匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

注意：在非静态内部类中不能定义静态成员；
      静态内部类不能访问外部类的非静态成员。

如何获取父类的类名
|获    class Father{}
|取    public Children extends Father{
|子        public void test(){
|类            System.out.println(this.getClass().getName());
|的        }
|类
|名         public static void main(String[] args){
|             new Children().test();===============结果是Children
|        }
|    }

|获    class Father{}
|取    public Children extends Father{
|父         public void test(){
|类            System.out.println(super.getClass().getName());
|的        }
|类
|名         public static void main(String[] args){
|             new Children().test();===============结果是Children
|        }
|    }

解答原因:主要原因在于java语言中任何类都继承自object类，getClass()方法在object类中定义为final与native,子类不能覆
盖该方法。因此this.getClass()和super.getClass()最终调用的都是Object中的getClass()方法。而object的getClass()方法
的释义是：返回此object的运行时类。

使用反射获取父类的名字：getClass().getSuperclass().getName()；