关于单例模式的使用,通过object声明的对象实际为单例模式对象
1不带参数单例
class MyClass private constructor(){
private object Single{ val instance=MyClass()}
companion object{
fun create(){ return Single.instance}
}
}
调用方式：MyClass.create()
带参数单例
class Singletonprivateconstructor(str: String){varstring: String = str;
init {
println("str is $str")
println("string is $string")
}
companionobject{@Volatilevarinstance: Singleton? =nullfun getInstance(c: String): Singleton {if(instance ==null) {
synchronized(Singleton::class) {if(instance ==null) {
instance = Singleton(c)
}
}
}returninstance!!
}
}
}
静态类 companion object{ 只有静态方法和静态变量}
常见的setListener方式
setOnClickListener{toast("随意")}或者setOnClickListener(object:View.OnClickListener{
override funonClick(p0: View?) {}
})
setOnCheckedChangeListener{ compoundButton, b ->
}或者通上
addOnScrollListenner(object:RecycleView.OnScrollListenner(){
orrivite fun onScroll(a,b,c,d){
}})
附注：在TWOBBBLE中ItemShotAdapter中处理了下拉加载更多 的布局，经过我的处理可以在生产中使用
接口回调的一种实现方式通过构造函数
1 class ItemShotAdapter(varmShots: MutableList, valitemClick: (Int) -> Unit, valuserClick: (Int) -> Unit) : RecyclerView.Adapter() {
override funonBindViewHolder(holder: ViewHolder,position: Int) {
holder.itemView.mItemCard.setOnClickListener{
itemClick.invoke(position)//调用
holder.itemView.mHeadLayout.setOnClickListener{
userClick.invoke(position)//调用
}}
}
2.外部实现
mListAdapter= ItemShotAdapter(mShots,{
EventBus.getDefault().postSticky(mShots[it])
startDetailsActivity()
},{
EventBus.getDefault().postSticky(shots[it].user)
startActivity(Intent(activity,UserActivity::class.java))
})
关于inline函数的调用情景1
当参数类型是v: (Int) -> Unit是可以直接写在{}中
/**
* 当前网络是否可用
*/
inline funAny.netAvailable(block: (a: Boolean) -> Unit) {
if(Utils.isNetworkAvailable(App.instance)) block(true)elseblock(false)
}
调用
override fun onSubscribe(d: Disposable) {
//如果网络不可用取消链接
netAvailable{
if(!it) {
onFailure(App.instance.resources.getString(R.string.net_disable))
baseView?.hideProgress()
d.dispose()
}else{
baseView?.showProgress()
}
}
onStart(d)
}
编译之后实际的代码是
if(Utils.isNetworkAvailable(App.instance)) {
onFailure(App.instance.resources.getString(R.string.net_disable))
baseView?.hideProgress()
d.dispose()
}
else{
baseView?.showProgress()
}
}
onStart(d)
}
/**场景2
* dp2px
*/
inline funInt.dp2px(): Float = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this.toFloat(),App.instance.displayMetrics)
/**场景三
* 获取字符串
*/
inline fun Context.obtainString(resId: Int): String =this.resources.getString(resId)
dp2px和obtainString中this作为调用函数的对象呗函数本身使用
关于匿名内部类生成
1 Runnable delayRun=new Runnable() {
@Override
public voidrun() {
//TODO
};}
valr:Runnable=Runnable{"ddddd"}
2 mSortListSpinner.onItemSelectedListener=object: AdapterView.OnItemSelectedListener {
override funonNothingSelected(p0: AdapterView<*>?) {}
override funonItemSelected(p0: AdapterView<*>?,view: View?,position: Int,p3: Long) {
mListAdapter=null
mSortList=mList[position]
getShots(false)
}
}
kotlin网络请求订阅
1,采用subscrible(onnext,oneeror,oncomplete)
private val mCompositeDisposable= CompositeDisposable()
val disposable =mMoviesRepository
.getMovies()
.observeOn(AndroidSchedulers.mainThread())
.subscribe({it-> Logger.v("loadInTheatersMovies-size:${it.size}")
view.showMovies(it)}
,{error->view.showError(error.toString())}
,{view.hideProgressDialog()})
mCompositeDisposable.add(disposable)
2.采用subscrible（obeserver）
mDetailsBiz.unlikeShot(id,token,NetObserver({
mDisposables.add(it)
},{
mDetailsView.unLikeShotSuccess()
},{
mDetailsView.unLikeShotFailed("${App.instance.obtainString(R.string.unlike_failed)}:$it")
}))
封装NetObserver：Observer
class NetObserver<T>(valonStart: (Disposable) -> Unit,
private valonResult: (T) -> Unit,
private valonFailure: (String) -> Unit,
private valbaseView: IBaseView? =null) : Observer<T> {
override fun onError(e: Throwable) {
e.printStackTrace()
baseView?.hideProgress()
if(eisNetExceptionHandler.ResponseException) {
onFailure(e.message.toString())
}else{
onFailure("可能遇到了未知的错误，请重试")
}
}
override fun onComplete() {
baseView?.hideProgress()
}
override funonNext(t:T) {
onResult(t)
}
override funonSubscribe(d: Disposable) {
//如果网络不可用取消链接
netAvailable{
if(!it) {
onFailure(App.instance.resources.getString(R.string.net_disable))
baseView?.hideProgress()
d.dispose()
}else{
baseView?.showProgress()
}
}
onStart(d)
}
}
关于继承类的open注解与Java的final意义相反：允许其他类继承本类。kotlin默认的所有类都是final类型，父类中采用open注解的成员
才可以被复写
open class Base{open fun v(){}fun nv(){}}
class Derived():Base(){override funv(){} }
可以使用var属性来复写val属性，反过来不可。因为val属性本质上声明了getter方法，复写为var属性在派生类中声明了setter方法
interface Foo{val count:Int} class Bar1(override val count:Int):Foo classBar2:Foo{override var count:Int=0}
不言而喻，抽象类或抽象函数无须使用open注解可以使用抽象来复写非抽象的open函数
open class Base{open funf(){}}
abstract class Derived:Base(){override abstract funf()}
关于lateinit和lazy
*lateinit 只用于 var，而 lazy 只用于 val
*lazy 应用于单例模式(if-null-then-init-else-return)，而且当且仅当变量被第一次调用的时候，委托方法才会执行。
*lateinit 则用于只能生命周期流程中进行获取或者初始化的变量，比如 Android 的 onCreate()
lateinit不能用在可空的属性上和java的基本类型上 如：lateinit var age: Int//会报错.
f
