java面试题

abstract 抽象的 
一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现 

break 
一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行 
case 
Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。 
catch 
Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。 
char 
Java语言的一个关键字，用来定义一个字符类型 
continue 
一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。 
do 
一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置 
double 
一个Java语言的关键字，用来定义一个double类型的变量 
else 
一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。 
final 
一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，
一个final修饰的变量不能改变其初始值。 
finally 
一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。 
float 
一个Java语言的关键字，用来定义一个浮点数变量 
for 
一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。 
if 
Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。 
implements 
Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。 
import 
Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。 
instanceof 
一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。 
int 
Java(TM)的一个关键字，用来定义一个整形变量 
Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。 
long 
Java语言的一个关键字，用来定义一个long类型的变量。 
private 
Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。 
protected 
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。 
public 
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。 
return 
Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。 
short 
Java语言的关键字，用来定义一个short类型的变量。 
static 
Java语言的关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。
类方法通过类名调用而不是特定的实例，并且只能操作类变量。 
this 
Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。 
throw 
Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象 
throws 
Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。 
transient 
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。 
try 
Java语言的关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。
同时，一个finally语句块会被执行，无论一个异常是否被抛出。
void 
Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。 
volatile 
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。 
while 
Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。 
关于break和continue
continue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中,
continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。

public static void main(String[] args) {


  Map<String, String> map = new HashMap<String, String>();
  map.put("1", "value1");
  map.put("2", "value2");
  map.put("3", "value3");
  
  //第一种：普遍使用，二次取值
  System.out.println("通过Map.keySet遍历key和value：");
  for (String key : map.keySet()) {
   System.out.println("key= "+ key + " and value= " + map.get(key));
  }
  
  //第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value：");
  Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
  while (it.hasNext()) {
   Map.Entry<String, String> entry = it.next();
   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }
  
  //第三种：推荐，尤其是容量大时

 System.out.println("通过Map.entrySet遍历key和value");
 
 for (Map.Entry<String, String> entry : map.entrySet()) {

   System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
  }

  //第四种
  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
  for (String v : map.values()) {
   System.out.println("value= " + v);
  }
 }

1、复制表结构及数据到新表
CREATE TABLE 新表 SELECT * FROM 旧表 
这种方法会将oldtable中所有的内容都拷贝过来，当然我们可以用delete from newtable;来删除。 
不过这种方法的一个最不好的地方就是新表中没有了旧表的primary key、Extra（auto_increment）等属性。需要自己用"alter"添加，而且容易搞错。 


2、只复制表结构到新表 
CREATE TABLE 新表 SELECT * FROM 旧表 WHERE 1=2 
或CREATE TABLE 新表 LIKE 旧表 


3、复制旧表的数据到新表(假设两个表结构一样) 
INSERT INTO 新表 SELECT * FROM 旧表 


4、复制旧表的数据到新表(假设两个表结构不一样) 
INSERT INTO 新表(字段1,字段2,.......) SELECT 字段1,字段2,...... FROM 旧表 


5、可以将表1结构复制到表2 
SELECT * INTO 表2 FROM 表1 WHERE 1=2 


6、可以将表1内容全部复制到表2 
SELECT * INTO 表2 FROM 表1 


7、show create table 旧表; 
这样会将旧表的创建命令列出。我们只需要将该命令拷贝出来，更改table的名字，就可以建立一个完全一样的表

iterator标签：
用于对集合进行迭代，这里集合包含List、Set和数组，也可对Map类型的对象进行迭代输出。Value、id、Status三个属性都是可选属性，如果没有指定value属性，
则使用ValueStack栈顶的集合。
例：
<s:iterator var="u" value="users" status="sts">
<s:property value="#sts"/>
<s:property value="#u"/><br/>
</s:iterator>
如果为<s:iterator/>标签指定status属性，即每次迭代时都会有一个IteratorStatus实例，该实例的方法包含如下几个：
Int getCount():返回当前迭代了几个元素；
Int getIndex():返回当前元素的索引；
Boolean isEven(): 当前元素的索引是否是偶数；
Boolean isFirst()：当前元素是否是第一个元素；
Boolean isLast()：当前元素是否是最后一个元素；
Boolean isOdd()：当前元素的索引是否是奇数；
append标签：
用于将多个集合拼接起来，组成一个新的集合，通过阵中的拼接，从而允许通过一个<s:iterator …./>标签就完成对多个集合的迭代。

