Android面试知识点-java篇

最新推荐文章于 2024-09-09 15:43:07 发布

Carry_yang

最新推荐文章于 2024-09-09 15:43:07 发布

阅读量729

点赞数

CC 4.0 BY-SA版权

分类专栏： java Android 文章标签： android 面试

本文链接：https://blog.youkuaiyun.com/yangshaoby/article/details/52662353

java Android 专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了Java语言的关键概念和技术细节，包括抽象、继承、多态、泛型、枚举、线程管理、反射机制、引用类型、垃圾回收机制、类加载机制以及集合框架等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Android面试知识点总结-java篇

1. 对抽象，继承和多态的理解

java 中一个类只能继承于另一个类，继承带来了三个好处：减少代码冗余；维护变得简单；扩展变得容易。构造方法不能被继承！一个类得到构造构造方法只有两种途径：自定义构造方法；使用JVM分配的缺省构造方法。但是，可以在子类中可以通过super关键字访问父类的构造方法。

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

包含抽象方法的类称为抽象类，它和普通类一样，同样可以拥有成员变量和普通的成员方法，如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。接口中的变量会被隐式地指定为public static final变量（并且只能是publicstatic final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是publicabstract方法。

为什么接口中的常量必须使用public static final修饰？
public: 使接口的实现类可以使用这个常量
static：static修饰就表示它属于类的，随的类的加载而存在的，如果是非static的话，
就表示属于对象的，只有建立对象时才有它，而接口是不能建立对象的，所以
接口的常量必须定义为static
final：final修饰就是保证接口定义的常量不能被实现类去修改，如果没有final的话，
由子类随意去修改的话，接口建立这个常量就没有意义了。

2. 泛型的作用及使用场景

泛型是在类设计的时候，并不指定要处理的数据类型，而是在类使用的时候，实例化对象时指定传入的参数类型。使用场景：数据集（List Map），网络接口。

3. 枚举的特点及使用场景

枚举是我们自己定义的一个集合，比如说我们数学里面所学的集合A={1、2、3},当我们要使用A这个集合的时候，我们只能够使用集合A里面的1、2、3这三个元素，不是A里面的元素我们就不可以使用。

同样，枚举和这个集合是类似的，当我们定义了一个枚举类型的时候，我们声明它里面有几个元素，在我们使用这个枚举的时候，我们只能够使用它有的元素，没有的元素我们是无法使用，系统就会报错！

枚举还有一个特点，就是可以代表数值，比如说第一个定义的元素对应的值为0，每个枚举元素从0开始，逐一增加。此时，这个数值也代表他们本身，相当于每一个元素有两个名字。

常使用的地方：我们要从另一个函数得到一个值，但是这个值只能够在一个范围内的，此时我们就可以使用枚举来定义这个范围。限制另外一个函数能够传递进来的值，只能够是枚举类型里面的元素

4. 线程sleep和wait的区别

1、这两个方法来自不同的类分别是Thread和Object

　　2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

　　3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）

　　4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常。

5. java的反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

实现原理：Class类十分特殊。它和一般类一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces。当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM便自动产生一个Class对象。

1，反射机制获取类有三种方法，我们来获取Person类型

第一种方式：

Class c1 =Class.forName("Person");

第二种方式：

java中每个类型都有class 属性.

Class c2 = Person.class;

第三种方式：

//java语言中任何一个java对象都有getClass 方法

Person e =new Person ();

Class c3 =e.getClass(); //c3是运行时类 (e的运行时类是Person)

2，创建对象：获取类以后我们来创建它的对象，利用newInstance：

Class c =Class.forName("Person ");

//创建此Class 对象所表示的类的一个新实例

Object o = c.newInstance(); //调用了Person的无参数构造方法.

3,获取属性和方法。

获取所有属性的方法：

Class c =Class.forName("java.lang.Integer");

//获取所有的属性?

Field[] fs= c.getDeclaredFields();

//定义可变长的字符串，用来存储属性

StringBuffer sb = new StringBuffer();

//通过追加的方法，将每个属性拼接到此字符串中

//最外边的public定义

sb.append(Modifier.toString(c.getModifiers()) + " class " +c.getSimpleName() +"{\n");

//里边的每一个属性

for(Fieldfield:fs){

sb.append("\t");//空格

sb.append(Modifier.toString(field.getModifiers())+"");//获得属性的修饰符，例如public，static等等

sb.append(field.getType().getSimpleName()+ " ");//属性的类型的名字

sb.append(field.getName()+";\n");//属性的名字+回车

}

sb.append("}");

System.out.println(sb);

6. weak/soft/strong引用的区别

如果一个对象具有强引用，垃圾回收器绝不会回收它。当内存空间不足，Java虚拟机宁愿抛出OutOfMemoryError错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。

如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收，JAVA虚拟机就会把这个软引用加入到与之关联的引用队列中。

