1.&和&&的区别？

&：逻辑与（and）,运算符两边的表达式均为true时，整个结果才为true。
&&：短路与，如果第一个表达式为false时，第二个表达式就不会计算了。

2.在java中如何跳出当前的多重循环？

在循环语句外前面定义一个标号，然后在里层循环体的代码中使用带有标号的break语句，即可跳出循环。
比如：

  1. ok:
  2. for (int i = 0; i < 10; i++) 
  3. {
  4.     {
  5.          for (int j = 0; j < 10; j++) 
  6.          {
  7.                 break ok;
  8.          }
  9.     }
  10. }

3.最有效率的方法算出2X8等于几？

使用位运算，效率最高：2<<3,表示2向左移动了3位，就相当于2乘以2的3次方,结果：16。

4.”==”和equals方法究竟有什么区别？

==：表示两个变量的值是否相等，比较两个基本数据类型的数据或者引用变量，用==。
equals:用于比较两个独立对象的内容是否相同。字符串的比较也用equals。

5. Int和integer的区别？

Int是Java的8中基本数据类型之一，integer是int的封装类。Int类型的默认值为0，integer默认值为null，所以区别在于，integer能区分出null值和0的区别。

6.三个与取整有关的方法：

Math.ceil():表示向上取整；Math.ceil(11.3)=12;Math.ceil(-11.3)=-12。
Math.floor():表示向下取整；Math.floor(11.6)=11;Math.floor(-11.6)=-12。
Math.round():表示四舍五入；Math.round(11.5)=12;Math.round(-11.5)=-11;
Math.round(11.3)=11;Math.round(-11.3)=-11;

7.重载和重写的区别？

重载（Overload）：函数名相同，参数不同。可以改变返回值类型，参数的个数和类型。
重写（Override）：和父类的的方法名称、参数完全相同。

8.面向对象的特征？

封装：将对象属性和方法的代码封装到一个模块中，也就是一个类中，保证软件内部具有优良的模块性的基础，实现“高内聚，低耦合”。
抽象：找出一些事物的相似和共性之处，然后归为一个类，该类只考虑事物的相似和共性之处。抽象包括行为抽象和状态抽象。
继承：在已经存在的类的基础上进行，将其定义的内容作为自己的内容，并可以加入新的内容或者修改原来的方法适合特殊的需要。
多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，就是多态，简单点说：就是用父类的引用指向子类的对象。目的：提高代码复用性，解决项目中紧耦合问题，提高可扩展性。
多态的机制：靠的是父类的或者接口的引用变量可以指向子类或者具体实现类的实例对象。

9.String和StringBuffuer、StringBuilder的区别？

String:字符串数值不可变；
StringBuffer：字符串可修改，可以动态构造字符数据。StringBuffer类是可以通过Append()来修改值。线程安全。
StringBuilder：线程不安全。
三者在执行速度方面的比较：StringBuilder > StringBuffer > String
对于三者使用的总结：
1.如果要操作少量的数据用 = String　　
2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder
3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

10.java中有几种方法实现一个线程？用什么关键字修饰同步方法？stop()和suspend()方法为何不推荐使用？

第一种：继承Thread类。New Thread(){}.start():表示调用子类对象的run方法。
第二种：实现Runable接口。
第三种：线程池创建多线程。
第四种：实现Callable接口，重写call函数（
继承Thread类实现多线程，重写run方法时没有返回值也不能抛出异常，使用Callable接口就可以解决这个问题。
Callable接口和Runnable接口的不同之处：
1.Callable规定的方法是call，而Runnable是run
2.call方法可以抛出异常，但是run方法不行
3.Callable对象执行后可以有返回值，运行Callable任务可以得到一个Future对象，通过Future对象可以了解任务执行情况，可以取消任务的执行，而Runnable不可有返回值
）
用synchronized 关键字修饰同步方法。
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们，结果很难检查出真正的问题所在。
suspend() 方法容易发生死锁。调用 suspend() 的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被” 挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用 suspend() ，而应在自己的 Thread 类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait() 命其进入等待状态。若标志指出线程应当恢复，则用一个 notify()重新启动线程。

11.sleep()和wait()有什么区别？

sleep是线程被调用时，占着cpu休眠，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu。

sleep()和wait()方法的区别可从两个角度阐述：
1.cpu的抢占权；2.锁旗标是否释放
两者都会释放cpu的抢占权；
wait()方法执行完即可释放锁旗标，进入线程的等待队列；
sleep()执行完，不会释放，进入等待队列；

12. 同步和异步的区别？同步的实现方法？

