BigData-Java总结大全（一）苏暖人

Data-Java总结大全（一）基础篇

---

1.标识符的注意事项以及命名规范

定义

就是给类，接口方法，变量等起名字的字符序列

组成规则

可以有数字，下划线，字母,$，拼接而成
不能以数字开头
不能使用java中已有的关键字

注意事项

标识符区分大小写

A:包名全部小写

单级包：小写
列举：com
多级包:小写，并用.隔开
列举：cn.oracle.myproject

B：类或者接口

一个单词:首写大写(A)
多个单词:每个单词首写大写
列举:TestDemo

C：方法或变量

一个单词：首写字母小写
多个单词 :从第二个单词开始 ，每个单词大写
列举：textDemo

D:常量

全部大写
列举:PI="3.1415926";

Java中break、continue、return语句的使用区别

break:用于完全结束一个循环，跳出循环体。不管哪种循环，一旦在循环体中遇到break，系统将完全结束循环，开始执行循环之后得代码。break不仅可以结束其所在的循环，还可以结束其外层的循环。此时需要break后紧跟一个标签，这个标签用于标识一个外层循环。java中的标签就是一个紧跟着英文冒号（：）的标识符。且它必须放在循环语句之前才有用。

public class BreakTest2
{
　　public static void main(String[] args){
　　　　// 外层循环，outer作为标识符
　　　　outer:
　　　　for (int i = 0 ; i < 5 ; i++ ){
　　　　　　// 内层循环
　　　　　　for (int j = 0; j < 3 ; j++ ){
　　　　　　　　System.out.println("i的值为:" + i + " j的值为:" + j);
　　　　　　　　if (j == 1){
　　　　　　　　　　// 跳出outer标签所标识的循环。
　　　　　　　　　　　break outer;
　　　　　　　　}
　　　　　　}
　　　　}
　　}
}
continue:中止本次循环，接着开始下次循环。而break则完全中止循环。
public class ContinueTest
{
　　public static void main(String[] args){
// 一个简单的for循环
　　　　for (int i = 0; i < 3 ; i++ ){
　　　　　　　System.out.println("i的值是" + i);
　　　　　　　if (i == 1){
　　　　　　　　　// 忽略本次循环的剩下语句
　　　　　　　　　continue;
　　　　　　　}
　　　　　　　System.out.println("continue后的输出语句");
　　　　}
　　}
}
return:不是用来跳出循环的，而是用来结束一个方法，一旦在循环内执行到了一个return语句，return语句将会结束该方法，循环自然也随之结束.与continue和break不同的是，return直接结束的是整个方法，不管这个return处于多少层的循环之内。
    public class ReturnTest
{
　　public static void main(String[] args){
　　　　// 一个简单的for循环
　　　　for (int i = 0; i < 3 ; i++ ){
　　　　　　System.out.println("i的值是" + i);
　　　　　　if (i == 1){
　　　　　　　　return;
　　　　　　}
　　　　　　System.out.println("return后的输出语句");
　　　　}
　　}
}

Java面向对象

什么是对象

世界万物皆为对象，凡是能看得见摸得着的所以东西都叫对象。对象是由属性和行为组成，属性是对象所具有的特征，而行为是对象可以做的动作。

例如生活中常见的事物：汽车。汽车的品牌型号、颜色、轴距、车身大小等等都是汽车的属性；汽车向前行驶、倒车、开门等动作都叫汽车的行为。

什么是类

类：具有相同属性和行为一堆对象的集合或者叫抽象。

同学是一种类，是所有来学校上课同学的统称，集合。
程序员是一种类，是所有参与程序编写的员工的集合。

类与对象的关系

类是对象的抽象，对象的类的实例。对象的每个属性被表示为类中的一个成员变量，对象的每个行为成为类中的一个方法。

例如同学是一个类，张三就是同学类的一个实例，是一个对象。张三的姓名、年龄、成绩等都是类的成员变量，而张三说话、行走、做作业等行为就是类的方法。
代码实例：

public class Student {  //定义一个名为Student的类
    //定义成员变量name、age、javaScore  
    String name;        
    int age;
    double javaScore;
    public void say(){  //定义一个名为say的方法
        int age = 10;   //定义局部变量
        System.out.println("该学生姓名是："+name+"\n该学生年龄是："+age+"\n该学生成绩是："+javaScore);
    }
}   

