Android面试准备之Android基础

最新推荐文章于 2024-05-28 18:32:40 发布
最新推荐文章于 2024-05-28 18:32:40 发布
阅读量3.6k 收藏
点赞数
文章标签： android java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuqing155/article/details/122903475
版权

一、Handler机制

创建一个Handler

//提示已过时
Handler handler = new Handler();
Handler handler = new Handler(Looper.myLooper());

隐式指定Looper的Handler初始化方法已被Android 11报过时，根据注释，是由于不指定Looper在一些场景下会导致任务丢失或程序崩溃，比如没有Looper的线程。

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

下面寻找这个Looper是在哪里初始化的

在ActivityThread.java#main中

public static void main(String[] args) {
	...
	Looper.prepareMainLooper();
	...
	Looper.loop();
}

Looper.java

public static void prepareMainLooper() {
    prepare(false);
    synchronized (Looper.class) {
        if (sMainLooper != null) {
            throw new IllegalStateException("The main Looper has already been prepared.");
        }
        sMainLooper = myLooper();
    }
}

private static void prepare(boolean quitAllowed) {
    if (sThreadLocal.get() != null) {
        throw new RuntimeException("Only one Looper may be created per thread");
    }
    sThreadLocal.set(new Looper(quitAllowed));
}

public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

根据ThreadLocal原理，调用Looper.prepare(boolean quitAllowed)时将该<ThreadLocal<Looper>,Looper>键值对设置到了当前线程的成员变量ThreadLocal.ThreadLocalMap threadLocals中，从而保证了每个线程对应唯一一个Looper，且不能被重复初始化，否则将抛出异常。而且Looper对象在初始化时也初始化了MessageQueue，并将当前线程保存在成员变量中。

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

以上初步实现了主线程对应sMainLooper，同时对应唯一一个MessageQueue。
下面分析Looper、MessageQueue、Handler如何运转起来

public static void loop() {
	final Looper me = myLooper();
	...
	final MessageQueue queue = me.mQueue;
	...
	//死循环
	for (;;) {
		Message msg = queue.next();
		...
		try {
			//将消息分发给相应Handler处理
            msg.target.dispatchMessage(msg);
            ...
        } 
	}
	...
}

下面看Handler处理消息的过程
从sendMessage()、postDelayed()、post()都会调用到enqueueMessage

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

下面看MessageQueue#enqueueMessage：

