实习工作面试常问问题

一般来说，实习中常问这些问题：
基本的有
1、对这个职位有多少了解？
2、对工作中产生的问题如何解决？
3、对这个工作是否感兴趣？是否打算长期做这种工作？
对于我们IT行业来说,除了问以上三个问题以外，基本上，还会通过问你一些专业知识来了解你对这个行业，对技术的了解有多深！
以下，是我总结的常见的java实习生的一些笔试或者面试的题目：

1.Java有那些基本数据类型，String是不是基本数据类型，他们有何区别。
Java语言提供了八种基本类型：
六种数字类型（四个整数型，两个浮点型）
字节型byte 8位 短整型short 16位 整型int 32位
长整型long 64位 单精度float 32位 双精度double 64位
一种字符类型
字符型char 8位
还有一种布尔型
布尔型：boolean 8位 可存储”True”和”false”。
String本身就是一个对象而不是基本数据类型，String的变量名是对String类的引用。

2.字符串的操作：
写一个方法，实现字符串的反转，如：输入abc，输出cba

public static String reverse(String s){        int length=s.length();        StringBuffer result=new StringBuffer(length);        for(int i=length-1;i>=0;i--)            result.append(s.charAt(i));        return result.toString();    }

写一个方法，实现字符串的替换，如：输入bbbwlirbbb，输出bbbhhtccc。

    String s = "bbbwlirbbb";s.replaceAll("wlirbbb","hhtccc");

3.数据类型之间的转换
如何将数值型字符转换为数字（Integer，Double）
使用Integer.parseInt()和Double.parseDouble()方法。
如何将数字转换为字符
class my
{
int a=12;
Label label=new Label();
label.setText(String.valueOf(a));
}
如何取小数点前两位，并四舍五入。
System.out.println(“四舍五入取整:(3.856)=”
+ new BigDecimal(i).setScale(2, BigDecimal.ROUND_HALF_UP));

**4.日期和时间
如何取得年月日，小时分秒**
Date dat=new Date();
dat.getYear(); dat.getMonth(); dat.getDay(); dat.getHours(); dat.getMinutes(); dat.getSeconds();
如何取得从1970年到现在的毫秒数
long now=dat.getTime();
如何获取某个日期是当月的最后一天
DateFormate df=DateFormate.getInstance();df.Format(dat);
如何格式化日期
DateFormate df=DateFormate.getInstance();
df.Format(dat);
5.数组和集合
数组与集合的区别:一：数组声明了它容纳的元素的类型，而集合不声明。这是由于集合以object形式来存储它们的元素。二：一个数组实例具有固定的大小，不能伸缩。集合则可根据需要动态改变大小。三：数组是一种可读/可写数据结构没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly方 只读方式来使用集合。该方法将返回一个集合的只读版本。

**6.文件和目录（I/O）操作
如何列出某个目录下的所有文件
如何列出某个目录下的所有子目录
判断一个文件或目录是否存在
如何读写文件**

