JAVA基础相关面试题--03

流程控制：

• 顺序流程（main方法 、web容器加载的类开始执行）
• 分支流程：单分支流程–if语句、多选分支流程–which语句
• 循环流程：for 、 while 、 do-while、死循环

@for( ; ; ){ } 和 while( true ){ }这两个死循环哪个执行效率更高一些？（总结调查、经验）
for( ; ; ) 死循环里面的两个 ; ; 语句代表空语句，编译器一般会优化掉他们，直接进入循环体。
while ( true ) 死循环里的true 被看成表达式，每次循环一次都要判断表达式是否为真，相对来说 for循环更高效一点。
另一点，while循环中的表达式的循环变量 i 是需要在循环之外中定义的，他的作用域跟while作用域一样 （在main方法中），当while循环执行完成后，变量 i 所占内存不会被释放。
for循环中，变量 i 所占用的栈内存会随着for循环的结束而销毁。

@break 和 continue 关键字的区别？什么是位置标签？(break 和 continue 和位置标签搭配可以达到goto的效果，不推荐使用 )
break和continue都是循环的中断关键字。break 中断其所在的循环体。直接跳出循环、continue中断循环体中当前本次循环中的一次循环，直接跳入到下一次的循环。换句话说就是，continue值跳出了一次迭代，而break跳出了整个循环。
java中的goto是保留关键字，不推荐使用

方法（函数）
@ 形参和实参？
形参：方法定义时给定的参数列表。目的是用来接收调用函数时传递的参数。
形参变量只有在被调用时才分配内存单元，调用结束即刻释放锁分配的内存单元。
实参：方法调用时，主方法传递给子方法的参数。具有确定的值。
形参和实参的功能是做数据传送，发生函数调用时，主调函数把实参的值传送给被调函数的形参，从而实现主调函数向被调函数的数据传送。
函数调用时发生的数据传送是单向的。只能把实参的值传送给形参。
形参和实参要一一对应（个数、类型和顺序要对应）

@ void类型的返回方法是否可以使用return关键字？
函数用void声明代表不需要返回值，但是，有时候需要在函数内部强行终止函数继续运行下面的语句，即终止运行方法，这时就需要用到 return语句。格式：return ;

@java 中实参和形参的参数值的传递方式？ java传值的方式？java是如何传值的？
按值传参：八种基本类型+String类型 改变的是形参的值，不会影响实参。实参传递给形参是值的拷贝。
按引用（地址）传参：实参传递给形参的是实参的地址引用，形参值的改变会影响实参。除了八种基本类型和String类型之外的都是引用类型。
Java参数，不管是原始类型还是引用类型，传递的都是副本。
如果参数类型是原始类型，那么传递过来的就是这个参数的副本，改变副本的值不会改变原始的值。
如果参数类型是引用类型那么传过来的是这个引用参数的副本，副本存放的是参数的地址。
如果函数中没有改变副本的地址，而是通过地址改变改变了地址指向的值，那么函数内的改变会影响原始参数。
如果改变了副本的地址，如a=… 或 a = new … ，则代表将a指向新地址，原始数据不会改变。
java中指针的概念被替换掉了，取而代之的是在栈或堆空间里开辟空间存放值，然后把这个值指向栈中的某个对象，这个指向就是引用了。引用代替指针。

3. 方法的重载

@ 什么是方法的重载？重载的条件？什么是方法的重写？重写的条件？二者的异同？
重载：在同一个类中，具有多个同名的方法，但是要求形参不同。例如：类的构造函数
重载的条件：参数的个数不同，参数的类型不同，参数的顺序不同（不能是同一类型）
重载调用：通过实参列表决定调用哪个重载的方法

