java知识点

1．面向对象的软件开发有哪些优点？ 

1）把软件系统看成是各种对象的集合，这更接近人的思维。                                           

2）软件需求的变动往往是功能的变动，而功能的执行者--对象一般不会有太大的变化。这使得按照对象设计出来的系统结构比较稳定。

3）对象包括属性和方法，对象把属性和方法的具体实现方式一起封装起来，这使得方法与之相关的属性不再分离，提高每个子系统的相对独立性，从而提高了软件的可维护性。

4）支持封装、继承、多态和抽象，提高了软件的可重用性、可维护性和可扩展性。

2．把一个类放在包里有什么作用？(包的作用)

1）能够区分名字相同的类；

2）有助于实施访问权限控制；

3）有助于划分和组织java应用中的各个类。

3．说出一些常用的类，包，接口，请各举出5个。Runable,ActionListener,Conllection,Map,Set,List接口

1）java.lang包----包括线程类(Thread)、异常类(Exception)、系统类(System)、整数类(Integer)和字符串类(String)等， 这些类是java程序中经常用到的。

2）java.awt包----抽象窗口工具箱包，awt是(Abstract Window Toolkit) 的缩写。这个包中包含了用于构建GUI界面的类及绘图类。

3）java.io包----输入/输出包，包含各种输入流类和输出流类，如文件输入流类(FileInputStream类)及文件输出流类(FileOutputStream)等。

4）java.util包----提供一些实用类，如日期类(Data)和集合类(Collection)等。

5）java.net包----支持TCP/IP网络协议，包括Socket类及和URL相关的类，这些类都用于网络编程。

除了上面提到的基本包，JDK中还有很多其他包，比如用于数据库编程的java.sql包，用于编写网络程序的java.rmi包(rmi是“Remote Method Invocation”的缩写)。另外，javax.*包是对基本包的扩展，包括用于编写GUI的javax.Swing包，以及用于编写声音程序的javax.sound包等。

4. 描述一下你最常用的编程风格。

1）注意编码规则，符合编码要求；

2）变量，类等起名要有意义；

3）经常格式化代码，注意格式；

4）代码中加入测试方法或测试类，尽量提早发现错误；

5）代码中要加入注释，为别人和自己将来理解代码带来方便。

5. 说一说标识符的命名规则，以及java的编程规范。

Java标识符的命名规则：

1）标识符由字母、数字、下划线“_”、美元符号“$”或者人民币符号“￥”组成，并且首字母不能是数字。

2）不能把关键字和保留字作为标识符。

3）标识符没有长度限制。

4）标识符对大小写敏感。

Java编程规范：

1）类名和接口名：首字母大写，其余字母小写。如SamDoc

2）方法名和变量名：首字母小写，其余的字母大写。如bothEyesOfDoll。

3）包名：字母全部小写。如，com.abc.dollapp。

4）常量名：采用大写形式，单词之间以下划线“_”隔开。如DEFAULT_COLOR_DOL。

6．用new关键字的作用是什么？

1） 为对象分配内存空间，将对象的实例变量自动初始化为其变量类型的默认值；

2） 如果实例变量在声明时被显示初始化，那就把初始化值赋给实例变量；

3） 调用构造方法；

4） 返回对象的引用。

7．简述变量的作用域

1）成员变量：在类中声明，它的作用域是整个类。

2）局部变量：在一个方法的内部或方法的一个代码块的内部声明。如果在方法的内部声明，它的作用域是整个方法；如果在一个方法的某个代码块的内部声明，它的作用域是这个代码块。

3）方法参数：方法或者构造方法的参数，它的作用域是整个方法或者构造方法。

4）异常处理的参数：它的作用域是紧跟着catch(Exception e)后的代码块。

8．静态变量和实例变量有什么区别？

1） 类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被类所有实例共享。静态变量可以直接通过类名被访问。静态变量的生命周期取决于类的生命周期，当加载类的时候静态变量被创建并分配内存，当卸载类的时候，静态变量被销毁并撤销所在内存。

