javaSE面试题

jdk和jre有什么区别

jdk是java开发工具包
jre是java运行时环境
dk包含jre

&和&&有什么区别

 & 按位与
    -	a&b 是把a和b都转换成二进制数然后再进行与的运算
    -	不管前面的条件是否正确，后面都执行
 &&	逻辑与
 	-	a&&b 就是当两个操作数均为true时，其结果才为true;（短路功能）
 	-	当前面条件正确时，才执行后面，不正确时，就不执行，效率高

重载和重写有什么区别

重载

	1. 方法名相同，参数类型、个数、顺序至少有一个不同，与形参变量名和返回值类型无关，但建议返回值类型最好相同。
	2. 不能重载只有返回值不同的方法名
	3. 存在于父类、子类和同类中

重写

	1. 方法名、参数类型、返回值相同
	2. 子类方法的访问权限不能变小，可以相同或者变大
	3. 子类方法不能抛出比父类方法更大的异常（但子类方法可以不抛出异常）
	4. 被 final 修饰的方法不能被重写
	5. 存在于父类和子类之间

常见的访问控制符

   访问控制符		访问权限	本类内部	本包中的类	子类内部	其它包中的其它类    
--------------------------------------------------------------------------------
    public 		公有的		ok		ok		ok		ok   
    protected	保护的		ok		ok		ok		no
    啥也不写		默认的		ok		ok		no		no
    private		私有的		ok		no		no		no

a.public修饰的内容可以在任意位置使用；
b.private修饰的内容只能在本类中使用；
c.通常情况下，成员变量都是用private修饰，成员方法都使用public修饰；

final、finally、finalize的区别

1. final - 修饰符（关键字）

final表示"最终的，不可改变的"含义，修饰类、成员方法以及成员变量等。
被final关键字修饰的类不能被继承。
	- 为了防止滥用继承，如：java.lang.String类和System类等。
被final关键字修饰的成员方法不能被重写。
	- 为了防止不经意间造成的重写，如：java.text.DateFormat类中的format方法等。
被final关键字修饰的成员变量必须被初始化而且不能被更改。
	- 为了防止不经意间造成的修改，如：java.lang.Thread类中的MAX_PRIORITY等。    
扩展：
	在以后的开发中很少单独使用static或final关键字修饰成员变量，
通常都使用public static final共同修饰成员变量来表达常量的含义，
而常量的命名规范就是：所有字母大写，不同单词之间采用下划线连接，
如：
	public static final double PI = 3.1415926;

2. finally - 异常处理时提供finally块来执行操作

finally块是无论是否发生异常，都会执行finally块的内容

3. finalize - 方法名

finalize()方法是在垃圾收集器删除对象之前对这个对象调用的
它是object类中定义的，所有的类都继承它

抽象类和接口有什么区别

抽象类(abstract class)：
	1. 抽象类指不能直接创建实例，该类不能创建对象，使用abstract关键字修饰，并且没有方法体。
	2. 抽象类中可以有成员变量、成员方法以及构造方法。
	3. 抽象类中可以有抽象方法，也可以没有抽象方法。
	4. 拥有抽象方法的类必须是抽象类，因此包含抽象方法并且使用abstract关键字修饰的类才算真正意义上的抽象类。
	5. 抽象类只能被继承，一个类继承抽象类必须实现所有的抽象方法
实际意义
   抽象类的实际意义不在于自身创建对象而在于被继承，当一个类继承抽象类后必须重写抽象类中的抽象方法，否则该类也得变成抽象类。因此抽象类对子类具有强制性和规范性，叫做模板设计模式。
接口(interface)
	1、实现接口一定要实现接口里定义的所有方法
	2、接口可以实现多重继承
区别：
	1. 继承抽象类使用extends，而实现接口使用implements;
	2. 继承抽象类支持单继承，而实现接口支持多实现;
	3. 抽象类中可以有构造方法，而接口中不可以拥有;
	4. 抽象类中可以有成员变量，而接口中只可以有常量，也就是public static final共同修饰;
	5. 抽象类中可以有成员方法，而接口中只可以有抽象方法，也就是public abstract共同修饰;
	6. 抽象类中增加方法可以不影响子类，而接口中增加方法通常都影响实现类;
	7. 从jdk1.8开始允许接口中出现非抽象方法，但必须使用default关键字修饰;
	8. 有抽象方法的类必须被声明为抽象类，而抽象类未必要有抽象方法;
	9. 接口中增加方法一定会影响子类，而抽象类中不影响;
	10. 相同点是都不能被实例化，就是不能直接new()为它们分配空间，而是需要通过继承或者实现它们的类将它们实例化。

