JAVA基础

JAVA基础

一.JAVA 中的几种数据类型是什么，各自占用多少字节？

基本数据类型：
boolean 1 bit，不到一个字节
byte 8 bit，1字节
short 16 bit，2字节
char 16 bit，2字节
int 32 bit，4字节
float 32 bit，4字节
long 64 bit，8字节
double 64 bit，8字节

整数类型：
int short long byte

二.String 类能被继承吗，为什么？

String被关键字final修饰，所以不能被继承。
引出final：
1、修饰类
当用final去修饰一个类的时候，表示这个类不能被继承。
注意：
a. 被final修饰的类，final类中的成员变量可以根据自己的实际需要设计为fianl。
b. final类中的成员方法都会被隐式的指定为final方法。
说明：在JDK中，被设计为final类的有String、System等。

2、修饰方法
被final修饰的方法不能被重写。
注意：
a. 一个类的private方法会隐式的被指定为final方法。
b. 如果父类中有final修饰的方法，那么子类不能去重写。

3.修饰成员变量
注意：
a. 必须初始化值。
b. 被fianl修饰的成员变量赋值，有两种方式：1、直接赋值 2、全部在构造方法中赋初值。
c. 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
d. 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。

三.两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？

两个对象的 hashCode（）相同， 但equals（）不一定相同。
1.hashCode()返回该对象的哈希码值；equals()返回两个对象是否相等。
2.如果两个对象equals()相等，那么两个对象的hashCode()方法返回的结果也必然相等。
3.如果重写equals()方法，必须重写hashCode()方法，以保证equals方法相等时两个对象hashcode返回相同的值。

四.String 属于基础的数据类型吗？

java 中String 是个对象，是引用类型
（基础类型与引用类型的区别是：基础类型只表示简单的字符或数字，引用类型可以是任何复杂的数据结构）
1、存储位置
基本变量类型
在方法中定义的非全局基本数据类型变量的具体内容是存储在栈中的

引用变量类型
只要是引用数据类型变量，其具体内容都是存放在堆中的，而栈中存放的是其具体内容所在内存的地址（引用/句柄）

2、传递方式
基本变量类型
在方法中定义的非全局基本数据类型变量，调用方法时作为参数是按数值传递的

引用变量类型
引用数据类型变量，调用方法时作为参数是按引用传递的

五.Java 中操作字符串都有哪些类？它们之间有什么区别？

String、StringBuffer、StringBuilder

String：
String类是一个不可变的类，一旦创建就不可以修改。
String是final修饰的，不能被继承
String实现了equals()方法和hashCode()方法

StringBuffer：
继承自AbstractStringBuilder，是可变类。
StringBuffer是线程安全的
可以通过append方法动态构造数据。

StringBuilder：
继承自AbstractStringBuilder，是可变类。
StringBuilder是非线性安全的。
执行效率比StringBuffer高。

总结：
在单线程环境下我会选择使用StringBuilder,
多线程环境下使用StringBuffer.
如果声明的这个字符串几乎不做修改操作,那么我就直接使用String, 因为不调用new关键字声明String类型的变量的话它不会在堆内存中创建对象,直接指向String的常量池,并且可以复用.效率更高.

六.如何将字符串反转？

使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

七…抽象类必须要有抽象方法吗？

有抽象方法的类是抽象类，但抽象类中不一定要有抽象方法。

八.抽象类能使用 final 修饰吗？

抽象类不能用final来修饰。当用final修饰一个类时，表明这个类不能被继承。
final类中的所有成员方法都会被隐式地指定为final方法，这明显违背了抽象类存在的意义了。

九.普通类和抽象类有哪些区别？

1.抽象类不能被实例化，普通类可以被实例化

2.抽象类可以有抽象方法，抽象方法只需声明，无需实现
抽象类中既可以含有抽象方法也可以含有普通方法,普通类中不能含有抽象方法

3.抽象方法不能被声明为静态static，不能用private修饰，不能用final修饰

十.Atomic类如何保证原子性（CAS操作）