2） 类的每个实例都有相应的实例变量。每创建一个类的实例，java虚拟机就为实例变量分配一次内存，实例变量位于堆中。实例变量的生命周期取决于实例的生命周期，当创建实例的时候，实例变量被创建并分配内存，当销毁实例的时候，实例变量被销毁并撤销所在内存。

9．使用switch语句的时候需要注意什么事项？

1）在switch(exp)语句中，exp表达式的类型必须是与int类型兼容的基本类型，即能自动转换为int的类型。包括byte、short、char和int类型。其他类型不能作为exp表达式的类型。

2）在case value字句中，value表达式必须满足以下条件：

1．value类型必须是与int类型兼容的基本类型，包括byte、short、char和int类型。

2．value必须是常量。

3．每个case子句的value表达式的值必须不同。

3）在switch语句中最多只能有一个default子句。default子句是可选的，并且可以位于switch语句中的任何位置。

4）如果switch表达式与某个case表达式匹配，或者与default情况匹配，就从case子句或default子句开始执行。假如遇到了break语句，就退出整个switch语句，否则依次执行switch语句中后续的case子句，不再检查case表达式的值。

10．方法重载和覆盖

重载方法必须满足以下条件：

1）方法名相同

2）方法的参数的数据类型、个数、顺序至少有一项不同

3）方法的返回类型可以不相同

4）方法的修饰符可以不相同

覆盖方法必须满足以下条件：

1）子类方法的名称、参数签名和返回类型必须与父类方法的名称、参数签名和返回类型一致；

2）子类方法不能缩小父类方法的访问权限；

3）子类方法不能抛出比父类方法更多的异常；

4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间。在同一个类中方法只能被重载，不能被覆盖；

5）父类的静态方法不能被子类覆盖为非静态的方法；

6）子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法；

7）父类的非静态方法不能被子类覆盖为静态方法；

8）父类的私有方法不能被子类覆盖；

9）父类的抽象方法可以被子类通过两种途径覆盖：一是子类实现父类的抽象方法；二是子类重新声明父类的抽象方法；

10）父类的非抽象方法可以被覆盖为抽象方法。

方法重载和方法覆盖具有以下相同点：

1）都要求方法名相同；

2）都可以用于抽象方法和非抽象方法之间。

方法重载和方法覆盖具有以下不同点：

1）方法覆盖要求参数签名必须一致，而方法重载要求参数签名必须不一致；

2）方法覆盖要求返回类型必须一致，而方法重载对返回类型不做限制；

3）方法覆盖只能用于子类覆盖父类的方法，而方法重载用于同一类的所有方法；

4）方法的覆盖对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制；

5）父类的一个方法只能被子类覆盖一次，而一个方法在所在的类中可以被重载多次。

11．多态有什么样的特征？

多态的特征如下：

1）对于一个引用类型的变量，编译器按照它声明的类型处理。

2）对于一个引用类型的变量，运行时java虚拟机按照它实际引用的对象处理。

3）在运行时环境中，通过引用类型变量来访问所引用对象的方法和属性时，java虚拟机采用以下的绑定规则：

1 实例方法与引用变量实际引用的对象的方法绑定，这种绑定属于动态绑定，因为是在运行时由java虚拟机动态决定的。

2 静态方法与引用变量所声明的类型的方法绑定，这种绑定属于静态绑定，因为实际上是在编译阶段就已经做了绑定。

3 成员变量(包括静态变量和实例变量)与引用类型所声明的类型的成员变量绑定，这种绑定属于静态绑定，因为实际上是在编译阶段就已经做了绑定。

12．什么是多态？面向对象程序设计为什么要引入多态的特殊性？使用多态有什么优点？

   多态性是对象根据实际情况自动调用不同类层上适当的同名方法的一种现象。无论什么时候，创建有层次关系的一些类时，如果这些类有可能共享一个方法声明，就应当考虑分别在每个类中实现不同的方法。在超类中使用抽象(或普通)的方法，然后在子类中实现(或覆盖)该方法，这样就能产生多态性。多态性能使我们很容易在从超类继承来的新类上添加新的功能。

13．继承的使用原则。