同步:发送一个请求,等待返回,然后再发送下一个请求。实现：1. Synchronized修饰；2.wait和notify。
异步:发送一个请求,不等待返回,随时可以再发送下一个请求。
同步可以避免出现死锁,读脏数据的发生，一般共享某一资源的时候用，如果每个人都有修改权限，同时修改一个文件，有可能使一个人读取另一个人已经删除的内容，就会出错，同步就会按顺序来修改。
同步和异步最大的区别就在于，一个需要等待，一个不需要等待。
比如广播，就是一个异步例子。发起者不关心接收者的状态。不需要等待接收者的返回信息。
电话，就是一个同步例子。发起者需要等待接收者，接通电话后，通信才开始。需要等待接收者的返回信息。

13. 请对比synchronized与java.util.concurrent.locks.Lock的异同？

主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

14.String s =new String (“syz”);创建了几个String Object?

1.如果String常理池(常量缓冲区)中，已经创建”xyz”，则不会继续创建，此时只创建了一个对象new String(“xyz”)；
2.如果String常理池中，没有创建”xyz”，则会创建两个对象，一个对象的值是”xyz”，一个对象new String(“xyz”)。

15.作用域public、private、protected 以及不写时的区别？

private修饰的成员变量和函数只能在类本身和内部类中被访问。
protected 修饰的成员变量和函数能被类本身、子类及同一个包中的类访问。
public修饰的成员变量和函数可以被类、子类、同一个包中的类以及任意其他类访问。
默认情况（不写）下，属于一种包访问，即能被类本身以及同一个包中的类访问。

作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×

16.forward和redirect两种跳转方式的区别？

1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.
本质上说, 转发是服务器行为，重定向是客户端行为。其工作流程如下：
转发过程：客户浏览器发送http请求——》web服务器接受此请求—》调用内部的一个方法在容器内部完成请求处理和转发动作——》将目标资源发送给客户；在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。在客户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。
重定向过程：客户浏览器发送http请求——》web服务器接受后发送302状态码响应及对应新的location给客户浏览器—》客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的location地址——》服务器根据此请求寻找资源并发送给客户。在这里 location可以重定向到任意URL，既然是浏览器重新发出了请求，则就没有什么request传递的概念了。在客户浏览器路径栏显示的是其重定向的路径，客户可以观察到地址的变化的。重定向行为是浏览器做了至少两次的访问请求的。

18.编程单例模式：写一个singleton出来

Singleton分为：饱汉模式、饥汉模式、双重锁模式
//饱汉模式:类加载时完成初始化，创建出实例对象（不管用不用，先创建）。
public class SingleTon {
//实例化对象放到静态代码块中，可提高执行效率，但是可能更占用空间
private final static SingleTon instence=new SingleTon();
private SingleTon(){};//私有的构造函数
//获取方法
public static SingleTon getinstance(){
return instence;
};
}
//饥汉模式:延迟加载，在第一次用的时候才创建出对象，存在线程安全问题。
public class SingleTon {
private static SingleTon instence=null;
private SingleTon(){};//私有的构造函数
//获取方法
public static synchronized SingleTon getinstance(){
if(instence==null){
//第一次使用的时候创建对象
instence=new SingleTon();
}
return instence;
};
}

19.编程冒泡排序：用java实现冒泡排序？快速排序的方法。

冒泡排序：

  1. int temp = 0;
  2. int[] sortNum = {12,33,28,86,15,62,9,38};
  3. for (int i = 0; i < sortNum.length-1; i++) {  //第一个for循环控制排序要走多少趟，最多做n-1趟排序  
  4.     for (int j = 0; j < sortNum.length-1-i; j++) { //第2个for循环控制每趟比较多少次  
  5.                 if(sortNum[j+1]<sortNum[j]){  //大的 往后面排  
  6.                     temp = sortNum[j];  
  7.                     sortNum[j] = sortNum[j+1];  
  8.                     sortNum[j+1] = temp;  
  9.                 }  
  10.     }
  11. }
  12. System.out.println(Arrays.toString(sortNum));


1.对基本数据类型数组的排序
1>数字排序：

int[] intArray = new int[]{1,56,-5,33};
Arrays.sort(intArray);
System.out.println(Arrays.toString(intArray));


2>字符串排序(先大写后小写)：

String[] strArray = new String[]{“Z”, “a”, “D”};
Arrays.sort(strArray);
System.out.println(Arrays.toString(strArray));

20.HashMap和Hashtable的区别？

HashMap：实现了Map接口，允许空(null)键值(key),由于非线程安全，在只有一个线程访问的情况下，效率高于Hashtable。
Hashtable：不能将null作为key或者value。方法是同步的，线程安全。

