1.&和&&

              if(str != null& !str.equals("")){

                     System.out.println("ok");

              }//抛空指针异常

              if(str != null&& !str.equals("")){

                     System.out.println("ok");

              }//正常编译

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f 来与一个整数进行&运算，来获取该整数的最低4个 bit位，例如，0x31& 0x0f 的结果为0x01。

2.标记

              ok:

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

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

                            System.out.println("i="+ i + ",j=" + j);

                            if (j ==5) {

                                   System.out.println("j==5");

                                   break ok;

                            }

                     }

              }

3. 在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich 语句中。

4.

              short s1 = 1;

              //s1 = s1 + 1;//Type mismatch: cannot convert from int toshort

              //s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型 s1时，编译器将报告需要强制转换类型的错误。

              short s2 = 1;

              s2 += 1;

              //  +=是java 语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

5.char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

              char a = ‘你‘;

              System.out.println(a);

6.//用最有效率的方法算出 2乘以 8 等于几

              System.out.println(2 << 3);

将一个数左移n 位，就相当于乘以了2的n 次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。

7.设计一个一百亿的计算器

               int a = Integer.MAX_VALUE;

               int b = Integer.MAX_VALUE;

               int sum = a + b;

               System.out.println("a="+a+",b="+b+",sum="+sum);

               //a=2147483647,b=2147483647,sum=-2 越界

               BigInteger b1 = new BigInteger("2147483647");

               BigInteger b2 = new BigInteger("2147483647");

               System.out.println(b1.add(b2));

          //4294967294

8. 使用final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的

                final StringBuffer a=new StringBuffer("immutable");

                System.out.println(a);//immutable

//              a=newStringBuffer(""); //编译出错

                a.append(" broken!");  

                System.out.println(a);//immutablebroken!

9. "=="和 equals 方法的区别

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

              Stringa = "hello";

              Stringb = "hello";

              System.out.println(a == b);//true

              System.out.println(a.equals(b));//true  池···

              Stringc = new String("world");

              Stringd = new String("world");

              System.out.println(c == d);//false

              System.out.println(c.equals(d));//true

              Stringe = a + c;

              Stringf = "helloworld";

              System.out.println(e == f);//false

              System.out.println(e.equals(f));//true

10. 静态变量和实例变量

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

11.是否可以从一个static 方法内部发出对非 static方法的调用

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而 static 方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个 static方法内部发出对非 static方法的调用.

12.Integer 与 int的区别

int是java提供的8种原始数据类型之一。 Java为每个原始类型提供了封装类， Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即 Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el 表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

在Hibernate中，如果将OID 定义为Integer类型，那么Hibernate就可以根据其值是否为null 而判断一个对象是否是临时的，如果将OID 定义为了int类型，还需要在hbm映射文件中设置其unsaved-value 属性为0。另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

13.Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

Math 类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil 的英文意义是天花板，该方法就表示向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，Math.ceil(11.6)的结果为11,Math.ceil(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11.

14.public，private，protected作用域

如果在修饰的元素上面没有写任何访问修饰符，则表示 friendly。

15.Overload 和 Override 的区别

重载 Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写 Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

16.构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

17.接口可以继承接口。抽象类可以实现(implements)接口，抽象类可以继承具体类。抽象类中可以有静态的main 方法。抽象类与普通类的唯一区别：抽象类不能创建实例对象和允许有abstract方法。

18.写 clone()方法时，通常都有一行代码，super.clone();

clone 有缺省行为。首先要把父类中的成员复制到位，然后才是复制自己的成员。

19.面向对象的特征

封装:实现软件部件的“高内聚、低耦合”，防止程序相互依赖而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和兴味的代码封装在一个“class”中，属性用变量定义，行为用方法定义，方法可以直接访问同一个对象的属性。

继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

多态：多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。

20.Java中实现多态的机制

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

21.abstract class和 interface 的区别

含有 abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class， abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为publicabstract类型，接口中的成员变量类型默认为publicstatic final。 

抽象类和接口的语法区别

①   象类可以有构造方法，接口不能有构造方法。

②   抽象类中可以有普通成员变量，接口中没有普通成员变量。

③   抽象类中可以有非抽象的普通方法，接口中所有的方法必须的抽象的，不能有非抽象的普通方法。

④   抽象类中的抽象方法的访问类型可以是public、protected和默认类型（eclipse不报错，但应该也不行），但接口中的抽象方法只能是public的，并且默认即为public abstract类型。

⑤   抽象类中可以包含静态方法，接口中不可以包含静态方法。

⑥   抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但节后中定义的变量只能是public static final类型，并且默认即为此类型。

⑦   一个类可以实现多个接口，但只能继承一个类。

抽象类和接口的应用区别

       接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用。父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。