重写：子类的方法覆盖父类的方法，要求返回值、方法名、参数都相同，但是子类抛出的异常不能超出父类抛出的异常。子类访问级别不能低于父类的访问级别。
重写的条件：必须要有继承关系。函数名、参数列表、都必须相同。函数的访问权限必须大于等于父类的函数的访问权限。
相同：重写和重载都要求方法同名。都可以用于抽象方法和非抽象方法之间。
不同：
重写必须继承、重载不需要继承。
重写的方法名、参数数目、参数类型需要全部相同，重载只需要方法名相同
重写的方法修饰符大于等于父类的方法，重载和修饰符无关
父类的一个方法只能被子类重写一次，却可以重载多次。

访问权限： private <= default <= protected <= public
public : 任何类都可以访问
protected：在同一个包中的所有的类可以访问，以及该类的子类
default：同一个包中的所有类。
private：只能在本类中访问。
函数的访问权限必须大于等于父类的函数的访问权限？
重写的权限比父类低的话会导致父类不能正常运行，父类实例化后，不能调用子类的方法。向上转型的原因。

向上转型：子类对象转为父类对象。 Father f = new Son() ;
向下转型：父类对象转为子类对象。（不安全） Son s = ( Son ) f
需要使用instanceof关键字判断是否可以使用。
向上转型时，子类单独定义的方法会丢失，即父类不能调用子类单独写的方法。
子类引用不能指向父类对象。 Son s = (Son) new Father(); 错误
向上转型可以减少重复的代码，使代码变得简洁，提高了系统扩展性。
向下转型的前提是父类对象指向的是子类对象。
向下转型只能转型为本类的对象。
Animal a = new Cat(); Cat c = ( (Cat) a); c.eat();
Dog d = ( (Cat) a); d.eat(); 报错
instanceof关键字用于判断前面的对象是否是后面的类、子类、实现类的实例。做判断时，操作符的左右操作数必须有继承和实现关系。

@什么是变长参数（jdk1.5版本时候增加）？变长参数和重载的关系？
变长参数：只能是形参列表的最后一个，且一个方法至多只能使用一个变长参数。数据类型后面加 ’ … ‘为变长参数。可以把变长参数当成数组使用。
变长参数本质就是一个数组，但是二者又有细微的差别。变长参数在传递时可以传递0个1个或多个。
变长参数可以构成重载。重载时优先调用不使用变长参数的方法。（优先级比较低）

数组
连续存储、不能变长，从下标0开始
@什么是不规则二维数组？
非矩阵行的二维数组，每行所定义的列的个数可以不同

String类
以\0结束 底层也是一个字符数组
字符串特性：固定长度，默认值为null 参考jdk的API
Stringbuilder是变长的默认长度16个字节，可以频繁的进行字符串的链接，存放在堆中。
StringBuffer 属于线程安全类。
java中数组的声明方式

@ String 类在内存中的存储方式？
java把内存分为两种，一种是栈内存，一种是堆内存。
在函数中定义的基本类型变量和对象的引用变量都是在函数的栈内存中分配；
堆内存用来存放由new 创建的对象和数组以及对象的实例变量。
String是一个特殊的包装类，可以通过两种方式创建，String s = new String(“abc”); Stirng s = “abc”;

@String str1 = new Sring( ’ 小明 ’ ) ; 该行diamante执行之后在内存中创建了几个对象？
单独执行此行，在内存中有两个。现在常量池中创建一个“小明”，再在堆内存中new一个。
字符串的内存存储模型
变量引用：变量名（地址名）-- 会放在栈中
内存空间：
字符串常量池 — 存放在栈中 会过滤重复的 字符串常量都放在字符串常量池中。
堆 — 每次进行内存分配，其内容可以重复，new ， + 运算产生的字符串都是放在堆中

字符串常量都是放在字符串常量池中的，所以str00,str01的“小明”都存放在字符串常量池中。因为字符串常量池过滤重复的。str00,str01都指向常量池中的小明。str10中的“小明”仍然在字符串常量池中。new 出来的“小明”要存放在堆中，将常量池中的字符串复制到对内存中。常量池的变量要str10直接指向了堆中的“小明”。str11同str10，但是堆中允许重复，所以新new出一个“小明”。所以str10与str11地址不同。

