Java相关面试题

• =与==
• = 属于逻辑运算符，将右侧的值赋给左侧的变量名称
• ==数据关系运算符，判断左右两边的值是否相等，结果为boolean类型
• &与&&
• &是逻辑与，&&是短路与，都属于逻辑运算符，都表示并且执行结果都相同
• 当使用短路与，并且第一个条件为false时，则结果直接为false
• ｜与｜｜
• ｜时逻辑或，｜｜是短路或，都属于逻辑运算符，都表示或者，结果都相同
• 当使用短路或，并且第一个条件为true时，则结果直接为true

在java中，字符串比较时，使用==比较的是地址是否一致

如果在字符中比较内容，则必须使用equals()，如果相等则为true，否则为false

当字符串进行比较内容时，建议固定值编写在前面

• ==是判断两个变量或实例是不是指向同一个内存空间，equels是判断两个变量或实例所指向的内存空间的值是不是相同
• ==是指对内存地址进行比较，equals()是对字符串的内容进行比较
• ==指引用是否相同，equals()指的是值是否相同

多重if：可以做等职操作也可以做区间操作

switch case：只能做等值操作

• 使用场合不同
• break：可以在switch case中使用，也可以在循环中使用
• continue：只能在循环中使用
• 作用不同
• break：表示中断，当在switch case中或在循环中遇到break，结束当前整个switch case或循环，执行外面的语句

• continue：表示继续，当在循环中遇到continue，则结束本次循环进行下一次循环

• 面向对象：虚拟世界 模拟 现实生活，必须保证模拟一致

• 面向过程：面向过程是一种以事件为中心的编程思想，编程的时候把解决问题的步骤分析出来，然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。
• 类：对同一类事物的抽象描述，也就是不是具体的 例如：水杯类、电脑类
• 对象：万物皆对象，也就是具体的实例 例如：我的电脑、张三的水杯

• 类与对象的关系：抽象与具体的关系

• 声明位置不同

• 成员变量：在类中声明
• 局部变量：在方法中声明，其中形参也数据局部变量初始值不同：
• 成员变量：在没有赋值时，是有默认值的，数据类型不同则默认值不同
• 局部变量：没有默认值，必须先声明，再赋值，再使用
• 在同一个类中，成员变量名字可以与局部变量名字相同，但是局部变量名字优先，也就是就近优先，如果非要访问成员变量，必须加this。

• this代表当前这个对象，也就是说当前谁调用这个方法，这个对象就是谁

• 第一种方法：使用引用名称.使用名称=值 如：t.name = “欣欣”;

• 第二种方法：使用构造方法完成

• 作用：完成对象中的属性赋值

• 构造方法：
• 构造方法是一个特殊的方法，构造方法的名字必须与类名一致，构造方法必须没有返回类型，也就是不编写返回类型
• 语法格式： public 方法名称（【参数列表】）

多态语法格式： 父类类名 引用名称 = new 子类类名

注意：当是多态时，该引用名称只能访问父类中的属性和方法，但是优先访问子类重写以后的方法

多态：将多个对象调用同一个方法，得到不同的结果

满足多态的条件：（1）子类必须继承父类（2）子类重写父类的方法（3）父类类名 引用名称 = new 子类类名()

多态的好处：减少代码冗余

多态中的两种类型转换：（1）向上转型-也叫做自动类型转换，构成多态 父类类名 引用名称 = new 子类类名() （2）向下转型-当是多态时，并且访问子类独有的属性和方法时，则必须向下转型

（1）final是一个关键字，可以修饰类，修饰字段，修饰方法，修饰局部变量，修饰形参

（2）final修饰类表示最终类，不能被继承

（3）final修饰字段，必须显示初始化，不能再修改，一般final与static同时修饰某个字段所有字母都大写，称为final常量

（4）final修饰方法，不能被子类覆盖（重写），能被子类继承

（5）final修饰局部变量，一旦初始化就不能再修改，注意final修饰引用类型变量，引用类型变量不能再指向其他对象，可以修饰他的属性值

（6）final修饰方法参数，在方法体中不能修改final形参的值

（1）抽象类定义变量

（2）抽象类不能实例化对象

（3）抽象类的引用需要赋值子类对象

（4）抽象类的多态

