定義線程有兩種方法，一種是繼承Thread類，一種是實現Runnable接口，這兩種方法存在各自的優缺點。和定義線程對應的就是創建線程對象，也有兩種方法。下面給大家介紹一下這兩種方法來定義線程及相對應的創建線程對象的方法。

1.繼承Thread類定義線程

      定義一個線程可以通過繼承Thread類來實現，這是一種相對簡單的定義線程的方法。在Thread類中有一個run方法，在定義的線程中需要重寫這個方法。在重寫run方法中可以定義該線程要執行的語句。當線程啟動時，run方法中的程序就成為一條獨立的執行線程。示例代碼如下：

public  class   XianCheng  extends  Thread

{

       public void run()

      {

            System.out.println("run方法執行");

         }

}     

改程序是無法執行的，因為沒有main方法，也就是沒有啟動線程的方法。下面先介紹如何創建線程對象。代碼如下:

XianCheng   xc = new  XianCheng();

從上面的代碼可以看出，創建線程對象的方法和創建普通對象的方法是一樣的。但是這只是對于使用繼承Thread類創建線程的方法來說的。我們也可以通過Thread類來定義線程對象，如

Thread  th = new Thread（）；

2.實現Runnable接口定義線程

      在Runnable接口中具有一個抽象的run方法，在實現Runnable接口時，需要實現run方法。示例代碼如下：

public  class  test2  implements  Runnable{

    public   void   run（）{

        System.out.println("run方法執行");

        }

}

在使用實現Runnable接口定義的線程中，要比上面復雜些，因為直接創建類的對象創建的并不是一個線程對象，要想創建線程對象必須要借助Thread類。只有Thread類才能定義線程對象。

代碼如下：test2     t2 = new  test2（）；

             Thread  tt2 = new  Thread（t2）；

tt2才是線程對象，Thread類具有4個構造器，最常用的就是具有一個參數的，我們可以先創建一個實現Runnable接口的類對象，然后作為Thread類的參數來創建多個線程對象。

當我們建立了一個線程類的時候，就要啟動線程，初學者會認為啟動線程就是調用線程類中的方法。但這點是錯誤的，雖然可以用對象名.run（）來調用run方法，但這并不是線程的啟動。要想啟動線程還要調用線程的star方法，如：tt2.start（）；但要注意，一個線程只能調用一次star方法，第二次啟動線程會發生IllegalThreadException異常。有關線程的啟動，應用問題以后再做介紹。

好了，有關線程的基礎知識先介紹到這里。有不足的地方請大家批評指正。

學Java也有好一陣子了，當涉及到Java的實際應用時發現自己的基礎跟不上?；A不行，概念不清，對以后的學習造成不小的負面影響。仔細分析后，自己總結了一些Java里面很基礎的東西，希望以后把基礎打好，高手就不必過目了呀，哈哈~~~

一、有關super跟this的區別。

區別	Super	This
范圍	由子類訪問父類的內容	直接訪問本類中的內容
訪問屬性	super.父類屬性，如果屬性沒有被覆寫，則也可以不寫super。	This.本類屬性。
訪問方法	super.父類方法(),如果方法沒有被覆寫，則可以不用加super也表示調用父類中的方法。	this.本類方法(),可以不寫this,也表示調用本類的方法。
訪問構造方法	super是訪問父類中的構造方法，必須放在首行。	this 是訪問本類中的其他構造方法，必須放在首行。

 

二、重載和重寫的區別。

區別	重載	重寫/覆寫
單詞	Overloading	Override
概念	方法名稱相同，參數列表不同。	方法名稱相同，參數列表相同，方法的訪問權限不能更嚴格。
范圍	發生在一個類中。	發生在繼承關系中，由子類進行覆寫。

三、Vector和ArrayList

   1.vector是線程同步的，所以它也是線程安全的，而arraylist是線程異步的，是不安全的。如果不考慮到線程的安全因素，一般用
       arraylist效率比較高。
   2.如果集合中的元素的數目大于目前集合數組的長度時，vector增長率為目前數組長度的100%,而arraylist增長率為目前數組長度

      的50%.如過在集合中使用數據量比較大的數據，用vector有一定的優勢。
    ArrayList 和Vector是采用數組方式存儲數據，此數組元素數大于實際存儲的數據以便增加和插入元素，都允許直接序號索引元素，
    但是插入數據要設計到數組元素移動等內存操作，所以索引數據快插入數據慢，Vector由于使用了synchronized方法（線程安全）所以性能上比ArrayList要差，
    LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行向前或向后遍歷，但是插入數據時只需要記錄本項的前后項即可，所以插入數度較快！

