面试-java知识基础

下面是java的一些面试点,主要是基础知识。

1.  最常见的运行时异常    

  java运行时异常是可能在java虚拟机正常工作时抛出的异常。    

  java提供了两种异常机制。一种是运行时异常(RuntimeExepction),一种是检查式异常(checked execption)。

  检查式异常:我们经常遇到的IO异常及sql异常就属于检查式异常。对于这种异常,java编译器要求我们必须对出现的这些异常进行catch 所以 面对这种异常不管我们是否愿意,只能自己去写一堆catch来捕捉这些异常。

  运行时异常:我们可以不处理。当出现这样的异常时,总是由虚拟机接管。比如:我们从来没有人去处理过NullPointerException异常,它就是运行时异常,并且这种异常还是最常见的异常之一。

  RuntimeExecption在java.lang包下,

  ClassCastException(类转换异常)

  IndexOutOfBoundsException(数组越界)

  NullPointerException(空指针)

  ArrayStoreException(数据存储异常,操作数组时类型不一致)

  还有IO操作的BufferOverflowException异常

 

2.  String类是否可以被继承

  不能,final修饰的。

 

3. 一个".java"源文件中是否可以包括多个类(不是内部类)

  可以,但是一个文件中只能有一个public类,并且此public类必须与文件名相同。

4. 面向对象的编程方法具有四个基本特征:

抽象
抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。

 继承

类的重用。一个新类可以从现有的类中派生,这个过程称为类继承。派生类可以从它的基类那里继承方法和实例变量,并且类可以修改或增加新的方法使之更适合特殊的需要,提高代码的重用行。

 封装

   封装是把数据和过程(对数据的操作)包围起来,隐藏内部的实现细节,对数据的访问只能通过已定义的方法 。

 多态

   多态性是指允许不同类的对象对同一消息作出响应。

 

5.spring的aop编程(aop Aspect Oriented Programming 面向切面编程

AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

AOP/OOP区分

AOP、OOP在字面上虽然非常类似,但却是面向不同领域的两种设计思想。

OOP(面向对象编程)针对业务处理过程的实体及其属性和行为进行抽象封装,以获得更加清晰高效的逻辑单元划分。

而AOP则是针对业务处理过程中的切面进行提取,它所面对的是处理过程中的某个步骤或阶段,以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有着本质的差异。

上面的陈述可能过于理论化,举个简单的例子,对于“雇员”这样一个业务实体进行封装,自然是OOP/OOD的任务,我们可以为其建立一个“Employee”类,并将“雇员”相关的属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。

同样,对于“权限检查”这一动作片断进行划分,则是AOP的目标领域。而通过OOD/OOP对一个动作进行封装,则有点不伦不类。

换而言之,OOD/OOP面向名词领域,AOP面向动词领域。

 

IOC和AOP的区别

IoC就是Inversion of Control,控制反转。在Java开发中,IoC意味着将你设计好的类交给系统去控制,而不是在你的类内部控制。这称为控制反转。

将对象的创建和获取提取到外部。由外部容器提供需要的组件。

AOP 关注与主要的东西,也可以说让你只关注与业务,其他的东西就让AOP帮你完成。比如事务管理、持久化、资源池、系统统一的认证、权限管理等。允许通过分离应用的业务逻辑与系统级服务进行内聚性的开发。

 

6. 快速和归并算法

 快速排序:

  设要排序的数组是A[0]……A[N-1],首先任意选取一个数据(通常选用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。值得注意的是,快速排序不是一种稳定的排序算法,也就是说,多个相同的值的相对位置也许会在算法结束时产生变动。

  一趟快速排序的算法是:

  1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;

  2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];

  3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]和A[i]互换;

  4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]互换;

  5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成  的时候,此时令循环结束)。

  排序演示

  假设用户输入了如下数组:

下标

0

1

2

3

4

5

数据

6

2

7

3

8