（5）抽象类可以赋值匿名内部类对象

=============================

（1）为什么定义抽象类？

对事物进行进一步抽象可以形成抽象类，含有抽象方法的类必须定义为抽象类

（2）如何定义抽象类

使用abstract修饰

（3）为什么定义抽象方法

当一个类的某个操作无法具体实现时，这个操作可以定义为抽象方法

使用abstract修饰方法，只有方法的声明，没有方法体

（4）如何使用抽象类

抽象类一般作为一其他类的父类存在

子类继承了抽象类，子类需要重写抽象类中所有的抽象方法，如果子类没有重写所有的抽象方法，子类也需要定义为抽象类

注意：抽象类中不一定含有抽象方法

（5）抽象类不能实例化对象，需要赋值子类对象

（6）抽象类的引用可以赋值匿名内部类对象

（1）接口内容：接口中方法默认使用public abstract修饰，接口中还可以定义public static final常量，public static 方法，public default方法

（2）类实现了接口，需要重写接口的抽象方法，如果没有重写接口中所有的抽象方法，实现类需要定义为抽象类。

（3）接口是一种引用数据类型，可以定义变量，但接口不能实例化对象，接口引用需要赋值实现类对象，或者接口的匿名内部类对象

（4）接口多台：接口引用调用接口中抽象方法，实际上执行的是实现类对象的方法，接口存在就是为实现多态的

（5）一个类可以同时实现多个接口，需要重写所有接口的所有抽象方法

（6）接口也支持继承，并且接口支持多继承

相同点：

（1）都可以定义抽象方法

（2）都不能实例化对象

（3）定义的抽象方法都需要被重写

（4）都可以定义public static 方法，public static final常量

不同点：

1）意义不同

抽象类是对事物更高层级的抽象

接口是对功能的封装

2）定义方式不同

抽象类用abstract class定义

接口用interface定义

3）内容不容

抽象类中除了抽象方法外，还可以定义构造方法等普通类中定义的所有成员，

接口除了抽象方法等这四个内容外，不能定义构造方法等内容

4）使用方式不同

抽象类需要被子类extends继承

接口需要被实现类impelments实现

5）类只支持单继承，接口支持多继承

6）应用场景不同

一般情况下，对类就行功能的扩展，优先选择接口

除了扩展功能外，还需要保存不同的数据，只能选择抽象类；

抽象类的抽象方法需要子类重写，抽象类还可以约束所有的子类都具有相同的功能

1）使用接口用来封装功能（操作）

如在Flyable接口中封装了fly()飞行功能，在Swimmable接口中封装的swim()游泳功能

2）接口可以定义一组操作规范

如开发某个项目时，在相似模块中有一些操作是相同的，可以把这一组相同的操作封装在一个接口中，就相当于通过接口定义了一个操作规范

1）接口使用比较灵活，一个类在继承父类的同时，可以实现多个接口

2）接口比较容易扩展，接口因哟过可以赋值各种实现类对象，经常把接口引用作为方法形参，在调用方法时，可以传递各种实现类对象

3）接口可以使项目分层

（1）Exception：这就是我们所说的异常，是由程序引起的，是程序员可以处理的

Throwable：所有的异常都是可以抛出的

Error：这是JVM的错误，遇到Error只能退出程序

RuntimeException：RuntimeException类的所有子类都是运行时异常，这类异常不需要预处理，通过规范代码可以避免

ClassCastException：在转换前，先通过instanceof运算符判断堆中对象，是否为目标类型

NullPointException：在访问对象的实例程成员前，先判断对象是否为null

受检异常：也叫受控异常，程序员在编译时必须进行预处理，否则编译报错，又叫编译时异常。注意：所有的异常都是在进行时才会发生。

