java学习--基础知识阶段性总结--基础面试题

1. 静态变量和实例变量的区别

局部变量不能用静态的，如果用了静态的，则不会从静态区消失

* 静态变量也叫类变量  成员变量也叫对象变量

* A:所属不同

* 静态变量属于类，所以也称为为类变量

* 成员变量属于对象，所以也称为实例变量(对象变量)

* B:内存中位置不同

* 静态变量存储于方法区的静态区

* 成员变量存储于堆内存

* C:内存出现时间不同

* 静态变量随着类的加载而加载，随着类的消失而消失

* 成员变量随着对象的创建而存在，随着对象的消失而消失

* D:调用不同

* 静态变量可以通过类名调用，也可以通过对象调用

* 成员变量只能通过对 象名调用

 

2. Interger和int的区别

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。

int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，

另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

 

3.谈谈你对面向对象的理解

如何大象装进冰箱？
面向过程：
为了把大象装进冰箱，需要3个过程。
1) 把冰箱门打开（得到打开门的冰箱）
2) 把大象装进去（打开门后，得到里面装着大象的冰箱）
3) 把冰箱门关上（打开门、装好大象后，获得关好门的冰箱）
每个过程有一个阶段性的目标，依次完成这些过程，就能把大象装进冰箱。
1:
冰箱开门(冰箱)
冰箱装进(冰箱, 大象)
冰箱关门(冰箱)
==换个写法
(冰箱开门 冰箱)
(冰箱装进 冰箱 大象)
(冰箱关门 冰箱)

2:
冰箱关门(冰箱装进(冰箱开门(冰箱), 大象))
==换个写法
(冰箱关门 (冰箱装进 (冰箱开门 冰箱) 大象))

面向对象：
每个动作有一个执行者，它就是对象。
1) 冰箱，你给我把门打开
2) 冰箱，你给我把大象装进去（或者说，大象，你给我钻到冰箱里去）
3) 冰箱，你给我把门关上
依次做这些动作，就能把大象装进冰箱。
1:
冰箱.开门()
冰箱.装进(大象)
冰箱.关门()
2:
冰箱.开门().装进(大象).关门()

 

4.谈谈面向对象的三个特征,分别是什么? 各特征有什么优缺点?（封装 继承 多态）

封 装（：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

 

继 承

好处：

1：提高了代码的复用性。

2：让类与类之间产生了关系，提供了另一个特征多态的前提。

 

多 态：函数本身就具备多态性，某一种事物有不同的具体的体现。

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。

我理解的多态与继承体系有关，与方法覆盖有关，与方法重载无关。

 

5. 重写和重载的区别？

1、重写override概念(掌握)

   子父类关系中，子类中存在与父类中方法声明完全一样的方法叫重写

   一句话：除了方法体以外其他都相同,但是子类修饰符权限要大于等于父类

2、重载overload概念(掌握)

   一个类中或者子父类关系中存在多个同名方法，并且参数列表不同的方法 叫重载

   子父类关系中：子类中的方法和父类中的方法构成了重载关系

3、重写的作用\应用(理解)

   升级改造父类的方法

4、注意(掌握)

   只有方法才存在重写，变量不存在

 

6.构造方法的特点？

* A:构造方法概述和作用

* 给对象的数据(属性)进行初始化

* B:构造方法格式特点

* a:方法名与类名相同(大小也要与类名一致)

* b:没有返回值类型，连void都没有

* c:没有具体的返回值return;（有return 语句 return;）

当创建对象的时候，系统就调用了构造方法；            

构造方法不能用对象调用

 

7.Static关键字有什么特点，静态方法是否可以加this和super？为什么

1、概述

     1、static 可以修饰成员变量和成员方法

     2、被static修饰的成员有一个最大的特点，就是可以被该类下所有的对象共享

2、什么时候用

     多个对象共享某一数据的时候，我们就把这个数据用static修饰.举例：小鸡吃食

3、特点(掌握)

     1、被static修饰的内容随着类的加载而加载，优先于对象存在

     2、可以直接通过类名调用

     3、被该类下所有对象共享

