老袁面试题

基础:

 

 

成员变量和局部变量的区别？

 

1,源代码的位置：

成员变量定义在类中,该变量在整个类访问有效。

局部变量定义在方法中,该变量只在方法内有效。

 

2，内存中的位置：

成员变量在堆内存的对象中存储。成员变量所属于对象。

局部变量在栈内存的方法中存储。局部变量所属于方法。

 

3，初始化。

成员变量都有默认的初始化。根据类型不同初始化值不同。

局部变量没有默认初始化。使用时，必须初始化才可以用。

 

 

 

 

1、字符串   拼接？   stringbuffer  stringbuider区别？

拼接：public StringBuffer append(String str)

字符串表示形式追加到序列

public StringBuffer insert(int offset,String str)

指定位置，字符串表示形式插入到序列

StringBuffer：同步的，数据安全，效率低。

StringBuilder：不同步的，数据不安全，效率高。

 

2、集合  map中的线性安全的集合

         Arraylist  linkedlist区别

ArrayList

底层数据结构是数组，查询快，增删慢。

线程不安全，效率高。

Vector

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

LinkedList

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

 

到底使用谁呢?看需求?

分析：

要安全吗?

要：Vector(即使要，也不使用这个，后面再说)

不要：ArrayList或者LinkedList

查询多；ArrayList

增删多：LinkedList

Hashmap   hashtable区别

 

迭代

//遍历集合

Iterator it = list.iterator();

while(it.hasNext()) {

String s =(String) it.next();

System.out.println(s);

}

 

3、线程  创建线程方法（2种）

两种。

 

继承Thread类

实现Runnable接口

 

 怎么处理多线程并发问题

问题出现原因：

是否是多线程环境

是否有共享数据

是否有多条语句操作共享数据

如何解决多线程安全问题呢?

基本思想：让程序的环境没有安全问题

怎么实现呢?

把多个语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可。

同步代码块:

synchronized(对象){需要同步的代码;}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

访问同一个资源，多个代码使用同一把锁，有效。多个程序使用多把锁，锁不住。

锁方法的锁对象是当前对象（this）

静态锁方法的锁对象是该当前类的class对象 (当前类名.class )

 

 调用线程的方法

启动一个线程是run()还是start()?它们的区别?

start();

 

run():封装了被线程执行的代码,直接调用仅仅是普通方法的调用

start():启动线程，并由JVM自动调用run()方法

5、线程池技术（如果想拿高工资的话，还是自己在网上了解一下）

4、static、final、abstract、implements关键字

final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符，因为 abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆 盖，private是不能够继承到子类，所以也就不能覆盖，static是可以覆盖的，但是在调用时会调用编译时类型的方法，因为调用的是父类的方法，而 父类的方法又是抽象的方法，又不能够调用，所以上的修饰符不能放在一起。

   Static的加载？

静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了,到程序运行结束时释放。

当类加载的时候所有的静态信息就被加载了，所以不能使用super,this关键字。如果去调用非静态（没有被加载）会发生错误，反过来非静态方法可以调用静态内容。

静态方法不能调用非静态的方法和属性。

 

5、方法的重载（写出来）

 

 

6、面向对象的三大特征（谈谈自己的理解）  继承多态？什么是面向对象？

所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

所谓继承是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

 

所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。

7、for循环中怎样删除一个元素？

for (int i = 0, len = list.size(); i < len; i++) {  

  if("4".equals(list.get(i))){

       System.out.println("len="+len+";i="+i+";删除元素："+list.get(i));

  list.remove(i);  

  len--;  

  i--;

  }

 }  

8、字符串和基本数据类型的相互转换？

byte[] getBytes() //将String转换为byte[]

char[] toCharArray() //将String转换为char[]

static String valueOf(char[] chs) //将char[]转换为String

static String valueOf(int i) //将int转为为String

9、自己写一个单例（synchronized）?

//懒汉式单例类.在第一次调用的时候实例化自己

public class Singleton {    

    private static class LazyHolder {    

       private static final Singleton INSTANCE = new Singleton();    

    }    

