Java基础知识
基本概念
1. Java语言的优点
- Java语言是纯面向对象的语言
- 平台无关性
- Java提供了很多内置类库
- 提供了对web应用开发的支持
- 具有较好的安全性和健壮性
- 去除了C++语言中难以理解，容易混淆的特性，使程序更加严谨，简洁
2. Java与c/c++有什么异同
- Java与C++都是面向对象的语言，都使用了面向对象的思想（封装、继承、多态）
- Java为解释性语言
- Java为纯面向对象的语言，所有代码（包括函数、变量等）必须在类中实现，除了基本类型（包括int、float等）外，所有类型都是类。
- ···
3. 为什么需要public static void main(String[] args)这个方法
main是JVM识别的特殊方法名，是程序的入口方法，程序开始执行时，没有实例化的对象，所以main()方法需要被定义成public和static才能执行。
4. Java程序的初始化的顺序是怎么样的
Java程序初始化的原则：
- 静态对象（变量）优先于非静态对象（变量）初始化，其中，静态对象（变量）只初始化一次，而非静态对象（变量）可能初始化多次
- 父类优先于子类进行初始化
- 按照成员变量的定义顺序进行初始化
Java程序的代码块顺序
- 父类静态变量
- 父类静态代码块
- 子类静态变量
- 子类静态代码块
- 父类非静态变量
- 父类非静态代码块
- 父类构造函数
- 子类非静态变量
- 子类非静态代码块
- 子类构造函数
初始化程序示例
/**
* 创建时间 2021/7/29 11:20
* 初始化顺序
* @author Ye
* @version 1.0
*/
class Base {
static {
System.out.println("Base static block");
}
{
System.out.println("Base block");
}
public Base(){
System.out.println("Base constructor");
}
}
public class Derived extends Base{
static {
System.out.println("Derived static block");
}
{
System.out.println("Derived block");
}
public Derived(){
System.out.println("Derived constructor");
}
public static void main(String[] args) {
new Derived();
}
}
运行结果
5. Java中的作用域
Java中，变量的类型主要有3种：成员变量、静态变量和局部变量。类的成员变量的作用范围与类的实例化对象的作用范围相同。static修饰的成员变量称为静态变量或者全局变量，静态变量不依赖于特定实例，被所有实例共享。局部变量的作用域与可见性在它的花括号内。
成员变量的4种作用域
| 作用域 与可见性 | 当前类 | 同一package | 子类 | 其他package |
|---|---|---|---|---|
| public | 1 | 1 | 1 | 1 |
| private | 1 | 0 | 0 | 0 |
| protected | 1 | 1 | 1 | 0 |
| default | 1 | 1 | 0 | 0 |
6. 一个Java文件中是否可以定义多个类
一个Java文件中可以定义多个类，但是最多只能有一个类被public修饰，并且这个类的类名与文件名必须相同。
7. 什么构造函数
构造函数是一种特殊的函数，用来在对象实例化初始化对象的成员变量。在Java语言中，构造函数的特点如下：
- 构造函数必须与类的名字相同，并且不能有返回值（返回值也不能为void）
- 每个类可以有多个构造函数
- 构造函数可以有0个，1个或者1个以上的参数
- 构造函数总是伴随着new操作一起调用，且不能由程序的编写者直接调用，必须由系统调用
- 构造函数主要作用是完成对象的初始化工作
- 构造函数不能被继承
- 当父类没有提供无参构造函数时，子类构造函数必须通过super显式的调用父类的构造函数
8. 为什么Java中有些接口没有任何方法
由于Java不支持多重继承，经常采用实现多个接口来间接达到多重继承的目的。在Java语言中，有些接口没有任何方法，这些没有方法的接口又被叫标识接口，标识接口对它的类没有任何语义要求，它仅仅充当一个标识的作用。
9. Java中的clone方法有什么作用
Java中基本数据类型是按值传递，除此之外都是引用传递。在实际的编程中，经常需要创建一个与已经存在的对象具有相同状态的对象，clone的作用就在与此。实现方法：
- 实现Cloneable接口（标识接口）
- 重写Object中的clone()方法
- 在clone方法中调用super.clone()
- 把浅复制的引用指向原型对象新的克隆体
浅复制是指只复制一个对象，但是不复制对象的当前状态
浅复制代码示例：
/**
* 创建时间 2021/7/29 17:30
* clone浅复制
* @author Ye
* @version 1.0
*/
class Copy implements Cloneable{
private int data = 0;
public int getData(){
return data;
}
public void setData(int data) {
this.data = data;
}
public void changeData(){
data = 1;
}
@Override
public Object clone(){
Object obj = null;
try{
obj = (Copy)super.clone();
}catch (Exception e){
e.printStackTrace();
}
return obj;
}
}
public class TestRef {
public static void main(String[] args) {
Copy copy = new Copy();
Copy copy1 = (Copy)copy.clone();
copy1.changeData();
System.out.println("copy: "+copy.getData());
System.out.println("copy1: "+copy1.getData());
}
}
运行截图：
深复制：指既复制对象又复制对象的状态
深复制示例代码：
import java.util.Date;
/**
* 创建时间 2021/7/29 18:28
* 深复制
* @author Ye
* @version 1.0
*/
class Obj implements Cloneable{
private Date birth = new Date();
public Date getData(){
return birth;
}
public void setData(Date birth) {
this.birth = birth;
}
public void changeData(){
this.birth.setTime(100000);
}
@Override
public Object clone(){
Object obj = null;
try{
obj = (Obj)super.clone();
}catch (Exception e){
e.printStackTrace();
}
//实现深复制
((Obj) obj).birth = (Date)this.birth.clone();
return obj;
}
}
/**
* 创建时间 2021/7/29 18:28
* 深复制
* @author Ye
* @version 1.0
*/
public class TestRef1 {
public static void main(String[] args) {
Obj obj = new Obj();
Obj obj1 = (Obj) obj.clone();
obj1.changeData();
System.out.println("obj: " + obj.getData());
System.out.println("obj1: " + obj1.getData());
}
}
运行截图：
10. 什么是反射机制
反射机制是Java语言中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。反射机制的主要功能有：
- 得到一个对象所属的类
- 获取一个类的所有成员变量和方法
- 在运行时创建对象
- 在运行时调用对象的方法
代码示例：
class Base1{
public void fun(){
System.out.println("Base");
}
}
class Sub1 extends Base1{
@Override
public void fun(){
System.out.println("Sub");
}
}
/**
* 创建时间 2021/7/29 19:15
* 反射测试
* @author Ye
* @version 1.0
*/
public class ReflectionTest {
public static void main(String[] args) {
try{
// 使用反射机制加载类
Class sub = Class.forName("com.test.test.Sub1");
Base1 base = (Base1)sub.newInstance();
base.fun();
}catch (Exception e){
e.printStackTrace();
}
}
}
运行截图：
Java创建对象的4种方法：
- 通过new语句实例化一个对象
- 通过反射机制创建对象
- 通过clone()创建一个对象
- 通过反序列化的方式创建对象
11.如何实现类似于C语言中函数指针的功能
可以先定义一个接口，在接口中声明一个要调用的方法，接着实现这个接口，最后把这个实现类的一个对象作为参数传递给调用程序，调用程序通过这个参数来调用指定的函数，从而实现回调函数的功能。
具体代码如下：
interface IntCompare{
public int cmp(int a,int b);
}
class Cmp1 implements IntCompare{
@Override
public int cmp(int a, int b) {
if (a > b){
return 1;
}else if (a < b){
return -1;
}else {
return 0;
}
}
}
class Cmp2 implements IntCompare{
@Override
public int cmp(int a, int b) {
if (a > b){
return -1;
}else if (a < b){
return 1;
}else {
return 0;
}
}
}
/**
* 创建时间 2021/7/29 19:56
* java实现类似指针功能
* @author Ye
* @version 1.0
*/
public class Test3 {
public static void insertSort(int[] a,IntCompare cmp){
if (a != null){
for (int i=1;i<a.length;i++){
int temp = a[i],j = i;
if (cmp.cmp(a[j-1],temp) == 1){
while (j >= 1 && cmp.cmp(a[j-1],temp) == 1){
a[j] = a[j-1];
j--;
}
}
a[j] = temp;
}
}
}
public static void main(String[] args) {
int[] array1 = {8,9,6,5,2,1,3};
insertSort(array1,new Cmp1());
System.out.print("升序排序： ");
for (int i = 0;i < array1.length;i++){
System.out.print(array1[i] + " ");
}
System.out.println();
int[] array2 = {8,9,6,5,2,1,3};
insertSort(array2,new Cmp2());
System.out.print("降序排序： ");
for (int i = 0;i < array2.length;i++){
System.out.print(array2[i] + " ");
}
}
}
运行截图：
参考：《Java程序员面试笔试宝典》 何昊、薛鹏、叶向阳 编著