1）继承树的层次不可太多，应该尽量保持在两到三层。如果继承树的层次过多会导致以下弊端：

   1．对象模型的结构太复杂，难以理解，增加了设计和开发的难度。

   2．影响了系统的可扩展性。

2）继承层的上层为抽象层，继承树上层的类具有以下的作用：

   1．定义了下层子类都拥有的相同属性和方法，并且尽可能地为多数方法提供默认的实现，从而提高代码的可重用性。

   2．代表系统的接口，描述系统所能提供的服务。

3）继承关系最大的弱点是打破了封装，对于专门用于被继承的类必须精心设计，应该遵循以下原则：

   1．对这些类必须提供良好的文档说明，使得创建该类的子类的开发人员知道如何安全的扩展它。

   2．尽可能的封装父类的实现细节，也就是把代表实现细节的属性和方法定义为private类型。

   3．把不允许被子类覆盖的方法定义为final类型。

   4．父类的构造方法不允许调用可被子类覆盖的方法。

   5．如果某些类不是专门为了继承而设计，那么随意继承它是不安全的，因此可以采用以下两种措施来禁止继承：

    (1) 把类声明为final类型。

    (2) 把这个类的所有构造方法声明为private类型，然后通过一些静态方法来负责构造自身的实例。

14．Abstract修饰符的用法

1）用abstract修饰的类表示抽象类，抽象类位于继承树的抽象层，抽象类不能被实例化，即不允许创建抽象类本身的实例。

2）用abstract修饰的方法表示抽象方法，抽象方法没有方法体，不提供具体的实现。

3）抽象类可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。

4）如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类，否则编译出错。

5）没有抽象构造方法，也没有抽象静态方法。

6）抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。

7）抽象类及抽象方法不能被final修饰符修饰。

15．Final修饰符的用法。

1）用final修饰的类不能被继承，即没有子类。

2）用final修饰的方法不能被子类的方法覆盖。

3）用final修饰的变量表示常量。

4）final不能用来修饰构造方法。

5）用final修饰的变量表示常量，只能被赋一次值。

16．Static修饰符的用法。

1）静态变量在内存中只有一个拷贝，在类的所有实例中共享。

2）在静态方法中不能直接访问实例方法和实例变量。

3）在静态方法中不能使用this和super关键字。

4）静态方法不能被abstract修饰。

5）静态方法和静态变量都可以通过类名直接被访问。

6）在类被加载时，静态代码块只被执行一次。类中不同的静态代码块按它们在类中出现的顺序被依次执行。

17．接口的特征。

1）接口中的成员变量默认都是public、static、final类型的，必须被显示初始化。

2）接口中的方法默认都是public、abstract类型的。

3）接口中只能包含public、static、final类型的成员变量和public、abstract类型的成员方法。

4）接口没有构造方法，不能被实例化。

5）一个接口不能实现另一个接口，但它可以继承多个其他接口。

6）接口必须通过类来实现它的抽象方法。

7）与子类继承抽象父类相似，当类实现某个接口时，它必须实现接口中的所有抽象方法，否则这个类必须被定义为抽象类。

8）不能创建接口的实例，但允许定义接口类型的引用变量，该变量引用实现了这个接口的类的实例。

9）一个类只能继承一个直接的父类，但能实现多个接口。

18．比较抽象类与接口。

抽象类与接口都位于继承树的上层，它们具有以下的相同点：

1）代表系统的抽象层。 2）都不能被实例化 。3）都能包含抽象方法。这些抽象方法用于描述系统能提供那些服务，但不必提供具体的实现 。

抽象类与接口主要有两大区别：

1）在抽象类中可以为部分方法提供默认的实现，从而避免在子类中重复实现它们，提高代码的可重用性，这是抽象类的优势所在；而接口中只能包含抽象的方法。

2）一个类只能继承一个直接的父类，这个父类有可能是抽象类；但一个类可以实现多个接口，这是接口的优势所在。

接口和抽象类各有优缺点，开发人员应该扬长避短，发挥接口和抽象类各自的长处。使用接口和抽象类总的原则如下：

1）用接口作为系统与外界交互的窗口。