Object类

基本概念
   java.lang.Object类是Java类层次结构的根类，任何类都是该类的直接或间接子类。
常用的包
	java.lang包 - 该包是Java语言中的核心包，该包中的内容由JVM自动加载和导入。
               - 如：String类、System类等
	java.util包 - 该包是Java语言中的工具包，该包中提供了大量的工具类和集合类等。
               - 如：Scanner类、Random类等
	java.io包   - 该包是Java语言中的输入输出包，该包中提供了大量读写文件的类等。
               - 如：FileInputStream类、FileOutputStream类等
	java.net包  - 该包是Java语言中的网络包，该包中提供了大量网络编程相关的类等。
               - 如：ServerSocket类、Socket类等
	... ...
常用的方法
	Object() - 无参构造方法
	boolean equals(Object obj)
       - 主要用于判断调用对象是否与参数对象相等。
       - 该方法默认比较两个对象的地址，与 == 运算符的效果等价。
       - 为了使得该方法能够比较两个对象的内容，则需要重写该方法。
       - 当该方法被重写时，通常有必要重写hashCode方法
	int hashCode() 
       - 主要用于获取调用对象的哈希码值(对象内存地址的编号)。
       - 当两个对象调用equals方法相等时，则各自调用hashCode方法得到的结果必须相同。
       - 当两个对象调用equals方法不相等时，则各自调用hashCode方法的结果应该不同。
       - 为了使得两个方法保持一致，因此要重写hashCode方法。
	String toString() 
       - 主要用于获取调用对象的字符串形式。
       - 该方法的默认形式为：包名.类名@哈希码的无符号十六进制形式
       - 为了返回更有意义的数据内容，则应该重写该方法。
       - 当使用print/println打印引用时或者使用字符串拼接引用时都会自动调用该方法。 

String、 StringBuffer、StringBuilder的区别

- 运行速度快慢为：StringBuilder > StringBuffer > String
	- String为字符串常量
	- StringBuilder 和 StringBuffer均为字符串变量
	- String对象一旦创建之后 该对象是不可更改的
- StringBuilder是线程不安全的，而String，StringBuffer是线程安全的

String类

基本概念
	java.lang.String类用于描述字符串，Java程序中所有的字符串字面值都可以使用该类的对象加以描述，如："abc"。
	该类由final关键字修饰，表示该类不能被继承。
	该类描述的字符串内容是个常量不可更改，因此可以被共享使用。
如：
	String s1 = "hello";  - "hello"这个字符串的内容是个常量。    
	s1 = "world";         - 使用"world"字符串的地址赋值给变量s1，也就是改变s1的指向
常量池的概念
	由于String类型描述的字符串内容是个常量不可改变，因此当Java程序中出现字符串时先去常量池中查找，若存在则直接使用池中已有的对象，若不存在则创建对象后放入池中，对于重复出现的字符串来说无需重新创建对象，从而提高效率；
	
String类常用的方法
(1)常用的构造方法
   String() - 使用无参方式构造对象得到空字符序列，如:""
   String(byte[] bytes, int offset, int length) 
      - 使用bytes数组中下标从offset位置开始的length个字节来构造对象。
   String(byte[] bytes) 
      - 使用bytes数组中的所有内容构造对象。
   String(char[] value, int offset, int count) 
      - 使用value数组中下标从offset位置开始的count个字符来构造对象。
   String(char[] value) 
      - 使用value数组中的所有内容构造对象。
   String(String original) 
      - 根据参数指定的字符串内容来构造对象，新创建对象为参数对象的副本。
注意：""和null之间的区别：
       a.""表示有字符串对象，但里面没有存放数据内容；
       b.null表示没有字符串对象，调用方法会引发空指针异常；