boolean enqueueMessage(Message msg, long when) {
	...
	synchronized (this) {
		...
		Message p = mMessages;
		boolean needWake;
		if (p == null || when == 0 || when < p.when) {
			// New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
		} else {
			...
			Message prev;
			for (;;) {
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
		}
		...//唤醒线程本地方法
	}
}

可以看到，消息入队时加了锁，保证了多个Handler向MessageQueue添加数据时的线程安全。添加消息首先判断队列中是否有消息，没有消息的时候需要对线程进行唤醒。如果不需要唤醒，则按照延迟时间入队。至于时间的判定，来自于Handler#sendMessageDelayed

public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

这个时间在SystemClock.java中有说明：

/**
 * Returns milliseconds since boot, not counting time spent in deep sleep.
 *
 * @return milliseconds of non-sleep uptime since boot.
 */
@CriticalNative
native public static long uptimeMillis();

根据注释，它获取的是系统从开机开始的时间，除去休眠时间。

相关面试问题：

  • Linux的epoll机制
  • 一个线程有几个Handler
  • 一个线程有几个Looper？如何保证？
  • 子线程可以创建Handler吗
  • 多个Handler往MessageQueue中添加数据，如何确保线程安全
  • Looper.loop()为什么不会阻塞主线程
  • Message的数据结构
  • Handler内存泄漏场景有哪些，如何避免

二、View绘制流程

Activity通过attach和Window关联起来，Window通过setContentView和View关联起来

从setContentView开始看绘制流程

public void setContentView(@LayoutRes int layoutResID) {
    getWindow().setContentView(layoutResID);
    initWindowDecorActionBar();
}

PhoneWindow#setContentView

public void setContentView(int layoutResID) {
    if (mContentParent == null) {
        installDecor();
    }
    ...
}

private void installDecor() {
	if (mDecor == null) {
        mDecor = generateDecor(-1);
        ...
    }
    ...
}

protected DecorView generateDecor(int featureId) {
	...
	return new DecorView(context, featureId, this, getAttributes());
}

PhoneWindow类中包含DecorView成员变量，由此将Window和View联系起来

下面看布局是怎么被设置进去的：

private void installDecor() {
	...//DecorView初始化
	if (mContentParent == null) {
        mContentParent = generateLayout(mDecor);
        ...
    }       
    ...
}

protected ViewGroup generateLayout(DecorView decor) {
	...
	int layoutResource;//系统加载布局资源id
    int features = getLocalFeatures();
    ...
    mDecor.startChanging();
    mDecor.onResourcesLoaded(mLayoutInflater, layoutResource);
}

DecorView.java

void onResourcesLoaded(LayoutInflater inflater, int layoutResource) {
	...
	final View root = inflater.inflate(layoutResource, null);
	...
	addView(root, 0, new ViewGroup.LayoutParams(MATCH_PARENT, MATCH_PARENT));
	...
}

根据设置的feature参数，按照类型加载系统布局资源文件，然后通过addView加载到自身DecorView中
然后回到PhoneWindow#setContentView：

mLayoutInflater.inflate(layoutResID, mContentParent);

到此自己的资源文件已经加载到mContentParent中，构成了一个完整的控件树。

  • 更新UI的线程检查
public ViewRootImpl(Context context, Display display, IWindowSession session,
            boolean useSfChoreographer) {
      ...
      mThread = Thread.currentThread();
      ...
}

void checkThread() {
    if (mThread != Thread.currentThread()) {
        throw new CalledFromWrongThreadException(
                "Only the original thread that created a view hierarchy can touch its views.");
    }
}

由此可见，检查的并非是主线程，而是ViewRootImpl创建时的线程，下面寻找ViewRootImpl是在哪里创建出来的。
通过打断点查看调用栈，能够找到调用链：

ActivityThread.java

@Override
public void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,
            String reason) {
	...
	final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);//执行Activity的onResume方法
	...
	wm.addView(decor, l);
	...
}

WindowManagerImpl.java

private final WindowManagerGlobal mGlobal = WindowManagerGlobal.getInstance();

public void addView(@NonNull View view, @NonNull ViewGroup.LayoutParams params) {
        applyDefaultToken(params);
        mGlobal.addView(view, params, mContext.getDisplayNoVerify(), mParentWindow,
                mContext.getUserId());
}

WindowManagerGlobal.java

public void addView(View view, ViewGroup.LayoutParams params,
            Display display, Window parentWindow, int userId) {
    ...
    root = new ViewRootImpl(view.getContext(), display);
    ....
    root.setView(view, wparams, panelParentView, userId);//此时也会将ViewRootImpl设置为DecorView的parent
    ...
}

每一个Activity都持有一个WindowManagerImpl对象，操作都会被转发给全局只有一个的WindowManagerGlobal对象。
由代码执行过程可以看出，设置的mThread一定是主线程。

  • 开始绘制

ViewRootImpl#setView：

public void setView(View view, WindowManager.LayoutParams attrs, View panelParentView,
            int userId) {
    synchronized (this) {
    	...
    	requestLayout();//开始绘制第一帧，执行测量布局绘制操作
    	...
    }
    ...
    view.assignParent(this);//将ViewRootImpl设置为DecorView的父View
}

public void requestLayout() {
    if (!mHandlingLayoutInLayoutRequest) {
        checkThread();
        mLayoutRequested = true;
        scheduleTraversals();
    }
}