4、注意事项

     1、在静态方法中是没有this关键字,因为静态是随着类的加载而加载。而this是对象创建才存在的

     2、静态方法只能访问静态成员变量和静态成员方法 一句话 静态只 能访问静态

     3、静态内容可以通过对象调用，也可以通过类名调用。推荐使用类名调用

 

8.多态的特点（包括多态中调用成员的特点）

1、概念-什么是多态(掌握)

     对象在不同时刻表现出来的不同状态。

2、针对引用类型的理解

     编译期间状态和运行期间状态不一样

     比如 

          Person p = new Person();//第一行

          p = new Man();//第二行

          p = new Woman();//第三行

          p在第一行和第二行的状态是不一样的，在第一行表示人对象，在第二行表示学生对象

3、举例

         水(水,冰,水蒸气)

         狗：狗是狗，狗是动物，狗是宠物，狗是食物//该处强调谁是谁的一种

4、前提条件(掌握)

       A:要有继承关系或实现关系

       B:要有方法重写或实现关系

       C:要有父类引用指向子类对象，或父接口引用指向子类对象

     1、成员变量

          编译看左边,运行看左边。//就是因为变量不存在重写(掌握)

          Fu fu  = new Zi();

          System.out.println(fu.name);//调用的是父类的name属性

     2、非静态成员方法 

          编译看左边,运行看右边。//因为方法存在重写(掌握)

          Fu fu = new Zi();

          fu.show();//调用的是子类的show()

     3、产生以上现象的原因(掌握)

          因为方法有重写，变量没有

     总结一句话：方法运行看右边

* 成员变量

* 编译看左边(父类)，运行看左边(父类)。

* 成员方法

* 编译看左边(父类)，运行看右边(子类)。

* 静态方法

* 编译看左边(父类)，运行看左边(父类)。

* (静态和类相关，算不上重写，所以，访问还是左边的)

* 只有非静态的成员方法,编译看左边,运行看右边 

 

9.抽象类和接口的区别？

抽象类和接口的关系(掌握)

抽象类：

      成员变量：可以是变量，也可以是常量。

      构造方法：有构造方法。

      成员方法：可以是抽象方法，也可以是非抽象方法。

接口：

     成员变量：只能是常量。

     默认修饰符：public static final

     成员方法：只能是抽象方法。

     默认修饰符：public abstract

A：抽象类只能被单继承；接口可以被多实现。

B：抽象类中的成员：

成员变量:可以是常量，也可以是变量。

成员方法:可以是抽象的，也可以是非抽象的。

构造方法:虽然不可以创建对象，但是可以给子类实例化用。

接口中的成员：

成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象的。默认修饰符 public abstract

C：抽象类中定义的是体系结构中的共性的内容。

接口中定义的是对象的扩展功能。

D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。

接口被实现表示的是: "like a"的关系。xx像yy中的一种。

 

10.抽象类中能是否可以有构造方法？

构造方法 

  有构造方法，但是不能通过构造方法创建对象

 

问：既然不能被实例化，那么有构造方法有什么用?

答：可以用于子类访问父类数据前，对父类数据进行初始化。

 

11.接口中是否可以有构造方法？

没有构造方法

因为接口中的成员变量都被final修饰，定义的时候必须做初始化

任何类如果没有继承父类，那么这个类就继承自Object类。

//所有类都直接或者间接的继承自Object类。Object类是所有类的超类

 

12. 接口是否可继承接口?

 类与类：

继承关系,只能单继承,可以多层继承。

类与接口：

实现关系,可以单实现,也可以多实现。

并且还可以在继承一个类的同时实现多个接口。

接口与接口：

继承关系,可以单继承,也可以多继承。

 

13. 抽象类是否可实现(implements)接口?

可以

 

14. 抽象类是否可继承具体类(concrete class)?

可以

class Tool{}

abstract class List extends Tool{}

 

15. 抽象类中是否可以有静态的main方法？ 

可以

public static void main(Strirng[] args{})

只抽取了很多类的方法的声明，为了保证不出问题，方法声明用abstract修饰。（掌握）

 

16. 抽象类的特点（掌握）(演讲内容)

A：一个类如果有了抽象方法，那么这个类必须是抽象类。抽象类里边可以没有抽象方法。

