2024.2.10 面经+Java基础

面经

1 南京小米Java开发二面

小米南京——Java二面_牛客网

1.runable和Thread的区别

他们两个除了最主要的区别：一个是接口，一个是实现类。常用接口可以避免单继承的局限性外，还有继承Thread类的方式可能会导致类的局部变量不能正确的被共享。因为每个线程都是一个独立的对象，它们之间不能共享实例变量，如果需要共享变量，就必须使用静态变量或共享对象锁。而使用Runnable接口的方式，多个线程可以共享同一个Runnable实例，从而共享实例变量。

使用Runnable接口可以更好的体现面向对象编程的思想，把任务和线程分离开来。任务可以看作是一个对象，而线程可以看作是该对象的执行者。这样就可以更好的实现模块化设计，提高代码的可重用性和可维护性。

使用Runnable接口可以更好地处理多个线程之间的交互和协作。因为Runnable实例可以作为参数传递给Thread构造函数，线程可以共享同一个Runnable实例，并且多个线程可以同时执行同一个Runnable实例的不同方法，从而实现多个线程之间的交互和协作。总的来说，使用Runnable接口的方式更加灵活和通用，可以实现更多的多线程编程场景，更好的体现面向对象编程的思想，提高代码的可重用性和可维护性。但是，使用Thread类的方式也有其适用的场景，例如在一些简单的多线程编程场景中可以使用继承Thread类的方式来实现。

2.final关键字的作用，如何实现不能被修改

final 关键字，意思是最终的、不可修改的，最见不得变化 ，用来修饰类、方法和变量，具有以下特点：

  1. final 修饰的类不能被继承，final 类中的所有成员方法都会被隐式的指定为 final 方法；
  2. final 修饰的方法不能被重写；
  3. final 修饰的变量是常量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能让其指向另一个对象。

说明：使用 final 方法的原因有两个：

  1. 把方法锁定，以防任何继承类修改它的含义；
  2. 效率。在早期的 Java 实现版本中，会将 final 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的 Java 版本已经不需要使用 final 方法进行这些优化了）。

3.java反射

反射机制是一种让我们在运行时分析类以及执行类中方法的能力。通过反射，我们可以获取任意一个类的所有属性和方法，并调用它们。它使得我们的代码更加灵活，为各种框架提供了便利。虽然反射带来了灵活性，但也增加了安全问题，并且性能稍差。在实际开发中，大量框架如Spring、MyBatis都广泛使用了反射。反射的应用场景包括动态代理、注解实现等，通过反射可以获取类、属性、方法以及方法参数上的注解，进而实现各种高级功能。

4.使用Executors创建有10个线程的线程池

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.zr.demo01;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 使用Executors创建有10个线程的线程池,该线程池的线程都是待机状态,所以避免了开启新线程的时间
 * @author ZR
 *
 */
public class Seventeenth {

	public static void main(String[] args) {
		MyRunable myRunable=new MyRunable();
		
		//有10个线程的线程池
		ExecutorService service = Executors.newFixedThreadPool(10);
		
		//使用4个线程
		service.submit(myRunable);
		service.submit(myRunable);
		service.submit(myRunable);
		service.submit(myRunable);
		
		//关闭线程池
		service.shutdown();
	}

}

class MyRunable implements Runnable{
	private static int i=1;
	
	@Override
	public void run() {
		while(true) {
			synchronized (MyRunable.class) {
				if (i<=100) {
					System.out.println(Thread.currentThread().getName()+"------------------->"+i);
					i++;
				}else {
					return;
				}
			}	
		}
	}
}

Java基础

1 抽象类

*1.1 概述

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类只需要提供一个没有方法体的定义即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

  • 抽象方法 ：没有方法体的方法。
  • 抽象类：包含抽象方法的类。

*1.2 abstract使用格式

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

1.抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

1
修饰符 abstract 返回值类型 方法名 (参数列表)；

2.抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

1
2
3
abstract class 类名字 { 
  
}

要求：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

1.3 抽象类的特征

抽象类的特征总结起来可以说是 有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

其他成员（构造方法，实例方法，静态方法等）抽象类都是具备的。

1.4 抽象类的细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

  1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

  2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

  3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

    理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

  4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

    理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

  5. 抽象类存在的意义是为了被子类继承。

    理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

*1.5 抽象类存在的意义

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义。抽象类可以强制让子类一定要按照规定的格式进行重写。

2 接口

2.1 概述

我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的。

定义格式

1
2
3
4
5
6
7
//接口的定义格式：
interface 接口名称{
    // 抽象方法
}

// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

*2.2 接口成分的特点

在JDK7，包括JDK7之前，接口中的只有包含：抽象方法和常量。

抽象方法

注意：接口中的抽象方法默认会自动加上public abstract修饰，程序员无需自己手写！！

按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

常量

在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

*2.3 基本的实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

实现接口的格式