    private Singleton (){}    

    public static final Singleton getInstance() {    

       return LazyHolder.INSTANCE;    

    }    

}  

 

//饿汉式单例类.在类初始化时，已经自行实例化   

public class Singleton1 {  

    private Singleton1() {}  

    private static final Singleton1 single = new Singleton1();  

    //静态工厂方法   

    public static Singleton1 getInstance() {  

        return single;  

    }  

}   

数据库：

1、 函数（各种函数：聚合函数、单行函数、结婚操作）

2、 Oracle数据库中序列的作用？（视图、索引、序列、同义词、触发器）

索引会问到，其他的可以忽略。

Web：

10、选择器的分类以及各种选择器（默写）

[a  b]/[a>b]/[a+b]分别是什么选择器？

&(“a  b”)  &(“a>b”)   &(“a+b”)层次选择器

 

11、反射原理、反射加载类方法

获取Class对象的三种方式：

1、 Person p = new Person();

  Class c = p.getClass();

2、 Class c2 = Person.class; // 任意数据类型都具备一个class静态属性,看上去要比第一种方式简单.

3、 Class c3 = Class.forName("Person"); // 这里的字符串必须是类的全路径

// 将类名作为字符串传递给Class类中的静态方法forName即可

分析第三种和前两种的区别：
前两种你必须明确Person类型.

后者只需要知道类的字符串形式，扩展性更强。按照配置文件加载就可以了。

Ppoerson p = new person();

Class c= p.getclass();

 

Class c2 = person.class;’

Class c3 = class.forname(“person”)

 

12、C标签<c:foreach>、<c:if>、<c:choose>

<c:foreach>

forEach当前就是循环标签了，forEach标签有两种使用方式：

使用循环变量，指定开始和结束值，类似for(int i = 1; i <= 10; i++) {}；

循环遍历集合，类似for(Object o : 集合)；

指定循环次数进行操作：

 

增强for

 

 

<c:if>

if标签的test属性必须是一个boolean类型的值，如果test的值为true，那么执行if标签的内容，否则不执行。

<c:set var="a" value="hello"/>  在page域中创建名为a的变量

<c:if test="${not empty a  }">

<c:out value="${a }"/>

</c:if>

 

<c:choose>

choose标签对应Java中的if/else if/else结构。when标签的test为true时，会执行这个when的内容。当所有when标签的test都为false时，才会执行otherwise标签的内容。

 

13、Ajax、jquery、json、上传下载（看看写过的例子）

 

 

上传流程：

1、jsp页面上传文件

2、后台获取文件流（原理都是一样的，实现方式有所不同。

sevelet一般用ServletFileUpload从HttpServletRequest获取；

struts2会自动将文件流封装为File对象；springmvc则是MultipartFile）

3、获取输出流，在相应目录生成文件

下面结合以前做的项目，我给个简单的例子。

前台jsp上传代码就有不说了。如果用form的话，enctype="multipart/form-data"注意别丢了。

下载流程如下：

1、读取待下载文件路径。

2、获取文件输入流（从待下载文件获取输入流）

3、设置文件输出流（即设置HttpServletResponse）。

4、核心：从输入流读入文件，从输出流生成文件。

特别是其中的配置文件，特别容易让默写

1、 servlet中拦截器的配置（web.xml）

框架：

14、struts的拦截器interceptor配置文件、校验文件？（面试会让默写的）

 

action用法（3中）、

 

action中数据提交（3种）

 

文件的上传下载、ognl表达式（值栈、map）

15、struts中的<package>配置（面试会让默写的）

 

16、hibernate配置（分页技术，包括my sql中的分页肯定会问到的）

