java基础题目总结，java基础总结

java基础题目总结，java基础总结

1.        Java的跨平台原理，和C语言跨平台原理的不同之处（*****）。

Java的跨平台是通过java虚拟机JVM来实现的

C语言是“一次编写，到出编译”  java是“一次编译，到处运行”

2.        什么是JVM？什么是JDK？什么是JRE？

JVM是java虚拟机，所有的java程序都在java虚拟机中运行

Jdk是java开发工具包，用来开发java程序

JRE 是运行java程序所必须的环境的集合

3.        Java的优点

Java是一种跨平台，适合与分布式计算机环境的面向对象编程语言

特性：面向对象、分布式、解释性、可靠、安全、平台无关、可移植性、高性能、多线程、多态性

4.        什么是注释?注释分为几种?注释有什么作用?

注释是一种对代码的说明   分为 单行注释  多行注释   和文档注释 

作用：能够方便更好的阅读

5.        Java语言的执行过程。（*****）

Java编译生成字节码文件，生成的字节码在所有操作系统都是一样的

不同的操作系统，其java虚拟机不一样。虚拟机将java字节码转换为对应系统的相关指令，保证其正常运行

解释器在java虚拟机中，编译器在jdk或jre中

6.        环境变量path和classpath的作用（*****）

Path环境变量。作用是指定命令搜索路径，在命令行下面执行命令，他会到path变量指定的路径查找看是否能找到对应的命令程序。设置好path变量后，就可以在任何目录下执行javac等

Classpath环境变量。作用是指定类搜索路径，告诉java执行环境，在那些目录下可以找到您所需要的类或包

7.        Java是一种强类型语言，说明Java的数据类型分类。

Java分为基本数据类型和引用数据类型；基本数据类型分为整数型：byte  short 

Int  long  ； 浮点型： float  double ；布尔型boolean ：true  false ；

字符型：char （character）

8.        i++和++i的异同之处

i++和++i如果单独在语句中使用没有什么区别；不是单独的语句，i++先使用iba的值再加1；++i是先加1再使用i的值！

9.        运算符||和|的异同之处

||的是逻辑运算符，|是位运算符！

        条件“或”运算符 (||) 执行 bool 操作数的逻辑“或”运算，但仅在必要时才计算第二个操作数。如表达式X||Y和X|Y,如果X为true，Y为false。则第一个表达式只计算X，不计算Y，因为不论Y为何值，“或”操作的结果都是true。这种情况被称作“短路”计算。

| 运算符是为整型和 bool 预定义的。 对于整型， |计算操作数的按位“或”，就是对0/1，当且仅当两个操作数中的一个为1，结果就是1。

10.    Java中基本数据类型转换的规则

布尔型和其它基本数据类型之间不能相互转换； 
byte型可以转换为short、int、、long、float和double； 
short可转换为int、long、float和double； 
char可转换为int、long、float和double； 
int可转换为long、float和double； 
long可转换为float和double； 
float可转换为double

11.      if多分支语句和switch语句的异同之处

答：switch只能用在比较特殊的情况下，就是表达式能得到一个整数值；而if语句比较自由，可以写各种条件。

 

12.    while和do-while语句的异同之处

答：都是进行循环语句；do-while是先执行后判断，至少要循环一次；而while是先判断再执行，如果条件不满足，则一次循环体也不执行

 

13.    break和continue语句的作用

答：使流程跳出switch结构可以用来从循环体内跳出循环体，即提前结束循环，接着执行循环下面的语句；结束本次循环，即忽略循环体中continue语句下面尚未执行的语句，接着进行下一次是否执行循环的判定。

14.        在多重循环中，如何在内层循环中使用break跳出外层循环。

需要往外层循环在传递信息，一个布尔值，外层循环一旦检测到该布尔值为真，则各自break

15.    方法重载的定义、作用和判断依据

  方法重载是指在一个类中定义多个同名的方法，但要求们每个方法具有不同的参数类型或参数的个数

 作用：方法的重载是让类以统一的方式处理不同类型数据的一中手段

判断依据：方法名一定要相同

方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

16.    递归的定义和优缺点

  调用自身的编程技巧称为递归

优点：结构清晰，可读性强，而且容易用数学递归来证明算法的正确性，因此很方便