void scheduleTraversals() {
	if (!mTraversalScheduled) {
		...
		mChoreographer.postCallback(
                Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);
        ...
	}
}

绘制第一帧的操作是在ViewRootIImpl中被调用，但调用时通过向主线程post一个Runnable实现的，所以绘制操作实际上是到下一次Loop循环时才会执行，而不是立即执行的

  • 如何在子线程更新UI
  1. 由于对于线程的检查是在ViewRootImpl初始化的时候做的，那么可以在子线程中创建一个ViewRootImpl就可以了
new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                //创建View
                getWindowManager().addView(创建的View, new WindowManager.LayoutParams());
                //更新UI操作
                Looper.loop();
            }
        }).start();
  1. 也可以开启硬件加速，并设置控件为固定大小，绕过线程检查

在硬件加速的支持下，如果控件只是经常了 invalidate() ，而没有触发
requestLayout() 是不会 触发 ViewRootImpl#checkThread() 的。

常见问题

  • 首次绘制触发时机以及ViewRootImpl创建时机

首次绘制是在 ActivityThread#handleResumeActivity 里触发的，调用链为WindowManagerImpl.addView -> WindowManagerGlobal.addView -> ViewRootImpl.setView -> ViewRootImpl.requestLayout，ViewRootImpl也是在 ActivityThread.handleResumeActivity 里创建的。

  • ViewRootImpl 和 DecorView 的关系

在 ViewRootImpl.setView 里，通过 DecorView.assignParent 把 ViewRootImpl 设置为 DecorView 的 parent。

三、触摸机制

  1. getAction和getActionMask区别

getAction获取到的是多点触控融合到一块的模糊信息，而getActionMask获取的是准确信息，支持多点触控。两者之间没有性能差别。

  1. onTouchEvent源码分析
public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int viewFlags = mViewFlags;
        final int action = event.getAction();
        //判断是否可点击
        final boolean clickable = ((viewFlags & CLICKABLE) == CLICKABLE
                || (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)
                || (viewFlags & CONTEXT_CLICKABLE) == CONTEXT_CLICKABLE;

        //如果被禁用，返回clickable的值，意味着如果被禁用，而clickable为true，那么这个事件被消费了，下面的view以及当前view的父view也收不到这个事件
        if ((viewFlags & ENABLED_MASK) == DISABLED) {
            if (action == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
                setPressed(false);
            }
            mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
            return clickable;
        }
        //触摸代理，增加点击区域
        if (mTouchDelegate != null) {
            if (mTouchDelegate.onTouchEvent(event)) {
                return true;
            }
        }

		//tooltip为解释工具，与xml中设置的tooltiptext相对应
		if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
			switch (action) {
                case MotionEvent.ACTION_UP:
                    ...
                    break;

                case MotionEvent.ACTION_DOWN:
                	...
                    break;
                case MotionEvent.ACTION_CANCEL:
                    ...
                    break;

                case MotionEvent.ACTION_MOVE:
                    ...
                    break;
            }
            return true;
		}
}

ACTION_DOWN分析