//HQL的分页查询
Query q2 = session.createQuery("from Employees");//查询所有记录
int page=1; //设置默认的页数为1
q2.setFirstResult((page-1)*5); //每页起始数
q2.setMaxResults(5); //每页最最多显示的页数
List emps = q2.list();//返回list集合
for (Employees emp:emps) {
System.out.println(emp.getEmployeeId());//打印输出属性
}
例如

 public Page getPage(int currentPage,int pageSize,String hql,Object...args){

String countHql="select count(*) "+hql.substring(hql.indexOf("from"));

Session session=HibernateUtil.getInstance().getSession();

Query query=session.createQuery(countHql);

for (int i = 0; i < args.length; i++) {

query.setParameter(i, args[i]);

}

int totalRecord=Integer.valueOf(query.uniqueResult()+"");

query=session.createQuery(hql);

for (int i = 0; i < args.length; i++) {

query.setParameter(i, args[i]);

}

query.setFirstResult(pageSize*(currentPage-1));

query.setMaxResults(pageSize);

List<House> list=(List<House>)query.list();

Page page=new Page();

page.setCurrentPage(currentPage);

page.setPageSize(pageSize);

page.setTotalRecord(totalRecord);

page.setList(list);

return page;

}

 

17、spring的作用？ioc、aop概念，ioc、di区别？

Spring的核心是一个轻量级（Lightweight）的容器（Container），它是实现IoC（Inversion of Control）容器和非入侵性（No intrusive）的框架，并提供AOP（Aspect-oriented programming）概念的实现方式；提供对持久层（Persistence）、事务（Transcation）的支持；提供MVC Web框架的实现，并对一些常用的企业服务API（Application Interface）提供一致的模型封装，是一个全方位的应用程序框架（Application Framework），除此之外，对现存的各种框架（Structs、JSF、Hibernate、Ibatis、Webwork等），Spring也提供了与他们相整合的方案。
简单地说，spring是用来管理你的类的框架，管理它们之间的互相调用和依赖关系，通过接口解藕，可以方便的更换使用多种不同的技术实现来完成你的系统。

 

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。

  控制反转又成为依赖注入，DI—Dependency Injection，即“依赖注入”：IoC的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（Dependency Injection，依赖注入）来实现的。也就是说组件之间依赖关系由容器在运行期决定，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

 

 

18、Spring中的对象的注入（肯定会问到的）

 

19、Bean的生命周期？（会问的，还有servlet的生命周期）

 

 

（面试会让你写的spring中的简单的bean）注意bean中的参数，一定要记住,因为面试是让你默写的！！！

1、 Ssh结合起来使用：配置文件（一般会让你默写的）

其他题目：

1、 会让你写sql语句的（如过没写也没有问你，那就是面试挂了！！！）

会用到函数的！

20、map集合遍历key用的是那个方法？遍历出来是一个什么对象？为什么是set？

 

21、For循环中怎样删除一个元素？

 

2、 在数据库中插入一条相同id的会怎样？（主键id没有自增）

22、@autowired和@resource的区别？

 

23、Servlet和action中的拦截器（简单默写一下），action中的interceptor路径？

Servlet

 

Struts2

 

SpringMVC

 

SSM

 

SSH

 

24、Mvc模式？

典型的MVC就是JSP + servlet + javabean的模式

 

 

3、 如果前后端中断的话，怎样在前端进行错误提示？

4、 会给一道具体的题目进行编程。

5、 会问你在做项目的过程中的遇到那些问题（最好提前想想2个）？

6、 怎样在2分钟内调用线程10000次？

25、写一下冒泡算法；

int[] c = { 3, 89, 65, 98, 67, 987, 258, 6, 954, 38 };

//冒泡排序:先排出最后一个最大的

System.out.println("冒泡排序：");

for (int i = 0; i < c.length; i++) {

for (int j = 0; j < c.length - 1 - i; j++) {

if (c[j] > c[j + 1]) {

int emp = c[j];

c[j] = c[j + 1];

c[j + 1] = emp;

}

}

}

 

for (int i : c) {

System.out.print(i+"  ");

}

System.out.println();

 

//选择排序：先排出第一个最小的，再按顺序往后排

System.out.println("选择排序:");

for (int i = 0; i < c.length; i++) {

for (int j = i + 1; j < c.length; j++) {

if (c[i] > c[j]) {

int temp = c[i];

 

c[i] = c[j];

c[j] = temp;

}

}

}