try{

对可能产生异常的代码进行检视

如果try代码块的某条语句产生了异常，就立即跳转到catch子句执行，try代码块后面的代码不再执行

}catch（异常类型1 e1）{

捕获一场类型1的处理，进行处理

在开发阶段，一般的处理方式要么获得异常信息，要么打印异常栈跟踪信息

e1.printStackTrace()

在部署后，如果有异常，一般把异常信息打印到日志文件中

catch（异常类型2 e1）{

捕获一场类型2的处理，进行处理

如果捕获的异常类型有继承关系，应该先捕获子异常再捕获父异常，如果没有继承关系，catch子句没有先后顺序

}finally{

不管是否产生了异常，finally子句总是会执行

一般情况下，会在finally子句中释放系统资源

在定义方法时，如果方法体中有受检异常需要预处理，可以捕获异常，也可以抛出处理。

谁调用这个方法，谁负责处理该异常，在定义方法时，把异常抛出就是为了提醒方法的使用者，有异常需要预处理

在处理异常时，是选择捕获处理还是抛出处理？？

1）一般情况下，在调用其他方法时，如果被调用的方法有受检异常需要预处理，选择捕获处理

2）在定义方法时，如果方法体中有受检异常需要预处理，可以选择捕获，也可以选择抛出处理。

如果方法体中通过throw语句抛出一个异常对象，所在的方法应该使用throws声明该异常

方法覆盖（重写）规则：

（1）方法签名必须相同，方法名与参数列表就是方法签名

（2）方法的返回值类型可以相同，子类方法的返回值类型可以时父类方法返回值类型的子类型

（3）子类方法的访问权限可以更宽泛（更大）

1）如果父类方法使用public修饰，子类方法只能是public修饰

2）如果父类方法使用protected修饰，子类方法可以时protected/public修饰

（4）子类方法的异常要比父类方法异常更小

1）如果父类方法没有抛出异常，子类重写后也不能抛出异常

2）如果父类方法抛出了异常，子类方法可以抛出相同的异常，也可以抛出父类异常的子异常，也可以不抛出异常

一、一维数组的定义与访问

保存一个数据可以定义一个变量，如果保存100个数据呢？？可以使用数组。数组用来保存同一类型若干数据的容器。
如何定义数组？
数据类型 [] 数组名 = new 数据类型[数组的长度]
说明：
（1）数据类型就是数组中存储元素的数据类型
（2）方括弧就是定义的是数组
（3）数组名其实就是一个变量名，保存数组的引用（数组的起始地址）
（4）new运算符会在队中分配一块连续的存储空间，把这块连续存储空间的引用（起始地址）保存到数组名中
（5）数组本质上就是堆中一块连续的存储空间
如：
int [] data = new int[5]
定义一个数组，这个数组可以存储5个int类型的数据，数组名是data，通过索引值访问数组的元素
如何访问数组？
通过索引值访问数组的元素
定义一个数组之后，系统为每个元素指定一个索引值，索引值从0开始的，即数组data的5个元素分别是：
data[0],data[1],data[2],data[3],data[4]

二、数组的遍历

for循环或者foreach循环

三、数组是一种引用数据类型

数组可以作为方法的返回值类型，也可以作为方法参数类型

四、可变长参数

定义一个方法，可以接收任意个数据，可以使用可变长参数
定义：
方法名(参数类型……参数名)
说明：
（1）一个方法最多有一个可变长参数
（2）可变长参数只能放到参数列表后面
（3）可变长参数当作数组使用即可

五、数组扩容

当定义了数组之后，数组的长度就确定了，即数组存储元素的个数就确定了，如果想要在数组中保存更多的数据，就需要对数组进行扩容。
数组扩容：
1）定义一个更大的数组
2）把原来数组的内容复制到新的数组中
3）让数组名指向新的数组

六、数组的特点

优点：数组可以通过索引值（下标）可以实现数组元素的随机访问缺点：向数组中添加元素/删除元素时，效率比较低应用场景：以查询为主，很少进行添加/删除时，选择数组存储这些数据

七、对象数组

数组中存储的是引用类型数组，就是对象数组

八、二维数组

二维数组的每个元素又是一个一维数组
存储一维数组的数组就是二维数组
（1）二维数组的定义
int [][] mydata = new int [5];

九、Arrays工具类

排序：sort
打印：Arrays.toString
扩容：Arrays.copyOf(data,data.length2)
填充：Arrays.fill
数组缩减：Arrays.copyOf(data,data.length/32)
二分查找，前提是数组由小到大排序：Arrays.binarySearch

一、与字符串相关的类

String类

StringBuilder类

二、包装类

三、日期类

四、数学类

Original: https://www.cnblogs.com/xinxin1994/p/14912056.html
Author: 李清欣
Title: Java相关面试题