@ == 和 equal 的区别？object中有equals方法吗？
== 判断地址是否相同，也就是在内存中是否存在同一个存储空间
==是比较的两个变量的引用。如果两个变量的引用相同的haul返回true，否则返回false。equals比较的是两个变量的内容是否相同。
在object中 == 和equals是一样的作用

面向对象是一种思想，是一种方法论。是高级编程语言的一个特性。
核心特性：抽象、封装、继承、多态
四大关键字： static 、 final、abstract、interface
编程过程：
1. 创建一个类
2.编写属性
3.编写行为方法 （封装）
4.new 一个实例对象
5.调用行为方法

面向对象：找谁去做 ，谁就是对象，对象由类进行规范定义。 抽象了属性和行为。
抽象：把一类的共性抽取出来，从个体到整体抽象共性。
行为–成员方法 属性–成员变量
局部变量和成员变量的区别。同名的局部变量覆盖同名的成员变量，范围最小优先：就近原则。
封装：将抽象的结果属性和行为以成员变量和成员方法的形式封装类中。
使用访问控制修饰符实现访问范围的限定。
封装原则：属性使用public 、行为使用private、属性提供getter、setter方法，适当提供构造方法。
构造方法可以重载，在继承中的父子类之间的调用关系：先执行父类，后执行子类构造方法。
继承：子类继承父类可以继承的属性和行为
多态：子类行为和父类行为不一样。父类指代子类：向上塑型和向下溯型（只有指向子类实例对象的父类才能向下溯型。）多态体现在：重写：子类方法覆盖了父类方法

【细节很多】
@ 面向对象的核心思想？你如何理解面向对象？什么是面向对象的编程？什么是抽象？什么是封装？什么是继承？什么是多态？
抽象、封装、继承、多态
面向对象：是一种对现实世界理解和抽象的方法。
面向过程：是一种以过程为中心的编程思想。
面向对象的编程方式使得每一个类只做一件事，面向过程会让一个类越来越全能，做所有的事情。
抽象：把一类的共性抽取出来，从个体到整体抽象共性。
封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者操作，对不可信的信息进行隐藏。
继承：可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展。通过扩展的类成为子类或派生类，被继承的成为基类、父类或超类。
多态：子类行为和父类行为不一样。实现多态有两种方式：重写和重载。重写是在运行时决定的，重载是在编译时局决定的。

@抽象封装的软件工程的原则：高内聚低耦合
耦合性：块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块间联系越紧密耦合性就越强，模块的独立性就越差。模块间的耦合性高低取决于模块间接口的复杂性、调用的方式以及传递的信息。
耦合性（低–>高）：无直接耦合、数据耦合、标记耦合、控制耦合、公共耦合、内容耦合。
数据耦合：两个模块之间具有调用关系，传递的是简单的数据值
标记耦合：两个模块之间传递的是数据结构的地址
控制耦合：两个模块之间传递的是控制变量，通过控制变量选择执行某一功能
公共耦合：公共数据环境相互作用的那些模块间的耦合。随着耦合模块的增加而增加。
内容耦合：一个模块直接使用另一个模块的内部数据，或直接转入另一模块的内部。
内聚性：块内联系。值模块的功能强度的度量。即一个模块内部各个元素彼此结合的紧密程度的度量。若联系越紧密，则内聚性越高。
内聚性（低–>高）：偶然内聚、逻辑内聚、时间内聚、通信内聚、顺序内聚、功能内聚。
偶然内聚：模块内元素之间没有任何联系。
逻辑内聚：模块内执行几个逻辑上相似的功能。
时间内聚：同时执行的动作组合在一起形成的模块
通信内聚：模块内所有处理元素都在一个数据结构上操作，或是使用相同的输入数据或产生相同的输出数据。
顺序内聚：模块内完成同一功能必须顺序执行，前一个功能的输出数据是下一个功能的输入数据。
功能内聚：模块内所有元素共同完成同一个功能，缺一不可。