上述代码中需要注意以下几点：

1. 类名首字要大写，不能是关键字；
2. static尽量少用，不必要的麻烦；
3. 成员变量又叫全局变量，可以不用赋初始值，为默认值；
4. 局部变量必须赋初始值，另外局部变量只在方法域中起作用。

类的实例化

我们在创建了一个类之后，就需要对类进行实例化，使用类，如下面代码：

public static void main(String[] args) {
    Student stu = new Student();   //实例化一个Student类
    stu.name = "张三";             //给每一个属性赋值
    stu.age = 18;
    stu.javaScore = 95;
    stu.say();                     //调用类的方法
}  

上面代码运行后的结果是：

该学生姓名是：张三  
该学生年龄是：18   
该学生成绩是：95.0  

如果是存储一组学生信息，则需要用数组对Student类进行实例化，如下面代码：

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    Student[] stu = new Student[3];       //实例化长度为3的Student类数组，存储3名同学信息
    Student student = null;
    for (int i = 0; i < stu.length; i++) {
        student = new Student();
        System.out.println("请输入学生姓名：");
        String name = s.next();
        System.out.println("请输入学生成绩：");
        double score = s.nextDouble();
        student.name = name;
        student.javaScore = score;
        stu[i] = student;
    }
    for (Student ss : stu){
        System.out.println("学生姓名：" + ss.name + "   成绩是：" + ss.javaScore);
    }  
}    

当我们输入“张三、100、李四、90、王二、80”运行结果如下：

学生姓名：张三   成绩是：100.0
学生姓名：李四   成绩是：90.0
学生姓名：王二   成绩是：80.0

栈与堆的区别

1. 栈空间小，堆空间大；
2. 所有的数据都是放在栈与堆里面的；
3. 栈运行快，对运行慢；
4. 所有的基本类型以及引用变量本身都放在栈中；
5. 引用所指向的对象都放在堆中；
6. 运行方法都放在栈中，其中main方法放在最底层；
7. 入栈的方法都要被执行，并遵行先入后出的原则

构造器

构造器是类中的一个特殊的方法，该方法在对象实例化时被调用。构造器的用途是当对象实例化时，初始化对象中的对象。构造器必须满足下面两个属性：

1. 构造器的名称必须与类名相同；
2. 构造器不能声明返回值，也不能返回void。

如下面的代码：

 public class Pet {
    String name;
    int age;
    String colore;
    public Pet(){
        System.out.println("我是构造函数"); //构造函数
    }
    public void show(){
        System.out.println("你好我是："+name+"，今年"+age+"岁了，"+colore+"色的！");
    }
 }

构造器与方法类似，但它不是方法。每个类都必须有一个构造器，如果我们没有给类添加构造器，编译器会自动给我们添加一个构造器，默认构造器的形式参数列表是空的，如果我们给类添加了构造器，编译器就不会为类添加默认构造器。

构造器的使用

一个类可以有多个构造器，这种情况下，要调用哪个构造器就取决于new运算符所使用的实际参数。

继承（Inheritance）

什么是继承

在面向对象编程中，可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类，这种方式成为继承。
已有的类称为父类，而新类成为子类，父类也叫基类、超类。
使用继承不仅可以重用已有的代码，从而避免代码重复，还可以创建一个更容易维护和修改代码的程序。

使用“is a”关系判断继承

“is a”关系用于判断父类和子类的继承关系是否正确。当使用继承时，我们必须能够说子类“is a（是一个）”父类。如果这个语句是真的，那么继承关系就是对的。

Java中继承的实现

在Java中，一个类使用关键字extends继承其他类。关键字extends出现在类声明时的类名后，extends后面跟着的是要继承的类的名称。例如，下面的语句用于声明Dog类是Pet类的子类：

public class Dog extends Pet{             //extends继承Pet类
    String name;
    public Dog(){
        super();                         //调用父类的构造器
        System.out.println("我是子类构造函数");
    }
}  

单继承与多继承

在Java中，只能有一个父类
所有类的根类Object
Java语言API中包含了一个名为Object的特殊类，他是整个Java类层次中的根类。Object类在java.lang包中，是每个Java类的父类，要么是直接的父类，要么就是间接父类。
在Java中，当引用与一个字符串连接时，JVM将隐式地调用toString()方法。