缺点：运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多

 

17.    数组的特点。

数组元素一次存放，使用连续的内存

数组名为常量指针

Sizeof表示数组所占的内存字节数

18.    数组的优缺点

数组优点   使用方便，查询效率，内存为一连续的区域

缺点：大小固定，不方便动态添加

19.    冒泡排序的算法。

重复地走过要排序的序列，一次比较两个元素，如果顺序错误就把他们交换过来，直到没有在需要交换

20.    面向过程和面向对象的区别。

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候依次调用即可

面向对象是把构成问题事物分解成各个对象，建立对象的目的视为了描述某个事物在解决问题的步骤中的行为。

21.    类和对象的关系

类是一中抽象的数据类型     对象是对客观事物的抽象，类是对对象的抽象

22.    构造方法的作用和特征

特征：方法名和类名完全相同、没有返回值类型、构造方法可以被重载

作用：可以构造带参数和无参数的对象，这些对象可以使用类方法

23.    this关键字的作用和用法

作用是在类中通过this访问自身的属性和方法

用法：当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量； 把自己当作参数传递时，也可以使用this

24.    简述static关键字的作用。

提示：从static可以修饰变量，方法，代码块，内部类四个方面来回答。

1）static方法

　　     static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

　　     要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

 2）static变量

　      　static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态  变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

　　      static成员变量的初始化顺序按照定义的顺序进行初始化。

3）static代码块

　     　 static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

       4）静态内部类

定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

通常称为嵌套类，当内部类是static时，意味着：

[1]要创建嵌套类的对象，并不需要其外围类的对象；