1
2
3
4
5
6
/**接口的实现：
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
class 类名 implements 接口1,接口2,接口3...{

}

类实现接口的要求和意义

  1. 必须重写实现的全部接口中所有抽象方法。
  2. 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
  3. 意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。

2.4 接口与接口的多继承

Java中，接口与接口之间是可以多继承的：也就是一个接口可以同时继承多个接口。大家一定要注意：

类与接口是实现关系

接口与接口是继承关系

接口继承接口就是把其他接口的抽象方法与本接口进行了合并。

2.5 接口的细节

不需要背，只要当idea报错之后，知道如何修改即可。

关于接口的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

  1. 当两个接口中存在相同抽象方法的时候，该怎么办？

只要重写一次即可。此时重写的方法，既表示重写1接口的，也表示重写2接口的。

  1. 实现类能不能继承A类的时候，同时实现其他接口呢？

继承的父类，就好比是亲爸爸一样
实现的接口，就好比是干爹一样
可以继承一个类的同时，再实现多个接口，只不过，要把接口里面所有的抽象方法，全部实现。

  1. 实现类能不能继承一个抽象类的时候，同时实现其他接口呢？

实现类可以继承一个抽象类的同时，再实现其他多个接口，只不过要把里面所有的抽象方法全部重写。

  1. 实现类Zi，实现了一个接口，还继承了一个Fu类。假设在接口中有一个方法，父类中也有一个相同的方法。子类如何操作呢？

处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。
处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

  1. 如果一个接口中，有10个抽象方法，但是我在实现类中，只需要用其中一个，该怎么办?

可以在接口跟实现类中间，新建一个中间类（适配器类）
让这个适配器类去实现接口，对接口里面的所有的方法做空重写。
让子类继承这个适配器类，想要用到哪个方法，就重写哪个方法。
因为中间类没有什么实际的意义，所以一般会把中间类定义为抽象的，不让外界创建对象

3 内部类

3.1 概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

什么时候使用内部类

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用：

  1. 人里面有一颗心脏。
  2. 汽车内部有一个发动机。
  3. 为了实现更好的封装性。

3.2 内部类的分类

按定义的位置来分

  1. 成员内部类，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)；
  2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)；
  3. 局部内部类，类定义在方法内；
  4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

3.3 成员内部类

成员内部类特点：

  • 无static修饰的内部类，属于外部类对象的。例如，ArrayList类就包含了一个实现了Iterator的内部类。
  • 宿主：外部类对象。

内部类的使用格式：

1
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

1
外部类.内部类 变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

成员内部类的细节

编写成员内部类的注意点：

  1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
  2. 在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。
  3. 创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。

成员内部类内存图

内部类内存图

3.7 静态内部类

静态内部类特点：

  • 静态内部类是一种特殊的成员内部类。
  • 有static修饰，属于外部类本身的。
  • 总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。
  • 拓展1:静态内部类可以直接访问外部类的静态成员。
  • 拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。
  • 拓展3:静态内部类中没有银行的Outer.this。

内部类的使用格式：

1
外部类.内部类。

静态内部类对象的创建格式：

1
外部类.内部类  变量 = new 外部类.内部类构造器;

调用方法的格式：

  • 调用非静态方法的格式：先创建对象，用对象调用
  • 调用静态方法的格式：外部类名.内部类名.方法名();

3.8 局部内部类

  • 局部内部类 ：定义在方法中的类。

定义格式:

1
2
3
4
5
6
7
8
9
10
11
class 外部类名 {
	数据类型 变量名;
	
	修饰符 返回值类型 方法名(参数列表) {
		// …
		class 内部类 {
			// 成员变量
			// 成员方法
		}
	}
}

*3.9 匿名内部类

匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。格式如下：

1
2
3
new 类名或者接口名() {
     重写方法;
};

包含了：

  • 继承或者实现关系

  • 方法重写

  • 创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

什么时候用到匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

匿名内部类前提和格式

匿名内部类必须继承一个父类或者实现一个父接口。

1
2
3
4
5
6
7
new 父类名或者接口名(){
    // 方法重写
    @Override 
    public void method() {
        // 执行语句
    }
};

匿名内部类的特点

  1. 定义一个没有名字的内部类；
  2. 这个类实现了父类或者父类接口；
  3. 匿名内部类会创建这个没有名字的类的对象。

匿名内部类的使用场景

通常在方法的形式参数是接口或者抽象类时，也可以将匿名内部类作为参数传递。当你在项目中需要一个临时的小功能，但是又不想专门创建一个新的类来实现它，这时候匿名内部类就派上用场了。

比如，你在Swing界面中点击按钮后需要执行一些操作，你可以用匿名内部类来写这个按钮的点击事件监听器。或者，你需要在某个方法里开启一个新的线程去做一些事情，你可以使用匿名内部类创建这个线程对象。

2024.2.10 面经+Java基础
https://fulequn.github.io/2024/02/Article202402101/
作者
Fulequn
发布于
2024年2月10日
许可协议