Atomic使用了volatile修饰value，然后一直使用CAS保证原子性。
cas （compare and swap) 有三个值
内存值 V
预估值 A
更新值 B
如果V和A相同时才会把B赋值给V，否则什么都不做，重新操作
CAS是乐观锁，如果发现寄存器旧值发生了改变，说明有CPU在修改，重新进行这次操作。用CAS一直判断 就可以保证随时获得最新的值，保证操作的原子性。

十一.重写和重载的区别

重载：发生在同一个类中，方法名必须相同，参数类型不同，个数不同，顺序不同，方法返回值和方法修饰符可以不同，发生在编译时

重写：发生在父子类中，方法名，参数列表必须相同，如果父类方法访问修饰符为private，则子类不能重写

重载靠什么来决定要调用的方法？
重载是根据调用方法时指定的参数来调用对应的方法

十二.包装类，自动装箱和拆箱

byte short int long float double char boolean
Byte Short Integer Long Float Double Character Boolean

装箱：将基本类型用他们对应的引用类型包装起来

拆箱：将包装类型转为基础类型

十三.==和equals

== : 他的作用是判断两个对象的地址是不是相等，即判断两个对象是不是同一个对象（基本数据类型比较的是值，引用数据类型比较的是内存地址）

equals：它的作用也是判断两个对象是否相等。他一般有两种使用情况：
1.类没有覆盖equals方法，则通过equals比较该类的两个对象时，等价于通过"=="比较这两个对象
2.类覆盖了equals方法，就比较两个对象的内容是否相等，相等就返回true
（String中的equals方法就是被重写过的，因为object的equals方法比较的是对象的内存地址，String的equals方法比较的是对象的值）

十四.final关键字总结

final关键字一般用在三个地方：变量，方法，类

1.对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象

2.当用final修饰一个类时，表明这个类不能被继承，final类中的所有成员方法都会被隐式的指定为final方法

3.使用final方法的原因有两个， 第一个原因是把方法锁住，以防任何继承类修改它的含义； 第二个原因是效率，在早期的Java版本中，会把final方法转为内嵌调用，但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的java版本已经不需要使用final方法进行这些优化了）。类中所有的private方法都被隐式的指定为final

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

十五. 接口和抽象类（都不能被实例化）

区别：
1.抽象类可以有构造方法，接口中不能有构造方法。

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

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

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

7. 一个类可以实现多个接口，但只能继承一个抽象类。

应用：
抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。
接口更多的是在系统架构设计上发挥作用，主要用于定义模块之间的通信。而抽象类在代码实现方面发挥作用，可以实现代码的重用

十六.Java 中的异常处理

所有的异常都有一个共同的java.lang包中的 Throwable类。Throwable： 有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）: 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当
JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

Exception（异常）: 是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由Java虚拟机抛出。

NullPointerException（要访问的变量没有引用任何对象时，抛出该
异常）、ArithmeticException（算术运算异常，一个整数除以0时，抛出该异常）和ArrayIndexOutOfBoundsException （下标越界异常）。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

Throwable类常用方法
public string getMessage():返回异常发生时的详细信息
public string toString():返回异常发生时的简要描述
public string getLocalizedMessage():返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可
以声称本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印Throwable对象封装的异常信息

异常处理总结
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句
时，finally语句块将在方法返回之前被执行。

在以下4种特殊情况下，finally块不会被执行：

1. 在finally语句块中发生了异常。
2. 在前面的代码中用了System.exit()退出程序。
3. 程序所在的线程死亡。
4. 关闭CPU

throw和throws区别：
throws用在方法的声明上，throw用在方法体
throws抛出的是异常的类型，throw抛出的是异常对象
throws可以抛出多个异常，throw只能抛出一个异常对象

十七.int和Integer区别

1.Integer是int的包装类，int是基础数据类型
2.Integer变量必须实例化后才能使用，int变量不需要
3.Integer是对象的引用，指向new出Integer对象，int直接存储数据值
4.Integer默认值是null,int的默认值是0
Integer的范围是-128到127

