一、Java基础部分

1、面向对象的特征有哪些方面?

a.抽象：

抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

b.继承：

继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

c.封装：

封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

d. 多态性：

多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

2、访问修饰符public,private,protected,以及不写（默认）时的区别？

区别如下：

作用域    当前类  同包 子类 其他

public        √        √       √      √

protected  √        √       √      ×

default       √       √       ×      ×

private       √        ×      ×      ×

类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开（public），对于不是同一个包中的其他类相当于私有（private）。受保护（protected）对子类相当于公开，对不是同一包中的没有父子关系的类相当于私有。

3、String 是最基本的数据类型吗?

不是。Java中的基本数据类型只有8个：byte、short、int、long、float、double、char、boolean；除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）。

4、float f=3.4;是否正确?

不正确。3.4是双精度数，将双精度型（double）赋值给浮点型（float）属于下转型（down-casting，也称为窄化）会造成精度损失，因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。

5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗?

对于short s1 = 1; s1 = s1 + 1;由于1是int类型，因此s1+1运算结果也是int 型，需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译，因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

6、Java 有没有goto?

goto 是Java中的保留字，在目前版本的Java中没有使用。（根据James Gosling（Java之父）编写的《TheJavaProgramming Language》一书的附录中给出了一个Java关键字列表，其中有goto和const，但是这两个是目前无法使用的关键字，因此有些地方将其称之为保留字，其实保留字这个词应该有更广泛的意义，因为熟悉C语言的程序员都知道，在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字）

7、int 和Integer 有什么区别?

引用类型和原始类型（或内置类型）。int 是 java 的原始数据类型，Integer 是 java 为 int 提供的封装类。Java 为每个原始类型提供了封装类。

Java 为每个原始类型提供了包装类型：

原始类型: boolean，char，byte，short，int，long，float，double

包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

区别：

1、Integer是int提供的封装类，而int是Java的基本数据类型；

2、Integer默认值是null，而int默认值是0；

3、声明为Integer的变量需要实例化，而声明为int的变量不需要实例化；

4、Integer是对象，用一个引用指向这个对象，而int是基本类型，直接存储数值

8、&和&&的区别？

简要说明

按位与：a&b是把a和b都转换成二进制数然后再进行与的运算；

逻辑与：a&&b就是当且仅当两个操作数均为true时，其结果才为true；只要有一个为零，a&&b就为零。

例如：

a&b9&8

1001

1000

结果是1000

a&&b9&&8结果是1

&对每一个都判断；

&&只要前面是false就输出false，而不继续判断后面了

详细解释

有关&和&&的详细解释如下：

&，双目运算符：将两个表达式的值按二进制位展开，对应的位(bit)按值进行“与”运算，结果保留在该位上…比如170&204对应二进制就是

10101010B

&11001100B

=10001000B…

170&204=136…该位只要有一个值为0结果为0，否则结果为1。

如果两数位数不同，则较短数高位补零，再运算，比如char a=100;int b=260;

a&b实际是0000 0000 0110 0100&0000 0001 0000 0100.其结果为int型0000 0000 000 0100即4…

&&:双目运算符，计算两个表达式同时成立的“真值”（同时成立真值为真否则为假）

逻辑真值有两种，1为真，0为假，但在运算时用非零表示真，0表示假…即：数值->逻辑真值－－非0为真，0为假/逻辑真值->数值－－真为1，假为0…例如：char a=1,b=0,c=-1;那么a真b假c真。a&&b和c&&b为假值为0，a&&c为真值为1

9、解释内存中的栈（stack）、堆(heap)和静态存储区的用法

Java的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)

堆区:

1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)

2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身.

3.一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

栈区:

1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中

2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。

3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。

4.由编译器自动分配释放 ，存放函数的参数值，局部变量的值等．

静态区/方法区:

1.方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。

2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

3.全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；而通过new关键字和构造器创建的对象放在堆空间；程序中的字面量（literal）如直接书写的100、“hello”和常量都是放在静态存储区中。栈空间操作最快但是也很小，通常大量的对象都是放在堆空间，整个内存包括硬盘上的虚拟内存都可以被当成堆空间来使用。

String str = new String(“hello”);

上面的语句中str放在栈上，用new创建出来的字符串对象放在堆上，而“hello”这个字面量放在静态存储区。

注：较新版本的Java中使用了一项叫“逃逸分析“的技术，可以将一些局部对象放在栈上以提升对象的操作性能。

10、Math.round(11.5) 等于多少? Math.round(-11.5)等于多少?

Math.round(11.5)的返回值是12，Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

11、swtich 是否能作用在byte 上，是否能作用在long 上，是否能作用在String上?

早期的JDK中，switch（expr）中，expr可以是byte、short、char、int。从1.5版开始，Java中引入了枚举类型（enum），expr也可以是枚举，从JDK 1.7版开始，还可以是字符串（String）。长整型（long）是不可以的。

12、用最有效率的方法计算2乘以8?

2 << 3（左移3位相当于乘以2的3次方，右移3位相当于除以2的3次方）。

因为将一个数左移n 位，就相当于乘以了2 的n 次方，那么，一个数乘以8 只要将其左移3 位

即可，而位运算cpu 直接支持的，效率最高，所以，2 乘以8 等於几的最效率的方法是2 << 3。

13、数组有没有length()方法?String 有没有length()方法？

数组没有length()这个方法，有length的属性。String有有length()这个方法。

int a[];

a.length;//返回a的长度