B：抽象类是不能够被实例化的。不能够创建对象的。

C：如果一个类继承抽象类，那么，它要么实现抽象类中的所有抽象方法，

要么本身也是抽象类。

 

17. 抽象类的成员特点：（掌握）

A：成员变量：子类可以直接继承抽象类中的成员变量。(抽象类中的成员变量可以和以前是一样的)

B：成员方法：抽象类中分为两种方法，一种是抽象方法，这种方法在子类中必须要被实现。

C：构造方法：抽象类不能被实例化，那么它有构造方法吗?抽象类是class，那么它就有构造方法。

它的构造方法有用吗？有，为了让子类实例化的时候使用。

 

18. 抽象类的相关问题：

A：抽象类中是否有构造函数？

B：抽象关键字abstract不可以和哪些关键字共存？

private

私有的，外部直接无法访问。

static

那么这个时候抽象方法就可以可以通过类名调用，但是这样是没有意义的。

final

final修饰的方法不能被重写。所以它和abstract冲突。

C：抽象类中可不可以没有抽象方法？

可以。防止其他类创建该类对象。

 

19. 接口特点：(掌握,演讲面试题)

A：接口是对外暴露的规则

B：接口是功能的扩展

C：接口降低了程序的耦合性。

**内聚(自己实现功能的能力)

**高内聚，低耦合。

举例：主板和CPU,USB接口,电源插座。

D：扩展说了下接口的理解

**狭义的理解就是java中的接口。

**广义的理解就是：任何定义的规范都是接口。

 

20.什么叫匿名对象

* A:什么是匿名对象

* 没有名字的对象 

* B:匿名对象应用场景

调用方法，仅仅只调用一次的时候。

匿名对象可以作为实际参数传递

那么，这种匿名调用有什么好处吗?

* 节省代码；匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

 

21. 匿名内部类和匿名对象的区别(理解)

不同点

匿名内部类是一个继承了类或者实现了接口的子类对象

匿名对象就是这个类的本类对象

相同点

都作为实际参数传递时使用，或者该对象的方法只调用 1次的时候使用.

注意：一般情况匿名对象或者匿名内部类对象里面最多有3个方法

无论是匿名内部类还是匿名对象，一般使用方式

1、只调用该类中的一个方法，这种情况一般该抽象类或者该接口只有一个抽象方法时使用

2、作为实际参数传递(一般该匿名对象或匿名内部类中的方法不超过3个)

 

22. 什么是内部类？

B类如果要直接使用A类中的 所有(包括私有 ) 成员的时候就把B类定义到A类里面

内部类访问特点

* a:内部类可以直接访问外部类的成员，包括私有。

* b:外部类要访问内部类的成员，必须创建对象。

* 外部类名.内部类名 对象名  = 外部类对象.内部类对象;

静态的：外部类名.内部类名 对象名  = 外部类对象.内部类;

 

23. 介绍一下匿名内部类？

概念：没有名字的局部内部类 (掌握)

前提：必须存在一个类，抽象类或者接口(掌握)

格式：     (掌握)

                    new 类名或接口名(){

                          //重写类或者接口中的方法

                          //也可自定义方法

                    };

     本质：其实就是继承了一个类或者实现了一个接口的匿名的子类对象(掌握)

 

 

24. 匿名内部类中的方法是否可以调用局部变量？为什么？

局部内部类在访问他所在方法中的局部变量必须用final修饰,为什么?

因为当调用这个方法时,局部变量如果没有用final修饰,他的生命周期和方法的生命周期是一样的,

当方法弹栈,这个局部变量也会消失,那么如果局部内部类对象还没有马上消失想用这个局部变量,就没有了,

如果用final修饰会在类加载的时候进入常量池,即使方法弹栈,常量池的常量还在,也可以继续使用

 

25. 介绍一下异常？

异常就是Java程序在运行过程中出现的错误

Throwable

          |—Error                          严重的错误，比如硬件坏了

          |—Exception                                   

                    |—RuntimeException     运行时异常，不需要处理,需要改代码

                    |—非RuntimeException  编译时异常，需要处理

 

26. Throw和throws的区别？有几种方式处理？

A:throw