四、arraylist和linkedlist

     1.ArrayList是實現了基于動態數組的數據結構，LinkedList基于鏈表的數據結構。
     2.對于隨機訪問get和set，ArrayList覺對優于LinkedList，因為LinkedList要移動指針。
     3.對于新增和刪除操作add和remove，LinedList比較占優勢，因為ArrayList要移動數據。
       這一點要看實際情況的。若只對單條數據插入或刪除，ArrayList的速度反而優于LinkedList。
       但若是批量隨機的插入刪除數據，LinkedList的速度大大優于ArrayList. 因為ArrayList每插入一條數據，要移動插入點及之后的所有數據。

五、HashMap與TreeMap

       1、HashMap通過hashcode對其內容進行快速查找，而TreeMap中所有的元素都保持著某種固定的順序，如果你需要得到一個有序的結果你就應該使用TreeMap（HashMap中元素的排列順序是不固定的）。

          HashMap中元素的排列順序是不固定的）。

       2、HashMap通過hashcode對其內容進行快速查找，而TreeMap中所有的元素都保持著某種固定的順序，如果你需要得到一個有序的結果你就應該使用TreeMap（HashMap中元素的排列順序是不固定的）。集合框架”提供兩種常規的Map實現：HashMap和TreeMap (TreeMap實現SortedMap接口)。

       3、在Map 中插入、刪除和定位元素，HashMap 是最好的選擇。但如果您要按自然順序或自定義順序遍歷鍵，那么TreeMap會更好。使用HashMap要求添加的鍵類明確定義了hashCode()和 equals()的實現?！　∵@個TreeMap沒有調優選項，因為該樹總處于平衡狀態。

六、hashtable與hashmap

     1.歷史原因:Hashtable是基于陳舊的Dictionary類的，HashMap是Java 1.2引進的Map接口的一個實現

     2.同步性:Hashtable是線程安全的，也就是說是同步的，而HashMap是線程序不安全的，不是同步的

     3.值：只有HashMap可以讓你將空值作為一個表的條目的key或value

七、Set中的數據對象沒有順序且不可以重復。
      List中的數據對象有順序且可以重復。

我們知道面向對象語言的三大特征是封裝、繼承、多態。我們在定義了一個類之后，可以通過再定義一個類，且這個類繼承上一個類來擴展其功能。其實，在我們定義類時，類中的成員變量除了基本數據類型也可以是引用數據類型。下面我將編寫一個有關類成員變量中引用數據類型使用的例子。

在這個程序中，首先定義一個學校類，再定義一個班級類，最后定義一個學生類。在主程序中通過設置不同類型對象間的關系，達到類與類之間包含的關系。

代碼如下：

//學校類

package com.TinySK;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
class School{   
        private String name;   
        //一個學校有多個班級 ，通過集合類List  實現。
        private List<Cls> allClss;   
        public School(String name){   
                this.setName(name);   
                this.setAllClss(new ArrayList<Cls>());   
        }   
        //向學校中加入班級   
        public void add(Cls cls){   
                this.allClss.add(cls);   
        }   
        public void setName(String name){   
                this.name = name;   
        }   
        public String getName(){   
                return this.name;   
        }   
        public void setAllClss(List<Cls> allClss){   
                this.allClss = allClss;   
        }   
        public List<Cls> getAllClss(){   
                return this.allClss;   
        }   
}

//班級類

class Cls{   
        private String name;   
        private School school;  //此處定義了一個學校類的對象。 
        private List<Student> allStudents;//一個班級有多個學生 ，通過集合類List  實現。

       public Cls(String name){   
                this.setName(name);   
                this.setAllStudents(new ArrayList<Student>());   
        }   
        //向班級中加入學生   
        public void add(Student stu){   
                this.allStudents.add(stu);   
        }   
        public List<Student> getAllStudents(){   
                return this.allStudents;   
        }   
        public void setAllStudents(List<Student> allStudents){   
                this.allStudents = allStudents;   
        }   
        public void setSchool(School school){   
                this.school = school;   
        }   
        public School getSchool(){   
                return this.school;   
        }   
        public void setName(String name){   
                this.name = name;   
        }   
        public String getName(){   
                return this.name;   
        }   
}   

//學生類

class Student{   
        private String name;   
        private int age;   
        //一個學生屬于一個班級   
        private Cls cls;   
        public Student(String name,int age){   
                this.setName(name);   
                this.setAge(age);   
        }   
        public void setName(String name){   
                this.name = name;   
        }   
        public String getName(){   
                return this.name;   
        }   
        public void setAge(int age){   
                this.age = age;   
        }   
        public int getAge(){   
                return this.age;   
        }   
        public void setCls(Cls cls){   
                this.cls = cls;   
        }   
        public Cls getCls(){   
                return this.cls;   
        }   
}   