9

  创建变量i=0(指向第一个数据), j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。

  我们要把所有比k小的数移动到k的左面,所以我们可以开始寻找比6小的数,从j开始,从右往左找,不断递减变量j的值,我们找到第一个下标3的数据比6小,于是把数据3移到下标0的位置,把下标0的数据6移到下标3,完成第一次比较:

下标

0

1

2

3

4

5

数据

3

2

7

6

8

9

  i=0 j=3 k=6

  接着,开始第二次比较,这次要变成找比k大的了,而且要从前往后找了。递加变量i,发现下标2的数据是第一个比k大的,于是用下标2的数据7和j指向的下标3的数据的6做交换,数据状态变成下表:

下标

0

1

2

3

4

5

数据

3

2

6

7

8

9

  i=2 j=3 k=6

  称上面两次比较为一个循环。

  接着,再递减变量j,不断重复进行上面的循环比较。

  在本例中,我们进行一次循环,就发现i和j“碰头”了:他们都指向了下标2。于是,第一遍比较结束。得到结果如下,凡是k(=6)左边的数都比它小,凡是k右边的数都比它大:

下标

0

1

2

3

4

5

数据

3

2

6

7

8

9

  如果i和j没有碰头的话,就递加i找大的,还没有,就再递减j找小的,如此反复,不断循环。注意判断和寻找是同时进行的。

  然后,对k两边的数据,再分组分别进行上述的过程,直到不能再分组为止。

  注意:第一遍快速排序不会直接得到最终结果,只会把比k大和比k小的数分到k的两边。为了得到最后结果,需要再次对下标2两边的数组分别执行此步骤,然后再分解数组,直到数组不能再分解为止(只有一个数据),才能得到正确结果。

  代码:

public class QuickSort {
    private static int par(int[]arr,int left,int right){
            int key=arr[left];

            while(left < right){
                //从最右边开始找比key小的数
                while(left=key)
                    right--;
                
                //把找到的数移到左边
                arr[left]=arr[right];
                
                //从最左边开始找比key大的数
                while(leftkey)
                    left++;
                
                //把找到的数移到右边
                arr[right]=arr[left];
            }
            
            //最后,left等于right,将key至于中间,这样,key之前的数,比key小,key之后的数,比key大
            arr[left]=key;
            return left;
    }
    
    private static void quickSort(int[]arr,int left,int right) {
        if(arr==null || arr.length==0 || left>=right){
            return ;
        }
        int pos=par(arr,left,right);
        quickSort(arr,left,pos-1);
        quickSort(arr,left+1,right);
    }
    
    public static void main(String[]args) {
        int[] arr={22,11,23,32,45,32,21,33,67,12};
        quickSort(arr,0,arr.length-1);
        for(int k:arr)
            System.out.print(k+" ");
    }
}

 

 归并排序

  建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

归 并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1;否则将第二 个有序表中的元素a[j]复制到r[k]中,并令j和k分别加上1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到r中 从下标k到下标t的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序,最后把左 区间和右区间用一次归并操作合并成有序的区间[s,t]。

  归并操作

  归并操作(merge),也叫归并算法,指的是将两个顺序序列合并成一个顺序序列的方法。

  如 设有数列{6,202,100,301,38,8,1}

  初始状态:6,202,100,301,38,8,1

  第一次归并后:{6,202},{100,301},{8,38},{1},比较次数:3;

  第二次归并后:{6,100,202,301},{1,8,38},比较次数:4;

  第三次归并后:{1,6,8,38,100,202,301},比较次数:4;

  总的比较次数为:3+4+4=11,;

  逆序数为14;

 

  算法描述

  归并操作的工作原理如下:

  第一步:申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列

  第二步:设定两个指针,最初位置分别为两个已经排序序列的起始位置

  第三步:比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置

  重复步骤3直到某一指针超出序列尾

  将另一序列剩下的所有元素直接复制到合并序列尾

      

 代码:

public class MergeSort {
    