for (int i : c) {

System.out.print(i+"  ");

}

System.out.println();

26、写一个方法，参数为int，倒序并去重，返回值也是int，如：输入12347364，输出：463721；

 

数字去重排序

 

27、写过存储过程吗？

 

 

28、写出的一个算法。

int sum = 0;

    for (int i = 1; i < 11; i++) {

        int n = 0;

        for (int j = 0; j < i; j++) {

            n = n * j;

        }

        sum = sum + n;

    }

    System.out.println("1！+2！+3！+……+10！="+sum);

}

 

29、给出一个字符串，例如“35；14；50”，大概意思是让你把他它化成一个数组，并按照从小到大的顺序排列。

 

30、anion和unionall,比如：

A表               B表

Id    no        id     no

1 2         4      1

2 3         5      2

3 4

 

A  union   B ---? （2，3，4，1）

A  unionall    B-----?（2，3，4，1，2）

31、JSP的组成部分？JSP的语法？

 

32、单例模式

1. public class Singleton {  
2. private static class SingletonHolder {  
3.  private static final Singleton INSTANCE = new Singleton();  
4. }  
5. private Singleton (){}  
6. public static final Singleton getInstance() {  
7. return SingletonHolder.INSTANCE;  
8. }  
9. } 

1）利用了classloder的机制来保证初始化instance时只有一个线程

2）达到lazy loading效果，调用getInstance方法时才实例化instance可以节省资源，避免其他的地方被主动使用从而被加载。

@33、设计模式

 

34、二分查找、递归

 

35、比较openSession和getCurrentSession这两个方法

Configuration cfg = new Configuration(); // 获得配置信息对象
SessionFactory sf = cfg.configure().buildSessionFactory(); //解析并建立Session工厂

1. Session session = sf.getCurrentSession(); // 获得Session

2. Session session = sf.openSession(); // 打开Session

 

对于上述的两个方法，有以下区别：

这里简单说明一下openSession 和 getCurrentSession这两个方法的区别。很容易看出来，openSession每次都是创建一个新的session，而getCurrentSession会查看，如果当前上下文中已经有Session，则直接使用原有的，否则会创建一个新的session。

当然这样说并不是很形象。很多人会理解为，后面一个只是前面的略微优化而已，每次都打开新的也不会出错。当然这样理解并没有完全错误，其实这里的Session使用上没有很大的区别，区别是在于使用openSession时，如果涉及到对数据库的数据的修改（增、删、改），在事务提交之后，session必须手动关闭（session.close()），否则会出错，一般是数据已经保存进数据库，但使用Hibernate再次查询数据时并没有显示新的值。而getCurrentSession在事务提交后会自动关闭当前session。

所以，一般推荐使用getCurrentSession，这样需要我们关心的内容就更少，而且更不容易出错。

 

对于getCurrentSession 来说，有以下一些特点：

1.用途，界定事务边界

2.事务提交会自动close，不需要像openSession一样自己调用close方法关闭session

3.上下文配置（即在hibernate.cfg.xml）中，需要配置：

<property name="current_session_context_class">thread</property>

（需要注意，这里的current_session_context_class属性有几个属性值：jta 、 thread 常用 , custom、managed 少用 )

a).thread使用connection 单数据库连接管理事务

b).jta （java transaction api） Java 分布式事务管理 （多数据库访问），jta 由中间件提供（JBoss WebLogic 等， 但是tomcat 不支持）

 

对于getCurrentSession 来说，有以下一些特点：

1.用途，界定事务边界

2.事务提交会自动close，不需要像openSession一样自己调用close方法关闭session

3.上下文配置（即在hibernate.cfg.xml）中，需要配置：

<property name="current_session_context_class">thread</property>

（需要注意，这里的current_session_context_class属性有几个属性值：jta 、 thread 常用 , custom、managed 少用 )

a).thread使用connection 单数据库连接管理事务

b).jta （java transaction api） Java 分布式事务管理 （多数据库访问），jta 由中间件提供（JBoss WebLogic 等， 但是tomcat 不支持）