热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

【深入理解Kotlin协程】lifecycleScope源码追踪扒皮

lifecycleScope是LifecycleOwner的扩展属性,而ComponentActivity和Fragment(androidxÿ


lifecycleScopeLifecycleOwner的扩展属性,而 ComponentActivity 和 Fragment(androidx)都实现了 LifecycleOwner 接口,所以这就是为什么说lifecycleScope的作用范围是只能在Activity、Fragment中使用。

public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScopeget() = lifecycle.coroutineScope

其中LifecycleOwner.lifecycleScope返回的是LifecycleOwnergetLifecycle().coroutineScope, coroutineScope又是Lifecycle的扩展属性:

public val Lifecycle.coroutineScope: LifecycleCoroutineScopeget() {while (true) {val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?if (existing != null) {return existing}val newScope = LifecycleCoroutineScopeImpl(this,SupervisorJob() + Dispatchers.Main.immediate)if (mInternalScopeRef.compareAndSet(null, newScope)) {newScope.register()return newScope}}}

lifecycleScope返回的是一个LifecycleCoroutineScopeImpl对象,而LifecycleCoroutineScope则是一个使用 SupervisorJob() + Dispatchers.Main.immediate 作为协程上下文的CoroutineScope对象。

LifecycleCoroutineScopeImpl的源码:

internal class LifecycleCoroutineScopeImpl(override val lifecycle: Lifecycle,override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {init {if (lifecycle.currentState == Lifecycle.State.DESTROYED) {coroutineContext.cancel()}}fun register() {launch(Dispatchers.Main.immediate) {if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)} else {coroutineContext.cancel()}}}override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {lifecycle.removeObserver(this)coroutineContext.cancel()}}
}

内部是通过 lifecycle.addObserver(this) 注册了观察者对象,即将当前对象自身注册到了lifecycle对象中,当生命周期状态发生变化的时候,就会回调当前对象作为观察者的接口方法  onStateChanged() 。
     
