Java基础知识1----基本概念（1）
目录
- 1. 基础概念和常识
-
- 1.1 Java语言有哪些特点
- 1.2 JVM vs JDK vs JRE ？
- 1.3 什么是字节码，采用字节码好处
- 1.4 为什么说 Java 语言“编译与解释并存”？
- 1.5 Java 和 C++ 的区别?
- 2. 基本语法
-
- 2.1 字符型常量和字符串常量的区别?
- 2.2 注释有哪几种写法？
- 2.3 标识符和关键字的区别是什么？
- 2.4 continue、break 和 return 的区别是什么？
- 2.5 方法
- 2.6 == 和 equals() 的区别？
- 2.7 hashCode() 与 equals()？
- 2.7 什么是可变长参数？
- 2.8 关键字static和final的注意事项
- 3. 基本数据结构
-
- 3.1 数据类型分类
- 3.2 包装类型和其常量池技术了解么
- 3.3 包装类型自动装箱与拆箱
- 4. 面向对象基础
-
- 4.1 面向对象和面向过程的区别？
- 4.2 成员变量与局部变量的区别有哪些？
- 4.3 创建一个对象用什么运算符?对象实体与对象引用有何不同?
- 4.4 对象的相等与指向他们的引用相等,两者有什么不同?
- 4.5 一个类的构造方法的作用是什么?
- 4.6 如果一个类没有声明构造方法，该程序能正确执行吗?
- 4.7 面向对象三大特征
- 4.8 接口和抽象类有什么共同点和区别？
- 4.9 深拷贝和浅拷贝区别了解吗？什么是引用拷贝？
- 4.10 Java创建对象有几种方式？
- 4.11 抽象类，普通类和接口的区别
- 5 Java 常见对象
-
- 5.1 Object
- 5.2 String、StringBuffer、StringBuilder 的区别？
- 5.3 String 为什么是不可变的?
- 5.5 String#equals() 和 Object#equals() 有何区别？
1. 基础概念和常识
1.1 Java语言有哪些特点
- 简单易学
- 面向对象：封装，继承和多态
- 平台无关性：Java虚拟机实现
- 支持网络编程，并且很方便
1.2 JVM vs JDK vs JRE ？
-
JVM: Java虚拟机，是用来运行Java字节码的虚拟机。
是一种抽象化的计算机，通过在实际的计算机上仿真模拟各种计算机功能来实现的。 -
JRE：面向程序使用者。Java运行时的环境，包括：Java虚拟机，Java类库，java命令和一些基础构建，不能够创建新程序，只能用于运行程序。
-
JDK：面向程序开发者。Java开发工具包，提供了编译器javac等工具，能够运行和编写程序。
-
范围大小： JDK >JRE >JVM
1.3 什么是字节码，采用字节码好处
- 字节码文件：JVM可以理解的代码，.class文件。只面向虚拟机。
- java文件–经过JRE编译—.class字节码文件-----经过虚拟机编译和解释器解释—机器码
- 在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点
1.4 为什么说 Java 语言“编译与解释并存”？
Java语言具有编译和解释两个的特征。Java文件需要先经过编译为字节码文件，再通过解释器执行两个过程。
- 编程语言按照程序执行方式：
1）编译型语言：
定义：通过编译器将代码一次性翻译成平台可执行的机器码。
特点：执行速度快，开发效率低
举例：C,C++，Go和Rust
2）解释型语言：
定义：通过解释器一句一句将代码翻译为机器代码执行。
特点：执行速度慢，开发效率高
举例：Python, JavaScrip和PHP
3）两者结合 JAVA
1.5 Java 和 C++ 的区别?
-
相同地方：都是面向对象的语言，都支持封装，继承和多态。
-
不同的地方：
1）Java不提供指针来直接访问内存，程序内存更安全。
2）Java的类是单继承的，C++的类支持多重继承。但是Java的接口是支持多继承的。
3）Java有自动内存管理垃圾回收装机制（GC)，不需要手动释放
4）Java只支持方法的重载，不支持操作符重载。 -
重载和重写的区别：
1）重载：方法名相同，而参数不同，返回值可以相同，也可以不相同。常用于不同的构造器的重载。
2）重写：子类重写父类的方法，外壳不变，里面的东西变了。方法名和形参列表一定要相同，但是返回值也可以不同。
2. 基本语法
2.1 字符型常量和字符串常量的区别?
- 形式：字符型常量是字符‘ ’两个字节，字符串常量是字符串“ ”，占若干个字节。
- 含义：字符相当于一个整型值，ASCII，能够参与计算 ；字符串常量代表一个地址（存放的位置）
2.2 注释有哪几种写法？
- 单行注释：
// 注释的内容
- 多行注释：
/*
*注释的内容
*/
- 文档注释： 一般用在类、方法和变量上面，用来描述其作用
/**
* 文档注释
*
*/
2.3 标识符和关键字的区别是什么？
- 标识符：标识符就是一个名字 。用户自定义；
- 关键字：关键字是被赋予特殊含义的标识符
注意：虽然 true, false, 和 null 看起来像关键字但实际上他们是字面值，同时你也不可以作为标识符来使用。
2.4 continue、break 和 return 的区别是什么？
三者都有跳出循环的意思。
- continue：跳出本次循环，进入下一次循环
- break : 跳出整个循环体，进入循环体后面的程序
- return：跳出所在方法，结束方法的运行。
1） return； 适用于无返回值的方法
2） return value; 适用于有返回值的方法
2.5 方法
-
方法的返回值：获取到某个方法执行后的结果
-
方法的类型：有无返回值，有无参数
-
静态方法为什么不能调用非静态成员?
静态方法属于类，非静态成员属于实例对象。类不能够调用对象的值。当定义为静态成员，则属于类了。 -
静态方法和实例方法有何不同？
（1）调用方式：静态方法通过类进行调用（类名.方法名）; 实例方法需要新建对象，通过实例对象进行调用（对象名.方法名）
（2）访问类成员限制：静态方法只允许访问静态成员（方法和变量）；实例方法没有限制。 -
重载和重写的区别
（1）重载：方法名相同，而参数不同，返回值可以相同，也可以不相同。常用于不同的构造器的重载。
（2）重写：子类重写父类的方法，外壳不变，里面的东西变了。
（3）方法的重写要遵循“两同两小一大”
两同：方法名和形参列表（类型个数顺序均一样）
两小：返回值类型和抛出异常的范围
一大：子类访问权限要比父类大或者相等
2.6 == 和 equals() 的区别？
1）=-=：因为Java是进行值传递，所以 =-=比较的都是值的大小
基本数据类型：==比较的是值的大小,不同数据类型也是可以的。
引用数据类型：‘’=-=‘’比较的是地址的大小，首先要数据类型相同，且为同一个对象
2）equals() ：不能用于基本数据类型，只能为引用数据类型。
（1）不重写：比较两个对象是否为同一个对象。比较地址。等价于‘’=-=‘’
（2）重写：两个对象的属性是否相等。可以不为同一个对象。只需要内部值相同
//1)基本数据类型，==比较的是值是否相等,和数据类型没有关系
int A=1;
double B=1.0;
System.out.println("A==B? "+(A==B)); //true
//2）引用数据类型（类，接口，数组），==比较值的地址，地址相等才会相等
//如果为包装类型的话，会自动拆包和装包，但是一定要在缓存大小内，否则会新建对象
Integer C=1;
int D=1;
System.out.println("C==D? "+(C==D)); //true,自动拆包
Integer E=128;
Integer F=128;
//false:有一个缓存，如果Integer在-128-127之间相等，大于会新建对象
System.out.println("E==F? "+(E==F));
//如果不是一个对象，会进行判错
Integer G=new Integer(1);
Integer H=new Integer(1);
System.out.println("G==H? "+(G==H));
//false:两个引用数据类型不属于同一个对象
//equals比较
//1）首先equals只能对引用数据类型使用，先比较数据类型是否一致，再比较里面的值是否一致，
//可以属于不同的对象（注意：这是重写了equals方法后的性质）
int A=1;
int B=3;
Integer C=3;
//System.out.println(A.equals(C));//报错，不同数据类型不能比较,先判断数据类型，再判断里面的值
System.out.println(C.equals(A+B));//包装类会自动进行转包，转变为包装类
String s1=new String("abc");
String s2=new String("abc");
System.out.println(s1.equals(s2));//先判定数据类型是否一致，再判定内部的值，不比较地址
2.7 hashCode() 与 equals()？
面试常问问题：
“你重写过 hashCode() 和 equals()么?为什么重写 equals() 时必须重写 hashCode() 方法？”
equals 方法判断两个对象是相等的，那这两个对象的 hashCode 值也要相等。辅助验证（主要是在集合中Map和Set集合中要用到哈希表，查找值快）。hashCode 默认从Object继承来的hashCode是基于对象的ID实现的。不重写，对于同一个对象，可能会不一样。
两个对象有相同的 hashCode 值，他们也不一定是相等的（哈希碰撞）。
hashCode() 和 equals()都是用于比较两个对象是否相等。
1）hashCode() 有什么用？
为了获取哈希码。在哈希表中，通过hashCode()为对象获取哈希码，进而分配地址，便于查找，加快效率。
哈希表能快速找到对象原因：哈希表存储的是键值对(key-value)，能根据“键”快速的检索出对应的“值”。这其中就利用到了哈希码！（可以快速找到所需要的对象）
2）JDK 还要同时提供这两个方法？
因为在一些容器中，判断元素是否在容器中，通过hashCode()能够更快进行查找。
3）那为什么不只提供 hashCode() 方法呢？
因为两个对象的hashCode值相等，并不意味着两个对象就相等。优点类似于是重写 equals()的功能。因为多个对象可能存在相同的hashCode值。存在哈希碰撞。
4）如何解决哈希碰撞
开放寻址法：前数组位置1被占用了，就放到下一个位置2上去，如果2也被占用了，就继续往下找，直到找到空位置。
拉链法：链表的方式。在位置上多存一个相同哈希值的地址指向。（尾插法）
5）为什么重写 equals() 时必须重写 hashCode() 方法？
https://www.cnblogs.com/yaobolove/p/5086510.html
因为在Map集合和Set集合中要用到 hashCode() ，如果指的是内容相等，那就要重写
2.7 什么是可变长参数？
允许在调用方法时传入不定长度的参数。
Java 的可变参数编译后实际会被转换成一个数组。
2.8 关键字static和final的注意事项
1.static,修饰类，方法，变量和代码块
1）修饰类：只能够修饰静态内部类，如果修饰外部类，不让编译通过。
2）修饰方法：方法是全局的，不能够被重写。可以被继承和重载。
3）修饰变量：类变量，类加载的时候会进行初始化，只会被创建一次，可以重新赋值。
4）代码块：表示静态代码块，加载类时，会执行代码块，只执行一次。
2. final，可以修饰：类，方法和变量
1）修饰类：那么这个类就是静态的，不能够被继承（String是一个被static final修饰的类）
2）修饰方法：方法是常量的，不能够被重写。可以被继承和重载。
3）修饰变量：即是一个常量，一旦创建不可改变。
3. String是不可变的：String类的值是保存在value数组中的，并且是被private final修饰的。
3. 基本数据结构
3.1 数据类型分类
数据类型分为八种基本数据类型和引用数据类型。
- 基本数据类型(四种八类）：
定义：进行值比较。
种类：byte、short、int、long；float、double ；char；boolean（1,2，4,8，2,4，2,1） - 数据类型的转换
1）强制类型转换
//一：强制类型转换
//1)double 转变为int(不考虑四舍五入）
double double3=20.999999848418418485;
int int2=(int) double3;
System.out.println(int2);
//2)int 转变为 double
long long2=20;
double double2=(double) long2;
System.out.println(double2);
2）四舍五入转换
//二：浮点型转变为整型（考虑四舍五入）:一般情况下，int转不下，要用long
double double0=20.999999848418418485;
long int3=Math.round(double0);
System.out.println(int3);
-
引用数据类型：
定义：进行值地址比较。
种类：类（字符串是一种特殊的类），数组（int[ ]；String[ ]），接口（List；Set；Map） -
两种类型的区别（需要java中的栈、堆概念）：
1)基本数据类型是分配在栈上的，
2)引用类型是分配在堆上的 -
栈和堆的区别：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。 (经典！)
3.2 包装类型和其常量池技术了解么
- 包装类有两个是不仅仅改变了首字符大小：int–Integer; char —Character
- Java的基本数据类型和包装类都实现了常量池技术。在数据大小范围内，会被判定为相等。
- Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，
- Character 创建了数值在 [0,127] 范围的缓存数据，
- Boolean 直接返回 True or False。
- 基本数据类型常量池非常大。
- 注意：包装类如果数值超出范围，则会判定为不同对象。
- 包装类，一方面是把基本数据类型变为对象，在继承的时候好进行操作，另一方面是方便字符串转化为对应包装类
1）字符串2转化为整型2： Integer A= Integer.valueOf(“2”)
- 字符串2.5转为了浮点型2.5： Double B=Double.valueOf(“2.5”);
3.3 包装类型自动装箱与拆箱
包装类：
- 定义：每一个基本数据类型都有一个对应的包装类，作用是弥补基本数据无法参与转型，泛型，反射等过程。
- 种类：主要注意int–Integer; char–Character
- 特点：有自动装箱和拆箱功能；包装类不赋值为null,基本数据类型不赋值有特定的初值。基本数据类型比包装类占用更少内存。
1）装箱：将基本类型用它们对应的引用类型包装起来；
Integer i = 10; //装箱
2）拆箱：将包装类型转换为基本数据类型；
int n = i; //拆箱
4. 面向对象基础
4.1 面向对象和面向过程的区别？
差别主要在解决问题方式不同：
- 面向过程：把解决问题的过程拆解为一个个方法，通过一个个方法的执行解决问题。
- 面向对象：会抽象出对象，然后用对象执行方法额方式解决问题。方法是包含在对象里面的。具有封装性。
- 面向对象开发的程序一般更易维护，易复用和易扩展
4.2 成员变量与局部变量的区别有哪些？
成员变量：属于类的变量
局部变量：在代码块或或者方法中定义的变量，或者是方法中的参数。
区别主要体现在三方面：
1）语法形式：修饰：成员变量能够被public,private,static 等修饰符所修饰；而局部变量不能；但是两者都能被final修饰
2）存储方式：位置：成员变量被static修饰则属于类，没被修饰则属于实例对象；类和对象都是存储在堆中；局部变量存储在栈中。
3）生存时间：成员变量是对象的一部分，随着对象存在而存在；局部变量属于方法，方法结束就释放内存。
默认值：成员变量有初值，局部变量没有
4.3 创建一个对象用什么运算符?对象实体与对象引用有何不同?
- 创建一个对象用什么运算符?
1）使用new运算符 - 对象实体与对象引用有何不同?
1） 对象实体存放在堆中，对象引用存放在栈中
2） 对象实体可以被多次引用；对象引用可以引用多个对象
4.4 对象的相等与指向他们的引用相等,两者有什么不同?
- 对象相等
一般比较的是内存中存放的内容相等 - 引用相等
一般比较的是内存地址是否相等（更加严格的相等）
4.5 一个类的构造方法的作用是什么?
完成对象的初始化操作
4.6 如果一个类没有声明构造方法，该程序能正确执行吗?
存在默认的构造方法，即无参构造器；
如果申明了构造方法，需要手写无参构造器
4.7 面向对象三大特征
面向对象三大特征：封装，继承和多态
- 封装：把对象的状态信息（也就是属性）隐藏在对象内容，不允许外借对象直接访问对象的内部信息，但是可以提供一些方法供外部对象操作使用。
1）封装举例：就像一台空调，不知道里面的零件和工作的原理（属性信息），但是可以通过提供的遥控器（访问方法）进行使用。如果没有遥控器，空调也无法使用。 - 继承：不同类型的对象，相互之间经常有一定数量的共同点。通过继承能够在已存在的类定义基础上建立新类的技术。提高代码的复用性，提高开发效率。
1）继承举例：作为一个人，我们有很多信息：身高，性别，年龄等；作为一个男人，是属于人的，所以很多信息是相同的，可以继承人这个类，然后再添加一些男人特有的信息。 - 多态：一个对象具有多种状态，父类可以被多个子类继承。一个接口可以被多个对象实现。（一个子类只能继承一个对象，但是可以实现多个接口）
1）多态举例：作为一个人，有多种形态（男人和女人）对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
继承要注意的额外三点：
1） 子类拥有父类对象所有的属性和方法（包括 私有属性和私有方法），但是子类不能够使用父类私有属性和私有方法，只是拥有。
2）子类拥有自我的属性和方法，在父类基础上拓展。
3）子类可以用自己的方式实现父类的方法。
4.8 接口和抽象类有什么共同点和区别？
- 相同点：
1）都不能够被实例化，需要被实现或者继承
2）都可以包含抽象方法
3）都可以有默认实现的方法**（没看懂）** - 不同点：
1）接口主要是用于对类行为的约束；抽象类主要是代码复用，强调所属关系
2）一个子类只能继承一个父类，但是一个类能够实现多个接口
3）接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default
4.9 深拷贝和浅拷贝区别了解吗？什么是引用拷贝？
- 浅拷贝：
在堆上创建一个新的对象（引用拷贝是在栈上），如果原对象内部的属性为引用类型，则会复制内部对象的引用地址，两个对象共用同一个内部对象。仅仅复制对象的对象，而不是对象引用的对象。 - 深拷贝：
会复制整个对象，包括这个对象的全部内部对象。在栈中建立对象。复制对象引用的对象，和之前对象无关了。 - 引用拷贝：
就是两个不同的引用指向同一个对象。
4.10 Java创建对象有几种方式？
- new创建对象
- 通过反射机制创建对象
- 通过clone创建对象
- 通过序列化机制创建对象
4.11 抽象类，普通类和接口的区别
1）抽象类与普通类相比，就是拥有抽象方法，定义为abstract,其他大部分与普通类相同
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
（2）抽象类不能用来创建对象；
（3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
2）抽象类与接口相比：接口相当于是全部方法都是抽象方法的抽象类
（1）抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现
5 Java 常见对象
5.1 Object
Object 类是一个特殊的类，是所有类的父类
5.2 String、StringBuffer、StringBuilder 的区别？
- 三者的区别：
1）可变性：String不可变，后者可变
2）线程安全性：String线程安全，StringBuffer加了同步锁，也是线程安全的。StringBuilder线程不安全
3）性能：String 类型进行改变的时候，都会生成一个新的 String 对象。后两者不会，会在原有基础上修改，但是StringBuilder 比StringBuffer性能更好，只是没有线程安全
4）StringBuffer线程安全原因：StringBuilder是为了加强StringBuffer效率而存在的。在length()和capacity()、append等方法中，都有synchronized 关键字实现线程同步。 - 三者的使用说明：
1）操作少量的数据: 适用 String
2）单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
3）多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer
5.3 String 为什么是不可变的?
-
String 类:
定义：使用private static final 关键字修饰字符数组来保存字符串。 -
StringBuilder 与 StringBuffer ：
定义：都继承自 AbstractStringBuilder 类使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，提供字符串修改方法。 -
String不可变原因：
1）保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。
2）String 类被 final 修饰导致其不能被继承 -
StringBuilder 与 StringBuffer 可变原因：
没有使用 final 和 private 关键字修饰
提供字符串修改方法。 -
StringBuilder 与 StringBuffer的常用API
1）增加：append(“a”) /insert(index,‘a’)
2）删除：delete(start,end) / deleteCharAt(index)
3）修改：delete(start,end) / deleteCharAt(index)
4）查看：charAt(index)
5）反转：reverse()
StringBuilder string=new StringBuilder();
//1）增加
//(1)在末尾添加
string.append("a");
string.append("b");
string.append("c");
string.append("d");
string.append("e");
System.out.println("原来的="+string);
//(2)在指定位置添加
string.insert(1,"11");
System.out.println("插入后的="+string);
//2)删除
//(1)单个元素,指定位置的元素
string.deleteCharAt(1);
//(2)连续几个元素(start,end) ,采用包前不包后的原则
string.delete(1,3);
System.out.println("插入新的="+string);
//3）修改
string.setCharAt(1, 'z');
//4)查看
char temp=string.charAt(1);
System.out.println("char="+temp);
//5)反转字符串
string.reverse();
System.out.println("反转后的字符串="+string);
5.5 String#equals() 和 Object#equals() 有何区别？
参考文章：https://javaguide.cn/
static和final的区别