2）由于外界使用者依赖系统的接口，并且系统内部会实现接口，因此接口本身必须十分稳定，接口一旦制定，就不允许随意修改，否则会对外界使用者及系统内部都造成影响。

3）用抽象类来定制系统中的扩展点。

19．传统的异常处理与java异常处理有什么区别。

1）传统的表示异常情况的能力有限，仅靠方法的返回值难以表达异常情况所包含的所有信息。Java把不同类型的异常情况进行分类，用java类来表示异常情况，这种类被称为异常类。

2）传统异常流程的代码和正常流程的代码混合在一起，会影响程序的可读性，容易增加程序结构的复杂性。Java异常流程的代码和正常流程的代码分离，提高了程序的可读性，简化了程序的结构。

3）随着系统规模的不断扩大，传统处理方式已经成为创建大型可维护应用程序的障碍。Java可以灵活的处理异常，如果当前方法有能力处理异常，就捕获并处理它，否则只需要抛出异常，由方法调用者来处理它。

20．Java 中的异常处理机制的简单原理和应用。

   当java程序违反了java的语义规则时，java虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况，一种是java类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是java允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是java.lang.Thowable的子类。

21．异常处理的优点和缺点及处理原则。

Java异常处理机制有以下的优点：

1）把不同类型的异常情况进行分类，用java类来表示异常情况，这种类被称为异常类。

2）异常流程的代码和正常流程的代码分离，提高了程序的可读性，简化了程序的结构。

3）可以灵活的处理异常，如果当前方法有能力处理异常，就捕获并处理它，否则只需要抛出异常，由方法调用者来处它。

异常处理只能用于非正常情况，用异常来控制程序的正常流程具有以下的缺点：

1）滥用异常流程会降低程序的性能。

2）用异常处理来表示正常的情况，违背了异常处理的机制。

3）模糊了程序代码的意图，影响可读性。

4）容易覆盖程序代码中的错误，增加了调试的复杂性。

所以异常处理应该遵循以下原则：

1）异常只能用于非正常情况。    2）为异常提供说明文档。    3）尽可能地避免异常，尤其是运行时异常。4）保持异常的原子性。   5）避免过于庞大的try代码块。    6）在catch子句中制定具体的异常类型。7）不要在catch代码块中忽略被捕获的异常。

22．垃圾回收的优点和特点。

垃圾回收具有以下优点：

1）把程序从复杂的内存跟踪、监测和释放等的工作中解放出来，减轻程序员进行内存管理的负担。

2）防止系统内存被非法释放，从而使系统更加健壮和稳定。

垃圾回收具有以下特点：

1）只有当对象不再被程序中的任何引用变量引用时，它的内存才可能被释放。

2）程序无法迫使垃圾回收器立即执行垃圾回收操作。

3）当垃圾回收器将要回收无用对象的内存时，先调用该对象的finalize()方法，该方法有可能使对象复活，导致垃圾回收器取消回收该对象的内存。

23．简述构造方法的特点和功能。

构造方法是类的一种特殊方法,在使用时必须满足以下语法规则： 

1） 构造方法名与类名相同。 2）在类实例化对象时被执行，并且没有返回值。 3）不能被static、final、synchronized、Abstract和native修饰。 4）构造方法不能像一般方法那样用“对象.”显示地直接调用，应该用new关键字调用构造方法为新对象初始化。

构造方法被用来完成初始化成员变量、分配资源以及其他的辅助工作。构造方法可以有参数也可以没有参数，有参数的构造方法可以完成特定的初始化工作，无参数的构造方法称为默认的构造方法

24．类的初始化机制。

Java虚拟机只有在程序首次主动使用一个类或接口时才会初始化它，只有6种活动被看做是程序对类或接口的主动使用。

1）创建类的实例。2）调用类的静态方法。3）访问某个类或接口的静态变量，或者对该静态变量赋值。4）调用Java API中的某些反射方法。    5）初始化一个类的子类。    6）Java虚拟机启动时被标明为启动类的类。

25．this和super的区别。

当一个对象创建好后，java虚拟机就会给它分配一个引用自身的指针：this，所有对象的默认引用名都叫this。

在程序中，以下情况会使用this关键字：

