java面试基础知识总结（一）

 1.  static的作用

解析：static是静态修饰符，（在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的，而所谓静态就是指编译后所分配的内存会一直存在，知道程序退出才会释放这个空间，即程序运行中这块内存一直存在）。因为在java中，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用它的成员，那么普通情况下就必须先实例化对象后通过对象的引用才能够访问这些成员，但是有static声明的成员除外，可以直接访问到。

1.  static修饰变量、方法

        被static修饰的变量、方法被称为静态方法。可以直接调用这些变量、方法而不需要创建它们所在类的实例。静态方法中只能直接使用静态变量而不能使用非静态变量，也只能调用其他静态方法。

2.  static修饰一个语句块

        叫做静态语句块。静态语句块在类加载时即执行，会在main方法及构造前执行且执行一次。

3.  static修饰内部类

        叫做静态内部类。静态内部类可以独立于外部类，不需要创建外部类的实例即可调用此内部类，因此可想而知静态内部类是不能访问外部类中的非静态成员。

4 . static导包

        static也可用来引用包/类。具体使用法为import static xx.xx.xx;使用这种方法我们可以用来导入一些静态方法或者静态内部类以方便我们使用。

 

2.      final的作用

解析：1 修饰类，不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要子类，类的实现细节不允许改变。并且确信这个类不会再被扩展，那就使用final类。

         2 修饰方法，不能被改类子类的方法覆盖，但可以被继承。如果一个类不允许其子类覆盖某个方法，可以把这个方法声明为final。（优势：方法锁定和高效）

         3 修饰成员变量表示常量，只能被赋值一次，之后无法改变。Final变量定义时，可以先声明，而不给初始值，称为final空白。无论什么情况，编译器都确保空白final在使用之前必须被初始化。它提供可更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，并保持其恒定不变的特征。

         4 修饰参数，可以读取不能改变该参数的值。

         5 不能修饰构造方法。

3.      overload和override的区别

解析：overload是重载，override是覆盖。

重载表示一个类中可以有多个名称相同的方法。使方法的参数列表名不相同。

注意：1 不能通过访问权限、返回类型、抛出的异常进行重载。

          2 方法的异常和数目不会对重载造成影响。

          3 对于继承来说，不能重载，只能是个定义一个新方法。

覆盖表示子类中的方法可以与类中的某个方法的名称和参数完全相同，相当于覆盖了父类中的方法，（多态性）

注意：1覆盖的方法的标志要和被覆盖的方法的标志完全匹配。才能达到覆盖的效果。

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

          3 抛出的异常必须为覆盖异常一致或事其子类。

           4 被覆盖的方法不能为private。

4.      组合和继承的区别

解析：组合（has-a）关系可以显式地获得被包含类（继承中的父类）的对象，而继承（is-a）则是隐式地获得父类的对象，被包含类和父类对应，而组合外部类和子类对应。

        1 组合就是一个类的对象是另外一个类的成员，一般的程序都有组合的意味，只不过基本数据类型是成员变量。组合关系在运行期决定，而继承关系在编译期就已经决定。

        2 组合是在组合类和被包含类之间的一种松耦合关系，而继承则是父类和子类之间的一种紧耦合关系。

        3 组合一般用于在新类中使用现有类的功能而不是他的接口的情况。继承则是用于在新；类需要向基类转化的情况（多态）。

5.      clone的作用

解析： clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法复制一个对象时，此对象的引用也同时会被复制一份。

        clone()方法对象复制一份并返还给调用者。克隆对象与原对象不是同一个对象；克隆对象与原对象的类型一样；

        浅克隆只是按值传递数据（比如基本数据类型），而不复制它所引用的对象。其实对其他对象的引用仍然指向原来的对象。

        深克隆在浅克隆的基础上，引用其他对象的变量将指向被复制过的新对象，

6.      前置++与后置++

解析：i++返回值是i原来的值（下次调用是+1后的值），++i是返回值是+1之后的值。

7.      内部类

解析：内部类就是类中类，作用

          1 内部类可以很好的实现隐藏：一般内部类中不能定义静态成员，内部类可以是private和protected权限的。通常是用于创建内部对象用的。

          2 内部类拥有外部类所有元素的访问权限。

          3 可以实现多重继承，因为内部类可以继承其他类。

          4 可以避免修改接口而实现同一个类中两种同名方法的调用。当继承的类和接口里面有两个同名的方法是，就使用内部类来实现接口，外部类继承来解决冲突。

8.      二维数组的表示

解析：int[][] x; int x[][];int[] x[](很少使用)

9.      接口与抽象类的对比

解析：1抽象方法是一种特殊的方法：它只声明，而没有具体实现（修饰符abstract）。如果一个类含有抽象方法，则为抽象类加abstract修饰。就因为抽象类中没有具体实现的方法，所以不能常见实例对象。抽象类就是为继承而存在的，即在具体子类中进行实例化实现抽象方法。注意：若子类中没有实现抽象父类中的所有抽象方法，那么子类必须定义为abstract类型；抽象类中可以包含：构造方法、普通成员变量、非抽象的方法、静态方法。

          2接口是对行为的抽象，就是一种特殊的抽象类。接口中的所有方法必须是抽象的，且定义为public abstract;成员变量类型默认为public static final.以上抽象类中包含的都不能包含。

         3 除上述区别外，一个类只能继承一个抽象类，而一个类可以实现多个接口。

         4 设计层面的区别，举例：飞机和鸟，共性是都会飞。会飞是一张行为属性，设计为一个接口fly，然后飞机airplane和鸟bird根据自己的需要实现fly接口。然后各种类型的飞机就可以继承airplane，鸟也同样。在这里继承是一种“is-a”的关系，接口实现则是“has-a”的关系。 

               对于抽象类，如果需要修改或添加新的方法，可以直接在抽象类中添加具体的实现，子类不用进行变更；而接口则不行，如果接口改变，则实现这个接口的类都必须进行相应的改动。