如果一个对象只具有弱引用，那就类似于可有可物的生活用品。弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被垃圾回收，Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

"虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收。虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列（ReferenceQueue）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

特别注意，在世纪程序设计中一般很少使用弱引用与虚引用，使用软用的情况较多，这是因为软引用可以加速JVM对垃圾内存的回收速度，可以维护系统的运行安全，防止内存溢出（OutOfMemory）等问题的产生。

来源：http://blog.youkuaiyun.com/lengyuhong/article/details/6398184

7. Object的hashCode()与equals()的区别与作用

规范1：若重写equals(Object obj)方法，有必要重写hashcode()方法，确保通过equals(Object obj)方法判断结果为true的两个对象具备相等的hashcode()返回值。说得简单点就是：“如果两个对象相同，那么他们的hashcode应该相等”。不过请注意：这个只是规范，如果你非要写一个类让equals(Object obj)返回true而hashcode()返回两个不相等的值，编译和运行都是不会报错的。不过这样违反了Java规范，程序也就埋下了BUG。

规范2：如果equals(Objectobj)返回false，即两个对象“不相同”，并不要求对这两个对象调用hashcode()方法得到两个不相同的数。说的简单点就是：“如果两个对象不相同，他们的hashcode可能相同”。

根据这两个规范，可以得到如下推论：

1、如果两个对象equals，Java运行时环境会认为他们的hashcode一定相等。

2、如果两个对象不equals，他们的hashcode有可能相等。

3、如果两个对象hashcode相等，他们不一定equals。

4、如果两个对象hashcode不相等，他们一定不equals。

来源：http://blog.youkuaiyun.com/lclai/article/details/6195104

8. java的类加载机制

类加载过程：初始化，装载，验证，准备

类加载器

(1) BootstrapClassLoader : 将存放于<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar 名字不符合的类库即使放在lib目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被Java程序直接引用

(2) ExtensionClassLoader : 将<JAVA_HOME>\lib\ext目录下的，或者被java.ext.dirs系统变量所指定的路径中的所有类库加载。开发者可以直接使用扩展类加载器。

(3) ApplicationClassLoader : 负责加载用户类路径(ClassPath)上所指定的类库,开发者可直接使用。

双亲委派模型

工作过程：如果一个类加载器接收到了类加载的请求，它首先把这个请求委托给他的父类加载器去完成，每个层次的类加载器都是如此，因此所有的加载请求都应该传送到顶层的启动类加载器中，只有当父加载器反馈自己无法完成这个加载请求（它在搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载。

好处：java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object，它存放在rt.jar中，无论哪个类加载器要加载这个类，最终都会委派给启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。相反，如果用户自己写了一个名为java.lang.Object的类，并放在程序的Classpath中，那系统中将会出现多个不同的Object类，java类型体系中最基础的行为也无法保证，应用程序也会变得一片混乱。

来源：http://www.cnblogs.com/ITtangtang/p/3978102.html

2. jvm垃圾回收机制

许多语言利用栈数据结构来记录函数调用的次序和相关变量(参考Linux从程序到进程)。

在Java中，JVM中的栈记录了线程的方法调用。每个线程拥有一个栈。在某个线程的运行过程中，如果有新的方法调用，那么该线程对应的栈就会增加一个存储单元，即帧(frame)。在frame中，保存有该方法调用的参数、局部变量和返回地址。

3. 调用栈

Java的参数和局部变量只能是基本类型的变量(比如int)，或者对象的引用(reference)。因此，在栈中，只保存有基本类型的变量和对象引用。

引用所指向的对象保存在堆中。(引用可能为Null值，即不指向任何对象)

4. 引用与对象

当被调用方法运行结束时，该方法对应的帧将被删除，参数和局部变量所占据的空间也随之释放。线程回到原方法，继续执行。当所有的栈都清空时，程序也随之运行结束。

5. 堆

如上所述，栈(stack)可以自己照顾自己。但堆必须要小心对待。堆是JVM中一块可自由分配给对象的区域。当我们谈论垃圾回收(garbage collection)时，我们主要回收堆(heap)的空间。

Java的普通对象存活在堆中。与栈不同，堆的空间不会随着方法调用结束而清空。因此，在某个方法中创建的对象，可以在方法调用结束之后，继续存在于堆中。这带来的一个问题是，如果我们不断的创建新的对象，内存空间将最终消耗殆尽。

6. 垃圾回收

垃圾回收(garbage collection，简称GC)可以自动清空堆中不再使用的对象。垃圾回收机制最早出现于1959年，被用于解决Lisp语言中的问题。垃圾回收是Java的一大特征。并不是所有的语言都有垃圾回收功能。比如在C/C++中，并没有垃圾回收的机制。程序员需要手动释放堆中的内存。