String s;

s.length();//返回s的长度

14、在Java 中，如何跳出当前的多重嵌套循环？

标号方式

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号break语句，即可跳出外层循环。

ok:

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

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

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

if(j ==5)breakok;

}

}

break跳出当前循环，通过内部跳出条件控制跳出外部循环

for(int i=0;i<4;i++){ for(int j=0;j<5;j++){ System.out.println("i="+i+"; j="+j); if(j==3) { i=4;                break;            }        } }

抛出异常也可以跳出多重循环

try{for(inti =0; i <4; i++) {for(intj =0; j <5; j++) {

System.out.println("i="+ i +"; j="+ j);if(j ==3) {thrownewException();

}

}

}

}catch(Exception e) {

System.out.println("e");

}

通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制

15、构造器（constructor）是否可被重写（override）?

构造器是干什么用的？（what）

构造器是用来生成一个类的实例是用来初始化这个实例用的

构造器如何工作？（how）

Java在构造实例时的顺序是这样的：

1、分配对象空间，并将对象中成员初始化为0或者空，java不允许用户操纵一个不定值的对象。

2、执行属性值的显式初始化

3、执行构造器

4、将变量关联到堆中的对象上

而执行构造器的步骤有可以分为以下几步：

1、Bind构造器的参数

2、如果显式的调用了this，那就递归调用this构造器然后跳到步骤5

3、递归调用显式或者隐式的父类构造器，除了Object以外，因为它没有父类

4、执行显式的实例变量初始化（也就是上边的流程中的第二步，调用返回以后执行，

这个步骤相当于在父构造器执行后隐含执行的，看样子像一个特殊处理）

构造器不可被orerride（why）

其实只需要记住：构造器不是方法，那么用来修饰方法特性的所有修饰符都不能用来修饰构造器（并不等与构造器具备这些特性，虽然不能用static修饰构造器，但它却有静态特性）构造器只能用public private protected这三个权限修饰符，且不能有返回语句。

16、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对？

不对，

如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。

Java对于eqauls方法和hashCode方法是这样规定的：

(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；

(2)如果两个对象的hashCode相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在Set集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。

注：首先equals方法必须满足自反性（x.equals(x)必须返回true）、对称性（x.equals(y)返回true时，y.equals(x)也必须返回true）、传递性（x.equals(y)和y.equals(z)都返回true时，x.equals(z)也必须返回true）和一致性（当x和y引用的对象信息没有被修改时，多次调用x.equals(y)应该得到同样的返回值），而且对于任何非null值的引用x，x.equals(null)必须返回false。

实现高质量的equals方法的诀窍包括：

1. 使用==操作符检查“参数是否为这个对象的引用”；

2. 使用instanceof操作符检查“参数是否为正确的类型”；

3. 对于类中的关键属性，检查参数传入对象的属性是否与之相匹配；

4. 编写完equals方法后，问自己它是否满足对称性、传递性、一致性；

5. 重写equals时总是要重写hashCode；

6. 不要将equals方法参数中的Object对象替换为其他的类型，在重写时不要忘掉@Override注解。

17、是否可以继承String 类?

String 类是final类，不可以被继承。

注：继承String本身就是一个错误的行为，对String类型最好的重用方式是关联（HAS-A）而不是继承（IS-A）。

18、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变，但对象的引用是永远不会改变的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。

19、String 和StringBuilder、StringBuffer 的区别?

记住三者的特征：

String 字符串常量

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

定义

查看 API 会发现，String、StringBuffer、StringBuilder 都实现了 CharSequence 接口，内部都是用一个char数组实现，虽然它们都与字符串相关，但是其处理机制不同。

String：是不可改变的量，也就是创建后就不能在修改了。

StringBuffer：是一个可变字符串序列，它与 String 一样，在内存中保存的都是一个有序的字符串序列（char 类型的数组），不同点是 StringBuffer 对象的值都是可变的。

StringBuilder：与 StringBuffer 类基本相同，都是可变字符换字符串序列，不同点是 StringBuffer 是线程安全的，StringBuilder 是线程不安全的。

使用场景

使用 String 类的场景：在字符串不经常变化的场景中可以使用 String 类，例如常量的声明、少量的变量运算。

使用 StringBuffer 类的场景：在频繁进行字符串运算（如拼接、替换、删除等），并且运行在多线程环境中，则可以考虑使用 StringBuffer，例如 XML 解析、HTTP 参数解析和封装。

使用 StringBuilder 类的场景：在频繁进行字符串运算（如拼接、替换、和删除等），并且运行在单线程的环境中，则可以考虑使用 StringBuilder，如 SQL 语句的拼装、JSON 封装等。

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

对于三者使用的总结：

 1.如果要操作少量的数据用 = String  　　　　　　　　　　             

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

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

20、重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分?

重载和重写都是多态性的体现，区别是重载是编译时的多态性，重写是运行时的多态性；

重载：只发生在一个类中，通过同名方法名不同参数类型或者参数个数来区分

重写：发生在父类和子类之间，重写要求子类的重写方法必须和父类被重写方法有相同的返回类型，比父类的方法更好访问，不能比父类被重写的方法声明更多的异常，而重载没有返回类型的特殊要求

重载的方法能否根据返回类型进行区分？

不可以，

如果用返回类型区分 如果同一个类中public void test1(){}和public String test1(){return "";}(编译不通过)假如编译通过，当提出方法时 类.test1 无法识别调用的是哪个方法