用法：用在方法内部，后面跟的是异常对象。

区别：用 throw抛出了编译时期异常，方法上面必须用 throws抛出。

      用throw抛出了运行时期异常，方法上面可以不用 throws抛出。

B:throws

用法：用在方法声明上，后面跟的是异常类名。

区别：用 throws在方法上声明了异常，内部可以没有 throw

* a:throws

* 用在方法声明后面，跟的是异常类名

* 可以跟多个异常类名，用逗号隔开

* 表示抛出异常，由该方法的调用者来处理

* b:throw

* 用在方法体内，跟的是异常对象名

* 只能抛出一个异常对象名

* 表示抛出异常，由方法体内的语句处理

 

27.谈一下set和list的区别

set集合

元素存入取出有序，元素可以重复

list集合

元素存入取出无序，元素唯一

 

28.String类的特点？与Stringbuffer有什么区别？

特点及注意事项

   字符串一旦被赋值，就不能改变。

   注意：字符串的值不能改变，引用是可以改变的。

String是一个不可变的字符序列

StringBuffer,StringBuilder是可变的字符序列

 

29. 说一说list得三个子类？以及list的遍历方式有几种?

list

ArrayList：底层是数组，线程不安全，不同步；查询快，增删慢

LinkedList：底层是链表，线程不安全，不同步；增删快，查询慢

Vector：底层是数组，线程安全；

普通for循环

迭代器遍历  Listiterator

增强for循环

 

30. 说一说set集合是怎么样保持唯一性的？

1.HashSet原理

* 我们使用Set集合都是需要去掉重复元素的, 如果在存储的时候逐个equals()比较, 效率较低,哈希算法提高了去重复的效率, 降低了使用equals()方法的次数

* 当HashSet调用add()方法存储对象的时候, 先调用对象的hashCode()方法得到一个哈希值, 然后在集合中查找是否有哈希值相同的对象

* 如果没有哈希值相同的对象就直接存入集合

* 如果有哈希值相同的对象, 就和哈希值相同的对象逐个进行equals()比较,比较结果为false就存入, true则不存

2.将自定义类的对象存入HashSet去重复

* 类中必须重写hashCode()和equals()方法

* hashCode(): 属性相同的对象返回值必须相同, 属性不同的返回值尽量不同(提高效率)

* equals(): 属性相同返回true, 属性不同返回false,返回false的时候存储

 

31. 说一下Map？HashTable和HashMap的区别

* HashMap和Hashtable的区别

  都是双列集合

  都是Hash算法实现的

* Hashtable是JDK1.0版本出现的,是线程安全的,效率低,

  HashMap是JDK1.2版本出现的,是线程不安全的,效率高

* Hashtable不可以存储null键和null值,

  HashMap可以存储null键和null值

 

32. 说一说集合体系？

只有Vector和HashTable是线程安全的，效率低

Collection(单列集合)

|--Collection(单列)

  |--List(有序,可重复)

          |--ArrayList

                         底层数据结构是数组，查询快，增删慢。

                         线程不安全，效率高。

          |--Vector

                         底层数据结构是数组，查询快，增删慢。

                         线程安全，效率低。

          |--LinkedList    

                         底层数据结构是链表，查询慢，增删快。

                         线程不安全，效率高。

  |--Set(可能无序,肯定唯一)

          |--HashSet

                         底层数据结构是哈希表。

                         线程不安全，效率高。

怎么保证唯一性的呢?

  它依赖两个方法：hashCode()和equals()

   顺序：

首先判断hashCode()值是否相同。

同：继续走equals()，看返回值；

如果true：就不添加到集合。如果false：就添加到集合。

不同：就添加到集合。

           |--TreeSet

                         底层数据结构是二叉树。

                         线程不安全，效率高。

 

                         怎么保证唯一性的呢?是根据返回是否是0。

                         怎么保证排序的呢?两种方式

                              自然排序(元素具备比较性)

                                   实现Comparable接口

                              比较器排序(集合具备比较性)

                                   实现Comparator接口

Map(双列集合)