由于不需要手动释放内存，程序员在编程中也可以减少犯错的机会。利用垃圾回收，程序员可以避免一些指针和内存泄露相关的bug(这一类bug通常很隐蔽)。但另一方面，垃圾回收需要耗费更多的计算时间。垃圾回收实际上是将原本属于程序员的责任转移给计算机。使用垃圾回收的程序需要更长的运行时间。

在Java中，对象的是通过引用使用的(把对象相像成致命的毒物，引用就像是用于提取毒物的镊子)。如果不再有引用指向对象，那么我们就再也无从调用或者处理该对象。这样的对象将不可到达(unreachable)。垃圾回收用于释放不可到达对象所占据的内存。这是垃圾回收的基本原则。

(不可到达对象是死对象，是垃圾回收所要回收的垃圾)

早期的垃圾回收采用引用计数(reference counting)的机制。每个对象包含一个计数器。当有新的指向该对象的引用时，计数器加1。当引用移除时，计数器减1。当计数器为0时，认为该对象可以进行垃圾回收。

然而，一个可能的问题是，如果有两个对象循环引用(cyclic reference)，比如两个对象互相引用，而且此时没有其它(指向A或者指向B)的引用，我们实际上根本无法通过引用到达这两个对象。

因此，我们以栈和static数据为根(root)，从根出发，跟随所有的引用，就可以找到所有的可到达对象。也就是说，一个可到达对象，一定被根引用，或者被其他可到达对象引用。

7. 橙色，可到达；绿色，不可到达

8. JVM实施

JVM的垃圾回收是多种机制的混合。JVM会根据程序运行状况，自行决定采用哪种垃圾回收。

我们先来了解"mark and sweep"。这种机制下，每个对象将有标记信息，用于表示该对象是否可到达。当垃圾回收启动时，Java程序暂停运行。JVM从根出发，找到所有的可到达对象，并标记(mark)。随后，JVM需要扫描整个堆，找到剩余的对象，并清空这些对象所占据的内存。

另一种是"copy and sweep"。这种机制下，堆被分为两个区域。对象总存活于两个区域中的一个。当垃圾回收启动时，Java程序暂停运行。JVM从根出发，找到可到达对象，将可到达对象复制到空白区域中并紧密排列，修改由于对象移动所造成的引用地址的变化。最后，直接清空对象原先存活的整个区域，使其成为新的空白区域。

可以看到，"copy and sweep"需要更加复杂的操作，但也让对象可以紧密排列，避免"mark and sweep"中可能出现的空隙。在新建对象时，"copy and sweep"可以提供大块的连续空间。因此，如果对象都比较"长寿"，那么适用于"mark and sweep"。如果对象的"新陈代谢"比较活跃，那么适用于"copyand sweep"。

上面两种机制是通过分代回收(generationalcollection)混合在一起的。每个对象记录有它的世代(generation)信息。所谓的世代，是指该对象所经历的垃圾回收的次数。世代越久远的对象，在内存中存活的时间越久。

根据对Java程序的统计观察，世代越久的对象，越不可能被垃圾回收(富人越富，穷人越穷)。因此，当我们在垃圾回收时，要更多关注那些年轻的对象。

现在，具体看一下JVM中的堆:

我们看到，堆分为三代。其中的永久世代(permanent generation)中存活的是Class对象。这些对象不会被垃圾回收。我们在RTTI中已经了解到，每个Class对象代表一个类，包含有类相关的数据与方法，并提供类定义的代码。每个对象在创建时，都要参照相应的Class对象。每个对象都包含有指向其对应Class对象的引用。

年轻世代(young generation)和成熟世代(tenured generation)需要进行垃圾回收。年轻世代中的对象世代较近，而成熟世代中的对象世代较久。

9. 世代

年轻世代进一步分为三个区域

eden(伊甸): 新生对象存活于该区域。新生对象指从上次GC后新建的对象。

10.新生对象生活于伊甸园

from, to: 这两个区域大小相等，相当于copy and sweep中的两个区域。

当新建对象无法放入eden区时，将出发minor collection。JVM采用copy and sweep的策略，将eden区与from区的可到达对象复制到to区。经过一次垃圾回收，eden区和from区清空，to区中则紧密的存放着存活对象。随后，from区成为新的to区， to区成为新的from区。

如果进行minor collection的时候，发现to区放不下，则将部分对象放入成熟世代。另一方面，即使to区没有满，JVM依然会移动世代足够久远的对象到成熟世代。

如果成熟世代放满对象，无法移入新的对象，那么将触发major collection。JVM采用mark and sweep的策略，对成熟世代进行垃圾回收。

来源：http://www.cnblogs.com/vamei/archive/2013/04/28/3048353.html

9. java数集框架

Collection是最基本的集合接口，由Collection接口派生的两个接口是List和Set。

实现List接口的常用类有LinkedList，ArrayList，Vector。

LinkedList实现了List接口，允许null元素。注意LinkedList没有同步方法。

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和 ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了 Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出 ConcurrentModificationException，因此必须捕获该异常。