Android开发基本知识汇总

>>>>>>java中的原码,反码和补码以及~运算符理解

java中,正数的原码,反码和补码是一样的,
负数的反码为原码取反(符号位不变),负数的补码是反码加1,
比如,-10的原码是1000 1010,反码就是1111 0101,补码就是1111 0110,
~3运算过程:3的原码是0000 0011,~的意思是取反就是1111 1100,这个得到的是补码,然后转反码就是补码减1得到1111 1011,再取反得到原码(符号位不变)为1000 0100,也就是-4

>>>>>>java虚拟机和android的dalvik虚拟机、ART

JVM和Dalvik:
1)可执行程序的字节码不同,JVM是java字节码(.class文件),dalvik是dalvik字节码(.dex文件);
2)JVM基于栈架构,dalvik基于寄存器架构,dalvik速度比JVM更快;
3).class文件一般对应一个类,.dex一般对应大量类,dalvik对于各类中重复的字符串和常量进行了优化处理,减少了整个文件的体积,使IO读取速度加快
dalvik和ART
dalvik是在运行时通过JIT把dalvik字节码即时编译成机器码来运行的,而ART在7.0之前都是在安装的时候通过AOT把dalvik字节码全部转化为机器码的,这样在运行速度、电量消耗等都有很大提升;ART在7.0之后,在安装的时候也不会对dalvik字节码进行转化,而是在应用运行的时候通过JIT先把最常用的部分编译成机器码,并生成一个profile文件,然后,在应用空闲的时候定时的通过AOT把其他的部分编译成机器码并实时更新profile文件。

>>>>>>java中的几种算法:冒泡、快排、选择、插入

冒泡排序:依次比较对相邻元素进行比较,大的后移,小的前移

Android开发基本知识汇总_第1张图片
image.png

int[] arr = {....};
int tamp = 0;
for ( int i = 0;i < arr.length- 1;i++ ) {
  for ( int j = 0;j < arr.length- 1 - i ; j++ ) {
    if(arr[j] > arr[j+1]){
        tamp = arr[j];
        arr[j] = arr[j+1];
        arr[j+1] = tamp;
    }
  }
}

选择排序:从待排的元素中选出一最小元素作为首元素

int[] arr = {....};
int min_index = 0;
for(int i=0;i

插入排序:依次取出待排序的元素,插入到已排好序的序列中。

        int[] arr = {9,0,3,7,8,2,3,6,5};
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0 && arr[j - 1] > arr[j]; j--) {
                arr[j] ^= arr[j - 1];
                arr[j - 1] ^= arr[j];
                arr[j] ^= arr[j - 1];
            }
        }
>>>>>>java泛型

为啥需要泛型:功能复用,风险前移
什么是泛型:为了参数化类型,即将类型当做参数传给类、方法。
类型擦除:为了兼容低版本JDK,泛型只在编译期起作用,在运行期是没有泛型概念的。造成的问题是可以通过反射绕过编译器检查。
运行时如何获取泛型信息:类定义

List users = new ArrayList(){};//注意这里的双大括号
Type type = users.getClass().getGenericSuperclass();
ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
System.out.println(parameterizedType.getActualTypeArguments()[0].getTypeName());
>>>>>>Activity四种启动模式
>>>>>>android4.0到9.0每个版本变化
Android开发基本知识汇总_第2张图片
image.png

Android开发基本知识汇总_第3张图片
image.png
>>>>>>内存溢出、内存泄露,内存分析