[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；

嵌套类与普通的内部类还有一个区别：普通内部类的字段的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，             也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。

另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于该类的对象，更不属于其他外部类的对象。

25.    private、默认、protected、public四个权限修饰符的作用

     Java中访问修饰符public、private、protecte、default的意义讲解：
public（接口访问权限）： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
private（你无法访问）: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
protected（继承访问权限）: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
default（包访问权限）：即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问。 

26.    方法重载和方法重写（覆盖）的区别。

       1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。 

2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

3、覆盖要求参数列表相同；重载要求参数列表不同。

4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。

 

27.    java.lang.Object类的六个常用方法的声明并说明其作用。

 Object类有一个默认构造方法pubilcObject()，在构造子类实例时，都会先调用这个默认构造方法。    

equals()方法：用于测试某个对象是否同另一个对象相等。它在Object类中的实现是判断两个对象是否指向同一块内存区域。

toString()：返回该对象的字符串表示。Object类中的toString()方法会打印出类名和对象的内存位置。几乎每个类都会覆盖该方法，以便打印对该对象当前状态的表示。

finalize

protected void finalize()

                 throws Throwable

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。

wait

public final void wait()

                throws InterruptedException

导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。换句话说，此方法的行为就好像它仅执行 wait(0) 调用一样。

notify

public final void notify()

唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。

 

28.    继承条件下子类构造方法的执行过程

      1、子类的构造过程中必须调用其基类的构造方法。

2、子类可以在自己的构造方法中使用super(argument_list）调用基类的构造方法。

  　　   2.1、使用this(argument_list)调用本类的另外构造方法。

　　     2.2、如果调用super，必须写在子类构造方法的第一行。

3、如果子类的构造方法中没有显示的调用基类的构造方法，则系统默认调用基类的无参数构造方法。

4、如果子类构造方法中既没有显示调用基类构造方法，而基类又没有无参数的构造方法，则编译出错。

 

29.    super关键字的作用和使用

  super子类可以通过它调用父类的方法      写在构造方法的第一行

30.    ==和equals()的联系和区别

   基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 
  他们之间的比较，应用双等号（==）,比较的是他们的值。 
2.复合数据类型(类) 
  当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
  对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

31.    多态的含义和作用

  多态的三个条件：  继承、子类对象指向父类引用  重写父类方法

  把不同的子类对象都当作父类来看，可以屏蔽不同子类对象指尖的差异，写出通用的代码，做出通用的编程。  赋值以后，父类对象就可以根据当前赋值给它的自对象的特性以不同的方式运作。

32.    向上转型和向下转型

   向上转型  不需要强转

   向下转型   必须强制类型转换   父类转子类

33.    final和abstract关键字的作用。

Final放在类前面，该类不能被继承

Final放在属性前面，该属性值不能呗更改

Final放在方法前面  该方法可以调用不能重写

Abstract修饰类，会使这个类成为抽象类，这个类不能生成对象实例，但可以作为对象变量声明的类型

Abstratct修饰方法，会使这个方法变成抽象方法，只声明而未实现，需要子类继承实现

34.    接口和抽象类的联系和区别。

抽象类里面可以有非抽象方法但接口里只能有抽象方法声明方法的存在而不去实现它的类被叫做抽像类

接口是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。分为静态内部类和非静态内部类

35.    内部类的类型及其特点。

内部类面向对象程序设计中，可以在一个类的内部定义另一个类

36.    介绍Java垃圾回收机制。

Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。

37.    Error和Exception的区别

  Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。

Exception（违例）表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。

38.    Checked异常和Runtime异常的区别。

   Checked(检查时异常必须处理)

    Runtime(运行时异常可处理可不处理)

39.    Java异常处理中，关键字try、catch、finally、throw、throws分别代表什么含义？

     throws是获取异常,throw是抛出异常,try是将会发生异常的语句括起来，从而进行异常的处理，catch是如果有异常就会执行他里面的语句，而finally不论是否有异常都会进行执行的语句。
throw 仅用于方法定义后面，指示该方法可能会抛出什么异常，使用该方法的方法必须处理该异常，或者再次抛出。
throws 用于当程序判断发生异常时，用该语句抛出异常，或处理异常时再次抛出异常。

40.    throws和throw的区别

   throw是语句抛出一个异常。
语法：throw (异常对象);
         throw e;

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)
语法：[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
            public voiddoA(int a) throws Exception1,Exception3{......}

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理。

throws主要是声明这个方法会抛出这种类型的异常，使它的调用者知道要捕获这个异常。
throw是具体向外抛异常的动作，所以它是抛出一个异常实例。 

throws说明你有那个可能，倾向。
throw的话，那就是你把那个倾向变成真实的了。

 

41.    自动装箱和自动拆箱

Interger a=1  //这就是一个自动装箱，如果没有自动装箱的话，需要integer a=new integer(1)

Int b=a  //这就是自动拆箱，如果没有自动拆箱的话，需要 int b=a.intvalue()

可看出自动装箱和自动拆箱是简化了基本数据类型和相对应对象的转换步骤

42.    String、StringBuffer、StringBuilder区别与联系。

String类中使用字符数组保存字符串

Stringbuilder   stringbuffer都继承自abstractstringbuilder，在abstractringbuilder中也是使用字符数组保存字符串  是可变的

Stringbuffer属于线程安全，相对为重量级

Stringbuilder属于非线程安全  相对为轻量级

线程安全的概念：网络编程中许多线程可能会同时运行一段代码。当每次运行结果和单独线程运行的结果是一样的，叫做线程安全。为了达到线程安全的目的在一定程度上会降低程序的性能。所以在单线程中，stringbuilder的性能要比stringbuffer高，多线程为了线程安全需要采用stringbuffer。

43.    String str=”bjsxt”;和String str=new String(“bjsxt”);的区别

前者是直接给他赋值      后者new了一个对象在对内存开了空间  引用

44.    java.sql.Date和java.util.Date的联系和区别

  java.util.Date 是 java.sql.Date 的父类

java.util.Date 就是在除了SQL语句的情况下面使用，我们通常格式化或者得到当前时间都是用他。java.sql.Date 是针对SQL语句使用的，一般在读写数据库的时候用他，因为PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date

转换是

java.sql.Date date=new java.sql.Date();

java.util.Date d=new java.util.Date (date.getTime());

45.    集合和数组的比较

   一：数组声明了它容纳的元素的类型，而集合不声明。这是由于集合以object形式来存储它们的元素。
二：一个数组实例具有固定的大小，不能伸缩。集合则可根据需要动态改变大小。
三：数组是一种可读/可写数据结构没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly方   只读方式来使用集合。该方法将返回一个集合的只读版本。

数组读快改慢，一旦定义便不能改变长度（大小）；
集合改快读慢，灵活性较高  随时可以添加和删减元素

46.    简述List、Set、Collection、Map的区别和联系。

     java集合主要由两个接口派生：Collection和Map，是集合框架的根接口。
collection的子接口：Set:接口 ---实现类： HashSet、LinkedHashSet
   set的子接口SortedSet接口---实现类：TreeSet
  List:接口---实现类： LinkedList,Vector,ArrayList 
List:有序列表，允许存放重复的元素； 
实现类： 
ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级  (线程安全、使用少)
Set:无序集合，不允许存放重复的元素；允许使用null元素
HashSet 的后台有一个HashMap;初始化后台容量；只不过生成一个HashSet的话，系统只提供key的访问；如果有两个Key重复，那么会覆盖之前的； 
实现类 
HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的数据是无序的。
LinkedHashSet：此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。存储的数据是有序的。

Map的实现类：HashMap、TreeMap、LinkedHashMap、Hashtable等
HashMap：键值对，key不能重复，但是value可以重复；key的实现就是HashSet；value对应着放；允许null的键或值；
Hashtable：线程安全的，不允许null的键或值；
Properties:：key和value都是String类型，用来读配置文件；
TreeMap：对key排好序的Map; key 就是TreeSet, value对应每个key; key要实现Comparable接口或TreeMap有自己的构造器； 
LinkedHashMap：此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。存储的数
据是有序的。

47.    ArrayList和LinkedList的区别和联系。

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

48.    HashSet采用了哈希表作为存储结构，请说明哈希表的特点和实现原理。

提示：结合Object类的hashCode()和equals()说明其原理

HashSet：equals返回true，hashCode返回相同的整数；哈希表；存储的数据是无序的。成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

HashMap键成员可为任意Object子类的对象，但如果覆盖了equals方法，同时注意修改hashCode方法。

特点：访问速度快

大小不受限制

按键进行索引，没有重复对象

用字符串(id:string)检索对象(object)

基本原理：我们使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一 个元素“分类”，然后将这个元素存储在相应“类”所对应的地方。 
但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了“冲突”，换句话说，就是把不同的元素分在了相同的“类”之中。后面我们将看到一种解决“冲突”的简便做法。 
总的来说，“直接定址”与“解决冲突”是哈希表的两大特点。 

49.    Vector和ArrayList的区别和联系。

            1、 Vector是多线程安全的，而ArrayList不是，这个可以从源码中看出，Vector类中的方法很多有synchronized进行修饰，这样就导致了                               Vector在效率上无法与ArrayList相比；

                2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同的，很多网友说Vector增加原来空间的一倍，ArrayList增加原来空间的50%，其实也差不多是这个意思，不过还有一点点问题可以从源码中看出，一会儿从源码中分析。

                 3、Vector可以设置增长因子，而ArrayList不可以。

 

50.    请你简述HashMap和Hashtable的区别？

   HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，

主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

 

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

 

HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

 

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Mapinterface的一个实现。

 

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步(Collections.synchronizedMap)。

 

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

Hashtable和HashMap类有三个重要的不同之处。第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

　　

　　也许最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。这就意味着，虽然你可以不用采取任何特殊的行为就可以在一个多线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的synchronizedMap()方法，它创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。

　　

　　第三点不同是，只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

　　

一些资料建议，当需要同步时，用Hashtable，反之用HashMap。但是，因为在需要时，HashMap可以被同步，HashMap的功能比Hashtable的功能更多，而且它不是基于一个陈旧的类的，所以有人认为，在各种情况下，HashMap都优先于Hashtable。

 

     51．     输入流和输出流的联系和区别，字符流和字节流的联系和区别

–   输入流：数据源到程序(InputStream、Reader读进来)

– 输出流：程序到目的地(OutPutStream、Writer写出去)

– 字节流：按照字节读取数据(InputStream、OutputStream)

– 字符流：按照字符读取数据(Reader、Writer)

 

52.        节点流和处理流的联系和区别

–    节点流：可以直接从数据源或目的地读写数据。

– 处理流(包装流)：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能.

 

53.      列举常用的字节输入流和字节输出流并说明其特点，至少5对。

  Filterinputstream                                   filteroutputstream

  Pipedlnputstream                                 pipedoutputstream

  Fileinputstream                                      fileoutputstream

  Bytearrayinputstream                         bytearrayoutputstream       

  Stringbufferinputstream                    stringbufferoutputstream

 

54.     说明缓冲流的优点和原理

      使用缓冲流的好处是，能够更高效的读写信息，原理是将数据先缓冲起来，然后一起写入或者读取出来。

        

55.   序列化的定义、实现和注意事项

       序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

实现：继承Serializable接口就

 1 、基本类型的数据可以直接序列化

2、对象要被序列化，它的类必须要实现Serializable接口；如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。

3、可以用这个代码：ObjectOutputStream out  = new ObjectOutputStream(new FileOutputStream("seria"));

但是不能用这个代码：ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("seria",true));

4、如果对象的引用类型没有实现序列化，但是还是想将这个对象序列化，那么可以将对象中用到的那个引用类型对象设置为transient类型。

（如果A包含了对B的引用，那么在序列化A的时候也会将B一并地序列化；如果此时A可以序列化，B无法序列化，那么在序列化A的时候就会发生异常，这时就需要将对B的引用设为transient，该关键字表示变量不会被序列化。）

 

5、如果用transient修饰引用类型对象，则这个引用类型的对象不会保存

如果一个类没有实现Serializable接口，但是它的父类实现了，那么这个类也可以序列化。

 

7、如果一个类实现了Serializable接口，但是它的父类没有实现，那么这个类可以进行序列化吗？

答案是可以的，因为超类Object类没有实现Serializable接口，所以你懂了吧，但是会有个问题，你需要在父类中是实现默认的构造方法，否则会报异常:no validconstructor。

 

56. 简述进程和线程的联系和区别。

进程：一个计算机程序的运行实例，包含了需要执行的指令；每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。

线程：表示程序的执行流程，是CPU调度执行的基本单位；线程有自己的程序计数器、寄存器、堆栈和帧。同一进程中的线程共用

相同的地址空间，同时共享进进程所拥有的内存和其他资源，线程切换开销小。

 

57.创建线程的两种方式分别是什么？各有什么优缺点。

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

实现Runnable接口，并重写该接口的run()方法，该run()方法同样是线程执行体，创建Runnable实现类的实例，并以此实例作为

Thread类的target来创建Thread对象，该Thread对象才是真正的线程对象。

实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

58.请你简述sleep( )和wait()有什么区别？

共同点： 
1. 他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。 
2. wait()和sleep()都可以通过interrupt()方法 打断线程的暂停状态 ，从而使线程立刻抛出InterruptedException

   如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在
wait/sleep /join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。 
   需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用 
interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线
程进入到 wait()/sleep()/join()后，就会立刻抛出InterruptedException。 

不同点： 
1. Thread类的方法：sleep(),yield()等 
   Object的方法：wait()和notify()等 
2. 每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 
   sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 
3. wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
4. sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
所以sleep()和wait()方法的最大区别是：
　　　　sleep()睡眠时，保持对象锁，仍然占有该锁；
　　　　而wait()睡眠时，释放对象锁。
　　       但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出 
              InterruptedException（但不建议使用该方法）。

 

 

59.Java中实现线程通信的三个方法及其作用

 wait()方法

wait()方法使得当前线程必须要等待，等到另外一个线程调用notify()或者notifyAll()方法。

notify()方法会唤醒一个等待当前对象的锁的线程。

　　如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关。（线程等待一个对象的锁是由于调用了wait方法中的一个）。

　　被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁。

synchronized一个时间内只能有一个线程得到执行

 

60.TCP/IP协议栈中，TCP协议和UDP协议的联系和区别？

   TCP/IP虽然名字是TCP，但是他的传输层包含TCP和UDP两个协议

TCP是Tranfer ControlProtocol的简称，是一种面向连接的保证可靠传输的协议。

UDP是UserDatagram Protocol的简称，是一种无连接的协议，每个数据报都是一个独立的信息

TCP：

优点：1、面向连接的传输；2、数据传输稳定可靠；3、端到端的通信；4、全双工方式；5、以字节为单位传输

缺点：传输速度不够快

UDP：

优点：1、传输速度快；2、效率高；

缺点：数据包可能会丢失

 

61.简述基于TCP的Socket编程的主要步骤。

提示：分别说明服务器端和客户端的编程步骤。

 

    在Socket的程序开发中，服务器端使用ServerSocket等待客户端的连接，对于java的网络程序来讲，每一个客户端都使用一个Socket对象表示。

socket通讯流程：
(1)创建Socket(客户端) ServerSocket(服务端) 
(2)客户端/服务端打开并连接Socket的输入/输出流
(3)按照一定的规则进行读/写操作
(4)关闭Socket相关

 

62.简述基于UDP的Socket编程的主要步骤。

提示：分别说明服务器端和客户端的编程步骤。

   实现流程：
服务器端（server）：
1. 构造DatagramSocket实例，指定本地端口。
2. 通过DatagramSocket实例的receive方法接收DatagramPacket.DatagramPacket中间就包含了通信的内容。
3. 通过DatagramSocket的send和receive方法来收和发DatagramPacket.
客户端（client）：
1. 构造DatagramSocket实例。
2.通过DatagramSocket实例的send和receive方法发送DatagramPacket报文。
3.结束后，调用DatagramSocket的close方法关闭。

 

 

 

 

最后：

 

1. int与Integer的区别。（5分）

1)       int是java提供的8种原始数据类型之一。Integer是java为int提供的封装类。(1分)