(2)常用的成员方法
	该类重写了equals()、hashCode()以及toString()方法。
	char charAt(int index) - 根据参数指定的下标返回对应的单个字符。
	int length() - 用于返回当前字符串的长度。
   
	int compareTo(String anotherString) - 用于比较调用对象和参数对象的大小关系。
       - 使用调用对象和参数对象中第一个字符起依次做减法运算
       - 若第一个字符能确定大小，则后续字符不用比较
       - 若第一个字符不能确定大小，则使用下一个对应位置的字符比较大小。
       - 直到其中一个字符串的所有字符比较完毕后也没有确定大小，则由长度来决定大小。
       - 若当前字符串大则返回正数；若当前字符串小则返回负数；若相等则返回零；
	int compareToIgnoreCase(String str) - 不考虑大小写，也就是'a'和'A'是相等的关系。
       
	boolean contains(CharSequence s) - 用于判断当前字符串是否包含参数指定的内容。
       - 其中参数是接口类型，因此实参需要传递实现类的对象，而String类就实现了该接口
	boolean endsWith(String suffix) 
       - 判断当前字符串是否以参数指定的内容为结尾。
	boolean startsWith(String prefix) 
       - 判断当前字符串中是否以参数指定的内容为开头。
	String toLowerCase() 
       - 用于将当前字符串中所有字符转换为小写。
	String toUpperCase() 
       - 用于将当前字符串中所有字符转换为大写。
	String trim() 
       - 用于去除当前字符串中两端的空白字符。
      
	boolean equals(Object anObject) 
        - 用于比较字符串内容是否相等并返回；
	boolean equalsIgnoreCase(String anotherString) 
        - 用于比较字符串内容是否相等并返回，不考虑大小写，如：'A'和'a'是相等。

	byte[] getBytes() - 用于将当前字符串内容转换为byte数组并返回。
	char[] toCharArray() - 用于将当前字符串内容转换为char数组并返回。
   
	int indexOf(int ch) - 用于返回当前字符串中参数ch指定的字符第一次出现的下标。
	int indexOf(int ch, int fromIndex) - 用于从fromIndex位置开始查找ch指定的字符。
       - 上述方法若查找失败，则返回-1.
	int indexOf(String str) - 用于查找参数str指定的字符串并返回下标。
	int indexOf(String str, int fromIndex) - 用于从fromIndex位置开始查找。
 
	int lastIndexOf(int ch) - 用于返回参数ch指定的字符最后一次出现的下标。
	int lastIndexOf(int ch, int fromIndex) 
        - 用于从fromIndex位置开始查找ch指定字符出现的下标，反向搜索的第一次。
	int lastIndexOf(String str) - 用于返回str指定字符串最后一次出现的下标。
	int lastIndexOf(String str, int fromIndex) 
        - 用于从fromIndex位置开始反向搜索的第一次。
 
	String substring(int beginIndex) 
        - 用于获取当前字符串中从beginIndex位置开始的子字符串并返回。
	String substring(int beginIndex, int endIndex) 
        - 用于获取当前字符串中从beginIndex位置开始到endIndex结尾的子字符串并返回。

StringBuilder类的常用方法

   StringBuilder(String str) 
      - 根据参数指定的字符串来构造对象，其中初始容量为：16 + 字符串的长度。
   int capacity() 
      - 用于返回调用对象的容量。
   int length() 
      - 用于返回字符串的长度，也就是字符的个数。

   StringBuilder insert(int offset, String str) 
      - 用于将参数指定的字符串内容str插入到下标为offset的位置上。
      - 返回调用对象的引用，也就是返回自己。
   StringBuilder append(String str) 
      - 用于将参数指定的内容追加到当前字符串的末尾。
   StringBuilder delete(int start, int end) 
      - 用于将字符串中从start(含)开始到end(不含)结尾之间的内容删除。
   StringBuilder deleteCharAt(int index) 
      - 用于将当前字符串中下标为index位置的单个字符删除。
   StringBuilder replace(int start, int end, String str) 
      - 用于将当前字符串中下标从start开始到end结尾之间的所有内容用str替换。
   StringBuilder reverse() 
      - 用于实现字符串内容的反转功能。

集合

   在Java语言中集合框架的顶层是：java.util.Collection集合 和 java.util.Map集合。
   其中Collection集合中存放元素的基本单位是：单个元素；
   其中Map集合中存放元素的基本单位是：单对元素；

数组和集合的比较

(1)数组的特点
   a.数组本质上就是一段连续的存储单元，用于存放多个类型相同的数据内容；
   b.支持下标访问，实现随机访问非常方便；
   c.增删操作不方便，可能会移动大量的元素；
   d.数组一旦声明则长度固定无法更改；   
   e.数组中支持基本数据类型，也支持引用数据类型；
(2)集合的特点
   a.集合的存储单元可以不连续，数据内容类型可以不相同；
   b.集合部分支持下标，部分不支持下标；
   c.集合中增删元素可以不移动大量的元素；
   d.集合的大小可以随时动态调整；
   e.集合中的元素必须是引用数据类型；

Collection集合

	在以后的开发中很少直接使用Collection集合，使用更多的是Collection集合的子集合：List集合、Queue集合、Set集合。