import java.io.BufferedReader;import java.io.File;import java.io.FileInputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;public class FileOpreate {    public static void main(String [] args)    {        FileOpreate fo=new FileOpreate();        try        {        //文件的写入        /*String[] testStr=new String[50];        for(int i=0;i<testStr.length;i++)        {         testStr[i]="我的测试数据00"+i;        }        fo.writeFile("D:\\","test.txt",testStr);        */        //文件的写入        /*String str="测试";        fo.writeFile("D:\\","test001.txt",str);*/        //创建或者删除文件        /*if(fo.createAndDeleteFile("D:\\","test001.txt"))        {            fo.createAndDeleteFile("D:\\","test002.txt");        }*/        //创建或者删除文件夹        /*fo.createAndDeleteFolder("D:\\","2009-07-06");*/        //输出一个文件内的文件名称        /*fo.readFolderByFile("D:\\");*/        //判断一个文件是否是空的        /*fo.fileIsNull("D:\\","test002.txt");*/        //读取全部的文件内容        /*fo.readAllFile("D:\\","test.txt");*/        //一行一行读取文件内容        fo.readLineFile("D:\\","test.txt");        }        catch(Exception e)        {            e.printStackTrace();        }    }

7.Java多态的实现（继承、重载、覆盖）
多态可分为：
1)编译多态：主要是体现在重载，系统在编译时就能确定调用重载函数的哪个版本。
2)运行多态：主要体现在OO设计的继承性上，子类的对象也是父类的对象，即上溯造型，所以子类对象可以作为父类对象使用，父类的对象变量可以指向子类对象。因此通过一个父类发出的方法调用可能执行的是方法在父类中的实现，也可能是某个子类中的实现，它是由运行时刻具体的对象类型决定的。
8.编码转换，怎样实现将GB2312编码的字符串转换为ISO-8859-1编码的字符串。
String str = new String(“字符串”.getBytes(“GB2312”),”ISO-8859-1”);
9.使用StringBuffer类与String类进行字符串连接时有何区别？
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。
10.谈谈final, finally, finalize的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
11.String s = new String(“xyz”);创建了几个String Object?
两个，一个是string s，另一个是”xyz”。
12.Java有没有goto?
goto是java中的保留字，现在没有在java中使用。
13.数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有length()这个方法。
14.Overload和Override的区别。
override（重写）
1）方法名、参数、返回值相同。
2）子类方法不能缩小父类方法的访问权限。
3）子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
4）存在于父类和子类之间。
5）方法被定义为final不能被重写。
overload（重载）
1）参数类型、个数、顺序至少有一个不相同。
2）不能重载只有返回值不同的方法名。
3）存在于父类和子类、同类中。
15.abstract class和interface有什么区别?
Interface只能有成员常量，只能是方法的声明；
而abstract class可以有成员变量，可以声明普通方法和抽象方法。
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
16.是否可以继承String类?
String类是final类故不可以继承。
17.面向对象的特征有哪些方面?
1）抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。
2）继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4) 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
18.int 和 Integer 有什么区别?
Java 提供两种不同的类型：引用类型和原始类型（或内置类型）。
Int是java的原始数据类型，
Integer是java为int提供的封装类。
Java为每个原始类型提供了封装类。
原始类型封装类booleanBoolean charCharacter byteByte shortShort intInteger longLong floatFloat doubleDouble
引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
19.作用域public,private,protected,以及不写时的区别?

访问 Public Protected 缺省的 Private
同类 √ √ √ √
同包 √ √ √ ×
子类 √ √ × ×
通用性 √ × × ×

20.用java写一个冒泡排序。
/**
* 对int数组进行升序排序
*
* @param intVal：要排序的数组
* @param asc：值为true，表示升序排序；传入值为false，表示降序排序
* @return 返回排序后的int数组
*/

