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异常。有关线程的启动，应用问题以后再做介绍。

好了，有关线程的基础知识先介绍到这里。有不足的地方请大家批评指正。

一、有关super跟this的区别。

二、重载和重写的区别。

三、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.say();和t2.say();这两条语句的结果我就不用多说了吧，下面是关键部分，当执行t1=t2;后内存中存储结果为：