21.List、Set和Map的区别？

List:是存储单列数据的集合，存储有顺序，允许重复。继承Collection接口。
Set: 是存储单列数据的集合。继承Collection接口。不允许重复。
Map:存储键和值这样的双列数据的集合，存储数据无顺序，键(key)不能重复，值(value)。可以重复。

22.什么时候用assert？

在调试程序时使用，对一个boolean表达式进行检查。为true，则程序正确，如果为false，系统则给出警告或者退出。

23.使用java.lang.Math,生成100个0到99之间的随机整数，找出最大和最小，并统计大于50的整数个数？

  1. import java.util.Random;
  3. public class RandomTest {
  5. public static void main(String args[]) {
  7. int max = 0;
  9. int min = 0;
  11. String sum="";
  13. int num=0;
  15. for (int i = 0; i <= 100; i++) {
  17. Random rand = new Random();
  19. int r = rand.nextInt(99);
  21. if (r >= max) {
  23. max = r;
  25. } else if (r < min) {
  27. min = r;
  29. }
  31. String s= ""+r;
  33. if (r > 50) {
  35. sum=sum+s+",";
  37. ++num;
  39. }
  41. }
  43. System.out.println("最大数max=" + max + "\n" + "最小数min=" + min);
  45. System.out.println("大于50的个数："+num);
  47. }
  49. }
  50. /*
  51. /*
  52. 备注：Random rand = new Random();
  53. int r = rand.nextInt(99);
  54. 表示产生的随机数为0-99的整数,不包括99。
  55.  */

24.java创建对象的方式有哪些？

1.使用new关键字
2.使用反射机制创建对象：
(1)使用Class类的newInstance方法
(2)java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。
3.使用clone方法：先实现Cloneable接口并实现其定义的clone方法
4.使用反序列化

25.java垃圾回收机制

GC是垃圾回收机制，是用来释放内存中的资源的。
垃圾回收可以有效的防止内存泄露，有效的使用空闲的内存。

26.error和exception有什么区别?

Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
Exception（违例）表示需要捕捉或者需要程序进行处理的异搜索常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。
Exception又分为运行时异常，受检查异常。
运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。
受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

27.Int如何去重复？

1.For循环
2.Set集合

28.JDBC使用步骤过程？

1、加载JDBC驱动程序：
2、提供JDBC连接的URL
3、创建数据库的连接
4、创建一个Statement
5、执行SQL语句
6、处理结果
7、关闭JDBC对象

29.运行时异常与一般异常有何异同？

Java提供了两类主要的异常:运行时异常runtime exception和一般异常checked exception。对于后者这种一般异常，JAVA要求程序员对其进行catch处理。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。
运行时异常我们可以不处理。这样的异常由虚拟机接管。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

30.抽象类和接口区别?

抽象类：用abstract修饰，抽象类不能创建实例对象。抽象方法必须在子类中实现，不能有抽象构造方法或者抽象静态方法。
接口：抽象类的一种特例，接口中的方法必须是抽象的。
两者的区别：

  1. 抽象类可以有构造方法，接口没有构造方法
  2. 抽象类可以有普通成员变量，接口没有普通成员变量。
  3. 抽象类可以有非抽象的普通方法，接口中的方法必须是抽象的。
  4. 抽象类中的抽象方法访问类型可以是public，protected，接口中抽闲方法必须是public类型的。
  5. 抽象类可以包含静态方法，接口中不能包含静态方法。
  6. 一个类可以实现多个接口，但是只能继承一个抽象类。

7.接口中基本数据类型的数据成员，都默认为static和final，抽象类则不是。

31.如何获取map集合中的数据？

  1. // 方法一： for each  +  map.keySet();   
  3. Set<Integer> set = map.keySet();  
  5. for (Integer key : set) {  
  7.     System.out.println("key:" + key + ", value:" + map.get(key));  
  9. }
  11. // 方法二：while循环(Iterator  +  map.keySet();)  
  13. Set<Integer> set = map.keySet();  
  15. Iterator<Integer> it = set.iterator();  
  17. while(it.hasNext()){  
  19.     Integer key = it.next();  
  21.     System.out.println("key:" + key + ", value:" + map.get(key));  
  23. }
  25. // 方法三：while循环(Iterator +Map.Entry<Key, Value>)  
  27. Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();  
  29. while (it.hasNext()) {  
  31.     Map.Entry<Integer, String> entry = it.next();  
  33.     System.out.println("key:"+entry.getKey() + ", value:"+entry.getValue());  
  35. }
  37. // 方法四：for循环(Iterator + Map.Entry<Key, Value>)  
  39. for(Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator(); it.hasNext();){  
  41.     Map.Entry<Integer, String> entry = it.next();  
  43.     System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());  
  45. }
  47. // 方法五：for each  +  Map.Entry<Key, Value>  
  49. for(Map.Entry<Integer, String> entry : map.entrySet()){  
  51.     System.out.println("key:" + entry.getKey() + ", value:" +entry.getValue());  
  53. }