    public static void mergeSort(int[] arr) {
    	if(arr==null || arr.length<=1){
    		return;
    	}
        mSort(arr, 0, arr.length-1);
    }

    public static void mSort(int[] arr, int left, int right) {
        if(left >= right)
            return ;
        int mid = (left + right) / 2;
        
        mSort(arr, left, mid); 		//递归排序左边
        mSort(arr, mid+1, right); 	//递归排序右边
        merge(arr, left, mid, right); //合并
    }
    
    /**
     * 合并两个有序数组
     * @param arr 待合并数组
     * @param left 左指针
     * @param mid 中间指针
     * @param right 右指针
     */
    public static void merge(int[] arr, int left, int mid, int right) {
        //[left, mid] [mid+1, right]
        int[] temp = new int[right - left + 1]; //中间数组
        
        int i = left;
        int j = mid + 1;
        int k = 0;
        while(i <= mid && j <= right) {
            if(arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            }
            else {
                temp[k++] = arr[j++];
            }
        }
        
        while(i <= mid) {
            temp[k++] = arr[i++];
        }
        
        while(j <= right) {
            temp[k++] = arr[j++];
        }
        
        for(int p=0; p

 

7. 洗牌算法

   所谓洗牌算法,就是给你一个1到n的序列,让你随机打乱,保证每个数出现在任意一个位置的概率相同,也就是说在n!个的排列中,每一个排列出现的概率相同。

我们考虑,当一个数被选之后,我们是没有必要在下一次随机的时候再考虑它的,因此,我们每次只从可选的数的集合中进行随机,也就不用考虑是否会碰到已经选过的数了,这样子直接将算法的复杂度降了一个数量级。

我们考虑,当一个数被选之后,我们是没有必要在下一次随机的时候再考虑它的,因此,我们每次只从可选的数的集合中进行随机,也就不用考虑是否会碰到已经选过的数了,这样子直接将算法的复杂度降了一个数量级。

  

void MySwap(int &x, int &y)
{
    int temp = x;
    x = y;
    y = temp;
}

void Shuffle(int n)
{
    for(int i=n-1; i>=1; i--)
    {
        MySwap(num[i], num[rand()%(i+1)]);
    }
}

 

8. Java序列化

把对象转换为字节序列的过程—序列化。

把字节序列恢复为对象的过程—反序列化。

对象的序列化主要有两种用途:
  1) 把对象的字节序列永久地保存到硬盘上,通常存放在一个文件中;
  2) 在网络上传送对象的字节序列。

 

JDK类库中的序列化API

  java.io.ObjectOutputStream代表对象输出流,它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化,把得到的字节序列写到一个目标输出流中。
  java.io.ObjectInputStream代表对象输入流,它的readObject()方法从一个源输入流中读取字节序列,再把它们反序列化为一个对象,并将其返回。
  只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口,实现Externalizable接口的类完全由自身来控制序列化的行为,而仅实现Serializable接口的类可以 采用默认的序列化方式 。
  对象序列化包括如下步骤:
  1) 创建一个对象输出流,它可以包装一个其他类型的目标输出流,如文件输出流;
  2) 通过对象输出流的writeObject()方法写对象。

  对象反序列化的步骤如下:
  1) 创建一个对象输入流,它可以包装一个其他类型的源输入流,如文件输入流;
  2) 通过对象输入流的readObject()方法读取对象。

 

9. String和StringBuffer的区别

  StringBuffer对象的内容可以修改;而String对象一旦产生后就不可以被修改,重新赋值后生成的新对象。

10. b/s和c/s的区别

硬件环境不同:

C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.  B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行

 

对安全要求不同 :

  C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息. 

  B/S 建立在广域网之上, 对安全的控制能力相对弱, 面向是不可知的用户群.  

 

对程序架构不同:

  C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑. 

  B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟. 

 

软件重用不同:

C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好. 

  B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子

 

系统维护不同 :

  系统维护是软件生存周期中,开销大, -------重要 

  C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统 

  B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.

 