@局部变量和成员变量的区别？
局部变量覆盖成员变量，依据范围最小优先，就近原则
在类中的位置不同：成员变量在类的方法外面，局部变量在方法或代码块中
在内存中的位置不同：
生命周期不同：成员变量随着对象的创建而存在，随着对象的消失而消失，局部变量在方法调用完成或代码块执行而存在，执行完毕而消失。
初始值：成员变量有默认初始值，局部变量没有默认初试值，使用之前需要赋值。

@构造方法的执行流程？父类和子类构造方法的关系？
内部静态对象的构造方法：按顺序执行
父类的构造方法：从最开始的基类开始调用
按声明顺序将成员引用对象变量初始化
调用子类的构造方法

java继承中，子类是不会继承父类的构造函数，只是必须调用（隐式或显式），因为子类是基于父类产生的。子类不能继承父类的显示定义的构造方法，若想要继承父类的构造方法，需要通过覆盖该构造方法，并在方法中通过super调用父类的该构造方法的方式来继承。

1. 父类中没有显式定义任何构造方法，此时父类中实际有一个默认的无参构造方法。这时，在子类中显式定义任何构造方法时，可以不用使用super调用父类的默认方法。
2. 父类中显式定义了默认的无参构造方法，那么子类可以定义任意的构造方法，而不必使用super调用父类的构造方法。
3. 父类中显式定义了构造方法，却没有显式定义默认的无参数构造方法，那么子类定义任何构造方法中都需要通过super调用父类的构造方法。

@什么是继承？java的继承是单继承？java能不能实现多继承？
继承：可以使用现有类的所有功能，并在无需重新编写原来类的情况下对这些功能进行扩展。实现代码复用。通过扩展的类成为子类或派生类，被继承的成为基类、父类或超类。
java中只支持类的单继承，也就是一个类有且只有一个父类。接口直接的继承同样也是使用extends关键字，但是接口之间是支持多继承的。
java中可以实现接口来实现类似多继承的效果。

@什么是多态？多态体现在那些方面？什么是重写？什么是溯型？
是父子类之间的行为关系。父类指代子类（向上溯型、向下溯型） 子类的行为覆盖父类同名行为。实现多态有两种方式：重写和重载。重写是在运行时决定的，重载是在编译时就决定的。
（多态体现在：一是：父类指代子类（溯型），二是重写（子类的行为覆盖父类同名行为））
重写：方法名字一样，参数列表一样。一般发生在继承实现中。子类的行为覆盖父类同名行为
溯型：分为上溯造型和下塑造性
上溯造型：将基类至于顶部，向下发展就是派生类。上溯造型是安全的类型转换
下塑造性：不安全，使用instanceof来判断对象的类型。

@构成重写的条件？
方法名相同、参数相同、返回值类型相同。
访问控制修饰符的范围：子类>=父类。抛出异常的范围：子类<=父类
接口是父类。接口是抽象的，必须有子类，所以其一定是父类。

@this 和 super 关键字的区别？
this 指代当前类的实例对象，用于区分同名的局部变量和成员变量
构造方法之间可以通过this相互调用。而且必须写在第一行。
super指代当前类的父类实例对象，可以调用被子类重写的父类的方法。
super可以调用父类构造方法，但是需要写在第一行。

四大关键字
static：可以修饰的对象：方法、属性、语句块。
静态方法只能调用静态的属性和方法。静态方法中不能使用this关键字。非静态的方法可以调用所有的。静态语句块在类加载时值执行一次，一般用于初始化。
final：可以修饰的对象：类、变量、方法
类是终结类，不能被继承。方法属于终结方法，不能被重写。修饰的常量，一旦初始化赋值后，不能再修改。
按值传参的类型，不能修改值。常量一旦初始化被赋值之后不允许修改。
按引用传参的类型，不能修改地址引用，可以修改内容。
搭配static关键字构成静态常量 接口里面的常量都是静态常量
abstract：可以修饰的对象：类、方法
抽象类不能被new创建实例对象–因为含有抽象部分，无法直接分配地址空间大小。
抽象方法中没有方法体，子类需要通过重写来实现父类抽象方法的方法体。
含有抽象方法的类一定是抽象类，抽象类不一定含有抽象方法。
interface：接口是一组抽象行为的集合体