常用的方法
   boolean add(E e) - 用于将参数指定的元素e放入当前集合中。
   boolean addAll(Collection<? extends E> c) 
       - 用于将参数指定集合c中的所有元素添加到当前集合中。
   boolean contains(Object o) 
       - 用于判断当前集合中是否包含参数指定的单个元素。
   boolean containsAll(Collection<?> c) 
       - 用于判断当前集合中是否包含参数指定集合中的所有元素。
   boolean remove(Object o) 
       - 用于将当前集合中参数指定的单个元素删除。
   boolean removeAll(Collection<?> c) 
       - 用于从当前集合中将参数指定集合c中的所有元素删除。
   void clear() 
       - 用于清空当前集合中的所有元素。
   boolean isEmpty() 
       - 用于判断当前集合是否为空。
   int size() 
       - 用于获取当前集合中元素的个数。
   boolean retainAll(Collection<?> c) 
       - 用于计算当前集合和参数集合之间的交集并保留到当前集合中。
       - 若当前集合中的元素发生了更改，则返回true

List集合

   java.util.List集合是Collection集合的子集合，元素有先后次序并且可以重复。
   该集合的主要实现类有：ArrayList类、LinkedList类、Stack类、Vector类等
   其中ArrayList类的底层是采用动态数组实现的，因此访问元素方便但增删元素不方便。
   其中LinkedList类的底层是采用双向链表实现的，因此访问不方便但增删元素方便。
   其中Stack类的底层是采用动态数组实现的，该类主要用于描述具有后进先出特征的数据结构，简称为LIFO(last in first out 栈).
   其中Vector类的底层是采用动态数组实现的，该类与ArrayList类相比属于早期提供的类，支持线程安全的类，因此效率比较低。
常用的方法
   void add(int index, E element) 
       - 用于将参数指定的元素插入到参数指定的下标位置上。
   boolean addAll(int index, Collection<? extends E> c) 
       - 用于将参数指定集合中的所有元素依次插入到参数指定的位置。
   E get(int index) 
       - 用于获取当前集合中下标为index位置的元素并返回。
   E set(int index, E element) 
       - 用于将当前集合中index位置的元素修改为element.
       - 该方法会返回该位置之前的旧值。
   E remove(int index) 
       - 用于将当前集合中index位置的元素删除并返回。

Queue集合

   java.util.Queue集合是Collection集合的子集合，与List集合是平级关系。
   该集合主要描述具有先进先出特征的数据结构，叫做队列，简称FIFO(first in first out)    该集合的主要实现类：LinkedList类，因为此类在增删方面有一定的优势。  
常用的方法
	boolean offer(E e) - 用于将参数指定的元素e插入到当前队列中。
	E poll() - 用于获取并移除队列中的队首元素，若队列为空则返回null。
	E peek() - 用于查看队列中的队首元素，若队列为空则返回null。

Set集合

   java.util.Set集合是Collection集合的子集合，与List集合属于平级关系。
   该集合中不允许有重复的元素，并且元素没有先后放入次序。
   该集合的主要实现类有：HashSet类 和 TreeSet类。
   其中HashSet类的底层是采用哈希表进行数据管理的。
   其中TreeSet类的底层是采用二叉树进行数据管理的。
常用的方法
   参考Collection集合的方法即可；
   Iterator<E> iterator() - 用于获取当前集合中的迭代器，可以迭代/访问/遍历每个元素
   其中Iterator是来自java.util包中的接口，常用方法如下：
       boolean hasNext() - 用于判断集合中是否有可以迭代/访问的元素。
       E next() - 用于取出一个元素并指向下一个元素。
       void remove() - 用于删除访问到的最后一个元素。
注意：
   当使用迭代器访问集合中的每个元素时，若需要删除某个元素则应该使用迭代器自己的remove方法，若使用集合的remove方法则会引发并发修改异常。

Arraylist和LinkedList的区别

- ArrayList是实现了基于动态数组的数据结构，而LinkedList是基于链表的数据结构
	默认长度为10，默认扩容算法为原长度的1.5倍
- 对于随机访问get和set，ArrayList要优于LinkedList
- LinkedList不支持高效的随机访问
- ArrayList适合查找，LinkedList适合增删
	默认长度为10，默认扩容算法为原长度的2倍

为啥重写equals方法就需要重写hashCode方法并且保持一致性呢？

	当两个元素调用equals方法相等时可以证明这两个元素相同，只有重写hashCode方法才能保证两个元素得到的哈希码值相同，
当交由同一个哈希算法后生成的索引位置相同，并且只需要与该索引位置已有的元素进行比较即可，从而提高效率并避免了集合中重复元素的出现。