处理问题不同:

  C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统 

  B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.  

 

用户接口不同 

  C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高 

  B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.

 

11.private可以修饰方法里的变量吗?

   不可以,private咳哟用来修饰类变量。方法内的变量作用域是从这个变量声明直到方法体结束,如果再使用private修饰的话两者就会冲突,所以不能在方法体内声明一个变量为private,而且在方法里 声明变量为private也没什么意义,方法内声明的变量的作用域本来就在方法体内,自然也不会被其它方法所访问。

 

12.当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?

可以进入其他非synchronized的方法,synchronized的方法不可以的!
Java中的每个对象都有一个锁(lock)或者叫做监视器(monitor),当访问某个对象的synchronized方法时,表示的将该对象上锁,此时其他任何线程都无法再去访问该synchronized方法了,直到之前的那个线程执行方法完毕后(或者是抛出了异常),才将该对象的锁释放掉,其他线程才有可能再去访问该synchronized方法。
如果一个对象有多个synchronized方法,某一时刻某个线程已经进入到了某个synchronized方法,那么在该方法没有执行完毕前,其他线程是无法访问该对象的任何synchronized方法的。

13.对象的上转型,子类重写了基类的方法A,那么上转型对象操作的这个方法A,是基类的方法A?还是子类的方法A?

  对象的上转型,操作的是子类的方法A。上转型对象只能操作基类的变量,子类继承的方法和子类重写的方法,不能使用子类新增的变量和方法。

 14 for循环里可以有boolean的表达式吗?

  可以。for( boolean1; boolean2&&条件表达式;boolean3)是正确的。

 15switch()的条件语句类型:

  byte、short、char、int、enum

  在jdk1.5上,Byte、Short、Character、Integer也支持。

 16 TreeMap是有序的map结构,HashMap不是,HashMap也是线程不稳定的。

 17hibernate操作数据库的运行过程。

  1  读取并解析配置文件

        Configuration conf = new Configuration().configure();

  2 读取并解析映射信息,创建SessionFactory

       SessionFactory sf  = conf.buildSessionFactoty();

  3 打开Session

      Session session = sf.openSession;//sf.getCurrentSession();

  4 开始一个事务(增删改操作必须,查询操作可选)

      Transaction tx = session.beginTransaction();

  5 数据库操作

     session.sava();

  6 提交事务(回滚事务)

     tx.commit();(tx.rollback();)

  7 关闭session

     session.close();

 18 定义内部类,外部怎么调用?

  一:static声明的内部类

  假设定义了一个类Outer,在Outer里定义了一个内部类Inner。

class Outer{        // 定义外部类  
    private static String info = "hello world" ;    // 定义外部类的私有属性  
    static class Inner{                // 使用static定义内部类为外部类  
        public void print(){                // 定义内部类的方法  
            System.out.println(info) ;      // 直接访问外部类的私有属性  
        }  
    };  
    public void fun(){                      // 定义外部类的方法  
        new Inner().print() ;               // 通过内部类的实例化对象调用方法  
    }  
}

  那么编译后会生成Outer.class和Outer$Inner.class。

  通过Outer.Inner in=new Outer.Inner(); 访问内部类。

  

  二:不使用statc声明一个内部类

 

class Outer{        // 定义外部类  
    private static String info = "hello world" ;    // 定义外部类的私有属性  
    class Inner{         // 使用static定义内部类为外部类  
        public void print(){                // 定义内部类的方法  
            System.out.println(info) ;      // 直接访问外部类的私有属性  
        }  
    };  
    public void fun(){                      // 定义外部类的方法  
        new Inner().print() ;               // 通过内部类的实例化对象调用方法  
    }  
}

  通过 Outer o=new Outer();  Outer.Inner in=o.new Inner();访问内部类。

  注意点:内部类不能含有static变量和方法,因为成员内部类的创建依赖于外部类对象。只有创建了外部类对象,才能创建内部类对象。

 