|--Map(双列 底层结构是针对键有效，跟值无关)

    |--HashMap

                    底层数据结构是哈希表。

                    线程不安全，效率高。允许null键和值

 

                    怎么保证唯一性的呢?

                    它依赖两个方法：hashCode()和equals()

                    顺序：

                         首先判断hashCode()值是否相同。

                         同：继续走equals()，看返回值

                              如果true：就不添加到集合。

                              如果false：就添加到集合。

                         不同：就添加到集合。

   |--Hashtable

                    底层数据结构是哈希表。

                    线程安全，效率低。不允许null键和值

 

                    怎么保证唯一性的呢?

                    它依赖两个方法：hashCode()和equals()

                    顺序：

                         首先判断hashCode()值是否相同。

                         同：继续走equals()，看返回值

                              如果true：就不添加到集合。

                              如果false：就添加到集合。

                         不同：就添加到集合。

   |--TreeMap

                    底层数据结构是二叉树。

                    线程不安全，效率高。

 

                    怎么保证唯一性的呢?是根据返回是否是0。

                    怎么保证排序的呢?两种方式

                         自然排序(元素具备比较性)

                              实现Comparable接口

                         比较器排序(集合具备比较性)

                              实现Comparator接口

 

33.Map集合的遍历方式？

创建Map集合

// 创建集合对象

              Map<String, String> map = new HashMap<String, String>();

              // 创建并添加元素

              map.put("杨过", "小龙女");

              map.put("郭靖", "黄蓉");

              map.put("梁山伯", "祝英台");

              map.put("牛郎", "织女");

第一种遍历方式(通过keySet())

 Set<String> keySet = map.keySet();

              for(String key : keySet){

                     System.out.println("key:"+key+"  value"+map.get(key));

              }

第二种遍历方式(通过entrySet())

  Set<Entry<String,String>> entrySet = map.entrySet();

              for(Map.Entry<String, String> entry : entrySet){

                   System.out.println("key"+entry.getKey()+"  value"+entry.getValue());

              }

 

34. 集合怎么添加一个元素和一个集合？

Collection集合：

add() 添加一个元素

addAll();添加一个集合中的所有元素

Map集合：

put(key,value)：当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null

void putAll(Map)

35.Io流体系？

 

36. 新建BufferedWriter InputStream对象的时候, 参数列表传递什么内容?

 

37.什么情况下用flush（）?

     flush只刷新缓冲区，不释放流资源，流对象还可以继续使用

     close刷新并且释放流资源，流对象不可以继续使用

 

38. mp3文件的复制用的是什么流？复制文件的步骤?

 

39. 哪个流有readLine（）newLine（）

 

40. 什么是序列化流以及特点?

 

41. 高效流是怎么实现高效的?

 

42. 与流关系密切的集合？

 

43. 谈谈Properties集合？property集合是用来做什么的?

 

44. 多线程有哪几种方式？具体？

 

45. 什么是进程？什么是线程？

 

46. 说一说线程的生命周期？

 

47. 说一说线程通信？为什么会出现线程不安全？

 

48. Sleep()和wait()的区别？Start（）和run（）的区别？

 

49. 介绍一下同步？

* 1.什么情况下需要同步

* 当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作. 这时就需要同步.

* 如果两段代码是同步的, 那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码.

            多个线程必须使用同一个锁对象,要不然锁无效

* 2.同步代码块

* 使用synchronized关键字加上一个锁对象来定义一段代码, 这就叫同步代码块

* 多个同步代码块如果使用相同的锁对象, 那么他们就是同步的

    //非静态的同步方法的锁对象是神马?

    //答:非静态的同步方法的锁对象是this

    //静态的同步方法的锁对象是什么?

    //是该类的字节码对象  

 

50. TCP和UDP的特点

UDP

     1.不需要建立连接；

     2.有数据大小限制，每个数据报的大小在限制在64k；

     3.无连接，是不可靠协议；

     4.速度快。

TCP

      1.在连接中进行大数据量传输（数据无限制）；

      2.通过三次握手完成连接；

      3.是可靠协议；

      4.必须建立连接，效率会稍低。

 

51. 网络通讯三要素?

端口：每个程序分配一个端口号

ip：给每一个设备分配地址

协议：定义的规则

 

52. 理解JDK,JRE,JVM都是做什么的?