""和null之间的区别

a. ""表示有字符串对象，但里面没有存放数据内容；
b. null表示没有字符串对象，调用方法会引发空指针异常；

跨平台原理

	由于不同的操作系统中都提供了Java虚拟机进行翻译，因此使得同一份字节码文
件可以在不同的操作系统中执行，从而实现了跨平台的效果。

标识符(变量)的命名规则

(1)要求由字母、数字、下划线以及$等组成，其中数字不能开头；
     如：name、age、year、time、name2、name3
(2)要求不能与Java语言中的关键字同名，关键字就是Java语言中用于表示特殊含义的单词；
     如：public、class、static、void
(3)区分大小写，长度没有限制但不宜过长；
     如：day和Day代表两个名字，不推荐使用
(4)尽量做到见名知意，支持中文但不推荐使用；
     如：length、size、month、day、年龄

数据类型

在Java语言中数据类型主要分为两大类：
	(1)基本数据类型
		byte(1字节)、	short(2字节)、	int(4字节)、		long(8字节)、
		float(4字节)、	double(8字节)、	boolean(1字节)、	char(2字节)
    (2)引用数据类型
		数组、类、接口、枚举、标注

什么是对象

万物皆对象

什么是面向对象

面向对象就是指以特征和行为的观点分析现实世界中事物的方式。

什么是面向对象编程？

面向对象编程就是先使用面向对象的观点进行分析，再使用面向对象的编程语言进行翻译的过程。
其中C语言是一门面向过程的编程语言；
其中C++语言是一门既面向过程又面向对象的编程语言；
其中Java语言是一门纯面向对象的编程语言；

为什么需要面向对象编程？

面向对象编程是软件产业化发展的需求；

类、对象和引用的概念

基本概念
	类就是"分类"的概念，是若干个对象共性特征和共性行为的抽象描述，在Java语言中表示为引用数据类型，里面包含了描述特征的成员变量 和 描述行为的成员方法。
	对象是客观存在的实体，在Java语言中体现为一块内存区域，具体结构由类来决定。
	使用引用数据类型声明的变量叫做引用型变量，简称为"引用"。   引用变量主要用于记录对象在堆区中的存储地址信息，为了便于下次访问。语法格式：类名 引用变量名;
注意：
   当类名由多个单词组成时，通常要求每个单词的首字母都要大写。
   当成员变量名由多个单词组成时，通常要求从第二个单词起每个单词的首字母大写。

java三大特性(封装、继承、多态)

封装：
	封装是面向对象编程的基本概念之一，它隐藏对象的内部实现细节，只暴露必要的接口给外部使用。
	封装的主要目的是提高代码的安全性和可维护性，同时保护数据不被外部直接访问和修改。
	在Java中，封装通过将类的属性设为私有（private），并提供公共的getter和setter方法来访问和修改这些属性来实现。
继承：
	继承允许一个类（子类）继承另一个类（父类）的属性和方法。这使得子类可以复用父类的代码，同时还可以添加或修改自己的属性和方法。
	继承提高了代码的重用性和可扩展性，使得软件设计更加灵活和易于维护。
	在Java中，继承通过关键字extends来实现。
多态：
	多态是指同一个方法可以被多个不同的对象以不同的方式使用。
	多态增加了程序的灵活性和可扩展性，因为它允许在运行时根据对象的实际类型来确定调用哪个实现的方法。
	多态的实现依赖于继承和方法重写（override）。
	在Java中，多态可以通过接口实现，继承父类并进行方法重写，或者在同一个类中进行方法重载来实现。

注意事项
(1)子类可以继承父类的成员变量和成员方法，包括私有成员变量但不可以直接访问；
   子类不可以继承父类的构造方法和私有方法；
(2)无论使用何种方式构造子类的对象时，默认会调用父类的无参构造方法来初始化从父类中
   继承下来的成员变量信息，相当于在子类构造方法的第一行增加代码：super()的效果；  
(3)Java语言中支持单继承但不支持多继承，也就是说一个子类只能有一个父类，但一个父类
   可以有多个子类；
(4)只有满足逻辑关系：子类 is a 父类 时才可以使用继承，也就是不能滥用继承；

经验的分享：
    在以后的开发中推荐使用多态的语法格式，此时父类类型的引用直接调用的所有方法一定是父类中拥有的方法，当希望更换子类时只需要将new关键字后面的数据类型修改而其它所有位置无需改变就立刻生效，因此提高了代码的可维护性。
    该方式的缺点就是父类引用不能直接调用子类独有的方法，若调用需要强制类型转换。