32.hashCode与equals的区别与联系？

一、equals方法的作用
1、默认情况（没有覆盖equals方法）下equals方法都是调用Object类的equals方法，而Object的equals方法主要用于判断对象的内存地址引用是不是同一个地址（是不是同一个对象）。
2 、要是类中覆盖了equals方法，那么就要根据具体的代码来确定equals方法的作用了，覆盖后一般都是通过对象的内容是否相等来判断对象是否相等。
二、Hashcode（）方法：
1、我们并没有覆盖equals方法只覆盖了hashCode方法，两个对象虽然hashCode一样，但在将stu1和stu2放入set集合时由于equals方法比较的两个对象是false，所以就没有在比较两个对象的hashcode值。
2、覆盖一下equals方法和hashCode方法，stu1和stu2通过equals方法比较相等，而且返回的hashCode值一样，所以放入set集合中时只放入了一个对象。
3、我们让两个对象equals方法比较相等，但hashCode值不相等试试，虽然stu1和stu2通过equals方法比较相等，但两个对象的hashcode的值并不相等，所以在将stu1和stu2放入set集合中时认为是两个不同的对象。
总结：
1、equals方法用于比较对象的内容是否相等（覆盖以后）
2、hashcode方法只有在集合中用到
3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。
4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

33.Java中什么是竞态条件?

当两个线程竞争同一资源时，如果对资源的访问顺序敏感，就称存在竞态条件。导致竞态条件发生的代码区称作临界区。在临界区中使用适当的同步就可以避免竞态条件。 界区实现方法有两种，一种是用synchronized，一种是用Lock显式锁实现。


34.线程死锁及解决办法

1)、让所有的线程按照同样的顺序获得一组锁。这种方法消除了 X 和 Y 的拥有者分别等待对方的资源的问题。
　　2)、将多个锁组成一组并放到同一个锁下。前面Java线程死锁的例子中，可以创建一个银器对象的锁。于是在获得刀或叉之前都必须获得这个银器的锁。
　　3)、将那些不会阻塞的可获得资源用变量标志出来。当某个线程获得银器对象的锁时，就可以通过检查变量来判断是否整个银器集合中的对象锁都可获得。如果是，它就可以获得相关的锁，否则，就要释放掉银器这个锁并稍后再尝试。

35.ArrayList和LinkList的区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据，而查询和修改ArrayList占优势。

36.Socket和HTTP区别？

socket则是对TCP/IP协议的封装和应用(程序员层面上)， Socket本身并不是协议，而是一个调用接口(API)。也可以说，TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。

37.BS与CS的联系与区别？

C/S 与 B/S 区别：
（bs 面向庞大、不同群体、不同平台的客户;cs 面向比较单一的客户）
1．硬件环境不同:
C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.
B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行
2．对安全要求不同
C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.
B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
3．对程序架构不同
C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.
B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.
4．软件重用不同
C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.
B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子
5．系统维护不同
C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统
B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.
6．处理问题不同
C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统
B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.
7．用户接口不同
C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高
B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.
8．信息流不同
C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低
B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。

38.多线程中thread的start（）和run()的区别？

　1） start：
　用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，Run方法运行结束，此线程随即终止。
　2） run：
　　run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。总结：调用start方法方可启动线程，而run方法只是thread的一个普通方法调用，还是在主线程里执行。这两个方法应该都比较熟悉，把需要并行处理的代码放在run()方法中，start()方法启动线程将自动调用 run()方法，这是由jvm的内存机制规定的。并且run()方法必须是public访问权限，返回值类型为void。

39.final关键字的用法

一、final修饰类：
被final修饰的类，是不可以被继承的，这样做的目的可以保证该类不被修改，Java的一些核心的API都是final类，例如String、Integer、Math等。
二、final修饰方法：
子类不可以重写父类中被final修饰的方法。
三、final修饰实例变量(类的属性，定义在类内，但是在类内的方法之外)
final修饰实例变量时必须初始化，且不可再修改。//
四、final修饰局部变量(方法体内的变量)
final修饰局部变量时只能初始化(赋值)一次，但也可以不初始化。
五、final修饰方法参数
final修饰方法参数时，是在调用方法传递参数时候初始化的。