2)       int的默认值是0，而Integer的默认值为null（1分）。

3)       Integer可以区分出未赋值和值为0的区别，int则无法表达未赋值的情况。（1分）

4)       Integer提供了多个与整数相关的操作方法，将一个字符串转换成整数,还定义了表示整数的最大值和最小值的常量。（1分）

5)       在使用集合存整数时，只能使用Integer而不能使用int。(1分)

 

2.请说明HashMap和Hashtable的区别。（5分）

1)       它们都属于Map接口的类，实现了将唯一键映射到特定的值上（1分）

2)       HashMap类没有分类或者排序，它允许一个null键和多个null值(0.5分)

3)       Hashtable类似于HashMap，但是不允许null键和null值（0.5分）

4)       Hashtable继承自Dictinary类，而HashMap是java1.2引进的Map接口的一个实现.(1分)

5)       HashMap把Hashtable的contains方法去掉，改成了containsvalue()和containsKey()（1分）

6)       Hashtable是线程同步的，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap则是非同步的，必须为之提供外同步。（1分）

 

3.方法重载和方法重写的区别。（5分）

 

	英文	位置不同	作用不同
重载	overload	同一个类中	在一个类里面为一种行为提供多种实现方式并提高可读性
重写	override	子类和父类间	父类方法无法满足子类的要求，子类通过方法重写满足要求

 

	修饰符	返回值	方法名	参数	抛出异常