十八.反射的原理，反射获取Class类实例的三种方式，反射获取对象实例的两种方式，暴力反射

Java反射机制：
Java 的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法； 并且对于任意一个对象，都能够调用它的任意一个方法。
Java中可以利用反射获取类的名称、构造函数、属性、方法。也就是说可以通过反射可以取得类的所有信息

Java 反射技术主要实现类有哪些，作用分别是什么？
Class 类：类的实例表示正在运行的 Java 应用程序中的类和接口。
Constructor 类：提供关于类的单个构造方法的信息以及对它的访问权限。
Field 类：提供有关类或接口的属性的信息，以及对它的动态访问权限。
Method 类：提供关于类或接口上单独某个方法的信息。

获取 Class 类对象三种方式：
使用 Class.forName 静态方法
使用类的.class 方法
使用实例对象的 getClass() 方法

获取对象实例两种方式：
1.无参构造器，直接用字节码文件获取对应实例：
Object o = clazz.newInstance();

2.有带参数的构造函数的类，先获取到其构造对象，再通过该构造方法类获取实例：
/ /获取构造函数类的对象
Constroctor constroctor = clazz.getConstructor(String.class,Integer.class); /
// 使用构造器对象的newInstance方法初始化对象
Object obj = constroctor.newInstance(“裴缘”, 18);

暴力反射：
正常情况下，构造方法，普通方法，字段被private修饰的话，在该类的外部是不允许被访问的，但如果想要访问被private修饰的方法的话可以使用暴力反射
//1 创建实例
Class Userclass = Class.forName(“com.zxf.User”);
Object obj = Userclass.newInstance();
//2 调用方法 --getDeclaredMethod() 获得声明的私有方法
Method method = Userclass.getDeclaredMethod(“info”);
//3 获得私有构造方法
Constructor cons = Userclass.getDeclaredConstructor(int.class , String.class);
//4设置可访问权限
method.setAccessible(true);
method.invoke(obj);

十九.序列化和反序列化

序列化：
通常一个类实现序列化方式是实现序列化接口： class XXX implements Serializable

**序列化的作用：**把对象转换为字节序列，就是把数据长久的保存在磁盘中，磁盘和内存是不同的，内存一般在程序运行时占用，数据保存周期短，随程序结束而结束，磁盘可以长久保存数据

什么时候用序列化：
当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
当你想用套接字在网络上传送对象的时候；
当你想通过RMI传输对象的时候；

transient关键字的作用：在已实现序列化的类中，有的变量不需要保存在磁盘中，就要transient关键字修饰，如银行卡密码等，总结一下就是------在已序列化的类中使变量不序列化

反序列化：
而反序列化则是将字节序列转换为对象的过程。

Java对象序列化是将实现了Serializable接口的对象转换成一个字节序列，能够通过网络传输、文件存储等方式传输 ，传输过程中却不必担心数据在不同机器、不同环境下发生改变，也不必关心字节的顺序或其他任何细节，并能够在以后将这个字节序列完全恢复为原来的对象。

二十. 请你说说Iterator和ListIterator的区别？

Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
ListIterator实现了Iterator接口，并包含其他的功能：增加元素，替换元素，获取前一个和后一个元素的索引

二十一.Java 跨平台原理（字节码文件、虚拟机）

java的跨平台不是java源程序的跨平台 ，如果是这样，那么所以语言都是跨平台的， java源程序先经过编译器编译成二进制的.class字节码文件，java的跨平台指的就是.class字节码文件的跨平台，.class字节码文件是与平台无关的，.class文件再运行在jvm上，java解释器会将其解释成对应平台的机器码执行，所以java所谓的跨平台就是在不同平台上安装了不同的jvm，而在不同平台上生成的.class文件都是一样的，而.class文件再由对应平台的jvm解释成对应平台的机器码执行。

二十二. 4种修饰符