JDK是Java Develop Kit，Java的开发工具包   (JRE+JAVA开发工具)

JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

JVM是Java虚拟机

JDK>JRE>JVM

 

53. & 和&&

逻辑与：

a&b是把a和b都转换成二进制数然后再进行与的运算；&对每一个都判断；

有false则false

短路与：

a&&b就是当且仅当两个操作数均为true时，其结果才为true；只要有一个为零，a&&b就为零。

&&具有短路效果，左边是false，右边不执行

 

54. |  和 ||

逻辑或：

有true则true

短路或：

||：如果左边为true，右边不执行

 

55.switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

基本数据类型可以接收byte，short，char，int

引用数据类型可以接收枚举（JDK1.5），String字符串（JDK1.7）

 

56. continue和break两个关键字的区别?

break:结束当前循环，循环不再继续

continue：结束本次循环，循环进入下一次

开发过程中如果要使用break或者continue，一般在前面我们都要加一个判断

break 和continue后面不能写语句，一般配合if语句使用

 

57. 函数的重载(overload)是什么?如何判断两个函数重载?

在同一个类中，函数名相同，参数列表不同(参数类型和个数)，与返回值类型无关

 

58. char型变量中能不能存贮一个中文汉字?为什么? 一个字符占几个字节？（面试题）

可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节

所以，Java中的字符可以存储一个中文汉字

中文在gbk编码中占2个字节；

中文在utf-8编码中占3个字节；

 

59.面向对象思想？（理解）

A、什么是面向对象(3点)

1、面向过程是以函数为基础，完成各种操作，强调的是过程，比如C语言

2、面向对象以对象为基础，完成各种操作，强调的是对象和结果

3、面向对象是基于面向过程的

B、面向对象的思想特点

1、是一种更符合人们思考习惯的思想

2、复杂的事情简单化

3、把我们从执行者变成了指挥者

C、举例

1、买电脑

2、洗衣做饭

3、旅游

4、把大象装进冰箱(伪代码体现)

5、买蛋糕

 

 

60.思考下面的问题

Person p = new Person(); (掌握,面试题)

它在内存中做了哪些事情？(演讲内容)

A：将Person.class文件加载到内存中。

B：在堆内存中创建一个对象Person。

C：把Person中的属性进行默认初始化。

D：把Person中的属性进行显示初始化。

E：调用构造代码块(如果没有，不执行这个操作)。

F：调用构造函数进行初始化。

G：在栈内存中声明Person类型的变量P。

H：把堆内存的地址(引用)赋给了栈内存中P。

 

 

61. 描述一下JVM加载class文件的原理机制?(面试题)

答案:  JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

 

62.static关键字、静态的含义?(理解)

1、static 可以修饰成员变量和成员方法

2、被static修饰的成员有一个最大的特点，就是可以被该类下所有的对象共享

3、随着类的加载而加载

4、优先于对象存在

5、可以通过类名调用

 

63. 静态的用法和特点?(掌握)

* a:随着类的加载而加载

* b:优先于对象存在

* c:被类的所有对象共享

* 举例：咱们班级的学生应该共用同一个班级编号。

* 其实这个特点也是在告诉我们什么时候使用静态?

* 如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

* d:可以通过类名调用

* 其实它本身也可以通过对象名调用。

* 推荐使用类名调用。

* 静态修饰的内容一般我们称其为：与类相关的，类成员

 

64. 16.举例：教师举例，学生举例，员工举例

 

65. 学生：Student

A：属性：学号,姓名,年龄 

B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)

 

发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

     但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。

     这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，

     我们定义一个接口来放抽烟这个功能。

        interface Smoking

{

public abstract void smoking();

}

 

  描述的是抽烟的学生：SmokeStudent extends Student implements Smoking

 

SmokeStudent ss = new SmokeStudent();

ss.eat();

ss.study();

ss.smoking();

 

 老师：Teacher

A：属性 教师编号,姓名,年龄

B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)

 

发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。

     但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。

     这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，

     我们定义一个接口来放抽烟这个功能。

         interface Smoking

{

public abstract void smoking();

}

 

  描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking

SmokeTeacher st = new SmokeTeacher();

st.eat();

st.teach();

st.smoking();

 

 最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。

 所以，我们进一步向上抽取。来了一个Person类

 Person：属性：姓名，年龄

         行为：吃饭(抽象eat)

 

66.构造器Constructor是否可被override? (演讲内容,面试题)

构造方法的重载

重载：方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

方法重写：

子类中出现了和父类中方法声明一模一样的方法。与返回值类型有关,返回值是一致(或者是子父类)的

 

67. 是否可以从一个static方法内部发出对非static方法的调用？(面试题)

答案:不可以。

因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

 

68.Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

答案:

override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：

1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；

2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；

3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；

4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，jVM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

 

69. wait和sleep的区别(面试题)

wait:是Object类的方法，可以不用传递参数，释放锁对象

sleep：是Thread类的静态方法，需要传递参数,不释放所对象

 

70.String是最基本的数据类型吗? (面试题)

基本数据类型：整数类型，浮点类型，字符型，布尔型

引用数据类型：类，接口，数组，枚举

String类虽然是引用数据类型，但是它作为参数传递时和基本数据类型是一样的

 

71. 是否可以继承String类?(面试题)

String类是final类故不可以继承。

 

72. StringBuffer与StringBuilder的区别?(面试题)

StringBuffer和StringBuilder的区别

StringBuffer是jdk1.0版本的,是线程安全的，同步的,效率低

StringBuilder是jdk1.5版本的,是线程不安全的，不同步的,效率高

 

String和StringBuffer,StringBuilder的区别

String是一个不可变的字符序列

StringBuffer,StringBuilder是可变的字符序列

 

73. "=="和equals方法究竟有什么区别？(面试题)

== 比较地址值，equals()比较对象的属性值，或者说具体内容

 

74. 35.ArrayList和Vector的区别?(面试题)

ArrayList:

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

Vector:

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

 

Vector相对ArrayList查询慢(线程安全的)

 

75. 说出ArrayList,Vector, LinkedList的存储性能和特性?(面试题)

 

Vector和ArrayList的区别

Vector是线程安全的,效率低

ArrayList是线程不安全的,效率高

共同点:都是数组实现的

ArrayList和LinkedList的区别

ArrayList底层是数组结果,查询和修改快

LinkedList底层是链表结构的,增和删比较快,查询和修改比较慢

共同点:都是线程不安全的

 

76. 说说 is a 和 has a 的区别?(面试题)

体现：is a

抽象类被继承,这个类中定义的是整个继承体现的共性内容。

体现：like a

接口被实现,这个接口中定义的是整个体现的扩展内容。

 

77. jdk中哪些类是不能继承的？(面试题)

 不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的，在jdk中System,String,StringBuffer等都是基本类型。

 

 

78. 39.HashMap和Hashtable的区别?(面试题)

HashTable:

               线程安全，效率低，不允许null键和值

HashMap:

               线程不安全，效率高，允许null键和值

 

如果要从Hashtable或者ConcurrentHashMap中选择,我们用ConcurrentHashMap

 

 

79.

List 和 Map 区别?(面试题)

 

 

80. java中实现多态的机制是什么？(面试题)

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，

而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

 

81. 静态变量和实例变量的区别？(面试题)

* 静态变量也叫类变量  成员变量也叫对象变量

* A:所属不同

* 静态变量属于类，所以也称为为类变量

* 成员变量属于对象，所以也称为实例变量(对象变量)

* B:内存中位置不同

* 静态变量存储于方法区的静态区

* 成员变量存储于堆内存

* C:内存出现时间不同

* 静态变量随着类的加载而加载，随着类的消失而消失

* 成员变量随着对象的创建而存在，随着对象的消失而消失

* D:调用不同

* 静态变量可以通过类名调用，也可以通过对象调用

* 成员变量只能通过对象名调用

 

82. IO操作中为什么要释放资源?(面试题)

 

83.

flush()和close()有什么区别?(面试题)

 

* flush()方法

* 用来刷新缓冲区的,刷新后可以再次写出 

* close()方法

* 用来关闭流释放资源的的；

   如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

 

     flush只刷新缓冲区，不释放流资源，流对象还可以继续使用

     close刷新并且释放流资源，流对象不可以继续使用

 

 