public static int[] intArraySort(int [] intVal,boolean asc){   int [] vals=intVal;   int temp;   if(vals.length>0){    if(asc==true){     for(int i=0;i<=vals.length-2;i++){      for(int j=0;j<vals.length-i-1;j++){       if(vals[j]>vals[j+1]){        //升序排列        temp=vals[j];        vals[j]=vals[j+1];        vals[j+1]=temp;       }      }     }    }else{     for(int i=0;i<=vals.length-2;i++){      for(int j=0;j<vals.length-i-1;j++){       if(vals[j]<vals[j+1]){        //降序排列        temp=vals[j];        vals[j]=vals[j+1];        vals[j+1]=temp;       }      }     }    }   }   return vals;}

21.short s1 =1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型） short s1 = 1; s1 += 1;（可以正确编译）
22.float型float f=3.4是否正确?
不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4 或float f = 3.4f
在java里面，没小数点的默认是int,有小数点的默认是 double;
23.ArrayList和Vector的区别,HashMap和Hashtable的区别。
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差。
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。 Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
24.Error与Exception有什么区别？
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
25.statement 和preparestatement区别
1）创建时的区别：
Statement stm=con.createStatement();
PreparedStatement pstm=con.prepareStatement(sql);
执行的时候:
stm.execute(sql);
pstm.execute();
2）pstm一旦绑定了SQL,此pstm就不能执行其他的Sql，即只能执行一条SQL命令。
stm可以执行多条SQL命令。
3）对于执行同构的sql（只有值不同，其他结构都相同）,用pstm的执行效率比较的高，对于异构的SQL语句，Statement的执行效率要高。
4）当需要外部变量的时候，pstm的执行效率更高.

26.写一个数据库连接类，包括查询及结果存储。

import java.sql.*;     //需要加入的包//类的定义class DBConnect {    private String con1 = "sun.jdbc.odbc.JdbcOdbcDriver"; //连接SQL所需要的字符串    private String url = "jdbc:odbc:test";    private String user = "sa", password = ""; //这里请根据您的数据库用户和密码自行修改    Connection con;           //用于连接数据库用的    PreparedStatement ps;     //其实用Statement也行,PreparedStatement集成了Statement.    ResultSet rs;             //一个集合,可以用于执行SQL命令    //构造函数    DBConnect() {        try {            Class.forName(con1); //Class.forName()用于将一些类加载到JVM            this.Connect();   //函数调用            try {                this.execute();            } catch (SQLException ex) {                System.out.println(ex.toString());            }        } catch (ClassNotFoundException ce) {            System.out.println(ce);        }    }    public void Connect() {        try {            con = DriverManager.getConnection(url, user, password); //做这部之前先把ODBC配置好            if (con != null) {                System.out.println("Connection Sucessfully!");            }        } catch (SQLException ex) {            System.out.println(ex.toString());        }    }    public void execute() throws SQLException {        ps = con.prepareStatement("select *from friends"); //把SQL语句搞给ps        rs = ps.executeQuery();                            //这里执行,之后让rs知道信息        while (rs.next())                                 //这里必须加next(),偏移量移动.        {            System.out.print(rs.getString(2) + "\t");            System.out.print(rs.getString(3) + "\t");            System.out.print(rs.getString(4) + "\t");            System.out.print(rs.getDate(5) + "\t");            System.out.print(rs.getInt(6) + "\t");            System.out.println("");        }    }    public void close()                        //用于释放资源,Java里没有析构函数,但是通过重写protected void finalize(),    {                                        //之后在调用System.runFinalization()和System.gc()可以提醒JVM执行finalize()以释放,        try{                                 //在以前的J2SE版本里可以通过以上方法调用finalize(),但目前的J2SE5.0只能提醒JVM,但JVM不一定执行        rs.close();                          //最好的方案还是自己写析构close();        ps.close();        con.close();        }catch(SQLException ce)        {            System.out.println(ce.toString());        }        System.out.println("Connection released!!!");    }    public static void main(String[] args) {        DBConnect dbc=new DBConnect();               dbc.close();    }}

String、StringBuffer与StringBuilder之间区别
　
关于这三个类在字符串处理中的位置不言而喻，那么他们到底有什么优缺点，到底什么时候该用谁呢？下面我们从以下几点说明一下

　　1.三者在执行速度方面的比较：StringBuilder > StringBuffer > String

　　2.String <（StringBuffer，StringBuilder）的原因

　　　　String：字符串常量

　　　　StringBuffer：字符创变量

　　　　StringBuilder：字符创变量

　　　　从上面的名字可以看到，String是“字符创常量”，也就是不可改变的对象。对于这句话的理解你可能会产生这样一个疑问 ，比如这段代码：

1 String s = “abcd”;
2 s = s+1;
3 System.out.print(s);// result : abcd1

　　　 我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　　　执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

　　　 而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

　　3.一个特殊的例子：

1 String str = “This is only a” + “ simple” + “ test”;
3 StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);

　　　　你会很惊讶的发现，生成str对象的速度简直太快了，而这个时候StringBuffer居然速度上根本一点都不占优势。其实这是JVM的一个把戏，实际上：

　　　　String str = “This is only a” + “ simple” + “test”;

　　　　其实就是：

　　　　String str = “This is only a simple test”;

　　　　所以不需要太多的时间了。但大家这里要注意的是，如果你的字符串是来自另外的String对象的话，速度就没那么快了，譬如：

　　　　String str2 = “This is only a”;

　　　　String str3 = “ simple”;

　　　　String str4 = “ test”;

　　　　String str1 = str2 +str3 + str4;

　　　　这时候JVM会规规矩矩的按照原来的方式去做。

　　4.StringBuilder与 StringBuffer

　　　　StringBuilder：线程非安全的

　　　　StringBuffer：线程安全的

　　　　当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。

       对于三者使用的总结： 1.如果要操作少量的数据用 = String

　　　　　　　　　　 2.单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

　　　　　　　　　　 3.多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

      偶是初学者，只是总结了自己学习的东西，难免写的东西里有别人的，学习是记忆的过程，这些东西只是用来学习罢了，有些东西可能不对，希望各位给予指正。