接口的多继承主要体现在两个方面：
一、类和接口的多继承 可以使用 类 implements 接口，…
二、接口与接口之间的多继承，可以使用 接口 extends 接口，…
接口中的变量都是公共静态常量，其中public、static、final可以部分省略或全部省略
接口中的方法都是公共抽象方法，其中public、abstract可以部分或全部省略。

@接口和抽象类的异同点？是否了解Default关键字？
接口中的变量都是静态常量 接口中的方法没有方法体。接口中加入Default关键字可以写方法体。
接口是一种行为
接口：
因为java不支持多继承，所以才有了接口，一个类只能继承一个父类，但可以实现多个接口，接口本身也可以继承多个接口
接口里面的成员变量默认都是 public static final 类型的，必须被显示的初始化。
接口里的方法都是 public abstract 类型的，隐式声明。
接口没有构造方法，不能被实例化。
接口不能实现另一个接口，但可以继承多个接口
类如果实现了一个接口，那么必须实现接口里面的所有抽象方法，否则类要被定义为抽象类。

抽象类：
如果将一个类声明为abstract，此类不能生成对象，只能被继承使用
抽象方法必须存在于抽象类中。
抽象类中可以有一般的变量和一般的方法。
子类继承抽象类必须实现其中抽象方法，除非子类为抽象类
private void print( ) { }; 此语句表示方法的空实现
abstract void print ( ) ; 此语句表示方法的抽象，无实现
区别：
接口只能包含抽象方法，抽象类可以包含普通方法。
接口只能定义静态常量属性，抽象类既可以定义普通属型，也可以定义静态常量属性。
接口不包含构造方法，抽象类里可以包含构造方法。
接口可以实现多继承，抽象类不可以。

Default关键字是java8中的一种新添加的 接口里面都是抽象方法，
1. 在switch语句中使用default。如果case里的值与switch里面的key没有匹配就执行default。
2. 在定义接口的时候使用default来修饰具体的方法。JDK8 中为了加强接口的能力，使得接口可以存在具体的方法，前提是方法需要被default 或 static 关键字所修饰。这样做的好处是接口的每个实现类如果都像想要实现相同的功能，就不需要写重复代码，而是在接口进行定义即可。默认方法在子类也可以被重写。
3. default 作为访问限制符。在成员函数定义时，访问限制符的函数，其访问等级为default。

位置	private	default	protected	public
同一个类	是	是	是	是
同一个包内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包并且不是子类	否	否	否	是

@匿名内部类？事件处理？委托？
可以使用new的方法调用接口或抽象类的行为方法，可以new，但是将实现和new创建合二为一。使用原则，当只关于行为动作的结果，而不关于行为动作的发出者时，使用匿名内部类进行抽象方法调用。
不需要给内部类命名，没有名字。使用构造函数来匿名。要注意的是，new 匿名类，这个类是需要先定义的。当所在的方法的形参需要被内部类里面使用时，该形参必须为final。因为内部类并不是直接调用方法传进来的参数，而是内部列将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。内部类中参数被修改，原值却没有改变，所以定义final来规避这种错误的存在。拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变。
事件处理机制深入理解：
编写事件处理类（事件监听者）
根据需求给事件处理类实现监听接口
在事件处理类中重写（实现）其事件处理函数
在事件源类中指定该事件的监听器（响应者）是谁，即注册监听。
java事件处理的三种方式：
使用接口
定义一个类，使用接口。
使用匿名内部类
java中采用委托机制处理事件，java中的事件是分类的（例如：鼠标时间、窗体事件、键盘事件等）。
java中一个类要监听某个事件，则必须实现相应的事件监听接口，在实现监听接口类中，要重写处理函数。事件源中需要注册事件监听类，否则事件监听类接受不到事件源发生的事件。