19 hibernate的inverse用法和含义

  Inverse是hibernate双向关系中的基本概念。inverse的真正作用就是指定由哪一方来维护之间的关联关系。当一方中指定了“inverse=true”,那么那一方就有责任负责之间的关联关系。

在set节点里设置。

 

20 get和post的区别

  ①浏览器和服务器会对用get方式提交的数据进行限制,服务器会对用post方式提交的数据进行限制。

  ②post的请求数据放置在http请求包中。

  ③get的参数个数理论上没有限制,但是浏览器和服务器会对用get方式提交的数据进行限制。

另外,get方式的提交的url采用ASCII编码。

 

21 看看下面的运行结果

  1. public static void main(String args[]){ {

     String a; 

     System.out.println("a="+a);

    }

 2. public class InnerClassDemo03{  
        static String a;
        public static void main(String args[]){ 
              System.out.println("a="+a);
        }  
    }

  结果:第一个编译会有问题,第二个运行输出a=null。

  分析:第一个很好理解,使用前没进行初始化,所以报错。第二个的a其实是成员变量,编译器有个默认初始化,初始化为null,所以有运行结果。

 

22 List、Set、Map的区别

  java集合(可以存储和操作数目不固定的一组数据,只能存放引用类型的数据,不能存放基本类型的数据,位于java.util包中)主要分为三种类型,set、list、map。

  List:可自动扩展的数组。

  Set:没有重复的数组。

23 java文件经编译后,会生成字节码(class)文件。

24 Spring里集成的hibernate的DAO层继承的哪个类?hibernateDAOSupport

25 部署java应用的服务器有哪些?和ajax有关的框架有哪些?

  部署java应用:Tomcat、Resin、Jboss、Weblogic

  和ajax有关的框架:JQuery、DWR、Dojo、ExtJs、Mootools

26 通知垃圾回收的方法

  System.gc()方法强制垃圾回收

27 抽象类和接口的区别:

① abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface,实现多重继承。接口还有标识(里面没有任何方法,如Remote接口)和数据共享(里面的变量全是常量)的作用。abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"has-a"关系

② 接口是公开的,里面不能有私有的方法或变量,是用于让别人使用的,而抽象类是可以有私有方法或私有变量的。

③ 在abstract class 中可以有abstract的成员方法,也可以有非abstarct的成员方法,而在interface中所有的成员方法默认都是public abstract 类型的

④ 接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以在子类中重新赋值。

⑤ 实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。抽象类中可以有非抽象方法。接口中则不能有实现方法。

 

28 transient使用小结

1)一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。

2)transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。

3)被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。

 

29 构造初始化顺序

对象的初始化顺序:(1)类加载之后,按从上到下(从父类到子类)执行被static修饰的语句;(2)当static语句执行完之后,再执行main方法;(3)如果有语句new了自身的对象,将从上到下执行构造代码块构造器(两者可以说绑定在一起)。

在Java中,子类的构造过程中必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来。但如果父类有多个构造函数时,该如何选择调用呢?第 一个规则:子类的构造过程中,必须调用其父类的构造方法。一个类,如果我们不写构造方法,那么编译器会帮我们加上一个默认的构造方法(就是没有参数的构造 方法),但是如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是如果在子类构造方法中我们并没有显示的调用基类的构造方法,如:super();  这样就会调用父类没有参数的构造方法。    

第二个规则:如果子类的构造方法中既没有显示的调用基类构造方法,而基类中又没有无参的构造方法,则编译出错,所以,通常我们需要显示的:super(参数列表),来调用父类有参数的构造函数,此时无参的构造函数就不会被调用。

总之,一句话:子类没有显示调用父类构造函数,不管子类构造函数是否带参数都默认调用父类无参的构造函数,若父类没有则编译出错。

转载于:https://www.cnblogs.com/lan-writenbook/p/5473345.html

你可能感兴趣的:(面试-java知识基础)