访问权限修饰符：
a、私有权限（private）
　　 private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。
　　 可以通过反射的方法调用private里的方法
　　 private和final不可以一起用，二者用一个就行
　　
　　 b、默认权限（default）
　　 类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。
　　
　　 c、受保护权限（protected）
　　 protected可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。被protected修饰的成员，能在定义它们的类中和同包的类中被调用。
如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类。

d、公共权限（public）
　　 public可以修饰类，数据成员，构造方法，方法成员。被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。

二十三.super和this

如果一个类从另一个类继承，我们new这个子类的实例对象时，这个子类中会有一个父类对象， 这个父类对象就可以用super去引用，this指的是对当前对象的引用

二十四.i++和++i

int i=1,a=0;

**i++ 先赋值在运算,例如 a=i++,先赋值a=i,后运算i=i+1,所以结果是a==1
  ++i 先运算在赋值,例如 a=++i,先运算i=i+1,后赋值a=i,所以结果是a==2**

为什么++和–不是原子性的？
因为++和–是先从内存中取值，然后改变值，最后放入内存，如果其中的一步出现错误他不会回滚，它不能保证这些操作一起成功或者一起失败。

二十五.continue break return

1.return ：作用于方法，结束当前方法，主要用来返回方法返回值（当方法有返回值的时候，返回对应类型的返回值，没有返回值时，可以返回空，或者不返回）

2.break：在循环体内结束整个循环过程

3. continue ：结束本次的循环，直接进行下一次的循环

二十六.泛型

泛型： 创建对象时，将未知的类型确定为具体的类型，当没有指定泛型时，默认类型是object

使用泛型的好处：
1.把运行时出现的错误ClassCastException转移到编译时期的错误
2.避免了类型强转

泛型擦除：
JVM并不知道泛型的存在，因为泛型在编译阶段就已经被处理成普通的类和方法， 处理机制是通过泛型擦除，擦除规则：

1.如果泛型类型没有指定具体类型，那么就用object作为原始类型
2.如果有一个限定类型，那就用它做原始类型
3.如果有多个限定类型，那么就选第一个作为原始类型

泛型使用的注意事项：

1.不能用基本数据类型实例化类型参数
Pair ×
Pair √

2.运行时类型查询只适用于原始类型
虚拟机中泛型对象都为原始类型,所以运行时查询只能比较原始类型.

3.不能创建参数化类型的数组

常用通配符：
？表示不确定的 java 类型

T (type) 表示具体的一个java类型

K V (key value) 分别代表java键值中的Key Value

E (element) 代表Element

？和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ？不行

T t = operate(); // 可以

？car = operate() // 不可以

二十七.Object子方法

1. clone()
   保护方法，实现对象的复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

clone方法其实就是说，一个person类，里面有姓名，年龄，性别，调用clone方法就是对person类创建一个副本，初始状态完全相同，互不影响，可以改变各自的状态

2. getClass()
   返回Class类型的对象，反射来获取对象。

3. toString()
   来获取对象信息，该方法用得比较多，一般子类都有覆盖。

4. finalize()
   该方法用于释放资源。

5. equals()
   比较对象的内容是否相等

6. hashCode()
   该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。

7.wait（）
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。

8. notify()
   该方法唤醒在该对象上等待的某个线程。

9. notifyAll()
   该方法唤醒在该对象上等待的所有线程

二十八.创建对象实例的几种方式

1.new
2.反射，newInstance（）方法
3.调用对象的clone（）方法
4.反序列化
5.通过工厂方法返回对象

二十九.JDK和JRE区别

JDK：Java 开发工具包，提供了 Java 的开发环境和运行环境。是面向开发人员使用的

JRE：Java 运行环境，为 Java 的运行提供了所需环境。面向Java程序的使用者，而不是开发者。JDK包含了JRE

三十.封装，继承，多态

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作，是继承关系。

封装就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。

子类继承父类，使得子类具有父类相同的行为。如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

特点：
一个子类只允许有一个父类，但是可以实现多级继承，及子类拥有唯一的父类，而父类还可以再继承。
​子类可以拥有父类的属性和方法。
子类可以拥有自己的属性和方法。
子类可以重写覆盖父类的方法。