在 onStateChanged() 方法中判断 lifecycle 当前的 state 如果小于等于 DESTROYED 就移除观察者并调用协程上下文的cancel方法(这个方法中会查询当前上下文的Job对象调用其cancel方法,从而取消协程)。
其中,Lifecycle.State是一个枚举类:

 public enum State {DESTROYED,   // 0INITIALIZED, // 1CREATED,     // 2STARTED,     // 3RESUMED;     // 4public boolean isAtLeast(@NonNull State state) {return compareTo(state) >= 0;}}

而 Activity和Fragment都实现了LifecycleOwner接口(可以通过getLifecycle()获取到Lifecycle的实例对象),在Activity和Fragment内部都实现了Lifecycle机制,Activity和Fragment对象中都有一个Lifecycle的实例对象LifecycleRegistry当Activity和Fragment生命周期函数变化时,会触发持有的Lifecycle实例对象的相关方法,改变对应的状态值,进而调用到其持有的观察者回调接口,即上面的LifecycleCoroutineScopeImpl对象里的onStateChanged()方法。并在其中判断如果是DESTROYED 状态就调用协程上下文的cancel方法取消协程。

因此,lifecycleScopeActivity执行onDestroy()方法之后就会自动取消协程的原理真相就是如此。
我们说 lifecycleScope 只能在 Activity、Fragment 中使用其实是不太准确的。上面分析了 lifecycleScope是 LifecycleOwner 的扩展属性,Receiver 是 LifecycleOwner。因为Activity、Fragment和默认实现了LifecycleOwner,所以在其内部可以直接使用。但是理论上来说只要是能获取到 LifecycleOwner 的地方都是可以使用 lifecycleScope 的!比如说从Activity、Fragment中创建的其他UI组件,只要是能获取Activity、Fragment对象的地方,那就可以间接地获取到LifecycleOwner。而像DialogFragment是Fragment的子类,自然也可以使用。
比如说LifecycleCoroutineScope内部就提供了几个方法,当你不是在Activity、Fragment内部调用的时候,可以调用使用这几个方法:

public abstract class LifecycleCoroutineScope internal constructor() : CoroutineScope {internal abstract val lifecycle: Lifecyclepublic fun launchWhenCreated(block: suspend CoroutineScope.() -> Unit): Job = launch {lifecycle.whenCreated(block)}public fun launchWhenStarted(block: suspend CoroutineScope.() -> Unit): Job = launch {lifecycle.whenStarted(block)}public fun launchWhenResumed(block: suspend CoroutineScope.() -> Unit): Job = launch {lifecycle.whenResumed(block)}
}

内部其实是一个DispatchQueue封装了ArrayDeque队列。判断生命周期如果小于当前可执行的生命周期则加入队列,等到对应生命周期来到在取出执行。

但是有个问题就是使用这几个方法的时候没有办法设置异常处理器!直接启用了一个默认的launch,还没有给传入上下文的入口。所以如果你想使用这几个方法还想传入异常处理器的话,可以这么做:自己写个launch。

val coroutineExceptiOnHandler= CoroutineExceptionHandler { coroutineContext, throwable ->throwable.printStackTrace()
}
lifecycleScope.launch(coroutineExceptionHandler) {lifecycle.whenCreated {// TODO:  }
}

Lifecycle原理机制

其实单独看lifecycleScope的源码定义就只有两层皮,人家一下子就被你看光了,但是当你看完之后,貌似心里还是不太踏实,不是说它会在页面销毁时自动取消吗?那具体的生命周期它是怎么感知的呢?既然都扒到Lifecycle了,那就顺便对它也扒一下皮吧。。
先简单看一下Lifecycle的使用。
首先 androidx 的 ComponentActivity 和 Fragment 都实现了 LifecycleOwner 接口,这个接口中就只有一个方法:

public interface LifecycleOwner { @NonNullLifecycle getLifecycle();
}

因此可以在Activity 和 Fragment 中调用这个方法getLifecycle(),这个方法会返回Lifecycle的实例对象。

Lifecycle的主要方法:

public abstract class Lifecycle {public abstract void addObserver(LifecycleObserver observer);public abstract void removeObserver(LifecycleObserver observer);public abstract State getCurrentState();public enum Event {ON_CREATE,ON_START,ON_RESUME,ON_PAUSE,ON_STOP,ON_DESTROY,ON_ANY;public static Event downFrom(State state) { ... }public static Event downTo(State state) { ... } public static Event upFrom(State state) { ... } public static Event upTo(State state) { ... } public State getTargetState() { ... } }public enum State {DESTROYED,INITIALIZED,CREATED,STARTED,RESUMED;public boolean isAtLeast(State state) {return compareTo(state) >= 0;}}
}

Lifecycle中有一个添加观察者的方法一个移除观察者的方法,然后就是两个枚举类Event和State, 分别对应不同的生命周期的方法和状态,剩下就是一些状态流转的操作方法。

因此可以Activity或Fragment调用:

getLifecycle().addObserver(new MyLifecycleObserver()) 

然后定义一个LifecycleObserver接口的实现类即可:

public class MyLifecycleObserver implements LifecycleEventObserver {private final static String TAG = MyLifecycleObserver.class.getSimpleName();@Overridepublic void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {Log.e(TAG, "onStateChanged 事件来源:"+source.getClass().getName());switch (event) {case ON_CREATE:Log.e(TAG, "onStateChanged: ON_CREATE");break;case ON_START:Log.e(TAG, "onStateChanged: ON_START");break;case ON_RESUME:Log.e(TAG, "onStateChanged: ON_RESUME");break;case ON_PAUSE:Log.e(TAG, "onStateChanged: ON_PAUSE");break;case ON_STOP:Log.e(TAG, "onStateChanged: ON_STOP");break;case ON_DESTROY:Log.e(TAG, "onStateChanged: ON_DESTROY");break;case ON_ANY:Log.e(TAG, "onStateChanged: ON_ANY");break;default:break;}}
}

其中LifecycleEventObserver继承了LifecycleObserver,而LifecycleObserver是一个空接口:

public interface LifecycleEventObserver extends LifecycleObserver { void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}
public interface LifecycleObserver {
}

当Activity生命周期方法变化时,onStateChanged方法就会回调,其中方法参数source表示事件来源event表示当前触发的生命周期事件。
   
使用真的非常简单。
接下来看一下 ComponentActivitygetLifecycle方法返回的是什么:

public class ComponentActivity extends androidx.core.app.ComponentActivity implements LifecycleOwner ... {private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);...public Lifecycle getLifecycle() {return mLifecycleRegistry;}
}

可以看到就是一个LifecycleRegistry类的全局成员变量,而LifecycleRegistry类正是Lifecycle接口的实现类:

public class LifecycleRegistry extends Lifecycle {public LifecycleRegistry(LifecycleOwner provider) {this(provider, true);}private LifecycleRegistry(LifecycleOwner provider, boolean enforceMainThread) {mLifecycleOwner = new WeakReference<>(provider);mState = INITIALIZED;mEnforceMainThread = enforceMainThread;}
}

LifecycleRegistry通过弱引用持有了LifecycleOwner的对象,也就是Activity对象   

addObserver()方法的实现:

@Override
public void addObserver(@NonNull LifecycleObserver observer) {//检查是否在主线程enforceMainThreadIfNeeded("addObserver");//设置初始状态值State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;//将观察者和初始化的状态值封装到ObserverWithState中ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);//以观察者为key,statefulObserver为value放到hashMap集合中ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);//不为null表示之前已经放进去了,否则没放进去,放进去了就添加结束if (previous != null) {return;}//获取被观察者对象,即Activity,如果被销毁了,则结束LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {// it is null we should be destroyed. Fallback quicklyreturn;}//mAddingObserverCounter 表示正在添加的观察者的数量,//开始添加新的observe之前,对该变量进行++操作,添加完成后,进行--操作。//mHandlingEvent表示是否正在处理boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;//计算状态,进行while循环State targetState = calculateTargetState(observer);mAddingObserverCounter++;//新添加的LifecycleObserver ,会不断更新自己的生命周期到指定的targetStatewhile ((statefulObserver.mState.compareTo(targetState) <0&& mObserverMap.contains(observer))) {//添加状态到list,计算当前状态,用于计算状态calculateTargetStatepushParentState(statefulObserver.mState);//final Event event = Event.upFrom(statefulObserver.mState);if (event == null) {throw new IllegalStateException("no event up from " + statefulObserver.mState);}//生命周期分发:分发到mLifecycleObserver里面statefulObserver.dispatchEvent(lifecycleOwner, event);//移除状态到listpopParentState();// mState / subling may have been changed recalculate//重新计算状态targetState = calculateTargetState(observer);}//没有事件正在处理,或者是添加了observe,就需要重新同步一次状态,下面详细介绍if (!isReentrance) {// we do sync only on the top level.sync();}mAddingObserverCounter--;
}
//计算状态规则
private State calculateTargetState(LifecycleObserver observer) {//在map中获取到当前observer的前一个observerMap.Entry previous = mObserverMap.ceil(observer);//前一个observer的stateState siblingState = previous != null ? previous.getValue().mState : null;//如果是嵌套添加observer,获取父级observer的状态State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1): null;//获取最小状态,DESTROYED }

Activity的生命周期如何通过LifecycleRegistry触发

触发的原理已经不是什么新鲜事了,就是在Activity的onCreate()方法中添加了一个透明的Fragment来专门处理生命周期:

ReportFragment.injectIfNeededIn(this);
public class ReportFragment extends android.app.Fragment { public static void injectIfNeededIn(Activity activity) {if (Build.VERSION.SDK_INT >= 29) {// 在 API 29+ 以上, 可以直接注册Activity的生命周期回调接口 LifecycleCallbacks.registerIn(activity);}// 以下是兼容 API 29 以前的版本android.app.FragmentManager manager = activity.getFragmentManager();if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();// Hopefully, we are the first to make a transaction.manager.executePendingTransactions();}}
}

先看 API >= 29 的处理,LifecycleCallbacks.registerIn方法的实现:

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {static void registerIn(Activity activity) {activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());}@Overridepublic void onActivityCreated(Activity activity, Bundle bundle) { }@Overridepublic void onActivityPostCreated(Activity activity, Bundle savedInstanceState) {dispatch(activity, Lifecycle.Event.ON_CREATE);}@Overridepublic void onActivityStarted(Activity activity) { }@Overridepublic void onActivityPostStarted(Activity activity) {dispatch(activity, Lifecycle.Event.ON_START);}....省略其他方法,跟上面 onCreated 和 onStarted 的处理雷同}

可以看到就是为Activity注册一个Application.ActivityLifecycleCallbacks的回调接口实现类,如继续追踪下去就会发现这个Callback被Actvity内部保存了起来。(注意这个保存的Activity直接就是android.app.Activity,而不是androidx.activity.ComponentActivity,也就是说高版本直接在最顶层的Activity类中处理了,不论什么xxxActivity都生效

然后看看Actvity内部什么时候调用注册的这个Callback,不出意外的话肯定会在生命周期方法中调用,所以我们随便找一个onStart()方法来看一下:

protected void onStart() {if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this);mCalled = true;mFragments.doLoaderStart();dispatchActivityStarted();getAutofillClientController().onActivityStarted();
}

发现这里有个 dispatchActivityStarted() 方法,继续追踪下去:

private void dispatchActivityStarted() {getApplication().dispatchActivityStarted(this);Object[] callbacks = collectActivityLifecycleCallbacks();if (callbacks != null) {for (int i = 0; i }

可以看到这里进行遍历保存的所有Callback对象的回调方法进行回调,其他生命周期方法处理也是类似的。回到LifecycleCallbacks中我们发现onActivityStarted的实现是空的,没有做事情,而是在onActivityPostStarted中处理的,因此我们再去Activity中看看onActivityPostStarted在什么时候调用:

final void performStart(String reason) {....dispatchActivityPostStarted();
}
private void dispatchActivityPostStarted() {Object[] callbacks = collectActivityLifecycleCallbacks();if (callbacks != null) {for (int i = 0; i }

最终是由Activity的performStart()触发的,但是在当前类范围内找不到调用它的地方了,那是在哪里调用的performStart()?答案是在ActivityThread类中调用的:

public void handleStartActivity(ActivityClientRecord r,PendingTransactionActions pendingActions, ActivityOptions activityOptions) {...  activity.performStart("handleStartActivity");
}

但是ActivityThread中的这个handleStartActivity方法又是哪里调用的呢?答案是由ATMS(ActivityStackManagerService)跨进程调用的,这里涉及Android 10.0以上Activity启动流程了,流程比较长就不展开了,总而言之,会由ATMS向应用端进程发起Binder调用, 然后通过如下路径进行处理:

ApplicationThread.scheduleTransaction() 
-> ActivityThread.scheduleTransaction()(在其父类中) 
-> mH.sendMessage(H.EXECUTE_TRANSACTION, ClientTransaction) 
-> H.handleMessage(EXECUTE_TRANSACTION) 
-> TransactionExecutor.execute(transaction) 
-> executeLifecycleState(transaction) 
-> cycleToPath(r, lifecycleItem.getTargetState(), true , transaction) 
-> performLifecycleSequence(r, path, transaction) 
-> ON_START 
-> mTransactionHandler.handleStartActivity(r, mPendingActions, null) 
-> ActivityThread.handleStartActivity() 
-> activity.performStart()
补充一张Android 10.0 Activity应用内启动流程图和LifecycleState管理相关的类图,这两个图都是别人总结的,我觉得还不错的,所以贴出来。(请点击放大看)

 再次回到ReportFragmentLifecycleCallbacks中:

static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {...@Overridepublic void onActivityPostStarted(@NonNull Activity activity) {dispatch(activity, Lifecycle.Event.ON_START);}...
}
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {if (activity instanceof LifecycleRegistryOwner) {((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);return;}if (activity instanceof LifecycleOwner) {Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();if (lifecycle instanceof LifecycleRegistry) {((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);}}
}

dispatch方法就是简单的判断当前如果是LifecycleOwner就获取到其持有的LifecycleRegistry对象,然后调用其handleLifecycleEvent方法:

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {enforceMainThreadIfNeeded("handleLifecycleEvent");moveToState(event.getTargetState());
}
private void moveToState(State next) {...sync();mHandlingEvent = false;if (mState == DESTROYED) {mObserverMap = new FastSafeIterableMap<>();}
}

最终会调用LifecycleRegistry对象的sync()方法:

private void sync() {LifecycleOwner lifecycleOwner = mLifecycleOwner.get();if (lifecycleOwner == null) {throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"+ "garbage collected. It is too late to change lifecycle state.");}//没有同步过,则同步while (!isSynced()) {mNewEventOccurred = false;// no need to check eldest for nullability, because isSynced does it for us.if (mState.compareTo(mObserverMap.eldest().getValue().mState) <0) {//如果ObserverWithState的state小于当前state,那么就调用forwardPass方法,backwardPass(lifecycleOwner);}Map.Entry newest = mObserverMap.newest();if (!mNewEventOccurred && newest != null&& mState.compareTo(newest.getValue().mState) > 0) {//如果大于当前state,那么就调用backwardPass方法。forwardPass(lifecycleOwner);}}mNewEventOccurred = false;
}

其中 backwardPassforwardPass方法都会调用 observer.dispatchEvent(lifecycleOwner, event) 也就是ObserverWithState这个包装类的dispatchEvent方法:

static class ObserverWithState {State mState;LifecycleEventObserver mLifecycleObserver;ObserverWithState(LifecycleObserver observer, State initialState) {mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);mState = initialState;}void dispatchEvent(LifecycleOwner owner, Event event) {State newState = event.getTargetState();mState = min(mState, newState);mLifecycleObserver.onStateChanged(owner, event);mState = newState;}
}

这里最终会回调我们最开始使用例子中为其注册的LifecycleEventObserver这个观察者对象的onStateChanged()接口方法,到此就破案了。

以上就是 API >= 29 的处理逻辑,接下来继续来继续看 API  <  29 的处理逻辑,那就只能是在ReportFragment的生命周期方法里了,我们还是挑一个onStart方法看看:

@Override
public void onStart() {super.onStart();dispatchStart(mProcessListener);dispatch(Lifecycle.Event.ON_START);
}
private void dispatch(@NonNull Lifecycle.Event event) {if (Build.VERSION.SDK_INT <29) {// Only dispatch events from ReportFragment on API levels prior// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks// added in ReportFragment.injectIfNeededIndispatch(getActivity(), event);}
}

可以看到这里注释也说明了,只有 API  <  29 的才走这个地方,但是这个dispatch方法点进去看,其实就是前面已经分析过的dispatch方法,所以这里最终殊途同归,也是调用ObserverWithState这个包装类的dispatchEvent方法里,进而回调LifecycleEventObserveronStateChanged()接口方法。

以上就是Activity的生命周期如何通过LifecycleRegistry触发的真相。
接下来再看看,普通的Fragment中是如何处理生命周期通过LifecycleRegistry触发的

public Fragment() {initLifecycle();
}
private void initLifecycle() {mLifecycleRegistry = new LifecycleRegistry(this);  ...
}
public Lifecycle getLifecycle() {return mLifecycleRegistry;
}

FragmentgetLifecycle()也是返回的LifecycleRegistry对象,这个对象是在Fragment()构造函数中就初始化的。直接在Fragment中全局搜索一下这个对象就会发现:

void performStart() {mChildFragmentManager.noteStateNotSaved();mChildFragmentManager.execPendingActions(true);mState = STARTED;mCalled = false;onStart();if (!mCalled) {throw new SuperNotCalledException("Fragment " + this+ " did not call through to super.onStart()");}mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);if (mView != null) {mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);}mChildFragmentManager.dispatchStart();
}

很明显在performStart()方法中进行了处理,这个handleLifecycleEvent()方法就是我们前面分析过的,所以跟前面Activity的最终处理逻辑路径又殊途同归了。

现在就剩下一个问题:Fragment.performStart()方法是在哪里调用的?答案不用想肯定是FragmentActivity中,因为我们知道Fragment要依赖一个FragmentActivity对象作为宿主,然后Fragment使用时肯定是被添加到FragmentManager中的,所以自然而然就找到了调用的地方。由于调用流程太长,不展开了直接贴出追踪路径如下:
FragmentActivity.onStart() 
-> FragmentController.dispatchStart() 
-> mHost.mFragmentManager.dispatchStart() 
-> dispatchStateChange(Fragment.STARTED) 
-> moveToState(nextState, false) 
-> startPendingDeferredFragments() 
-> performPendingDeferredStart(fragmentStateManager) 
-> fragmentStateManager.moveToExpectedState() 
-> Fragment.STARTED 
-> start() 
-> mFragment.performStart()
至此,我们的Lifecycle的皮就扒完了,以后不管是使用lifecycleScope还是直接使用Lifecycle时,就能做到心中有数。


推荐阅读
  • Android系统源码分析Zygote和SystemServer启动过程详解
    本文详细解析了Android系统源码中Zygote和SystemServer的启动过程。首先介绍了系统framework层启动的内容,帮助理解四大组件的启动和管理过程。接着介绍了AMS、PMS等系统服务的作用和调用方式。然后详细分析了Zygote的启动过程,解释了Zygote在Android启动过程中的决定作用。最后通过时序图展示了整个过程。 ... [详细]
  • 本文讨论了如何优化解决hdu 1003 java题目的动态规划方法,通过分析加法规则和最大和的性质,提出了一种优化的思路。具体方法是,当从1加到n为负时,即sum(1,n)sum(n,s),可以继续加法计算。同时,还考虑了两种特殊情况:都是负数的情况和有0的情况。最后,通过使用Scanner类来获取输入数据。 ... [详细]
  • Java学习笔记之面向对象编程(OOP)
    本文介绍了Java学习笔记中的面向对象编程(OOP)内容,包括OOP的三大特性(封装、继承、多态)和五大原则(单一职责原则、开放封闭原则、里式替换原则、依赖倒置原则)。通过学习OOP,可以提高代码复用性、拓展性和安全性。 ... [详细]
  • 本文讨论了如何使用IF函数从基于有限输入列表的有限输出列表中获取输出,并提出了是否有更快/更有效的执行代码的方法。作者希望了解是否有办法缩短代码,并从自我开发的角度来看是否有更好的方法。提供的代码可以按原样工作,但作者想知道是否有更好的方法来执行这样的任务。 ... [详细]
  • 欢乐的票圈重构之旅——RecyclerView的头尾布局增加
    项目重构的Git地址:https:github.comrazerdpFriendCircletreemain-dev项目同步更新的文集:http:www.jianshu.comno ... [详细]
  • Week04面向对象设计与继承学习总结及作业要求
    本文总结了Week04面向对象设计与继承的重要知识点,包括对象、类、封装性、静态属性、静态方法、重载、继承和多态等。同时,还介绍了私有构造函数在类外部无法被调用、static不能访问非静态属性以及该类实例可以共享类里的static属性等内容。此外,还提到了作业要求,包括讲述一个在网上商城购物或在班级博客进行学习的故事,并使用Markdown的加粗标记和语句块标记标注关键名词和动词。最后,还提到了参考资料中关于UML类图如何绘制的范例。 ... [详细]
  • Java SE从入门到放弃(三)的逻辑运算符详解
    本文详细介绍了Java SE中的逻辑运算符,包括逻辑运算符的操作和运算结果,以及与运算符的不同之处。通过代码演示,展示了逻辑运算符的使用方法和注意事项。文章以Java SE从入门到放弃(三)为背景,对逻辑运算符进行了深入的解析。 ... [详细]
  • [大整数乘法] java代码实现
    本文介绍了使用java代码实现大整数乘法的过程,同时也涉及到大整数加法和大整数减法的计算方法。通过分治算法来提高计算效率,并对算法的时间复杂度进行了研究。详细代码实现请参考文章链接。 ... [详细]
  • 前景:当UI一个查询条件为多项选择,或录入多个条件的时候,比如查询所有名称里面包含以下动态条件,需要模糊查询里面每一项时比如是这样一个数组条件:newstring[]{兴业银行, ... [详细]
  • 本文详细介绍了如何使用MySQL来显示SQL语句的执行时间,并通过MySQL Query Profiler获取CPU和内存使用量以及系统锁和表锁的时间。同时介绍了效能分析的三种方法:瓶颈分析、工作负载分析和基于比率的分析。 ... [详细]
  • Oracle优化新常态的五大禁止及其性能隐患
    本文介绍了Oracle优化新常态中的五大禁止措施,包括禁止外键、禁止视图、禁止触发器、禁止存储过程和禁止JOB,并分析了这些禁止措施可能带来的性能隐患。文章还讨论了这些禁止措施在C/S架构和B/S架构中的不同应用情况,并提出了解决方案。 ... [详细]
  • This article discusses the efficiency of using char str[] and char *str and whether there is any reason to prefer one over the other. It explains the difference between the two and provides an example to illustrate their usage. ... [详细]
  • 本文讨论了编写可保护的代码的重要性,包括提高代码的可读性、可调试性和直观性。同时介绍了优化代码的方法,如代码格式化、解释函数和提炼函数等。还提到了一些常见的坏代码味道,如不规范的命名、重复代码、过长的函数和参数列表等。最后,介绍了如何处理数据泥团和进行函数重构,以提高代码质量和可维护性。 ... [详细]
  • Android自定义控件绘图篇之Paint函数大汇总
    本文介绍了Android自定义控件绘图篇中的Paint函数大汇总,包括重置画笔、设置颜色、设置透明度、设置样式、设置宽度、设置抗锯齿等功能。通过学习这些函数,可以更好地掌握Paint的用法。 ... [详细]
  • 本文介绍了2015年九月八日的js学习总结及相关知识点,包括参考书《javaScript Dom编程的艺术》、js简史、Dom、DHTML、解释型程序设计和编译型程序设计等内容。同时还提到了最佳实践是将标签放到HTML文档的最后,并且对语句和注释的使用进行了说明。 ... [详细]
author-avatar
手机用户2502894533
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有