10.  反射机制

解析： 在java运行状态中，对任意一个类，都能够知道这个类中所有属性和方法；对于任意一个对象都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

        Java反射（Reflection放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。Perl，Python，Ruby是动态语言，C++、java，c#不是动态语言。但是java有着一个非常突出的动态相关机制：Reflection，用在java上指的是我们可以在运行时加载，探知、使用编译期间完全未知的classes。即java可以加载一个运行时才能得知名称的class，获悉其完整构造（不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

        主要功能是：在运行时判断任意一个对象所属的类；在运行时构造任一类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

11.  函数调用方式

解析：函数的调用是在一个叫方法调用栈的机制上的，规则是先进后出，意思是说先执行的方法后结束，一个程序最先执行的方法是main（）方法，是由java虚拟机执行的，因此main()最后结束。如果一个java程序是多线程的，那么它可以有多个调用栈。

        方法执行是有三种情况：1.方法返回一个值;2. 方法不返回一个值（void）； 3. 方法抛出一个异常给调用者。Java函数调用是，是把实际参数的数据复制个形式参数，这种过程叫做按值调用。

        根据是否按照返回值，有两种调用函数的方式：1 当有反沪指是，方法调用通常被当做一个值。getMaxnum(x,y).2 先生成一个对象，用对象.方法名（）来调用。因为main()是静态的，用于程序的入口，在静态方法中无法调用非静态方法，只能调用静态方法。想要调用非静态方法的话就要先生成该类的一个对象，通过对象调用非静态方法。

12.  重载函数

解析：是针对同一个类中的一个函数来说的。这组函数中，函数名称下相同；形式参数不同，包括参数的个数不同 、参数类型不同或参数个数和类型都不行相同；与函数的返回值类型没有关系；在调用函数时会根据参数的类型和个数自动匹配，决定调用哪个函数。

13.  构造函数

解析：构造函数是一种特殊的函数。主要是用来在创建对象时初始化对象，即为对象成员变量赋初值，总与new一起使用在创建对象的语句中。构造函数与类名相同，可以重载多个不同构造函数。

       1 构造方法的方法名必须与类名相同

        2 构造方法没有返回类型，也不能定义void，在方法名前面不声明方法类型；

        3 构造方法的主要作用是完成对象的初始化工作，它能够把定义对象时的参数传递给对象的域；

        4 一个类可以定义多个构造方法，如果定义类时没有定义构造方法，则编译系统会自动插入一个无参数的构造器，这个构造器不执行任何代码；

        5 构造方法可以重载，以参数的个数、类型，顺序；

子类必须调用（用super来调用父类的非默认构造函数，默认的构造函数系统自动调用）父类的默认构造函数，然后对对象进行初始化，然后调用子类自己的构造函数。执行顺序：

        a． 初始化 对象的存储空间为零或null值；

        b． 调用父类构造函数

        c． 按顺序分别调用类成员变量和实现成员变量的初始化表达式。

14.  合并两个有序链表

解析：

package MergrSinglyList;

/**

 * 合并两个有序链表

 */

 

import java.util.Scanner;

 

publicclass UnionLinkList {

       /**

     * 建立单链表

     * @param head  单链表头结点

     */

    publicvoid createLinkedList(LinkedList head) {

        LinkedList cur = head;

        Scanner scanner = new Scanner(System.in);

        String data;

        System.out.println("输入单链表结点的值，输入#结束");

        while (true) {

            data = scanner.next();

            if (data.equals("#")) {

                cur.next =null;

                break;

            }

            LinkedList node = new LinkedList();

            node.data = Integer.valueOf(data);

            cur.next = node;

            cur = cur.next;

        }

    }

    /**

     *

     * @param a           链表a

     * @param b           链表b

     * @param union       合并后的链表

     * @return          合并后的链表

     */

    public LinkedList union(LinkedList a,LinkedListb,LinkedList union){

        LinkedList pc = union = a;

        LinkedList pa = a.next;

        LinkedList pb = b.next;

        while(pa != null && pb != null){

            if(pa.data < pb.data){

                pc.next = pa;

                pc = pa;

                pa = pa.next;

            }else{

                pc.next = pb;

                pc = pb;

                pb = pb.next;              

            }

            if(pa != null){

                pc.next = pa;

            }

            if(pb != null){

                pc.next = pb;

            }

        }

        return union;

    }

    /**

     * 打印单链表

     * @param head   链表头指针

     */

    publicvoid printLinkList(LinkedList head){

        if(head == null || head.next ==null){

            return;

        }

        head = head.next;

        while(head != null){

            System.out.print(head.data+" ");

            head = head.next;

        }

        System.out.println();

    }

    publicstaticvoidmain(String[] args) {

        UnionLinkList ull = new UnionLinkList();

        LinkedList pa = new LinkedList();

        LinkedList pb = new LinkedList();

        ull.createLinkedList(pa);

        ull.createLinkedList(pb);

        LinkedList union = null;

        union = ull.union(pa,pb,union);

        ull.printLinkList(union);

    }

}