case MotionEvent.ACTION_DOWN:
		//判断是否触摸屏幕（而非实体按键）
        if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN) {
            mPrivateFlags3 |= PFLAG3_FINGER_DOWN;
        }
        mHasPerformedLongPress = false;
		//为了tooltip的设计
        if (!clickable) {
            checkForLongClick(
                    ViewConfiguration.getLongPressTimeout(),
                    x,
                    y,
                    TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
            break;
        }
		//早期功能，鼠标右键点击
        if (performButtonActionOnTouchDown(event)) {
            break;
        }

        // 递归判断是否在滑动控件里
        boolean isInScrollingContainer = isInScrollingContainer();
        if (isInScrollingContainer) {
        	//不知道用户滑动还是点击，先记录下预点击状态
            mPrivateFlags |= PFLAG_PREPRESSED;
            if (mPendingCheckForTap == null) {
            	mPendingCheckForTap = new CheckForTap();
            }
            mPendingCheckForTap.x = event.getX();
            mPendingCheckForTap.y = event.getY();
            postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
         } else {
            // 如果不在滑动控件中，设置为按下状态
            setPressed(true, x, y);
            //设置长按等待器，长按等待时间为500ms
            checkForLongClick(
                    ViewConfiguration.getLongPressTimeout(),
                    x,
                    y,
                    TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
        }
        break;

private final class CheckForTap implements Runnable {
        public float x;
        public float y;

        @Override
        public void run() {
        	//确认为点击事件而非滑动事件，预按下状态置空，设置为按下状态
            mPrivateFlags &= ~PFLAG_PREPRESSED;
            setPressed(true, x, y);
            //由于前面预按下状态等待了100ms，所以这里长按等待器设置另外等待400ms，与非滑动控件内的长按等待时间保持一致
            final long delay =
                    ViewConfiguration.getLongPressTimeout() - ViewConfiguration.getTapTimeout();
            checkForLongClick(delay, x, y, TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
        }
    }
  • 获取action用的是getAction，说明源码只支持单点触控，不支持多点。
  • 从代码逻辑中可以看出，clickable实际上控制是否可以消费事件，而disable控制是否可点击
  • 如果自定义一个不可滑动的ViewGroup，需要重写shouldDelayChildPressedState使其返回false，否则默认为可滑动控件，按下状态会延迟100ms

ACTION_DOWN核心操作为，标记为按下状态，并设置一个长按等待器。

ACTION_MOVE分析

case MotionEvent.ACTION_MOVE:
	if (clickable) {
		//效果中心改变，例如波纹效果
    	drawableHotspotChanged(x, y);
    }
	//这段目前不太清楚
    final int motionClassification = event.getClassification();
    final boolean ambiguousGesture =
        motionClassification == MotionEvent.CLASSIFICATION_AMBIGUOUS_GESTURE;
    int touchSlop = mTouchSlop;
    if (ambiguousGesture && hasPendingLongPressCallback()) {
    	if (!pointInView(x, y, touchSlop)) {
        	removeLongPressCallback();
            long delay = (long) (ViewConfiguration.getLongPressTimeout()
                                    * mAmbiguousGestureMultiplier);
            delay -= event.getEventTime() - event.getDownTime();
            checkForLongClick(
                delay,
                x,
                y,
                TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__LONG_PRESS);
        }
        touchSlop *= mAmbiguousGestureMultiplier;
	}

	//触摸出界，touchSlop为触摸边界
    if (!pointInView(x, y, touchSlop)) {
    	removeTapCallback();//移除预按下计时器
        removeLongPressCallback();//移除长按计时器
        if ((mPrivateFlags & PFLAG_PRESSED) != 0) {//取消按下状态
        	setPressed(false);
        }
        mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
    }

	//大力按下，则直接触发长按
    final boolean deepPress =
        motionClassification == MotionEvent.CLASSIFICATION_DEEP_PRESS;
    if (deepPress && hasPendingLongPressCallback()) {
    	removeLongPressCallback();
        checkForLongClick(
            0 /* send immediately */,
            x,
            y,
            TOUCH_GESTURE_CLASSIFIED__CLASSIFICATION__DEEP_PRESS);
     }

     break;

ACTION_UP分析

case MotionEvent.ACTION_UP:
	mPrivateFlags3 &= ~PFLAG3_FINGER_DOWN;
    if ((viewFlags & TOOLTIP) == TOOLTIP) {
    	//tooltip松手后延迟1.5s消失
    	handleTooltipUp();
    }
    if (!clickable) {
    	removeTapCallback();
        removeLongPressCallback();
        mInContextButtonPress = false;
        mHasPerformedLongPress = false;
        mIgnoreNextUpEvent = false;
        break;
    }
    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
    //按下或预按下状态
    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
        boolean focusTaken = false;
        //用于获取焦点，例如editText
    	if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
        	focusTaken = requestFocus();
        }

        if (prepressed) {
        	//预按下状态时抬起手指，设置为按下状态
        	setPressed(true, x, y);
        }

        if (!mHasPerformedLongPress && !mIgnoreNextUpEvent) {
        	removeLongPressCallback();
            if (!focusTaken) {
            	if (mPerformClick == null) {
                	mPerformClick = new PerformClick();
                }
                if (!post(mPerformClick)) {
                	//触发点击事件
                	performClickInternal();
                }
            }
        }

        if (mUnsetPressedState == null) {
        	mUnsetPressedState = new UnsetPressedState();
        }

		//预按下时间内抬起手指，前面设置为了按下状态，由于在同一个循环中，所以人为加一个延迟64ms来触发用户可感知的点击事件
        if (prepressed) {
        	postDelayed(mUnsetPressedState,
            	ViewConfiguration.getPressedStateDuration());
        } else if (!post(mUnsetPressedState)) {
            mUnsetPressedState.run();
        }

        removeTapCallback();
    }
    mIgnoreNextUpEvent = false;
    break;

ACTION_UP阶段做的事情是，触发点击事件，处理预点击状态下按下抬起效果，以及消除之前各种状态和runnable的设置。
ACTION_CANCEL只做了各种取消操作，这里不再单独分析。

  1. dispatchTouchEvent源码分析

ViewGroup的dispatchTouchEvent

public boolean dispatchTouchEvent(MotionEvent ev) {
	...
	//开启一个新的事件序列，清空之前的状态
	if (actionMasked == MotionEvent.ACTION_DOWN) {
    	cancelAndClearTouchTargets(ev);
    	resetTouchState();
    }

	//拦截处理
	final boolean intercepted;
    if (actionMasked == MotionEvent.ACTION_DOWN
            || mFirstTouchTarget != null) {
    final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
    	if (!disallowIntercept) {
        	intercepted = onInterceptTouchEvent(ev);
        	ev.setAction(action); // restore action in case it was changed
    	} else {
        	intercepted = false;
    	}
    } else {       
    	intercepted = true;
    }

	...
	if (!canceled && !intercepted) {
		...
		if (actionMasked == MotionEvent.ACTION_DOWN
            || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)//split和分屏状态有关
            || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
            ...
            newTouchTarget = getTouchTarget(child);//继续寻找能够消耗ACTION_DOWN事件的目标控件
        }
	}
}