//主函數

public class Test{   
        public static void main(String[] args){   
                School sch = new School("Java blog");   
                Cls c1 = new Cls("Java一班");   
                Cls c2 = new Cls("Java二班");   
                Cls c3 = new Cls("Java三班");   
                Student stu1 = new Student("Tiny",20);   
                Student stu2 = new Student("SK",25);   
                Student stu3 = new Student("sevn",23);   
                Student stu4 = new Student("puck",28);   
                Student stu5 = new Student("lion",35);   
                //設置關系   
                sch.add(c1);   
                c1.setSchool(sch);   
                sch.add(c2);   
                c2.setSchool(sch);   
                sch.add(c3);   
                c3.setSchool(sch);   
                c1.add(stu1);   
                stu1.setCls(c1);   
                c2.add(stu2);   
                stu2.setCls(c2);   
                c2.add(stu3);   
                stu3.setCls(c2);   
                c3.add(stu4);   
                stu4.setCls(c3);   
                c3.add(stu5);   
                stu5.setCls(c3);   
                //如果要輸出全部的內容，則要進行雙重循環   
                System.out.println("學校名稱："+sch.getName());   
                Iterator<Cls> iter1 = sch.getAllClss().iterator();   
                while(iter1.hasNext()){   
                        Cls c = iter1.next();   
                        System.out.println("\t|- 班級名稱："+c.getName());   
                        //輸出一個班級中的全部學生   
                        Iterator<Student> iter2 = c.getAllStudents().iterator();   
                        while(iter2.hasNext()){   
                                Student s = iter2.next();   
                                System.out.println("\t\t|- 學生姓名："+s.getName()+"，學生年齡："+s.getAge()+" --> "+s.getCls().getSchool().getName());   
                        }   
                }   
        }   
}

運行結果如圖：

本例并沒有什么太多的難點，只是想突出一下類與類之間的關系。本文到此結束，有很多不足之處望大家批評指正。

  兩個對象引用進行比較，比較的是這兩個對象的引用，而引用是在內存中的一個地址。當然在這之前我們一定要清楚引用數據類型的堆棧二段式內存管理模式。下面通過一個例子來掩飾引用間的比較。

public class Obj {
    public static  void main(String [] args)
       {
               Obj t1=new Obj();
               Obj t2=new Obj();
               if(t1.equals(t2))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
       }
}

運行結果為：  false

equals方法在這里比較的是對象的引用，用new關鍵字創建的對象地址是重新分配的，它們進行比較地址當然是不同的。

下面對上面的程序進行擴展：

public class Obj {
     public String name;
     public int age;
     public void say(){
      System.out.println("姓名："+name+"  年齡："+age);
     }
public static  void main(String [] args)
       {
                Obj t1=new Obj();
                Obj t2=new Obj();
                Obj t3=new Obj();
                      t3=t1;
          if(t1.equals(t2))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
                 t1.name="Tiny";
                 t1.age=20;
                 t1.say();
                 t2.name="SK";
                 t2.age=10;
                 t1.say();
                 t2.say();
                 t1=t2;
        if(t1.equals(t3))
          {System.out.println("true");
          }
          else
          {
              System.out.println("false");
          }
                 t1.say();
                 t2.say();
                 t3.say();
        if(t3.equals(t2))
        {System.out.println("true");
        }
        else
        {
            System.out.println("false");
        }
       }
}

運行結果如圖：

有關程序的具體執行，通過圖例演示，如下：

                Obj t1=new Obj();
                Obj t2=new Obj();
                Obj t3=new Obj();

創建Obj類的實例，在內存中開辟存儲空間。

當執行t3=t1;時，內存中存儲形式變為：                              

原來t3所指向的那塊堆內存將變為“垃圾”。由java垃圾回收機制自動回收。

if(t1.equals(t2))
          {···· }
          else
          {····  }輸出結果當然為 false了。

                 t1.name="Tiny";
                 t1.age=20;
                 t1.say();
                 t2.name="SK";
                 t2.age=10;
                 t1.say();
                 t2.say();

執行完這幾條語句后，內存結果為：

 

至于t1.say();和t2.say();這兩條語句的結果我就不用多說了吧，下面是關鍵部分，當執行t1=t2;后內存中存儲結果為：

最后執行的那幾步應該就很清晰了，整個程序的流程到此結束。