@异常的分类？异常跟错误的区别？
异常就是非正常执行的程序。
根据编译时是否对异常进行检查可分为：检查性异常（非运行、编译时异常）、非检查性异常（运行时异常）。检查性异常是在编译期间就会出现的异常，需要显示的异常处理机制。非检查性异常是在程序运行时才会出现的异常。不需要显式处理，可以通过编程的思维严密性避免。
所有的异常都有一个共同的祖先Throwable（可抛出）。Throwable有两个重要的子类：Exception（异常）和 Error（错误）。
异常是程序本身可以处理的异常，应用程序中可预测、可恢复问题。
错误是程序无法处理的错误，表示运行应用程序中比较严重的问题。大多错误与代码编写者执行的操作无关，是代码运行时JVM出现的问题。
异常能被程序本身可以处理，错误是无法处理的。

@异常的处理机制?finally语句块的特点？
异常的处理机制：try-catch-finally、throws。
try-catch-finally：多个catch分支范围从小到大，finally总会被执行，无论是否发生异常。使用或连接多个异常类型时，彼此之间不能有包含关系。
throws：谁调用谁负责处理异常，如果一直向上抛异常，则最终由jvm进行异常处理。
throw：人为抛出一个异常。
自定义异常：通过继承Exception及其子类实现。可以使用多态进行扩展。
finally语句块的特点：
被finally控制的与具体一定会执行。特殊情况是在执行到finally之前jvm退出了（System.exit(0) ; ）。所以通常在程序中为了保证哞资源一定会被释放，一般在finally语句块中释放资源。

@final、finally、finalize()的异同
final：用来修饰类、方法和变量。修饰类时，这个类不能被继承，此类中的所有成员方法都被隐式的定义为final。修饰方法不能被重写，类的private方法会隐式的指定为final方法。修饰变量，是引用不变，但是引用的对象其内容可变，只能赋值一次。被final修饰的变量必须被初始化。
finally：是try语句的一个与具体，不能单独使用，用来释放资源。提供finally块来执行任何清除操作。
finalize：finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。finalize()方法是在垃圾收集器喊出对下那个之前对这个对象调用的，finalize不一定被jvm调用，只有当垃圾回收器要清除垃圾时才被调用。

@什么是包装类？什么是装箱？什么是拆箱？

装箱：基本类型转变为包装器类型的过程 Integer i = 10 ;
拆箱：包装器类型转变为基本类型的过程 int n = i ;

@为什么要有包装类？包装类存在的价值？java中那些地方必须使用包装类？
java包装类将基本数据类型的值包装到对象中，对基本数据类型的操作变为了对对象进行操作，从而使基本值能够包含在为对象保留的操作中。更加方便类型的转换，如常见的integer向字符串的转换。八种基本类型不符合OO原则（面向对象编程的原则）
使用：Synchronize(此处必须是包装类) { }、泛型、集合中存储的是包装类、

Integer类的valueOf方法取值范围在 [-128 , 127] 。即在这个范围内取值相同的数表示同一地址，
Double 类的valueOf方法会采用与Integer类的valueOf方法不同的实现。在整个范围内的整型数值的隔阂是有限的，而浮点数不是。、

工具类：
包装类：八种基本类型纳入OO体系。包装类主要针对八种基本类型。八种基本类型的包装类，对象性包装类、数值型包装类
object类：根类、祖宗类。HashCode，toString，equals
Sting类：String类是对象类型，但是方法调用时按值传参。

@finally和return的用法（编程题）【有坑】？
Finally语句在执行return语句执行之后，return返回之前执行
finally语句块中return语句会覆盖try语句块中的return
如果finally语句块中没有return语句覆盖返回值，那么原来的返回值可能因为finally里的修改可能发生改变，也可能不发生改变。
Try语句块里的return语句在异常的情况下不会被执行，而最终的返回结果看具体情况。