84.

List、Map、Set三个接口，存取元素时，各有什么特点？(面试题)

 

首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。

Set里面不允许有重复的元素，

Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。·

 

List表示有先后顺序的集合

一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

 

Map与List和Set不同，它是双列的集合，其中有put方法，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。

取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。

 

List 以特定次序来持有元素，可有重复元素。

Set 无法拥有重复元素,内部排序。

Map 保存key-value值，value可多值。

 

HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。

 

LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？

 

hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。

 

同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。

 

85.

你所知道的集合类都有哪些？主要方法？(面试题)

最常用的集合类是 List 和 Map。

List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。

 

Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

Collection

List

ArrayList

Vector

Set

HashSet

TreeSet

 

Propeties

HashTable

 

Map

Treemap

HashMap

 

86. Collection 和 Collections的区别。

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

 

87. 字节流与字符流的区别

1、到底使用谁

     如果在写数据的时候需要另起一行或者读数据的时候一行一行读就用字符缓冲流：BufferedReader & BufferedWriter

     如果操作的是文本就用字符流，因为操作比较方便。否则就用字节流

     如果根本不知道用哪个，就用字节流，因为字节流很强大

2、复制文本文件

     (1)复制文本文件的几种方式

          字节流：

                      4 种

                             基本流一次读写一个字节

                             基本流一次读写一个字节数组

                             高效流一次读写一个字节

                             高效流一次读写一个字节数组

                  字符流：

                      5 种

                             基本流一次读写一个字符

                             基本流一次读写一个字符数组

                             高效流一次读写一个字符

                             高效流一次读写一个字符数组

                             高效流一次读写一个字符串

 

     (2)推荐

          既然是文本文件那么用字符串缓冲流读写是最好的方式

 

* 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符,写出时还要把字符转回字节.

* 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流

* 读取的时候是按照字符的大小读取的,不会出现半个中文

* 写出的时候可以直接将字符串写出,不用转换为字节数组

 

88. 能不能自己写个类，也叫java.lang.String？(面试题)

可以，但在应用的时候，需要用自己的类加载器去加载，

否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。

由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。

     虽然java提供了endorsed技术，可以覆盖jdk中的某些类，具体做法是….。但是，能够被覆盖的类是有限制范围，反正不包括java.lang这样的包中的类。

 

89. 什么是内部类？Static Nested Class 和 Inner Class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：

 

public class Outer

{

         int out_x  = 0;

         public void method()

            {

               Inner1 inner1 = new Inner1();

               public class Inner2   //在方法体内部定义的内部类

               {

                     public method()

                     {

                           out_x = 3;

                     }

               }

               Inner2 inner2 = new Inner2();

         }

         public class Inner1   //在方法体外面定义的内部类

         {

         }

}

在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：

Outer outer = new Outer();

Outer.Inner1 inner1 = outer.new Innner1();

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。

对于这些细节，只要在eclipse写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。

在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：

 

public class Outer

{

         public void start()

         {

               new Thread(

new Runable(){

                           public void run(){};

}

).start();

         }

}

最后，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以使用如下语句创建Inner类：

Outer.Inner inner = new Outer.Inner();

由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。

在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

 

备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。

 

 

90.

单例设计模式:

单例写法两种：

(1)饿汉式 开发用这种方式。(掌握)

class Student

{

private Student(){}

private static Student s = new Student();

public static Student getInstance()

{

return s;

}

}

(2)懒汉式 面试写这种方式。(掌握)

class Teacher

{

private Teacher(){}

private static Teacher t;

public static Teacher getInstance()

{

if(t==null)

{

t = new Teacher();

}

return t;

}

}

 

91. 反射：

就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

 

92. 获取class文件对象的方式：

获取class文件对象的三种方式 

* A:Object类的getClass()方法

 * B:数据类型的静态属性class

 * C:Class类中的静态方法

public static Class forName(String className)

 

93.通过反射获取带参构造方法

 

Class类的newInstance()方法是使用该类无参的构造函数创建对象,

如果一个类没有无参的构造函数, 就不能这样创建了,

可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象