方法重写

子类可以重写从父类继承的方法，从而允许子类添加或者改变父类中方法的行为，这称为方法重写，是OOP的特征之一。当子类重写父类的方法中，必须遵循如下的规则：

1. 子类的方法的返回值的类型、方法名和形式参数列表，必须和父类是相同的；
2. 访问修饰符必须不小于父类中的访问修饰符；
3. 子类中重写的异常不能抛出比父类更多的异常。

如下面的代码：

public class Dog extends Pet{
    String name;
    public Dog(){
        super();
        System.out.println("我是子类构造函数");
    }
    @Override                // 方法重写关键字
    public void show(){     // 方法重写
        System.out.println("你好我是："+name+"，今年"+age+"岁了，"+colore+"色的！");
        System.out.println("`````````汪汪汪`````````\n");
    }
}

方法重载(Overloading)

如何定义重载。

方法的重写和重载只有一个字不同，很多初学者认为这两者十分相似，其实不然。方法重载是让类以统一的方式处理不同类型数据的一种手段。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法，这就是多态性。

所谓方法重载是指在一个类中，多个方法的方法名相同，但是参数列表不同。参数列表不同指的是参数个数、参数类型或者参数的顺序不同。方法的重载在实际应用中也会经常用到。不仅是一般的方法，构造方法也可以重载。下面通过一个实例来分析。
重载的定义和使用方法。