重载	无关	无关	相同	不同	无关
重写	大于等于	小于等于	相同	相同	小于等于

 

4.对象序列化的含义以及如何实现序列化？（提示：如何序列化写出操作代码）（5分）

1)       Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里，并且可以从其它地方把该Byte 流里的数据读出来，重新构造一个相同的对象。(1分)

2)       这种机制允许你将对象通过网络进行传播(1分),并可以随时把对象持久化到数据库、文件等系统里。(1分)

3)       ObjectOutputStream oos=new ObjectOutputStream(newFileOutputStream(File对象或文件名)); (1分)

4)       oos.writeObject(需要序列化的对象);(1)分

 

 

5.Java异常处理try-catch-finally的执行过程。（提示：分别从无异常与产生异常，以及如果try或catch中存在return的情况的执行过程）（5分）

1)       程序首先执行可能发生异常的try语句块。如果try语句没有出现异常则执行完后跳至finally语句块执行；（1分）

2)       如果try语句出现异常，则中断执行并根据发生的异常类型跳至相应的catch语句块执行处理。(1分)catch语句块可以有多个，分别捕获不同类型的异常。catch语句块执行完后程序会继续执行finally语句块。(1分)

3)       finally语句是可选的，如果有的话，则不管是否发生异常，finally语句都会被执行（0.5分）。除非使用System.exit(0)退出java虚拟机(0.5分)

4)       需要注意的是即使try和catch块中存在return语句，finally语句也会执行。是在执行完finally语句后再通过return退出。(1分)