精华内容
下载资源
问答
  • java面试常考编程题

    2011-03-18 17:02:22
    代码与编程题 135、写一个Singleton出来 Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 一般Singleton模式通常有几种种形式: 第一种形式: 定义一个类,它构造函数为private...
    代码与编程题
    135、写一个Singleton出来
    Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。
    一般Singleton模式通常有几种种形式:
    第一种形式: 定义一个类,它的构造函数为private的,它有一个static的private的该类变量,在类初始化时实例话,通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
    public class Singleton {
    private Singleton(){}
       //在自己内部定义自己一个实例,是不是很奇怪?
       //注意这是private 只供内部调用
       private static Singleton instance = new Singleton();
       //这里提供了一个供外部访问本class的静态方法,可以直接访问  
       public static Singleton getInstance() {
         return instance;   
       }
    }
    第二种形式:
    public class Singleton {
      private static Singleton instance = null;
      public static synchronized Singleton getInstance() {
      //这个方法比上面有所改进,不用每次都进行生成对象,只是第一次     
      //使用时生成实例,提高了效率!
      if (instance==null)
        instance=new Singleton();
    return instance;   }
    }
    其他形式:
    定义一个类,它的构造函数为private的,所有方法为static的。
    一般认为第一种形式要更加安全些
    136、继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
    答:父类:
    package test;
    public class FatherClass{
    public FatherClass(){
    System.out.println("FatherClass Create");
    }
    }
    子类:
    package test;
    import test.FatherClass;
    public class ChildClass extends FatherClass{
    public ChildClass(){
    System.out.println("ChildClass Create");
    }
    public static void main(String[] args) {
    FatherClass fc = new FatherClass();
    ChildClass cc = new ChildClass();
    }
    }
    输出结果:
    C:\>java test.ChildClass
    FatherClass Create
    FatherClass Create
    ChildClass Create
    137、内部类的实现方式?
    答:示例代码如下:
    package test;
    public class OuterClass{
    private class InterClass{
    public InterClass( {
    System.out.println("InterClass Create");
    }
    }
    public OuterClass()
    {
    InterClass ic = new InterClass();
    System.out.println("OuterClass Create");
    }
    public static void main(String[] args)
    {
    OuterClass oc = new OuterClass();
    }
    }
    输出结果:
    C:\>java test/OuterClass
    InterClass Create
    OuterClass Create
    再一个例题:
    public class OuterClass {
    private double d1 = 1.0;
    //insert code here
    }
    You need to insert an inner class declaration at line 3. Which two inner class declarations are
    valid?(Choose two.)
    A. class InnerOne{
    public static double methoda() {return d1;}
    }
    B. public class InnerOne{
    static double methoda() {return d1;}
    }
    C. private class InnerOne{
    double methoda() {return d1;}
    }
    D. static class InnerOne{
    protected double methoda() {return d1;}
    }
    E. abstract class InnerOne{
    public abstract double methoda();
    }
    说明如下:
    一.静态内部类可以有静态成员,而非静态内部类则不能有静态成员。 故 A、B 错
    二.静态内部类的非静态成员可以访问外部类的静态变量,而不可访问外部类的非静态变量;return d1 出错。
    故 D 错
    三.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确
    四.答案为C、E
    138、Java 的通信编程,编程题(或问答),用JAVA SOCKET编程,读服务器几个字符,再写入本地显示?
    答:Server端程序:
    package test;
    import java.net.*;
    import java.io.*;
    public class Server
    {
    private ServerSocket ss;
    private Socket socket;
    private BufferedReader in;
    private PrintWriter out;
    public Server()
    {
    try
    {
    ss=new ServerSocket(10000);
    while(true)
    {
    socket = ss.accept();
    String RemoteIP = socket.getInetAddress().getHostAddress();
    String RemotePort = ":"+socket.getLocalPort();
    System.out.println("A client come in!IP:"+RemoteIP+RemotePort);
    in = new BufferedReader(new
    InputStreamReader(socket.getInputStream()));
    String line = in.readLine();
    System.out.println("Cleint send is :" + line);
    out = new PrintWriter(socket.getOutputStream(),true);
    out.println("Your Message Received!");
    out.close();
    in.close();
    socket.close();
    }
    }catch (IOException e)
    {
    out.println("wrong");
    }
    }
    public static void main(String[] args)
    {
    new Server();
    }
    };
    Client端程序:
    package test;
    import java.io.*;
    import java.net.*;
    public class Client
    {
    Socket socket;
    BufferedReader in;
    PrintWriter out;
    public Client()
    {
    try
    {
    System.out.println("Try to Connect to 127.0.0.1:10000");
    socket = new Socket("127.0.0.1",10000);
    System.out.println("The Server Connected!");
    System.out.println("Please enter some Character:");
    BufferedReader line = new BufferedReader(new
    InputStreamReader(System.in));
    out = new PrintWriter(socket.getOutputStream(),true);
    out.println(line.readLine());
    in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    System.out.println(in.readLine());
    out.close();
    in.close();
    socket.close();
    }catch(IOException e)
    {
    out.println("Wrong");
    }
    }
    public static void main(String[] args)
    {
    new Client();
    }
    };
    139、用JAVA实现一种排序,JAVA类实现序列化的方法(二种)? 如在COLLECTION框架中,实现比较要实现什么样的接口?
    答:用插入法进行排序代码如下
    package test;
    import java.util.*;
    class InsertSort
    {
    ArrayList al;
    public InsertSort(int num,int mod)
    {
    al = new ArrayList(num);
    Random rand = new Random();
    System.out.println("The ArrayList Sort Before:");
    for (int i=0;i<num ;i++ )
    {
    al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1));
    System.out.println("al["+i+"]="+al.get(i));
    }
    }
    public void SortIt()
    {
    Integer tempInt;
    int MaxSize=1;
    for(int i=1;i<al.size();i++)
    {
    tempInt = (Integer)al.remove(i);
    if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue())
    {
    al.add(MaxSize,tempInt);
    MaxSize++;
    System.out.println(al.toString());
    } else {
    for (int j=0;j<MaxSize ;j++ )
    {
    if
    (((Integer)al.get(j)).intValue()>=tempInt.intValue())
    {
    al.add(j,tempInt);
    MaxSize++;
    System.out.println(al.toString());
    break;
    }
    }
    }
    }
    System.out.println("The ArrayList Sort After:");
    for(int i=0;i<al.size();i++)
    {
    System.out.println("al["+i+"]="+al.get(i));
    }
    }
    public static void main(String[] args)
    {
    InsertSort is = new InsertSort(10,100);
    is.SortIt();
    }
    }
    140、编程:编写一个截取字符串的函数,输入为一个字符串和字节数,输出为按字节截取的字符串。 但是要保证汉字不被截半个,如“我ABC”4,应该截为“我AB”,输入“我ABC汉DEF”,6,应该输出为“我ABC”而不是“我ABC+汉的半个”。
    答:代码如下:
    package test;
    class SplitString
    {
    String SplitStr;
    int SplitByte;
    public SplitString(String str,int bytes)
    {
    SplitStr=str;
    SplitByte=bytes;
    System.out.println("The String is:'"+SplitStr+"';SplitBytes="+SplitByte);
    }
    public void SplitIt()
    {
    int loopCount;

    loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/Split
    Byte+1);
    System.out.println("Will Split into "+loopCount);
    for (int i=1;i<=loopCount ;i++ )
    {
    if (i==loopCount){

    System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length()));
    } else {

    System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte)));
    }
    }
    }
    public static void main(String[] args)
    {
    SplitString ss = new SplitString("test中dd文dsaf中男大3443n中国43中国人
    0ewldfls=103",4);
    ss.SplitIt();
    }
    }
    141、JAVA多线程编程。 用JAVA写一个多线程程序,如写四个线程,二个加1,二个对一个变量减一,输出。
    希望大家补上,谢谢
    142、可能会让你写一段Jdbc连Oracle的程序,并实现数据查询.
    答:程序如下:
    package hello.ant;
    import java.sql.*;
    public class jdbc
    {
    String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl";
    String theUser="admin";
    String thePw="manager";
    Connection c=null;
    Statement conn;
    ResultSet rs=null;
    public jdbc()
    {
    try{
    Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
    c = DriverManager.getConnection(dbUrl,theUser,thePw);
    conn=c.createStatement();
    }catch(Exception e){
    e.printStackTrace();
    }
    }
    public boolean executeUpdate(String sql)
    {
    try
    {
    conn.executeUpdate(sql);
    return true;
    }
    catch (SQLException e)
    {
    e.printStackTrace();
    return false;
    }
    }
    public ResultSet executeQuery(String sql)
    {
    rs=null;
    try
    {
    rs=conn.executeQuery(sql);
    }
    catch (SQLException e)
    {
    e.printStackTrace();
    }
    return rs;
    }
    public void close()
    {
    try
    {
    conn.close();
    c.close();
    }
    catch (Exception e)
    {
    e.printStackTrace();
    }
    }
    public static void main(String[] args)
    {
    ResultSet rs;
    jdbc conn = new jdbc();
    rs=conn.executeQuery("select * from test");
    try{
    while (rs.next())
    {
    System.out.println(rs.getString("id"));
    System.out.println(rs.getString("name"));
    }
    }catch(Exception e)
    {
    e.printStackTrace();
    }
    }
    }
    143、ORACLE大数据量下的分页解决方法。一般用截取ID方法,还有是三层嵌套方法。
    答:一种分页方法
    <%
    int i=1;
    int numPages=14;
    String pages = request.getParameter("page") ;
    int currentPage = 1;
    currentPage=(pages==null)?(1):{Integer.parseInt(pages)}
    sql = "select count(*) from tables";
    ResultSet rs = DBLink.executeQuery(sql) ;
    while(rs.next()) i = rs.getInt(1) ;
    int intPageCount=1;
    intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1);
    int nextPage ;
    int upPage;
    nextPage = currentPage+1;
    if (nextPage>=intPageCount) nextPage=intPageCount;
    upPage = currentPage-1;
    if (upPage<=1) upPage=1;
    rs.close();
    sql="select * from tables";
    rs=DBLink.executeQuery(sql);
    i=0;
    while((i<numPages*(currentPage-1))&&rs.next()){i++;}
    %>
    //输出内容
    //输出翻页连接
    合计:<%=currentPage%>/<%=intPageCount%><a href="List.jsp?page=1">第一页</a><a
    href="List.jsp?page=<%=upPage%>">上一页</a>
    <%
    for(int j=1;j<=intPageCount;j++){
    if(currentPage!=j){
    %>
    <a href="list.jsp?page=<%=j%>">[<%=j%>]</a>
    <%
    }else{
    out.println(j);
    }
    }
    %>
    <a href="List.jsp?page=<%=nextPage%>">下一页</a><a href="List.jsp?page=<%=intPageCount%>">最后页
    </a>
    144、用jdom解析xml文件时如何解决中文问题?如何解析?
    答:看如下代码,用编码方式加以解决
    package test;
    import java.io.*;
    public class DOMTest
    {
    private String inFile = "c:\\people.xml";
    private String outFile = "c:\\people.xml";
    public static void main(String args[])
    {
    new DOMTest();
    }
    public DOMTest()
    {
    try
    {
    javax.xml.parsers.DocumentBuilder builder =

    javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
    org.w3c.dom.Document doc = builder.newDocument();
    org.w3c.dom.Element root = doc.createElement("老师");
    org.w3c.dom.Element wang = doc.createElement("王");
    org.w3c.dom.Element liu = doc.createElement("刘");
    wang.appendChild(doc.createTextNode("我是王老师"));
    root.appendChild(wang);
    doc.appendChild(root);
    javax.xml.transform.Transformer transformer =
    javax.xml.transform.TransformerFactory.newInstance().newTransformer();
    transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312");
    transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes");

    transformer.transform(new javax.xml.transform.dom.DOMSource(doc),
    new
    javax.xml.transform.stream.StreamResult(outFile));
    }
    catch (Exception e)
    {
    System.out.println (e.getMessage());
    }
    }
    }
    145、编程用JAVA解析XML的方式.
    答:用SAX方式解析XML,XML文件如下:
    <?xml version="1.0" encoding="gb2312"?>
    <person>
    <name>王小明</name>
    <college>信息学院</college>
    <telephone>6258113</telephone>
    <notes>男,1955年生,博士,95年调入海南大学</notes>
    </person>
    事件回调类SAXHandler.java
    import java.io.*;
    import java.util.Hashtable;
    import org.xml.sax.*;
    public class SAXHandler extends HandlerBase
    {
    private Hashtable table = new Hashtable();
    private String currentElement = null;
    private String currentValue = null;
    public void setTable(Hashtable table)
    {
    this.table = table;
    }
    public Hashtable getTable()
    {
    return table;
    }
    public void startElement(String tag, AttributeList attrs)
    throws SAXException
    {
    currentElement = tag;
    }
    public void characters(char[] ch, int start, int length)
    throws SAXException
    {
    currentValue = new String(ch, start, length);
    }
    public void endElement(String name) throws SAXException
    {
    if (currentElement.equals(name))
    table.put(currentElement, currentValue);
    }
    }
    JSP内容显示源码,SaxXml.jsp:
    <HTML>
    <HEAD>
    <TITLE>剖析XML文件people.xml</TITLE>
    </HEAD>
    <BODY>
    <%@ page errorPage="ErrPage.jsp"
    contentType="text/html;charset=GB2312" %>
    <%@ page import="java.io.*" %>
    <%@ page import="java.util.Hashtable" %>
    <%@ page import="org.w3c.dom.*" %>
    <%@ page import="org.xml.sax.*" %>
    <%@ page import="javax.xml.parsers.SAXParserFactory" %>
    <%@ page import="javax.xml.parsers.SAXParser" %>
    <%@ page import="SAXHandler" %>
    <%
    File file = new File("c:\\people.xml");
    FileReader reader = new FileReader(file);
    Parser parser;
    SAXParserFactory spf = SAXParserFactory.newInstance();
    SAXParser sp = spf.newSAXParser();
    SAXHandler handler = new SAXHandler();
    sp.parse(new InputSource(reader), handler);
    Hashtable hashTable = handler.getTable();
    out.println("<TABLE BORDER=2><CAPTION>教师信息表</CAPTION>");
    out.println("<TR><TD>姓名</TD>" + "<TD>" +
    (String)hashTable.get(new String("name")) + "</TD></TR>");
    out.println("<TR><TD>学院</TD>" + "<TD>" +
    (String)hashTable.get(new String("college"))+"</TD></TR>");
    out.println("<TR><TD>电话</TD>" + "<TD>" +
    (String)hashTable.get(new String("telephone")) + "</TD></TR>");
    out.println("<TR><TD>备注</TD>" + "<TD>" +
    (String)hashTable.get(new String("notes")) + "</TD></TR>");
    out.println("</TABLE>");
    %>
    </BODY>
    </HTML>
    146、EJB的基本架构
    答:一个EJB包括三个部分:
    Remote Interface 接口的代码
    package Beans;
    import javax.ejb.EJBObject;
    import java.rmi.RemoteException;
    public interface Add extends EJBObject
    {
    //some method declare
    }
    Home Interface 接口的代码
    package Beans;
    import java.rmi.RemoteException;
    import jaax.ejb.CreateException;
    import javax.ejb.EJBHome;
    public interface AddHome extends EJBHome
    {
    //some method declare
    }
    EJB类的代码
    package Beans;
    import java.rmi.RemoteException;
    import javax.ejb.SessionBean;
    import javx.ejb.SessionContext;
    public class AddBean Implements SessionBean
    {
    //some method declare
    }
    147、如何校验数字型?
    var re=/^\d{1,8}$|\.\d{1,2}$/;
    var str=document.form1.all(i).value;
    var r=str.match(re);
    if (r==null)
    {
    sign=-4;
    break;
    }
    else{
    document.form1.all(i).value=parseFloat(str);
    }
    148、将一个键盘输入的数字转化成中文输出
    (例如:输入:1234567 输出:一百二拾三万四千五百六拾七)
    用java语言实现,,请编一段程序实现!
    public class Reader {
    private String strNum;
    private String strNumChFormat;
    private String strNumTemp;
    private int intNumLen;
    private String strBegin;
    public Reader(String strNum) {
    this.strNum = strNum;
    }
    public boolean check(String strNum) {
    boolean valid = false;

    if (strNum.substring(0,1).equals("0")){
    this.strNum = strNum.substring(1);
    }
    try {
    new Double(strNum);
    valid = true;
    }
    catch (NumberFormatException ex) {
    System.out.println("Bad number format!");
    }
    return valid;
    }
    public void init() {
    strNumChFormat = "";
    intNumLen = strNum.length();
    strNumTemp = strNum;
    strNumTemp = strNumTemp.replace('1', '一');
    strNumTemp = strNumTemp.replace('2', '二');
    strNumTemp = strNumTemp.replace('3', '三');
    strNumTemp = strNumTemp.replace('4', '四');
    strNumTemp = strNumTemp.replace('5', '五');
    strNumTemp = strNumTemp.replace('6', '六');
    strNumTemp = strNumTemp.replace('7', '七');
    strNumTemp = strNumTemp.replace('8', '八');
    strNumTemp = strNumTemp.replace('9', '九');
    strNumTemp = strNumTemp.replace('0', '零');
    strNumTemp = strNumTemp.replace('.', '点');
    strBegin = strNumTemp.substring(0, 1);
    }
    public String readNum() {
    if (check(strNum)) {
    init();
    try {
    for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
    if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
    strNumChFormat = "位";
    }
    else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
    strNumChFormat = "位" + strNumChFormat;
    }
    else if (strNumTemp.charAt(intNumLen - i) == '点') {
    j = 1;
    k = 1;
    strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
    continue;
    }
    else {
    strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
    }
    if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
    strNumTemp.charAt(intNumLen - i - 1) != '零') {
    if (j == 1 && i < intNumLen) {
    strNumChFormat = '拾' + strNumChFormat;
    }
    else if (j == 2 && i < intNumLen) {
    strNumChFormat = '百' + strNumChFormat;
    }
    else if (j == 3 && i < intNumLen) {
    strNumChFormat = '千' + strNumChFormat;
    }
    }
    if (j == 4 && i < intNumLen) {
    j = 0;
    }
    if (k == 4 && i < intNumLen) {
    strNumChFormat = '万' + strNumChFormat;
    }
    else if (k == 8 && i < intNumLen) {
    k = 0;
    strNumChFormat = '亿' + strNumChFormat;
    }
    j++;
    k++;
    }
    while (strNumChFormat.indexOf("位") != -1) {
    strNumChFormat = strNumChFormat.replaceAll("位", " ");
    }
    if (strNumChFormat.substring(0, 2) == "一拾") {
    strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
    }
    if (strNumChFormat.indexOf("点") >= 0) {
    String rebegin = strNumChFormat.substring(0,
    strNumChFormat.indexOf("点"));
    String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
    strNumChFormat.length());
    for (int i = 1; i <= relast.length(); i++) {
    relast = relast.replaceAll("拾", "");
    relast = relast.replaceAll("百", "");
    relast = relast.replaceAll("千", "");
    relast = relast.replaceAll("万", "");
    relast = relast.replaceAll("亿", "");
    }
    strNumChFormat = rebegin + relast;
    }
    }
    catch (ArrayIndexOutOfBoundsException ex) {
    ex.printStackTrace();
    }
    catch (Exception ex) {
    ex.printStackTrace();
    }
    int off = strNumChFormat.indexOf("点");
    strNumChFormat = strBegin + strNumChFormat.substring(0);
    }
    else {
    strNumChFormat = "";
    }
    return strNumChFormat;
    }
    public static void main(String args[]) {
    try {
    String number = args[0].toString();
    System.out.println("The number is: " + number);
    Reader reader = new Reader(number);
    System.out.println("Output String: " + reader.readNum());
    }
    catch (Exception ex) {
    System.out.println("Please input like that: javac Reader <number>");
    }
    }
    }
    149、JAVA代码查错
    1.
    abstract class Name {
    private String name;
    public abstract boolean isStupidName(String name) {}
    }
    大侠们,这有何错误?
    答案: 错。abstract method必须以分号结尾,且不带花括号。
    2.
    public class Something {
    void doSomething () {
    private String s = "";
    int l = s.length();
    }
    }
    有错吗?
    答案: 错。局部变量前不能放置任何访问修饰符 (private,public,和protected)。final可以用来修饰局部变量
    (final如同abstract和strictfp,都是非访问修饰符,strictfp只能修饰class和method而非variable)。
    3.
    abstract class Something {
    private abstract String doSomething ();
    }
    这好像没什么错吧?
    答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的,怎么可以用private把abstract
    method封锁起来呢? (同理,abstract method前不能加final)。
    4.
    public class Something {
    public int addOne(final int x) {
    return ++x;
    }
    }
    这个比较明显。
    答案: 错。int x被修饰成final,意味着x不能在addOne method中被修改。
    5.
    public class Something {
    public static void main(String[] args) {
    Other o = new Other();
    new Something().addOne(o);
    }
    public void addOne(final Other o) {
    o.i++;
    }
    }
    class Other {
    public int i;
    }
    和上面的很相似,都是关于final的问题,这有错吗?
    答案: 正确。在addOne method中,参数o被修饰成final。如果在addOne method里我们修改了o的reference
    (比如: o = new Other();),那么如同上例这题也是错的。但这里修改的是o的member vairable
    (成员变量),而o的reference并没有改变。
    6.
    class Something {
    int i;
    public void doSomething() {
    System.out.println("i = " + i);
    }
    }
    有什么错呢? 看不出来啊。
    答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量,或叫成员变量)。instant variable有default value。int的default value是0。
    7.
    class Something {
    final int i;
    public void doSomething() {
    System.out.println("i = " + i);
    }
    }
    和上面一题只有一个地方不同,就是多了一个final。这难道就错了吗?
    答案: 错。final int i是个final的instant variable (实例变量,或叫成员变量)。final的instant variable没有default value,必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
    8.
    public class Something {
    public static void main(String[] args) {
    Something s = new Something();
    System.out.println("s.doSomething() returns " + doSomething());
    }
    public String doSomething() {
    return "Do something ...";
    }
    }
    看上去很完美。
    答案: 错。看上去在main里call doSomething没有什么问题,毕竟两个methods都在同一个class里。但仔细看,main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理,static method不能访问non-static instant variable。
    9.
    此处,Something类的文件名叫OtherThing.java
    class Something {
    private static void main(String[] something_to_do) {
    System.out.println("Do something ...");
    }
    }
    这个好像很明显。
    答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。
    10.
    interface A{
    int x = 0;
    }
    class B{
    int x =1;
    }
    class C extends B implements A {
    public void pX(){
    System.out.println(x);
    }
    public static void main(String[] args) {
    new C().pX();
    }
    }
    答案:错误。在编译时会发生错误(错误描述不同的JVM有不同的信息,意思就是未明确的x调用,两个x都匹配(就象在同时import java.util和java.sql两个包时直接声明Date一样)。对于父类的变量,可以用super.x来明确,而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。
    11.
    interface Playable {
    void play();
    }
    interface Bounceable {
    void play();
    }
    interface Rollable extends Playable, Bounceable {
    Ball ball = new Ball("PingPang");
    }
    class Ball implements Rollable {
    private String name;
    public String getName() {
    return name;
    }
    public Ball(String name) {
    this.name = name;
    }
    public void play() {
    ball = new Ball("Football");
    System.out.println(ball.getName());
    }
    }
    这个错误不容易发现。
    答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces,所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量,也可称成员变量),默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中,"ball = new Ball("Football");"改变了ball的reference,而这里的ball来自Rollable interface,Rollable interface里的ball是public static final的,final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。
    28、设计4个线程,其中两个线程每次对j增加1,另外两个线程对j每次减少1。写出程序。
    以下程序使用内部类实现线程,对j增减的时候没有考虑顺序问题。
    public class ThreadTest1{
    private int j;
    public static void main(String args[]){
    ThreadTest1 tt=new ThreadTest1();
    Inc inc=tt.new Inc();
    Dec dec=tt.new Dec();
    for(int i=0;i<2;i++){
    Thread t=new Thread(inc);
    t.start();
    t=new Thread(dec);
    t.start();
    }
    }
    private synchronized void inc(){
    j++;
    System.out.println(Thread.currentThread().getName()+"-inc:"+j);
    }
    private synchronized void dec(){
    j--;
    System.out.println(Thread.currentThread().getName()+"-dec:"+j);
    }
    class Inc implements Runnable{
    public void run(){
    for(int i=0;i<100;i++){
    inc();
    }
    }
    }
    class Dec implements Runnable{
    public void run(){
    for(int i=0;i<100;i++){
    dec();
    }
    }
    }
    }
    展开全文
  • 这些技术都是JavaWeb面试题中的常客,下面为小伙伴们带来Java Web面试题中最常考的10道面试题。1、说一说 Servlet 的生命周期?web 容器加载 servlet,生命周期开始。通过调用 servlet 的 init()方法进行 servlet 的...

    在Java中,动态Web资源开发技术统称为Java Web,而动态web资源开发技术有JSP/Servlet、ASP、PHP等。这些技术都是Java

    Web面试题中的常客,下面为小伙伴们带来Java Web面试题中最常考的10道面试题。

    1、说一说 Servlet 的生命周期?

    web 容器加载 servlet,生命周期开始。通过调用 servlet 的 init()方法进行 servlet 的初始化。通过调用

    service()方法实现,根据请求的不同调用不同的 do***()方法。结束服务,web 容器调用 servlet 的 destroy()方法。

    2、SERVLET API 中 forward() 与 redirect()的区别?

    答:前者仅是容器中控制权的转向,在客户端浏览器地址栏中不会显示出转向后的地址;后者则是完全的跳转,浏览器将会得到跳转的地址,并重新发送请求链接。这样,从浏览器的地址栏中可以看到跳转后的链接地址。所以,前者更加高效,在前者可以满足需要时,尽量使用

    forward()方法,并且,这样也有助于隐藏实际的链接。

    在有些情况下,比如,需要跳转到一个其它服务器上的资源,则必须使用

    sendRedirect()方法。

    3、 jsp 有哪些内置对象

    request 用户端请求,此请求会包含来自 GET/POST 请求的参数

    response 网页传回用户端的回应

    pageContext 网页的属性是在这里管理

    session 与请求有关的会话期

    application servlet 正在执行的内容

    out 用来传送回应的输出

    config servlet 的构架部件

    page JSP 网页本身

    exception 针对错误网页,未捕捉的例外

    4、JSP 和 Servlet 有哪些相同点和不同点,他们之间的联系是什么?

    JSP 是 Servlet 技术的扩展,本质上是 Servlet 的简易方式,更强调应用的外表表达。

    JSP 编译后是"类 servlet"。Servlet 和 JSP 最主要的不同点在于,Servlet 的应用逻辑是 在 Java

    文件中,并且完全从表示层中的 HTML 里分离开来。而 JSP 的情况是 Java 和HTML 可以组合成一个扩展名为.jsp 的文件。JSP

    侧重于视图,Servlet 主要用于控制逻辑。

    5、MVC 的各个部分都有那些技术来实现?如何实现?

    MVC 是 Model-View-Controller 的简写。Model 代表的是应用的业务逻辑(通过JavaBean,EJB 组件实现), View

    是应用的表示面(由 JSP 页面产生),Controller 是提供应用的处理过程控制(一般是一个

    Servlet),通过这种设计模型把应用逻辑,处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

    6、MVC 的各个部分都有那些技术来实现?如何实现?

    MVC 是 Model-View-Controller 的简写。Model 代表的是应用的业务逻辑(通过JavaBean,EJB 组件实现), View

    是应用的表示面(由 JSP 页面产生),Controller 是提供应用的处理过程控制(一般是一个

    Servlet),通过这种设计模型把应用逻辑,处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

    7、Tomcat 的优化经验

    答:去掉对 web.xml 的监视,把 jsp 提前编辑成 Servlet。

    有富余物理内存的情况,加大 tomcat 使用的 jvm 的内存

    8、Servlet的基本架构

    答:

    public class ServletName extends HttpServlet

    {

    //初始化方法

    public void init()

    {

    ……

    }

    //GET请求处理的方法

    public void doGet(HttpServletRequest request,HttpServletResponse

    response)

    {

    ……

    }

    //POST请求处理的方法

    public void doPost(HttpServletRequest request,HttpServletResponse

    response)

    {

    ……

    }

    //结束服务的方法

    public void destroy()

    {

    ……

    }

    }

    9.、cookie和session的作用、区别、应用范围。

    答:a、cookie数据保存在客户端,session数据保存在服务端。

    b、cookie不是很安全,别人可以分析存放在本地的cookie并进行cookie欺骗,相当重要的数据,应该使用session保存到服务端。

    c、session会在一定时间内保持在服务器上,但是会占用内存资源,当访问的用户过多,会加重服务器的负载,考虑到减轻服务器的压力,可以将不重要的数据放在cookie中持久的保存。

    d、单个cookie保存的数据不能超过4k,很多浏览器都限制站点最多保存20个cookie。

    10.JSP的四种范围?

    答:a、page是代表一个页面相关的对象和属性。一个页面由一个编译好的java

    servlet类(可以带有include指令,但不可以带有include动作)表示。这既包括servlet又包括编译成servlet的jsp页面。

    b、request是代表与web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个web组件(由于forware指令和include动作的关系)

    c、session是代表与用于某个web客户机的一个用户体验相关的对象和属性。一个web回话也可以经常跨域多个客户机请求。

    d、application是代表与整个web应用程序相关的对象和属性。这实质上是跨域整个web应用程序,包括多个页面、请求和回话的一个全局作用域。

    以上就是为大家带来的10道最常考的Java

    Web面试题,希望能够为求职的小伙伴略尽绵薄之力。当然,这些只是出现频率比较高的面试题,想要稳拿offer还是要付出相应的努力的,本站的Java面试题库里面有海量高质量Java面试题,小伙伴们可以随时去刷题检验自己的Java水平哦。

    展开全文
  • Java常考面试题

    千次阅读 2019-10-25 17:50:17
    Java常考面试题,整理自牛客网和程序员 面试宝典,有的不太好。 1. 什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”? 答:Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能...
    Java常考面试题,整理自牛客网和程序员
    面试宝典,有的题不太好。 
    

    1. 什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”?

    答:Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。虚拟机是一种抽象化的计算机,通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机有自己完善的硬体架构,如 处理器、堆栈 、寄存器等,还具有相应的指令系统。 Java被设计成允许应用程序可以运行在任意的平台,而不需要 程序员为每一个平台单独重写或者是重新编译。Java虚拟机让这个变为可能,因为它知道底层硬件平台的指令长度和其他特性。JVM屏蔽了与具体操作系统平台相关的信息,使得Java程序只需生成在Java虚拟机上运行的目标代码字节码),就可以在多种平台上不加修改地运行。

    2. JDK和JRE的区别是什么?

    答:Java运行时环境(JRE)是将要执行Java程序的Java虚拟机。它同时也包含了执行applet需要的浏览器插件。Java开发工具包(JDK)是完整的Java软件开发包,包含了JRE,编译器和其他的工具(比如:JavaDoc,Java调试器),可以让开发者开发、编译、执行Java应用程序。


    3. ”static”关键字是什么意思?Java中是否可以覆盖(override)一个private或者是static的方法?

    答: “static”关键字表明一个成员变量或者是成员方法可以在没有所属的类的实例变量的情况下被访问。static还可以用于修饰内部类(静态内部类),还可以用在import中,可以直接使用某个类的静态属性而不需要类名。
    Java中static方法不能被覆盖,因为方法覆盖是基于运行时动态绑定的,而static方法是编译时静态绑定的。static方法跟类的任何实例都不相关,所以概念上不适用。


    4. 是否可以在static环境中访问非static变量?

    答:static变量在Java中是属于类的,它在所有的实例中的值是一样的。当类被Java虚拟机载入的时候,会对static变量进行初始化。如果你的代码尝试不用实例来访问非static的变量,编译器会报错,因为这些变量还没有被创建出来,还没有跟任何实例关联上。


    5. 从继承的角度看,将构造函数声明为私有会有何作用?

    答:将构造函数声明为私有(private),可以确保类以外的地方都不能直接实例化这个类。在这种情况下,要创建这个类的实例,唯一的办法是提供一个公共静态方法,就像工厂方法模式那样。
    此外,由于构造函数是私有的,因此这个类也不能被继承。


    6. 在Java中,若在try-catch-finally的try语句块中插入return语句,finally语句块是否会执行?

    *答:会执行。当退出try语句块时,finally语句块将执行。即使我们试图从try语句块里跳出(通过return语句、continue语句、break语句或任意异常语句),finally语句块仍将得以执行。
    *

    注意:有些情况下finally语句块将不会执行,比如:

    • 如果虚拟机在try/catch语句块执行期间退出;
    • 如果执行try/catch语句块的线程被杀死终止了。

    7. final、finally、finalize之间有何差异?

    答:非常笼统的讲,final用于控制变量、方法或类是否“可更改”;finally关键字用在try/catch语句块中,以确保一段代码一定会执行。一旦垃圾收集器确定没有任何引用指向某个对象,就会在销毁这个对象之前调用finalize()方法。下面是关于几个关键字和方法的更多细节:
    ① final
    上下文不同,final有不同的含义。

    • 应用于基本类型(primitive)变量时:该变量的值无法更改。
    • 应用于引用(reference)变量时:该引用变量不能指向堆上的其他任何对象。
    • 应用于方法时:该方法不允许重写。
    • 应用于类时:该类不能派生子类。
    ② finally 在try块或者catch块之后,可以选择加一个finally语句块,finally语句块里的语句一定会被执行(除非 java虚拟机在执行try语句块时退出)。我们会在finally语句块这里编写资源回收和清理的代码。

    ③finalize()
    当垃圾收集器确定再无任何引用指向某个对象实例时,就会在销毁对象之前调用finalize()方法,一般用于资源清理或者关闭文件。


    8. C++模板和java泛型之间有何不同?

    答:java泛型实现根植于“类型消除”这一概念。当源代码被转换为Java虚拟机字节码时,这种技术会消除参数化类型。有了Java泛型,我们可以做的事情也并没有真正改变多少;他只是让代码变得漂亮些。鉴于此,Java泛型有时也被称为“语法糖”。
    这和 C++模板截然不同。在 C++中,模板本质上就是一套宏指令集,只是换了个名头,编译器会针对每种类型创建一份模板代码的副本。
    由于架构设计上的差异,Java泛型和C++模板有很多不同点:

    • C++模板可以使用int等基本数据类型。Java则不行,必须转而使用Integer。
    • 在Java中,可以将模板的参数类型限定为某种特定类型。
    • 在C++中,类型参数可以实例化,但java不支持。
    • 在Java中,类型参数不能用于静态方法(?)和变量,因为它们会被不同类型参数指定的实例共享。在C++,这些类时不同的,因此类型参数可以用于静态方法和静态变量。
    • 在Java中,不管类型参数是什么,所有的实例变量都是同一类型。类型参数会在运行时被抹去。在C++中,类型参数不同,实例变量也不同。

    9. Java的对象反射是什么?它有什么用?

    答:对象反射是Java的一项特性,提供了获取Java类和对象的反射信息的方法,可以执行以下方法:

    • 运行时获得类的方法和字段的相关信息。
    • 创建某个类的新实例。
    • 通过取得字段引用直接获取和设置对象字段,不管访问修饰为何。

    反射的作用:

    • 有助于观察和操纵应用程序的运行时行为。
    • 有助于调试或测试程序,因为我们可以直接访问方法、构造函数和成员字段。
    • 即使事前那个不知道某个方法,我们也可以通过名字调用该方法。

    10. 线程和进程的区别?

    *答:线程和进程有关联,但是两者有着根本上的不同。
    进程可以看作是程序执行时的实例,是一个分配了系统资源的独立实体。每个进程都在各自独立的地址空间执行,一个进程无法访问另一个进程的变量和数据结构。如果一个进程想要访问其他进程的资源,就必须使用进程间通信机制,包括管道、文件、套接字以及其他形式。
    线程存在于进程中,共享进程的资源(包括它的对空间)。同一进程里的多个线程将共享同一个堆空间。这跟进程大不相同,一个进程不能直接访问另一个进程的内存。每个线程仍然会有自己的寄存器和栈,而其他线程可以读写堆内存。


    11. 判断对错。在java的多态调用中,new的是哪一个类就是调用的哪个类的方法。

    答:错误。
    java多态有两种情况:重载和覆写
    在覆写中,运用的是动态单分配,是根据new的类型确定对象,从而确定调用的方法;
    在重载中,运用的是静态多分派,即根据静态类型确定对象,因此不是根据new的类型确定调用的方法


    12. 为什么内部类调用的外部变量必须是final修饰的?

    答:因为生命周期的原因。方法中的局部变量,方法结束后这个变量就要释放掉,final保证这个变量始终指向一个对象。首先,内部类和外部类其实是处于同一个级别,内部类不会因为定义在方法中就会随着方法的执行完毕而跟随者被销毁。问题就来了,如果外部类的方法中的变量不定义final,那么当外部类方法执行完毕的时候,这个局部变量肯定也就被GC了,然而内部类的某个方法还没有执行完,这个时候他所引用的外部变量已经找不到了。如果定义为final,java会将这个变量复制一份作为成员变量内置于内部类中,这样的话,由于final所修饰的值始终无法改变,所以这个变量所指向的内存区域就不会变。
    为了解决:局部变量的生命周期与局部内部类的对象的生命周期的不一致性问题


    13. Java中,什么是构造函数?什么是构造函数重载?什么是复制构造函数?

    答:当新对象被创建的时候,构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下,Java编译器会为这个类创建一个默认的构造函数。
    Java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。
    Java不支持像C++中那样的复制构造函数,这个不同点是因为如果你不自己写构造函数的情况下,Java不会创建默认的复制构造函数。


    14. Java中的方法覆盖(Overriding)和方法重载(Overloading)是什么意思?

    答:Java中的方法重载发生在同一个类里面两个或者是多个方法的方法名相同但是参数不同的情况。与此相对,方法覆盖是说子类重新定义了父类的方法。方法覆盖必须有相同的方法名,参数列表和返回类型。覆盖者可能不会限制它所覆盖的方法的访问。


    15. Java支持多继承么?

    答:Java中类不支持多继承,只支持单继承(即一个类只有一个父类)。 但是java中的接口支持多继承,,即一个子接口可以有多个父接口。(接口的作用是用来扩展对象的功能,一个子接口继承多个父接口,说明子接口扩展了多个功能,当类实现接口时,类就扩展了相应的功能)。


    16. 接口和抽象类的区别是什么?

    答:Java提供和支持创建抽象类和接口。它们的实现有共同点,不同点在于:

    • 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。
    • 类可以实现很多个接口,但是只能继承一个抽象类
    • 类可以不实现抽象类和接口声明的所有方法,当然,在这种情况下,类也必须得声明成是抽象的。
    • 抽象类可以在不提供接口方法实现的情况下实现接口。
    • Java接口中声明的变量默认都是final的。抽象类可以包含非final的变量。
    • Java接口中的成员函数默认是public的。抽象类的成员函数可以是private,protected或者是public。
    • 接口是绝对抽象的,不可以被实例化。抽象类也不可以被实例化,但是,如果它包含main方法的话是可以被调用的。
    • 也可以参考JDK8中抽象类和接口的区别

    17. 创建线程有几种不同的方式?你喜欢哪一种?为什么?

    答:有三种方式可以用来创建线程:
    继承Thread类
    实现Runnable接口
    应用程序可以使用Executor框架来创建线程池
    实现Runnable接口这种方式更受欢迎,因为这不需要继承Thread类。在应用设计中已经继承了别的对象的情况下,这需要多继承(而Java不支持多继承),只能实现接口。同时,线程池也是非常高效的,很容易实现和使用。


    18. 概括的解释下线程的几种可用状态。

    *答:

    1. 新建(new):新创建了一个线程对象。
    2. 可运行(runnable):线程对象创建后,其他线程(比如 main线程)调用了该对象的 start()方法。该状态的线程位于可运行线程池中,等待被线程调度选中,获取 cpu 的使用权 。
    3. 运行(running):可运行状态(runnable)的线程获得了 cpu 时间片(timeslice),执行程序代码。
    4. 阻塞(block):阻塞状态是指线程因为某种原因放弃了 cpu 使用权,也即让出了 cpu timeslice,暂时停止运行。直到线程进入可运行(runnable)状态,才有 机会再次获得 cpu timeslice 转到运行(running)状态。阻塞的情况分三种:
      (一). 等待阻塞:运行(running)的线程执行 o.wait()方法, JVM会把该线程放入等待队列(waitting queue)中。
      (二). 同步阻塞:运行(running)的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则 JVM 会把该线程放入锁池(lock pool)中。
      (三). 其他阻塞: 运行(running)的线程执行 Thread.sleep (long ms)或 t.join()方法,或者发出了 I/O请求时, JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O 处理完毕时,线程重新转入可运行(runnable)状态。
    5. 死亡(dead):线程 run()、 main()方法执行结束,或者因异常退出了 run()方法,则该线程结束生命周期。死亡的线程不可再次复生。

    线程的运行状态_www.wityx.com*


    19. 同步方法和同步代码块的区别是什么?

    答:区别:
    同步方法默认用this或者当前类class对象作为锁;
    同步代码块可以选择以什么来加锁,比同步方法要更细颗粒度,我们可以选择只同步会发生同步问题的部分代码而不是整个方法;


    20. 在监视器(Monitor)内部,是如何做线程同步的?程序应该做哪种级别的同步?

    答:监视器和锁在Java虚拟机中是一块使用的。监视器监视一块同步代码块,确保一次只有一个线程执行同步代码块。每一个监视器都和一个对象引用相关联。线程在获取锁之前不允许执行同步代码。

    21. 什么是死锁(deadlock)?

    答:两个线程或两个以上线程都在等待对方执行完毕才能继续往下执行的时候就发生了死锁。结果就是这些线程都陷入了无限的等待中。


    22. 如何确保N个线程可以访问N个资源同时又不导致死锁?

    答:使用多线程的时候,一种非常简单的避免死锁的方式就是:指定获取锁的顺序,并强制线程按照指定的顺序获取锁。因此,如果所有的线程都是以同样的顺序加锁和释放锁,就不会出现死锁了。


    23. Java集合类框架的基本接口有哪些?

    答:集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键,有些不允许。
    Java集合类提供了一套设计良好的支持对一组对象进行操作的接口和类。Java集合类里面最基本的接口有:
    Collection:代表一组对象,每一个对象都是它的子元素。
    Set:不包含重复元素的Collection。
    List:有顺序的collection,并且可以包含重复元素。
    Map:可以把键(key)映射到值(value)的对象,键不能重复。


    24. 为什么集合类没有实现Cloneable和Serializable接口?

    答:克隆(cloning)或者是序列化(serialization)的语义和含义是跟具体的实现相关的。因此,应该由集合类的具体实现来决定如何被克隆或者是序列化。


    25. 什么是迭代器(Iterator)?

    答:Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素,但是不可以直接调用集合的
    remove(Object Obj)删除,可以通过迭代器的remove()方法删除。


    26. Iterator和ListIterator的区别是什么?

    答:下面列出了他们的区别:
    Iterator可用来遍历Set和List集合,但是ListIterator只能用来遍历List。
    Iterator对集合只能是前向遍历,ListIterator既可以前向也可以后向。
    ListIterator实现了Iterator接口,并包含其他的功能,比如:增加元素,替换元素,获取前一个和后一个元素的索引,等等。


    27. 快速失败(fail-fast)和安全失败(fail-safe)的区别是什么?

    答:Iterator的安全失败是基于对底层集合做拷贝,因此,它不受源集合上修改的影响。java.util包下面的所有的集合类都是快速失败的,而java.util.concurrent包下面的所有的类都是安全失败的。快速失败的迭代器会抛出ConcurrentModificationException异常,而安全失败的迭代器永远不会抛出这样的异常。


    28. Java中的HashMap的工作原理是什么?

    答:Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数,它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候,HashMap会计算key的hash值,然后把键值对存储在集合中合适的索引上。如果key已经存在了,value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity),负载因子(load factor)和扩容极限(threshold resizing)。


    29. hashCode()和equals()方法的重要性体现在什么地方?

    答:Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引,当根据键获取值的时候也会用到这两个方法。如果没有正确的实现这两个方法,两个不同的键可能会有相同的hash值,因此,可能会被集合认为是相等的。而且,这两个方法也用来发现重复元素。所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。


    30. HashMap和Hashtable有什么区别?

    答:HashMap和Hashtable都实现了Map接口,因此很多特性非常相似。但是,他们有以下不同点:
    HashMap允许键和值是null,而Hashtable不允许键或者值是null。
    Hashtable是同步的,而HashMap不是。因此,HashMap更适合于单线程环境,而Hashtable适合于多线程环境。
    HashMap提供了可供应用迭代的键的集合,因此,HashMap是快速失败的。另一方面,Hashtable提供了对键的列举(Enumeration)。
    一般认为Hashtable是一个遗留的类。


    31. 数组(Array)和列表(ArrayList)有什么区别?什么时候应该使用Array而不是ArrayList?

    答:下面列出了Array和ArrayList的不同点:
    Array可以包含基本类型和对象类型,ArrayList只能包含对象类型。
    Array大小是固定的,ArrayList的大小是动态变化的。
    ArrayList提供了更多的方法和特性,比如:addAll(),removeAll(),iterator()等等。
    对于基本类型数据,集合使用自动装箱来减少编码工作量。但是,当处理固定大小的基本数据类型的时候,这种方式相对比较慢。


    32. ArrayList和LinkedList有什么区别?

    答:ArrayList和LinkedList都实现了List接口,他们有以下的不同点:
    ArrayList是基于索引的数据接口,它的底层是数组。它可以以O(1)时间复杂度对元素进行随机访问。与此对应,LinkedList是以元素列表的形式存储它的数据,每一个元素都和它的前一个和后一个元素链接在一起,在这种情况下,查找某个元素的时间复杂度是O(n)。
    相对于ArrayList,LinkedList的插入,添加,删除操作速度更快,因为当元素被添加到集合任意位置的时候,不需要像数组那样重新计算大小或者是更新索引。
    LinkedList比ArrayList更占内存,因为LinkedList为每一个节点存储了两个引用,一个指向前一个元素,一个指向下一个元素。
    也可以参考ArrayList vs. LinkedList。


    33. Comparable和Comparator接口是干什么的?列出它们的区别。

    答:Java提供了只包含一个compareTo()方法的Comparable接口。这个方法可以个给两个对象排序。具体来说,它返回负数,0,正数来表明输入对象小于,等于,大于已经存在的对象。
    Java提供了包含compare()和equals()两个方法的Comparator接口。compare()方法用来给两个输入参数排序,返回负数,0,正数表明第一个参数是小于,等于,大于第二个参数。equals()方法需要一个对象作为参数,它用来决定输入参数是否和comparator相等。只有当输入参数也是一个comparator并且输入参数和当前comparator的排序结果是相同的时候,这个方法才返回true。


    34. 什么是Java优先级队列(Priority Queue)?

    答:PriorityQueue是一个基于优先级堆的无界队列,它的元素是按照自然顺序(natural order)排序的。在创建的时候,我们可以给它提供一个负责给元素排序的比较器。PriorityQueue不允许null值,因为他们没有自然顺序,或者说他们没有任何的相关联的比较器。最后,PriorityQueue不是线程安全的,入队和出队的时间复杂度是O(log(n))。


    35. 如何权衡是使用无序的数组还是有序的数组?

    答:有序数组最大的好处在于查找的时间复杂度是O(log n),而无序数组是O(n)。有序数组的缺点是插入操作的时间复杂度是O(n),因为值大的元素需要往后移动来给新元素腾位置。相反,无序数组的插入时间复杂度是常量O(1)。


    36. Java集合类框架的最佳实践有哪些?

    答:根据应用的需要正确选择要使用的集合的类型对性能非常重要,比如:假如元素的大小是固定的,而且能事先知道,我们就应该用Array而不是ArrayList。
    有些集合类允许指定初始容量。因此,如果我们能估计出存储的元素的数目,我们可以设置初始容量来避免重新计算hash值或者是扩容。
    为了类型安全,可读性和健壮性的原因总是要使用泛型。同时,使用泛型还可以避免运行时的ClassCastException。
    使用JDK提供的不变类(immutable class)作为Map的键可以避免为我们自己的类实现hashCode()和equals()方法。
    编程的时候接口优于实现。
    底层的集合实际上是空的情况下,返回长度是0的集合或者是数组,不要返回null。


    37. Enumeration接口和Iterator接口的区别有哪些?

    答:Enumeration速度是Iterator的2倍,同时占用更少的内存。但是,Iterator远远比Enumeration安全,因为其他线程不能够修改正在被iterator遍历的集合里面的对象。同时,Iterator允许调用者删除底层集合里面的元素,这对Enumeration来说是不可能的。


    38. HashSet和TreeSet有什么区别?

    答:HashSet是由一个hash表来实现的,因此,它的元素是无序的。add(),remove(),contains()方法的时间复杂度是O(1)。
    另一方面,TreeSet是由一个树形的结构来实现的,它里面的元素是有序的。因此,add(),remove(),contains()方法的时间复杂度是O(logn)。


    39. Java中垃圾回收有什么目的?什么时候进行垃圾回收?

    答:垃圾回收的目的是识别并且丢弃应用不再使用的对象来释放和重用资源。
    当堆中空间不足以分配给对象时会进行垃圾回收


    40. System.gc()和Runtime.gc()会做什么事情?

    答:这两个方法用来提示JVM要进行垃圾回收。但是,立即开始还是延迟进行垃圾回收是取决于JVM的。


    41. finalize()方法什么时候被调用?析构函数(finalization)的目的是什么?

    答:垃圾回收器(garbage colector)决定回收某对象时,就会运行该对象的finalize()方法 但是在Java中很不幸,如果内存总是充足的,那么垃圾回收可能永远不会进行,也就是说filalize()可能永远不被执行,显然指望它做收尾工作是靠不住的。 那么finalize()究竟是做什么的呢?它最主要的用途是回收特殊渠道申请的内存。Java程序有垃圾回收器,所以一般情况下内存问题不用程序员操心。但有一种JNI(Java Native Interface)调用non-Java程序(C或C++),finalize()的工作就是回收这部分的内存。


    42. 如果对象的引用被置为null,垃圾收集器是否会立即释放对象占用的内存?

    答:不会,在下一个垃圾回收周期中,这个对象将是可被回收的。


    43. Java堆的结构是什么样子的?什么是堆中的永久代(Perm Gen space)?

    答:JVM的堆是运行时数据区,所有类的实例和数组都是在堆上分配内存。它在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就是垃圾收集器回收。
    堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的,不会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收掉的对象。一直到垃圾收集器把这些对象回收掉之前,他们会一直占据堆内存空间。
    永久代,主要存放类定义,字节码和常量等很少变动的信息。在HotSpot虚拟机中运行时方法区是使用永久代实现的。


    44. 串行(serial)收集器和吞吐量(throughput)收集器的区别是什么?

    答:吞吐量收集器使用并行版本的新生代垃圾收集器,它用于中等规模和大规模数据的应用程序。而串行收集器对大多数的小应用(在现代处理器上需要大概100M左右的内存)就足够了。


    45. 在Java中,对象什么时候可以被垃圾回收?

    答:当对象对当前使用这个对象的应用程序变得不可触及的时候,这个对象就可以被回收了。


    46. JVM的永久代中会发生垃圾回收么?

    答:垃圾回收不会发生在永久代,如果永久代满了或者是超过了临界值,会触发完全垃圾回收(Full GC)。如果你仔细查看垃圾收集器的输出信息,就会发现永久代也是被回收的。这就是为什么正确的永久代大小对避免Full GC是非常重要的原因。请参考下Java8:从永久代到元数据区
    (注:Java8中已经移除了永久代,新加了一个叫做元数据区的native内存区)


    47. Java中的两种异常类型是什么?他们有什么区别?

    答:Java中有两种异常:受检查的(checked)异常和不受检查的(unchecked)异常。不受检查的异常不需要在方法或者是构造函数上声明,就算方法或者是构造函数的执行可能会抛出这样的异常,并且不受检查的异常可以传播到方法或者是构造函数的外面。相反,受检查的异常必须要用throws语句在方法或者是构造函数上声明,或者处理这个异常。


    48. Java中Exception和Error有什么区别?

    答:Exception和Error都是Throwable的子类。Exception用于用户程序可以捕获的异常情况。Error定义了不期望被用户程序捕获的异常。


    49. throw和throws有什么区别?

    答:throw关键字用来在程序中明确的抛出异常,相反,throws语句用来表明方法不能处理的异常。每一个方法都必须要指定哪些异常不能处理,所以方法的调用者才能够确保处理可能发生的异常,多个异常是用逗号分隔的。


    50. 异常处理完成以后,Exception对象会发生什么变化?

    答:Exception对象会在下一个垃圾回收过程中被回收掉。


    51. finally代码块和finalize()方法有什么区别?

    答:无论是否抛出异常,finally代码块都会执行,它主要是用来释放应用占用的资源。finalize()方法是Object类的一个protected方法,它是在对象被垃圾回收之前由Java虚拟机来调用的。


    52. 什么是JDBC?

    答:JDBC是允许用户在不同数据库之间做选择的一个抽象层。JDBC允许开发者用JAVA写数据库应用程序,而不需要关心底层特定数据库的细节。


    53. 解释下驱动(Driver)在JDBC中的角色。

    答:JDBC驱动提供了特定厂商对JDBC API接口类的实现,驱动必须要提供java.sql包下面这些类的实现:Connection, Statement, PreparedStatement,CallableStatement, ResultSet和Driver。


    54. Class.forName()方法有什么作用?

    答:初始化参数指定的类,并且返回此类对应的 Class 对象


    55. PreparedStatement比Statement有什么优势?

    答:PreparedStatements是预编译的,因此,性能会更好。同时,不同的查询参数值,PreparedStatement可以重用。


    56. 什么时候使用CallableStatement?用来准备CallableStatement的方法是什么?

    答:CallableStatement用来执行存储过程。存储过程是由数据库存储和提供的。存储过程可以接受输入参数,也可以有返回结果。非常鼓励使用存储过程,因为它提供了安全性和模块化。准备一个CallableStatement的方法是:
    CallableStament.prepareCall();


    57. 数据库连接池是什么意思?

    答:像打开关闭数据库连接这种和数据库的交互可能是很费时的,尤其是当客户端数量增加的时候,会消耗大量的资源,成本是非常高的。可以在应用服务器启动的时候建立很多个数据库连接并维护在一个池中。连接请求由池中的连接提供。在连接使用完毕以后,把连接归还到池中,以用于满足将来更多的请求。


    58. 什么是RMI?

    答:Java远程方法调用(Java RMI)是Java API对远程过程调用(RPC)提供的面向对象的等价形式,支持直接传输序列化的Java对象和分布式垃圾回收。远程方法调用可以看做是激活远程正在运行的对象上的方法的步骤。RMI对调用者是位置透明的,因为调用者感觉方法是执行在本地运行的对象上的。


    59. RMI体系结构的基本原则是什么?

    答:RMI 体系结构是基于一个非常重要的行为定义和行为实现相分离的原则。RMI 允许定义行为的代码和实现行为的代码相分离,并且运行在不同的 JVM 上。


    60. RMI体系结构分哪几层?

    答:RMI体系结构分以下几层:
    存根和骨架层(Stub and Skeleton layer):这一层对程序员是透明的,它主要负责拦截客户端发出的方法调用请求,然后把请求重定向给远程的RMI服务。
    远程引用层(Remote Reference Layer):RMI体系结构的第二层用来解析客户端对服务端远程对象的引用。这一层解析并管理客户端对服务端远程对象的引用。连接是点到点的。
    传输层(Transport layer):这一层负责连接参与服务的两个JVM。这一层是建立在网络上机器间的TCP/IP连接之上的。它提供了基本的连接服务,还有一些防火墙穿透策略。


    61. RMI中的远程接口(Remote Interface)扮演了什么样的角色?

    答:远程接口用来标识哪些方法是可以被非本地虚拟机调用的接口。远程对象必须要直接或者是间接实现远程接口。实现了远程接口的类应该声明被实现的远程接口,给每一个远程对象定义构造函数,给所有远程接口的方法提供实现。


    62. java.rmi.Naming类扮演了什么样的角色?

    答:java.rmi.Naming类用来存储和获取在远程对象注册表里面的远程对象的引用。Naming类的每一个方法接收一个 URL 格式的 String 对象作为它的参数。


    63. RMI的绑定(Binding)是什么意思?

    答:绑定是为了查询找远程对象而给远程对象关联或者是注册以后会用到的名称的过程。远程对象可以使用 Naming类的 bind()或者 rebind()方法跟名称相关联。


    64. Naming类的bind()和rebind()方法有什么区别?

    答:bind()方法负责把指定名称绑定给远程对象,rebind()方法负责把指定名称重新绑定到一个新的远程对象。如果那个名称已经绑定过了,先前的绑定会被替换掉。


    65. 让RMI程序能正确运行有哪些步骤?

    答:为了让RMI程序能正确运行必须要包含以下几个步骤:
    编译所有的源文件。
    使用 rmic 生成 stub。
    启动 rmiregistry。
    启动 RMI服务器。
    运行客户端程序。


    66. RMI的stub扮演了什么样的角色?

    答:远程对象的stub扮演了远程对象的代表或者代理的角色。调用者在本地 stub 上调用方法,它负责在远程对象上执行方法。当 stub 的方法被调用的时候,会经历以下几个步骤:
    初始化到包含了远程对象的 JVM 的连接。
    序列化参数到远程的 JVM。
    等待方法调用和执行的结果。
    反序列化返回的值或者是方法没有执行成功情况下的异常。
    把值返回给调用者。


    67. 什么是分布式垃圾回收(DGC)?它是如何工作的?

    答:DGC 叫做分布式垃圾回收。RMI使用 DGC 来做自动垃圾回收。因为 RMI 包含了跨虚拟机的远程对象的引用,垃圾回收是很困难的。DGC 使用引用计数算法来给远程对象提供自动内存管理。


    68. RMI中使用RMI安全管理器(RMISecurityManager)的目的是什么?

    答:RMISecurityManager使用下载好的代码提供可被 RMI 应用程序使用的安全管理器。如果没有设置安全管理器,RMI的类加载器就不会从远程下载任何的类。


    69. 解释下Serialization和Deserialization。

    答:Java提供了一种叫做对象序列化的机制,他把对象表示成一连串的字节,里面包含了对象的数据,对象的类型信息,对象内部的数据的类型信息等等。因此,序列化可以看成是为了把对象存储在磁盘上或者是从磁盘上读出来并重建对象而把对象扁平化的一种方式。反序列化是把对象从扁平状态转化成活动对象的相反的步骤。


    70. 什么是Servlet?

    答:Servlet 是用来处理客户端请求并产生动态网页内容的 Java 类。Servlet 主要是用来处理或者是存储 HTML 表单提交的数据,产生动态内容,在无状态的 HTTP 协议下管理状态信息。


    71. 说一下Servlet的体系结构。

    答:所有的 Servlet 都必须要实现的核心的接口是 javax.servlet.Servlet。每一个 Servlet 都必须要直接或者是间接实现这个接口,或者是继承 javax.servlet.GenericServlet 或者javax.servlet.http.HTTPServlet。最后,Servlet 使用多线程可以并行的为多个请求服务。


    72. GenericServlet和HttpServlet有什么区别?

    答:GenericServlet是一个通用的协议无关的 Servlet,它实现了 Servlet 和 ServletConfig 接口。继承自 GenericServlet 的 Servlet 应该要覆盖 service()方法。最后,为了开发一个能用在网页上服务于使用 HTTP 协议请求的 Servlet,你的 Servlet 必须要继承自 HttpServlet。


    73. 解释下Servlet的生命周期。

    答:对每一个客户端的请求,Servlet引擎载入 Servlet,调用它的 init()方法,完成 Servlet的初始化。然后,Servlet对象通过为每一个请求单独调用 service()方法来处理所有随后来自客户端的请求,最后,调用 Servlet(译者注:这里应该是 Servlet 而不是 server)的destroy()方法把 Servlet删除掉。


    74. 什么是Web应用程序?

    答:Web应用程序是对 Web 或者是应用服务器的动态扩展。有两种类型的Web应用:面向表现的和面向服务的。面向表现的 Web 应用程序会产生包含了很多种标记语言和动态内容的交互的web页面作为对请求的响应。而面向服务的 Web 应用实现了 Web 服务的端点(endpoint)。一般来说,一个Web应用可以看成是一组安装在服务器 URL名称空间的特定子集下面的 Servlet 的集合。


    75. 什么是服务端包含(Server Side Include)?

    答:服务端包含(SSI)是一种简单的解释型服务端脚本语言,大多数时候仅用在Web上,用 servlet 标签嵌入进来。SSI最常用的场景把一个或多个文件包含到Web服务器的一个Web页面中。当浏览器访问Web页面的时候,Web服务器会用对应的servlet产生的文本来替换Web页面中的servlet标签。


    76. 什么是Servlet链(Servlet Chaining)?

    答:Servlet链是把一个Servlet的输出发送给另一个Servlet的方法。第二个Servlet的输出可以发送给第三个Servlet,依次类推。链条上最后一个Servlet负责把响应发送给客户端。


    77. 如何知道是哪一个客户端的机器正在请求你的Servlet?

    答:ServletRequest类可以找出客户端机器的IP地址或者是主机名。getRemoteAddr()方法获取客户端主机的IP地址,getRemoteHost()可以获取主机名。


    78. HTTP响应的结构是怎么样的?

    答:HTTP响应由三个部分组成:
    状态码(Status Code):描述了响应的状态。可以用来检查是否成功的完成了请求。请求失败的情况下,状态码可用来找出失败的原因。如果Servlet没有返回状态码,默认会返回成功的状态码HttpServletResponse.SC_OK。
    HTTP头部(HTTP Header):它们包含了更多关于响应的信息。比如:头部可以指定认为响应过期的过期日期,或者是指定用来给用户安全的传输实体内容的编码格式。
    主体(Body):它包含了响应的内容。它可以包含 HTML 代码,图片,等等。主体是由传输在 HTTP 消息中紧跟在头部后面的数据字节组成的。


    79. 什么是cookie?session和cookie有什么区别?

    答:cookie是 Web 服务器发送给浏览器的一块信息。浏览器会在本地文件中给每一个 Web 服务器存储 cookie。以后浏览器在给特定的 Web 服务器发请求的时候,同时会发送所有为该服务器存储的cookie。下面列出了 session 和 cookie 的区别:
    无论客户端浏览器做怎么样的设置,session都应该能正常工作。客户端可以选择禁用 cookie,但是,session仍然是能够工作的,因为客户端无法禁用服务端的 session。
    在存储的数据量方面 session 和 cookies 也是不一样的。session能够存储任意的 Java 对象,cookie只能存储 String 类型的对象。


    80. 浏览器和Servlet通信使用的是什么协议?

    答:浏览器和Servlet通信使用的是HTTP协议。


    81. 什么是HTTP隧道?

    答:HTTP隧道是一种利用 HTTP 或者是 HTTPS 把多种网络协议封装起来进行通信的技术。因此,HTTP协议扮演了一个打通用于通信的网络协议的管道的包装器的角色。把其他协议的请求掩盖成 HTTP 的请求就是 HTTP 隧道。


    81. sendRedirect()和forward()方法有什么区别?

    答:sendRedirect()方法会创建一个新的请求,而 forward()方法只是把请求转发到一个新的目标上。重定向(redirect)以后,之前请求作用域范围以内的对象就失效了,因为会产生一个新的请求,而转发(forwarding)以后,之前请求作用域范围以内的对象还是能访问的。一般认为sendRedirect()比 forward()要慢。


    82. 什么是URL编码和URL解码?

    答:URL编码是负责把 URL 里面的空格和其他的特殊字符替换成对应的十六进制表示,反之就是解码。


    83. 什么是JSP页面?

    答:JSP页面是一种包含了静态数据和 JSP 元素两种类型的文本的文本文档。静态数据可以用任何基于文本的格式来表示,比如:HTML 或者 XML。JSP 是一种混合了静态内容和动态产生的内容的技术。


    84. JSP请求是如何被处理的?

    答:浏览器首先要请求一个以.jsp扩展名结尾的页面,发起 JSP 请求,然后,Web服务器读取这个请求,使用 JSP 编译器把 JSP 页面转化成一个 Servlet 类。需要注意的是,只有当第一次请求页面或者是 JSP 文件发生改变的时候 JSP 文件才会被编译,然后服务器调用 servlet 类,处理浏览器的请求。一旦请求执行结束,servlet会把响应发送给客户端。


    85. JSP有什么优点?

    答:下面列出了使用JSP的优点:
    JSP页面是被动态编译成 Servlet 的,因此,开发者可以很容易的更新展现代码。
    JSP页面可以被预编译。
    JSP页面可以很容易的和静态模板结合,包括:HTML或者 XML,也可以很容易的和产生动态内容的代码结合起来。
    开发者可以提供让页面设计者以类 XML格式来访问的自定义的 JSP 标签库。
    开发者可以在组件层做逻辑上的改变,而不需要编辑单独使用了应用层逻辑的页面。


    86. 什么是JSP指令(Directive)?JSP中有哪些不同类型的指令?

    答:Directive是当 JSP 页面被编译成 Servlet 的时候,JSP引擎要处理的指令。Directive用来设置页面级别的指令,从外部文件插入数据,指定自定义的标签库。Directive是定义在 <%@ 和 %>之间的。下面列出了不同类型的Directive:
    包含指令(Include directive):用来包含文件和合并文件内容到当前的页面。
    页面指令(Page directive):用来定义JSP页面中特定的属性,比如错误页面和缓冲区。
    Taglib指令: 用来声明页面中使用的自定义的标签库。


    87. 什么是JSP动作(JSP action)?

    答:JSP动作以 XML语法的结构来控制 Servlet 引擎的行为。当JSP页面被请求的时候,JSP动作会被执行。它们可以被动态的插入到文件中,重用JavaBean组件,转发用户到其他的页面,或者是给Java插件产生 HTML 代码。下面列出了可用的动作:
    jsp:include-当JSP页面被请求的时候包含一个文件。
    jsp:useBean-找出或者是初始化 Javabean。
    jsp:setProperty-设置 JavaBean的属性。
    jsp:getProperty-获取 JavaBean的属性。
    jsp:forward-把请求转发到新的页面。
    jsp:plugin-产生特定浏览器的代码。


    88. 什么是Scriptlets?

    答:JSP技术中,scriptlet是嵌入在 JSP 页面中的一段Java代码。scriptlet是位于标签内部的所有的东西,在标签与标签之间,用户可以添加任意有效的 scriplet。


    89. 声明(Decalaration)在哪里?

    答:声明跟 Java 中的变量声明很相似,它用来声明随后要被表达式或者scriptlet使用的变量。添加的声明必须要用开始和结束标签包起来。


    90. 什么是表达式(Expression)?

    答:JSP表达式是Web服务器把脚本语言表达式的值转化成一个 String 对象,插入到返回给客户端的数据流中。表达式是在 <%= 和 %> 这两个标签之间定义的。


    91. 隐含对象是什么意思?有哪些隐含对象?

    答:JSP隐含对象是页面中的一些 Java 对象,JSP容器让这些 Java 对象可以为开发者所使用。开发者不用明确的声明就可以直接使用他们。JSP隐含对象也叫做预定义变量。下面列出了JSP页面中的隐含对象:
    application
    page
    request
    response
    session
    exception
    out
    config
    pageContext


    92. 面向对象软件开发的优点有哪些?

    答:代码开发模块化,更易维护和修改。
    代码复用。
    增强代码的可靠性和灵活性。
    增加代码的可理解性。
    面向对象编程有很多重要的特性,比如:封装,继承,多态和抽象。


    93. 封装的定义和好处有哪些?

    答:封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改变它内部的数据。在 Java 当中,有 3 种修饰符:public,private和 protected。每一种修饰符给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。
    下面列出了使用封装的一些好处:
    通过隐藏对象的属性来保护对象内部的状态。
    提高了代码的可用性和可维护性,因为对象的行为可以被单独的改变或者是扩展。
    禁止对象之间的不良交互提高模块化。


    94. 多态的定义?

    答:多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。


    95. 继承的定义?

    答:继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行,也可以在不修改类的情况下给现存的类添加新特性。


    96. 抽象的定义?抽象和封装的不同点?

    答:抽象是把想法从具体的实例中分离出来的步骤,因此,要根据他们的功能而不是实现细节来创建类。Java支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。
    抽象和封装是互补的概念。一方面,抽象关注对象的行为。另一方面,封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装,因此,封装可以看成是用来提供抽象的一种策略。





    展开全文
  • SSM框架常考面试汇集(Java面试

    千次阅读 多人点赞 2020-03-15 17:32:04
    欢迎你的阅读,本文整理了JAVA面试SSM框架常考的面试,大家一起学习共同进步。 JAVA基础面试问题请参考:JAVA基础问题汇集 小编按:Spring-SpringMVC-Mybatis 顺序整理 文章目录1. 简述什么是 IoC 和 DI ?2...

    【辰兮要努力】:hello你好我是辰兮,很高兴你能来阅读,昵称是希望自己能不断精进,向着优秀程序员前行!

    博客来源于项目以及编程中遇到的问题总结,偶尔会有读书分享,我会陆续更新Java前端、后台、数据库、项目案例等相关知识点总结,感谢你的阅读和关注,希望我的博客能帮助到更多的人,分享获取新知,大家一起进步!

    吾等采石之人,应怀大教堂之心,愿你们奔赴在各自的热爱中…

    在这里插入图片描述

    • 小编按:Spring-SpringMVC-Mybatis 顺序整理


    1. 简述什么是 IoC 和 DI ?

    • IoC 叫控制反转,是 Inversion of Control 的缩写,DI(Dependency Injection)叫依赖注入,是对 IoC 更简单的诠释。
    • 控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理。所谓的"控制反转"就是对组件对象控制权的转移,从程序代码本身转移到了外部容器,由容器来创建对象并管理对象之间的依赖关系。

    IoC 体现了好莱坞原则 - “Don’t call me, we will call you”。依赖注入的基本原则是应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由容器负责,查找资源的逻辑应该从应用组件的代码中抽取出来,交给容器来完成。

    • DI 是对 IoC 更准确的描述,即组件之间的依赖关系由容器在运行期决定,形象的来说,即由容器动态的将某种依赖关系注入到组件之中。

    2. DI 是如何实现的?

    • ①依赖注入可以通过 setter 方法注入(设值注入)
    <property name="id" value="1314"></property>
    
    • ②构造器注入:通过构造方法初始化
    <constructor-arg index="0" type="java.lang.String" value="辰兮"></constructor-arg>
    
    • ③接口注入三种方式来实现

    Spring 支持 setter注入和构造器注入,通常使用构造器注入来注入必须的依赖关系,对于可选的依赖关系,则 setter注入是更好的选择,setter注入需要类提供无参构造器或者无参的静态工厂方法来创建对象。

    • 小结::IoC解决对象之间的依赖问题,把所有Bean的依赖关系通过配置文件或注解关联起来,降低了耦合度。

    3. 解释一下什么叫 AOP (面向切面编程)?

    • AOP(Aspect-Oriented Programming)指一种程序设计范型,该范型以一种称为切面(aspect)的语言构造为基础,切面是一种新的模块化机制,用来描述分散在对象、类或方法中的横切关注点(crosscutting concern)。

    4. 阐述 Spring 框架中 Bean 的生命周期?

    • ① Spring IoC 容器找到关于 Bean 的定义并实例化该 Bean。
    • ② Spring IoC 容器对 Bean 进行依赖注入。
    • ③ 如果 Bean 实现了 BeanNameAware 接口,则将该 Bean 的 id 传给 setBeanName 方法。
    • ④ 如果 Bean 实现了 BeanFactoryAware 接口,则将 BeanFactory 对象传给 setBeanFactory
      方法。
    • ⑤ 如果 Bean 实现了 BeanPostProcessor 接口,则调用其
      postProcessBeforeInitialization 方法。
    • ⑥ 如果 Bean 实现了 InitializingBean 接口,则调用其 afterPropertySet 方法。
    • ⑦ 如果有和 Bean 关联的 BeanPostProcessors 对象,则这些对象的postProcessAfterInitialization 方法被调用。
    • ⑧ 当销毁 Bean 实例时,如果 Bean 实现了 DisposableBean 接口,则调用其 destroy 方法。

    5. Spring 里面的 aop的原理是什么 ?

    • 实现 AOP 的技术,主要分为两大类:一是采用动态代理技术,利用截取消息的方式,对该消息进行装饰,以取代原有对象行为的执行;二是采用静态织入的方式,引入特定的语法创建“方面”,从而使得编译器可以在编译期间织入有关“方面”的代码。通过反射创建动态代理对象,拦截方法执行,在将自己需要额外执行的代码加塞进来执行。

    6. Spring主要使用了什么模式?

    • 工厂模式:每个Bean的创建通过方法
    • 单例模式:默认的每个Bean的作用域都是单例
    • 代理模式:关于Aop的实现通过代理模式

    7. 简述Spring 中的事务 ?

    • ①编程式事务管理:编程方式管理事务,极大灵活性,难维护。
    • ②声明式事务管理:可以将业务代码和事务管理分离,用注解和xml配置来管理事务。

    8. SpringMVC的核心是什么,请求的流程是怎么处理的 ?

    • springmvc 是基于 servlet 的前端控制框架,核心是 ioc 和 aop(基于 spring 实现)

    在这里插入图片描述

    • 请求流程结合图形脑补记忆

    • 1、客户端发出一个http请求给web服务器,web服务器对http请求进行解析,如果匹配DispatcherServlet的请求映射路径(在web.xml中指定),web容器将请求转交给DispatcherServlet.

    • 2、DipatcherServlet接收到这个请求之后将根据请求的信息(包括URL、Http方法、请求报文头和请求参数Cookie等)以及HandlerMapping的配置找到处理请求的处理器(Handler)。

    • 3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler(Handler将具体的处理进行封装),再由具体的HandlerAdapter对Handler进行具体的调用。

    • 5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。

    • 6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图,DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。

    • 7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。


    9. MyBatis 中使用 # 和 $ 书写占位符有什么区别 ?

    • ①#将传入的数据都当成一个字符串,会对传入的数据自动加上引号
    • ② $将传入的数据直接显示生成在 SQL 中。
    • 注意:使用 $ 占位符可能会导致 SQL 注射攻击,能用#的地方就不要使用 $ ,写 order by 子句的时候应该用$而不是#。

    10.Mybatis的好处 ?

    • ①把Sql语句从Java中独立出来。
    • ②封装了底层的JDBC,API的调用,并且能够将结果集自动转换成JavaBean对象,简化了Java数据库编程的重复工作。
    • ③自己编写Sql语句,更加的灵活。
    • ④入参无需用对象封装(或者map封装),使用@Param注解。

    11.简述Mybatis的一级缓存和二级缓存 ?

    • 一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象,在对象中有一个数据结构(HashMap)用于存储缓存数据。不同的sqlSession之间的缓存数据区域(HashMap)是互相不影响的。(但是增删改查等数据库操作都会清空缓存)。

    • 二级缓存是mapper级别的缓存,多个SqlSession去操作同一个Mapper的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的。


    12.MyBatis 中的动态 SQL 是什么意思 ?

    • 对于一些复杂的查询,我们可能会指定多个查询条件,但是这些条件可能存在也可能不存在,例如在 58同城上面找房子,我们可能会指定面积、楼层和所在位置来查找房源,也可能会指定面积、价格、户型和所在位置来查找房源,此时就需要根据用户指定的条件动态生成 SQL 语句。
    • 如果不使用持久层框架我们可能需要自己拼装 SQL 语句,还好 MyBatis 提供了动态 SQL 的功能来解决这个问题。MyBatis中用于实现动态 SQL 的元素主要有:
    • if
    • choose / when / otherwise
    • trim
    • where
    • set
    • foreach

    13.Mybatis工作原理简述

    在这里插入图片描述

    • ①通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件中构建出SqlSessionFactory。
    • ②SqlSessionFactory开启一个SqlSession,通过SqlSession实例获得Mapper对象并且运行Mapper映射的Sql语句。
    • ③完成数据库的CRUD操作和事务提交,关闭SqlSession。

    • Invest in yourself and improve yourself

    在这里插入图片描述

    • 2020.03.15. 记录辰兮的第28篇博客
    展开全文
  • 今天小编已经将这些大厂都技术点问题都整理出来了,希望能帮助到深夜还在为面试做准朋友、后续准备面试的朋友。面试题如下:并发编程28Synchronized 用过吗,其原理是什么?你刚才提到获取对象...
  • java常考面试题

    2017-09-04 22:17:00
    p { margin-bottom: 0.1in; direction: ltr;...为什么Java被称作是“平台无关的编程语言”? 参考答案 Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节...
  • 常考Java面试题和答案

    2018-01-13 15:50:02
    为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台,而不需要...
  • java常考面试题汇总

    2018-08-01 16:39:35
    为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台,而不需要...
  • Java常考面试题>

    2018-04-07 15:51:48
    为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机进程。 Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台,而不需要...
  • 为什么Java被称作是“平台无关的编程语言”? 2.JDK和JRE的区别是什么? 3.”static”关键字是什么意思?Java中是否可以覆盖(override)一个private或者是static的方法? 4.是否可以在static环境中访问非static变量?...
  • 为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台,而不需要...
  • Java常考面试题,整理自牛客网和程序员面试宝典,有的不太好。   1. 什么是Java虚拟机?为什么Java被称作是“平台无关的编程语言”? 答:Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译...
  • Java常考面试题(一)

    2019-11-10 17:37:56
    序言 给大家分享一些 面试题吧,希望对正在找工作的同学有所帮助。  ---WZY 一、什么是虚拟机?为什么Java被称作是“平台无关的编程语言”?  自己解答: ...
  • 为什么Java被称作是“平台无关的编程语言”? JDK和JRE的区别是什么? ”static”关键字是什么意思?Java中是否可以覆盖(override)一个private或者是static的方法? 是否可以在static环境中访问非...
  • 为什么Java被称作是“平台无关的编程语言”? Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。 Java被设计成允许应用程序可以运行在任意的平台,而不...
  • 为什么Java被称作是“平台无关的编程语言”?Java虚拟机是一个可以执行Java字节码的虚拟机进程。Java源文件被编译成能被Java虚拟机执行的字节码文件。Java被设计成允许应用程序可以运行在任意的平台,而不需要程序员...
  • 第一章Java基础 1、简述java程序的运行机制 2、简述java语言的跨平台...1、谈谈你对面向过程的编程和面向对象的编程的理解 2、面向对象的特征是什么、谈谈你对它们的理解 3、简述java中类的组成部分。 4、简述jav

空空如也

空空如也

1 2 3 4
收藏数 73
精华内容 29
关键字:

java面试常考的编程题

java 订阅