内存溢出:某一时刻向系统申请的内存超过了系统能提供的最大值;
内存泄露:因为不当的编程操作导致该被回收的对象没有被GC及时回收,不断积累最终耗尽系统内存;在java中,虚拟机运行时内存区域主要包括如下几块:
1)程序计数器:行号指示器
2)虚拟机栈:主要包含局部变量表(基本数据类型)、操作栈、对象引用、返回值地址等;
3)java堆:对象实例和数组;
4)方法区:类信息、常量、静态变量、JIT编译的代码;
5)直接内存:一些IO操作;
其他还有如java本地虚拟机栈、常量池等。在java中,GC回收机制采用的不是一般的程序计数器模式,其用的是根搜索算法,根据根搜索算法,任何一个对象,只要其和gc roots之间不可达,那么该对象就会被标记为可回收对象。在java中,能够作为GC Roots的对象主要包括以下几种:
1)虚拟机栈中的引用的对象
2)方法区中的类静态属性引用的对象
3)方法区中的常量引用的对象
4)本地虚拟机栈中JNI引用的对象
所以,只要按照以上这四点来避免就可以了,比如不要在activity中使用非静态的handle之类的,这个就是因为在java中,非静态内部类会默认持有外部类的一个引用,而handle本身又会被message引用,导致的结果就是最终activity没有被及时释放;还比如不要在单例中去持有activity等context对象,单例的生命周期一般和应用的生命周期一致,这也导致context对象不能及时释放;还比如一些IO操作要及时close,直接内存也会导致内存泄露。
常用内存分析工具:MAT,LeakCanary,Memory Profiler

>>>>>>LeakCanary原理

1)首先要了解下Reference和ReferenceQueue,当需要检测某个对象是否被回收的时候,可以进行如下操作:首先是构建一个ReferenceQueue,然后创建Reference并和ReferenceQueue进行关联,那么,当某个对象要被回收的时候,Reference会被放置到ReferenceQueue中,所以,检测某个对象是否被回收只要到ReferenceQueue中去找对应的Reference,找到了,表示对象回收了,没找到,表示对象没有被回收;
2)虽然LeakCanary也能进行其他对象的检测(通过如下方式LeakCanary.install(this).watch(new Object());)这里仅以Activity检测为例,其先是通过application的registerActivityLifecycleCallbacks()方法注入了一个全局的activity生命周期监听器,然后把每个执行过onDestroy()的activity实例和Reference绑定并和ReferenceQueue进行了关联,并且为每个activity实例随机生成了一个key保存到Set集合中,然后由对应的WatchExecutor去判断对应的activity对象是否被回收,如果没有回收,就dump出相关的信息发送到通知栏。
LeakCanary也提供了Fragment的检测,但是要android8及以上平台才有用。

>>>>>>listview,recycleview,数据绑定实现
>>>>>>MVC、MVP、MVVM
>>>>>>IPC,binder和socket

0)binder驱动,其跟硬件没有任何关系,它只是一段运行在内核中的代码,通过一个名为/dev/binder的文件实现用户空间和内核空间数据交互;其主要职责包括:binder节点的建立、binder在进程间的传递、binder引用计数管理;

1)ServiceManager所在进程打开/dev/binder设备,将BINDER_SET_CONTEXT_MGR命令发送给Binder驱动,Binder驱动会为ServiceManager在内核中创建名为binder_context_mgr_node的节点,该节点即为ServiceManager的Binder实体,而该进程就成为ServiceManager;

2)在整个系统中只会存在一个binder_context_mgr_node节点,也就能为其固定访问的句柄(在android中该句柄为0),所以当某个客户端想要访问SM的时候,只要告诉Binder驱动其要访问的句柄为0即可;

3)每一个server提供者,都会将自己封装成数据包发送给binder驱动,binder驱动读取数据包的时候如果发现有binder实体,会为这些binder实体创建binder节点和访问句柄(大于0),然后将该句柄和名字发送给SM

4)client要访问某个服务的时候,因为其只知道要访问的服务的名字,所以它会把句柄为0的值和服务名打包发给binder驱动,binder驱动发现句柄为0,就会把请求交给ServiceManager,ServiceManager根据服务名找到对应的服务的访问句柄,通过binder驱动传给client。Client获取到访问的句柄后,把句柄和需要访问的服务再发给binder,根据句柄binder驱动能找到句柄所对应的服务,因为client和server在两个进程中,对象没法直接访问,这个问题还是需要借助binder驱动来处理,binder驱动会对服务做一层转换,给服务生成一个代理对象,然后把这个代理对象传给client,这个代理对象从client那里获取相关参数,然后交给被代理对象,最终完成特定功能并返回结果,这样一次完整的通信就完成了。
AIDL手动实现的一个简单例子:
服务:

package org.module.a.aidl;

import android.os.IInterface;

/**
 * IInterface规定了Server进程对象具备什么样的服务
 */
public interface IAidlHello extends IInterface {

    String sayHello(String message);

}

服务的抽象实现

package org.module.a.aidl;

import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

/**
 * 继承Binder(实现了IBinder ),表示其具备跨进程传输的能力
 */
public abstract class AbstractAidlHello extends Binder implements IAidlHello {

    static final java.lang.String DESCRIPTOR = "org.module.a.aidl.IAidlHello";

    static final int TRANSACTION_sayHello = IBinder.FIRST_CALL_TRANSACTION + 0;

    public AbstractAidlHello() {
        /**
         * Binder和IInterface(服务)关联,并制定了服务名
         */
        this.attachInterface(this,DESCRIPTOR);
    }


    /**
     * 客户端通过这个方法获取服务
     * @param binder
     * @return
     */
    public static IAidlHello asInterface(IBinder binder){
        if(binder == null){
            return null;
        }
        /**
         * Client和Server在同一个进程中,那么直接使用对象引用就可以了
         */
        IInterface localInterface = binder.queryLocalInterface(DESCRIPTOR);
        if(localInterface != null && localInterface instanceof IAidlHello){
            return (IAidlHello) localInterface;
        }

        /**
         * Client和Server不在同一个进程中,则使用代理对象
         */
        return new AidlHelloProxy(binder);
    }

    @Override
    public IBinder asBinder() {
        return this;
    }

    /**
     * 如果涉及到跨进程交互,这里面的参数来自于AidlHelloProxy的传递,返回结果也是通过AidlHelloProxy传递给Client。
     */
    @Override
    protected boolean onTransact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
        switch (code){
            case INTERFACE_TRANSACTION:
                reply.writeString(DESCRIPTOR);
                return true;
            case TRANSACTION_sayHello:
                // 获取参数
                String message = data.readString();
                // 处理逻辑
                String result = sayHello(message);
                // 返回结果
                reply.writeNoException();
                reply.writeString(result);
                return true;
        }
        return super.onTransact(code, data, reply, flags);
    }
}


服务的代理实现

package org.module.a.aidl;

import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;

/**
 * 服务的代理,用于跨进程通信中binder驱动和客户端交互,
 * 其作用主要是参数传递和返回值传递
 */
public class AidlHelloProxy implements IAidlHello {

    private IBinder mRemote;

    public AidlHelloProxy(IBinder iBinder) {
        this.mRemote = iBinder;
    }

    @Override
    public String sayHello(String message) {
        Parcel _data = Parcel.obtain();
        Parcel _reply = Parcel.obtain();
        // 1、设置代理的是哪个服务
        _data.writeInterfaceToken(AbstractAidlHello.DESCRIPTOR);
        // 2、设置参数
        _data.writeString(message);
        //
        try {
            /**
             * Proxy的作用,仅仅是为了传参和接收返回值,AbstractAidlHello 才是真正的接口实现者。
             * 这里参数最终也是传给AbstractAidlHello的onTransact方法,返回值也是onTransact方法的返回值。
             */
            // 3、传参
            mRemote.transact(AbstractAidlHello.TRANSACTION_sayHello,_data,_reply,0);
            _reply.readException();
            // 4、接收返回值
            return _reply.readString();
        } catch (RemoteException e) {
            e.printStackTrace();
        } finally {
            _data.recycle();
            _reply.recycle();
        }
        return null;
    }

    @Override
    public IBinder asBinder() {
        return mRemote;
    }

    public String getInterfaceDescriptor() {
        return AbstractAidlHello.DESCRIPTOR;
    }
}

>>>>>>View事件分发机制
>>>>>>View的工作原理
>>>>>>android对应用资源的加载过程
>>>>>>packagemanagerservice分析
>>>>>>Activity启动过程
>>>>>>Handler/HandlerThread
>>>>>>classloader,热修复
>>>>>>okhttp原理,volley原理,glide原理,ORM数据库框架

你可能感兴趣的:(Android开发基本知识汇总)