private void resetTouchState() {
    clearTouchTargets();
    resetCancelNextUpFlag(this);
    mGroupFlags &= ~FLAG_DISALLOW_INTERCEPT;
    mNestedScrollAxes = SCROLL_AXIS_NONE;
}
  • 新事件序列清理状态时，有一个FLAG_DISALLOW_INTERCEPT标志，它与requestDisallowInterceptTouchEvent方法相对应，控制了此事件序列之间不会拦截事件，一般调用父view的该方法，保证事件不被父view拦截。
  • 拦截逻辑的处理：在事件为ACTION_DOWN时直接触发，其他的事件会根据是否存在消耗ACTION_DOWN事件的目标控件（即是否有mFirstTouchTarget记录）而决定。

四、ContraintLayout属性详解

  • 约束限制

限制控件大小不会超过约束范围

 app:layout_constrainedWidth="true"
  • 偏向

控制控件在垂直方向的30%的位置

app:layout_constraintVertical_bias="0.3"
  • 约束链

在约束链第一个控件加上chainStyle用来改变一组控件的布局方式

packed：打包
spread：扩散（默认）
spread_inside：内部扩散

app:layout_constraintVertical_chainStyle="packed"
  • 宽高比

需要设置宽或者高为0dp，字母指定那条边通过计算得出

app:layout_constrainDimensionRatio="W,2:1"
  • 百分比

指定控件相对于parent的百分比大小