1）在类的构造方法中，通过this语句来调用这个类的另一个构造方法。

2）在一个实例方法内，局部变量或参数和实例变量同名，实例变量被屏蔽，因此采用this.owner的方式来指代实例变量。

3）在一个实例方法内，访问当前实例的引用。

在程序中，在以下情况下会使用super关键字：

1）在类的构造方法中，通过super语句调用这个类的父类的构造方法。

2）在子类中访问父类的被屏蔽的方法和属性。

相同点：

super和this关键字都可以用来覆盖Java语言的默认作用域，使被屏蔽的方法或变量为可见。在以下场合会出现方法或

变量被屏蔽的现象：

1）在一个方法内，当局部变量和类的成员变量同名，或者局部变量和父类的成员变量同名时，按照变量的作用域规则，只有局部变量在方法内可见。

2）当子类的某个方法覆盖了父类的一个方法，在子类的范围内，父类的方法不可见。

3）当子类中定义了和父类同名的成员变量时，在子类的范围内，父类的成员变量不可见。

26．throw和throws的区别。

1）throws是用来声明一个方法可能抛出的所有异常信息，throw则是指抛出的一个具体的异常类型。通常在一个方法(类)的声明处通过throws声明方法(类)可能抛出的异常信息，而在方法(类)内部通过throw声明一个具体的异常信息。

2）throws通常不用显示的捕获异常，可由系统自动将所有捕获的异常信息抛给上级方法；throw则需要用户自己捕获相关的异常，而后在对其进行相关包装，最后在将包装后的异常信息抛出。

27．堆和栈有什么区别。

1.栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素。

2.堆内存是用来存放由new创建的对象和数组，而栈内存是用来放一些基本的数据类型和对象的引用。

3.当一段代码块定义一个变量时，JAVA就在栈中为这个变量分配相应的内存空间，当超过变量作用域后JAVA会自动释放掉为该变量分配的内存，而在堆中分配的内存需要由JAVA的虚拟机的自动垃圾回收器来管理，只有当内存不够时,垃圾回收器才来回收没有用的对象所占用的内存。 

28．Error 与 Exception有什么区别。

Error表示系统级的错误和程序不必处理的异常，error不用处理。

Exception表示需要捕获或者需要程序进行处理的异常，需要抛出或处理。

29．ArrayList和Vector的区别。

1）ArrayList是List接口的一个可变长数组实现。实现了所有List接口的操作，并允许存储null值。ArrayList基本等同于Vector，但Vector 是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的。

2）当需要增长时，Vector默认增长为原来一倍，而ArrayList却是原来的一半。

30．HashMap和Hashtable的区别

1）历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

2）同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程不安全的，不是同步的。

3）值：只有HashMap可以让你将空值作为一个表的条目的key或value，而Hashtable不能为空。

31．Collection 和 Collections 的区别

1）Collections是个java.util下的类，它包含各种有关集合操作的静态方法，实现对各种集合的搜索、排序、线程安全化等操作。

2）Collection是个java.util下的接口，它是各种集合结构的父接口，继承他的接口主要有set和list。

32．string与stringBuffer的区别

string的长度是不可变的，stringBuffer的长度是可变的。如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer 的toString()方法。

33．比较break、continue、return语句的区别。break语句可嵌在switch、for、while或者do循环语句中，它的作用是使用程序执行到break时就跳出包含它的语句，然后紧接着执行该语句之后的其他语句。coutinue语句可嵌在for、while、或者do语句中，它的作用是使程序执行到continue时就忽略其下面的语句，而跳到条件处判断。Return语句退出本方法，跳到上层调用方法。

34．谈谈final, finally, finalize的区别

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract 的，又被声明为final 的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final 的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。

finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

35． List与Set的区别：

1）List与Set均为Conllection子接口。

2）List 有序，可重复，常用子类ArrayList。

   Set 无序，不重复，常用子类HashSet。 

36．单子/单例模式

1）构造器私有。 2）私有静态常量。 3）公有的静态方法。

public class Singleton{

     private final static Singleton s = new Singleton();

     public static Singleton getSingleton(){

         return s;

     }

     Private Singleton(){

     }

}