装饰设计模式：
1、定义及作用
该模式以对客户端透明的方式扩展对象的功能。
2、涉及角色
抽象构件角色：定义一个抽象接口，来规范准备附加功能的类。
具体构件角色：将要被附加功能的类，实现抽象构件角色接口。
抽象装饰者角色：持有对具体构件角色的引用并定义与抽象构件角色一致的接口。
具体装饰角色：实现抽象装饰者角色，负责为具体构件添加额外功能。
3、优缺点
优点：1）提供比继承更多的灵活性 2）使用不同的装饰组合可以创造出不同行为的组合 3）需要的类的数目减少
缺点：1）灵活性带来比较大的出错性 2）产生更多的对象，给查错带来困难

一、装饰者和原组件的共同方法接口（抽象构件角色）

 package com.design.decorate2;

//装饰者和原组件的共同方法接口（抽象构件角色）
public interface InterfaceComponent {
 public void say();
}

二、原组件（具体构件角色或称为目标对象）
 package com.design.decorate2;

//原组件（具体构件角色）
public class Component implements InterfaceComponent {

 @Override
 public void say() {
  System.out.println("Component.say()：原组件的方法");
 }

}

 
三、抽象装饰者角色
 package com.design.decorate2;

//抽象装饰者角色
public abstract class AbstractDecorator implements InterfaceComponent {
 private InterfaceComponent interfaceComponent;
 
 public AbstractDecorator(InterfaceComponent interfaceComponent) {
  super();
  this.interfaceComponent = interfaceComponent;
 }
 
 //组件方法执行前预处理方法
 public void preSay(){};
 
 //组件方法执行后处理方法
 public void afterSay(){};
 
 @Override
 public void say() {
  // TODO Auto-generated method stub
  preSay();
  
  interfaceComponent.say();
  
  afterSay();
 }

}

 
四、装饰者一

package com.design.decorate2;

//装饰者一
public class DecoratorOne extends AbstractDecorator {

 public DecoratorOne(InterfaceComponent interfaceComponent) {
  super(interfaceComponent);
  // TODO Auto-generated constructor stub
 }
 
 @Override
 public void preSay() {
  // TODO Auto-generated method stub
  super.preSay();
  System.out.println("DecoratorOne.preSay():装饰者一的preSay()方法");
 }

 @Override
 public void afterSay() {
  // TODO Auto-generated method stub
  super.afterSay();
  System.out.println("DecoratorOne.afterSay():装饰者一的afterSay()方法");
 }
}
 


五、装饰者二
package com.design.decorate2;

//具体装饰者二
public class DecoratorTwo extends AbstractDecorator {

 public DecoratorTwo(InterfaceComponent interfaceComponent) {
  super(interfaceComponent);
  // TODO Auto-generated constructor stub
 }

 @Override
 public void preSay() {
  // TODO Auto-generated method stub
  super.preSay();
  System.out.println("DecoratorTwo.preSay():装饰者二的preSay()方法");
 }

 @Override
 public void afterSay() {
  // TODO Auto-generated method stub
  super.afterSay();
  System.out.println("DecoratorTwo.afterSay():装饰者二的afterSay()方法");
 } 

}
 


六、调用者
package com.design.decorate2;

//调用者
public class DecoratorClient {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  /*InterfaceComponent interfaceComponent = new DecoratorTwo(new DecoratorOne(new Component()));
  interfaceComponent.say();*/
  
  InterfaceComponent interfaceComponent1 = new DecoratorOne(new Component());
  interfaceComponent1.say();
  System.out.println("-----------------------");
  InterfaceComponent interfaceComponent2 = new DecoratorTwo(new Component());
  interfaceComponent2.say();
 }

}


打印结果：
DecoratorOne.preSay():装饰者一的preSay()方法
Component.say()：原组件的方法
DecoratorOne.afterSay():装饰者一的afterSay()方法
-----------------------
DecoratorTwo.preSay():装饰者二的preSay()方法
Component.say()：原组件的方法
DecoratorTwo.afterSay():装饰者二的afterSay()方法

jsp中利用a标签跳转到另外一个jsp的方法：
<!DOCTYPE html>
<html>
 <head>
  <title> New Document </title>
<meta name="content-type" content="text/html; charset=UTF-8">
 </head>
 <body>
  <a href="<%=request.getRealPath("/")%>/b.jsp">跳转</a>
 </body>
</html>
这个b.jsp必须放在工程的指定目录才能跳转。