app:layout_constraintWidth_percent="0.6"
北诺南兮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Android-高级-UI-进阶之路-(二)-深入理解-Android-8-0-View-触摸事件分发机制
m0_65145426的博客
12-29 820
public boolean dispatchTouchEvent(MotionEvent ev) { /** 首先按下的触发的是 ACTION_DOWN 事件 / if (ev.getAction() == MotionEvent.ACTION_DOWN) { onUserInteraction(); } /* 拿到当前 Window 调用 superDispatchTouchEvent 方法 / if (getWindow().superDispatchTouchEvent(ev)) { return
关于handler以及它已过时的构造函数handler()
Grekit_Sun的博客
03-22 2522
搬运自：https://blog.csdn.net/BitFu/article/details/110183184 ，仅作个人学习笔记用 一.android消息驱动机制 Thread、Looper、Handler这三个是android消息驱动机制的核心对象，让我们先分析并了解一下一个线程拥有消息处理能力的过程： class LooperThread extends Thread { public Handler mHandler; public void run() {
【Android】多线程编程、异步消息处理机制以及new Handler()被标记为过时的解决办法，解决Handler内存泄漏问题和AsyncTask的基本用法
摸鱼小小虫的博客
08-02 1921
Android多线程编程、异步消息处理机制以及new Handler()被标记为过时的解决办法，解决Handler内存泄漏问（当Activity被销毁时，如果其中使用的Handler被持有，并且在外部引用它的对象的生命周期之外保持活动状态，这就可能导致内存泄漏。）、AsyncTask的基本用法
android 关于自定义View在特殊情况下触发setPressed方法(View源码解析)
最新发布
我怀里的猫的博客
05-28 1135
最近在负责一些UI相关的工作,测试给到一个UI的bug,说是搜索框在点击的时候,旁边的’‘X’'变成按压的效果了,我转手就把bug转给负责公控的同事了,因为这个搜索框是公控同事提供的,但是公控大佬不一会就找到我说,我这里都是好的鸭,是不是你哪里没用对,我直接就晕乎了,我左看右看也没干啥鸭,于是开始对线,巴拉巴拉…但是问题还是没有解决,于是有了这篇文章.通过调试和分析源码,我们找到了问题的原因和解决方法。问题是因为在可滑动的父布局中，触发了setPressed方法，导致控件样式变为点按状态。
Android面试笔记
浅枫
02-27 143
Android面试 JAVA基础杂记 String相关 String longString = "aa......a"; 存储在栈内存中，编译时知道大小，编译成字节码时字节码中数组最多存储65535个字节（如果为拉丁字符，小于但不包含，如果为非拉丁字符，包含），最终存在虚拟机方法区的常量池中。 byte[] bytes = loadFromFile(new File("text.txt")); String superLongString = new String(bytes); 存储在堆内存中，
android面试题总结—摘自csdn
大江的专栏
08-07 2409
2. 横竖屏切换时候 activity 的生命周期 1. 不设置 Activity 的 android:configChanges 时 , 切屏会重新调用各个生命周期 , 切横屏时会执行一次 , 切竖屏时会执行两次 . 2. 设置 Activity 的 android:configChanges=”orientation” 时 , 切屏还是会重新调用各个生命周期 , 切横、竖屏时只会执行一次
Android面试准备系列
11-04
安卓面试题基础知识准备，从零开始，内附keep、滴滴、头条、阿里面试题
Android 面试指导.pdf
03-23
总的来说，《Android面试指导》是Android开发者提升技能和准备面试的宝贵资源，它全面覆盖了从Java基础到Android高级特性的各种知识点，对于求职者和在职开发者都具有很高的参考价值。通过深入学习和实践，开发者...
Android面试题(详细答案).pdf
01-25
Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题(详细答案)Android面试题...
Android基础面试笔记
06-27
Android面试过程中所涉及到的面试内容
Android面试宝典
10-14
在Android面试中，掌握Activity的生命周期是至关重要的。Activity的生命周期包括了六个主要的方法：onCreate()、onStart()、onResume()、onPause()、onStop()和onDestroy()。当一个新的Activity启动时，系统会按照...
面试准备android（四）
酷叮喵
04-17 808
这一篇主要是android的基础知识了解，还有一些server的处理使用等，慢慢发，因为最近腾讯面试导致心情不好。。。好吧，是相当不好……(╥﹏╥) －－－－－－－－－－－－我是悲伤的分割线－－－－－－－－－－－－－－－－－ （5.4五一小长假完了，继续准备携程boss面，把之前缺的补上来，有些事情靠运气，但是别忘了运气来时你得有实力！） －－－－－－－－－－－我是焦急的分割线－－－－－－－－
阿里面试官最新总结发布的1000+页Android面试八股文，真的太强了
m0_56255097的博客
08-19 429
世界这么大，Android 知识体系这么庞杂，我在面试的时候也会时不时地怀疑自己，感觉自己这也不会那也不会，特别是当看到有人出来时愁眉苦脸的 走出来之后，这种情感愈发强烈，会越来越近紧张。“是不是自己也会和他一样被pass掉呢？”带着这样的怀疑，为了帮助在面试时也存在这样疑惑的人，我准备分享以下这份最新版《Android 高级开发面试题以及答案整理 》包含各个大厂的高频面题及行业最新技术，是由阿里P6的大佬花两月时间整理和完善而出，资料内容全面、结构清晰，非常适合想要求职/跳槽的伙伴！！
Android面试准备
dream_caoyun的博客
03-05 273
什么是队列,集合是数组,本质是怎么实现的,hashmap的数据结构,与实现原理,二叉树(前序遍历,中序遍历,后序遍历,层序遍历),以及各种链表(什么邻接表,邻接多重表,十字链表)   懂点数据结构,设计模式和开源框架的源码,还是比较好找的     什么是队列,集合是数组,本质是怎么实现的,hashmap的数据结构,与实现原理,二叉树(前序遍历,中序遍历,后序遍历,层序遍历),以及各种链表...
Android 主动出发按下松开事件
xiaoerbuyu1233的博客
12-05 365
Android 主动出发按下松开事件
Android强行进阶—按键事件&焦点事件攻略，Android程序员最大的悲哀是什么
m0_66264134的博客
01-20 4986
handled = TextKeyListener.getInstance().onKeyDown( null, mDefaultKeySsb, keyCode, event); if (handled && mDefaultKeySsb.length() > 0) { final String str = mDefaultKeySsb.toString(); clearSpannable = true; switch (mDefaultKeyMode) { case DEFAULT_
Android常见基础面试题
lyy919062591的博客
10-12 2657
1. 请描述一下Activity 生命周期。 答: 如下图所示。共有七个周期函数，按顺序分别是: onCreate(), onStart(), onRestart(), onResume(), onPause(),onStop(), onDestroy()。 onCreate(): 创建Activity时调用，设置在该方法中，还以Bundle的形式提供对以前存储的任何状态的访问。 onStart(): Activity变为在屏幕上对用户可见时调用。 onResume(): Activity开始与用户
android面试（1）-Java基础
pgg_cold的博客
02-26 2384
最近需要面临找工作的压力，所以在寒假的时候恶补了一下关于android方面的知识，这是一个系列的博客，希望自己可以坚持更新下去。今天找了一些Java基础的面试题，我在里面挑选了一些我还有些模糊的题，在此处记录一下：1.面向对象的特征：（1）抽象：将一类对象的共同特征总结出来构造类的过程。（2）继承：从已有类得到继承信息，创建新类的过程。（3）封装：把数据和操作数据的方法绑定起来，对数据的访问只能通...
android面试题
01-20
Android面试题涵盖了广泛的主题，从...以上总结了Android面试题中的一些重要知识点，这些知识点对于Android开发人员来说非常重要，希望能够帮助面试者更好地准备面试，也希望能够对正在学习Android开发的人们有所帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值