Class Person {
{
    String name; 
    int age;
    void print(){ 
        System.out.println("姓名：" +name+"年龄：" +age); 
    }
    void print(String a，int b){ 
        System.out.println("姓名：" +a+"年龄："+b); 
        void print(String a，int b，intC){ 
        System.out.println("姓名："+a+"年龄：" +b+"ID号：" +c); 
}
    void print(String a，int b，doubleC){ 
        System.out.println("姓名："+a+"年龄：" +b+"ID号："+c); 
    } 
}

public class OverLoadExampleOL 
{
publicstaticvoidmain(String args[]) 
    {
    Personpl=newPerson();
        p1.nanle="李明";
        p1.age=22;
        p1.print(); 
        p1.print("王小早",19); 
        p1.print("金波",18,100325); 
        p1.print("婉宁",25,110903); 
    } 
}

在上面的程序中，可以看到Person类中有多个名为 void print的方法，这就是方法的重载。执行程序，运行结果如下：

姓名：李明年龄：22
姓名：王小早年龄：l9
姓名：金波年龄：18ID号：10 00325
姓名：婉宁年龄：25ID号：110903

重载要注意以下的几点:

1.在使用重载时只能通过不同的参数列表，必须具有不同的参数列表。例如，不同的参数类型，不同的参数个数，不同的参数顺序。当然，同一方法内的几个参数类型必须不一样，例如可以是 fun(int，float)，但是不能为 fun(int，int)。
2.不能通过访问权限、返回类型、抛出的异常进行重载。
3.方法的异常类型和数目不会对重载造成影响。.. 
4.可以有不同的返回类型，只要参数列表不同就可以了。
5.可以有不同的访问修饰符。
6.可以抛出不同的异常。

equals()方法

equals()方法比较两个对象，测试二者是否相等。
比较运算符“==”用于检测是否两个引用指向同一对象。

面向对象三大基本特性,五大基本原则

透切理解面向对象三大基本特性是理解面向对象五大基本原则的基础.

三大特性是：封装,继承,多态

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

---

所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

---

所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

---

五大基本原则

1.单一职责原则SRP(Single Responsibility Principle)
是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

---

2.开放封闭原则OCP(Open－Close Principle)
一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，
那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

---

3.替换原则(the Liskov Substitution Principle LSP)
子类应当可以替换父类并出现在父类能够出现的任何地方。比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，
也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

---

4.依赖原则(the Dependency Inversion Principle DIP) 具体依赖抽象，上层依赖下层。假设B是较A低的模块，但B需要使用到A的功能，
这个时候，B不应当直接使用A中的具体类： 而应当由B定义一抽象接口，并由A来实现这个抽象接口，B只使用这个抽象接口：这样就达到
了依赖倒置的目的，B也解除了对A的依赖，反过来是A依赖于B定义的抽象接口。通过上层模块难以避免依赖下层模块，假如B也直接依赖A的实现，那么就可能造成循环依赖。一个常见的问题就是编译A模块时需要直接包含到B模块的cpp文件，而编译B时同样要直接包含到A的cpp文件。

---

5.接口分离原则(the Interface Segregation Principle ISP)
模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来

---

this和super的区别?

（1）this代表本类对应的引用。

（2）super代表父类存储空间的标识(可以理解为父类引用可以操作父类的成员)

调用（访问）成员变量：

this.成员变量 调用本类的成员变量

super.成员变量 调用父类的成员变量

调用（访问）构造方法：

this(...) 调用本类的构造方法

super(...) 调用父类的构造方法

调用（访问）成员方法：

this.成员方法 调用本类的成员方法

super.成员方法 调用父类的成员方法

super()函数在子类构造函数中调用父类的构造函数时使用，而且必须要在构造函数的第一行

this()函数主要应用于同一类中从某个构造函数调用另一个重载版的构造函数。

this()只能用在构造函数中，并且也只能在第一行。所以在同一个构造函数中this()和super()不能同时出现。

接口和抽象类有什么区别

你选择使用接口和抽象类的依据是什么？

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

`抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。`

比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。

人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它.

所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。

第一点． 接口是抽象类的变体，接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。
第二点． 接口可以多继承，抽象类不行
第三点． 接口定义方法，不能实现，而抽象类可以实现部分方法。
第四点． 接口中基本数据类型为static 而抽类象不是的。

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。在这个类中，你必须继承或编写出其所有子类的

所有共性。虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。而且你可以在一个类中同时实现多个接口。在设计阶段会降低难度的。

有效处理java异常的三个原则

Java中异常提供了一种识别及响应错误情况的一致性机制，有效地异常处理能使程序更加健壮、易于调试。异常之所以是一种强大的调试手段，在于其回答了以下三个问题：

什么出了错?
在哪出的错?
为什么出错?

在有效使用异常的情况下，异常类型回答了“什么”被抛出，异常堆栈跟踪回答了“在哪“抛出，异常信息回答了“为什么“会抛出，如果你的异常没有回答以上全部问题，那么可能你没有很好地使用它们。有三个原则可以帮助你在调试过程中最大限度地使用好异常，这三个原则是：

具体明确
提早抛出
延迟捕获

01.异常

1.异常

：是对问题的描述，将问题进行对象的封装。

2.异常体系：

  Throwable
   |---Error
   |---Exception
     |---RuntimeException

3.异常体系的特点：

异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作，只有异常体系具备这个特点。

4.throw和throws的用法：

  throw定义在函数内，用于抛出异常对象。
  throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

5.当函数内有throw抛出异常对象 ，

并未进行try处理，必须要在函数上声明，否则编译失败。

  注意：RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常，
 函数上可以不用声明。如果函数声明了异常，调用者需要进行处理，处理方法可以throws
 也可以try.

6.异常有两种：

  (1)编译时被检测异常：
  <1>该异常在编译时，如果没有处理，那么编译失败。
  <2>该异常被标识，代表可以被处理。
  (2)运行时异常（编译时不检测）
  <1>在编译时，不需要处理，编译器不检查。
  <2>该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

7.异常处理语句

  try
  {
   需要被检测的代码;
  }
  catch()
  {
   处理异常的代码;
  }
  finally
  {
   一定会执行的代码;
  }

8.三和结合格式：（try-catch-finally）

  注：
   finally中定义的通常是关闭资源代码，因为资源必须释放。
   finally只有一种情况不会被执行，就是当执行到System.exit(0)时。

9.自定义异常：

(1)定义灯继承Exception或RuntimeException
<1>为了让该自定义类具备可抛性。
<2>让该类具备操作异常的共性方法。
(2)当要定义自定义异常的信息时，可以使用父类已经定义好的功能，将异常信息传递给父类的构造函数。
class MyException extends Exception
{
MyException(String message)
{
super(message);
}
}
自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

10异常的好处：

  (1)将问题进行封装。
  (2)将正常流程代码和问题处理代码相分离，方便于阅读。

11.异常处理原则：

  (1)处理方式有两种：try或throws.
  (2)调用到抛出异常的功能时，抛出几个就处理几个，一个try可对应多个catch.
  (3)多个catch时，父类的catch放到最下面。
  (4)catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace,输出语句，也不要不写。
  (5)当捕捉到的异常，本功能处理不了时，可以继续在catch中抛出。
  try
  {
   throw new AException();
  }
  catch(AException e)
  {
   throw e;
  }
  (6)如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，再抛出和该功能相关的异常。
  try
  {
   throw new AException();
  }
  catch(AException e)
  {
   //在抛出B之前，对A先进行处理。
   throw new BException();
  }
  注：或者异常可以处理，当需要将异常产生后和本功能相关的问题提供出去，当调用者知道，并处理
   也可以将捕获异常处理后，转换新的异常。

12.异常的注意事项：

  在子父类覆盖时：
  (1)子类抛出的异常必须是父类的异常的子类或子集。
  (2)如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

02.包（package）

1.包：

  包也是一种封装形式，可对类文件进行分类管理，给类提供多层命名空间。
  写在程序文件的第一行，类名的全称是：包名.类名

2.包的好处：

包的出现可以让类文件和java的源文件相分离，可以很方便地只将类文件提供给别人使用。

3.包与包之间的访问：

  (1)一个包中的类要被访问，必须要有足够大的权限，所以被访问的类要被public修饰。
  (2)类公有后，被访问的成员也要公有才可以被访问。
  (3)包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
  (4)不同包中的子类还可直接访问父类中被protected权限修饰的成员。
  (5)包与包之间可以使用的权限只有两种：public,protected.

4.java中四种权限

 public protected default private

image

5.import

  (1)为了简化类名的书写，使用一个关键字import,import导入的是包中的类。
  (2)import packb.*;为导入包中所有的类，尽量不要写通配符*，需要用到哪个类就导入哪个类，
  都导进来比较占内存。
  (3)建立定义包名不要重复，可以使用url来完成定义，因为url是唯一的。
  如：package cn.itcast.test
  (4)包和子包中有重名类时，创建对象必须加包名。
  如：packb包和子包haha中都有DemoC,创建包中DemoC对象代码为：
  packb.DemoC c = new packb.DemoC();

6.jar包

  (1)java中的jar包是通过工具jar.exe完成的。
  (2)java的压缩包方便项目的携带，方便于使用，只要在classpath设置jar路径即可。
  (3)数据库驱动，SSH框架等都是以jar包体现的。

JAVA多线程实现的四种方式

Java多线程实现方式主要有四种：继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

其中前两种方式线程执行完后都没有返回值，后两种是带返回值的。

1、继承Thread类创建线程

Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  
 
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();  

2、实现Runnable接口创建线程

如果自己的类已经extends另一个类，就无法直接extends Thread，此时，可以实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();  

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {  
　　if (target != null) {  
　　 target.run();  
　　}  
}  

3、实现Callable接口通过FutureTask包装器来创建Thread线程

Callable接口（也只有一个方法）定义如下：

public interface Callable   { 
  V call（） throws Exception;   } 
public class SomeCallable extends OtherClass implements Callable {

@Override
public V call() throws Exception {
// TODO Auto-generated method stub
return null;
}

}
Callable oneCallable = new SomeCallable();   
//由Callable创建一个FutureTask对象：   
FutureTask oneTask = new FutureTask(oneCallable);   
//注释：FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。 
  //由FutureTask创建一个Thread对象：   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   
//至此，一个线程就创建完成了。

4、使用ExecutorService、Callable、Future实现有返回结果的线程

ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征，有了这种特征就不需要再为了得到返回值而大费周折了。而且自己实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口。类似的，无返回值的任务必须实现Runnable接口。

执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了。

注意：get方法是阻塞的，即：线程无返回结果，get方法会一直等待。

再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：

import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  
  
/** 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List list = new ArrayList();  
   for (int i = 0; i < taskSize; i++) {  
Callable c = new MyCallable(i + " ");  
// 执行任务并获取Future对象  
Future f = pool.submit(c);  
// System.out.println(">>>" + f.get().toString());  
list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
// 从Future对象上获取任务的返回值，并输出到控制台  
System.out.println(">>>" + f.get().toString());  
   }  
  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----，程序运行时间【"  
 + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
  
class MyCallable implements Callable