精华内容
下载资源
问答
  • 项目背景 在app开发中经常遇到的一个问题是...一种实现方式是,通过Intent传一个值给Activity,并在Activity中通过switch语句判断该运行哪个具体的业务逻辑。如下: val intent = Intent(context, DemoActivity:...

    项目背景

    在app开发中经常遇到的一个问题是Activity的重用。对于很多页面布局相同,但是业务逻辑上有少量不同的页面。我们希望能够重复使用一个Activity来减少工作量。一种实现方式是,通过Intent传一个值给Activity,并在Activity中通过switch语句判断该运行哪个具体的业务逻辑。如下:

    val intent = Intent(context, DemoActivity::java.class)
    intent.putExtra(KEY_MODEL, MODEL_A)
    intent.putExtra(KEY_PARAMS_A, "abc")
    startActivity(intent)
    
    val intent = Intent(context, DemoActivity::java.class)
    intent.putExtra(KEY_MODEL, MODEL_B)
    intent.putExtra(KEY_PARAMS_B0, "hello word")
    intent.putExtra(KEY_PARAMS_B1, 10)
    startActivity(intent)
    
    
    class DemoActivity : AppCompactActivity {
    
    	onCreate(savedInstanceState : Bundle?) {
    		super.onCreate(savedInstanceState)
    		val model = intent.getIntExtra(KEY_MODEL)
    		
    		
    		when(model) {
    			MODEL_A->{
    				val paramsA = intent.getStringExtra(KEY_PARAMS_A)
    			}//执行A逻辑
    			MODEL_B->{
    				val paramsB0 = intent.getStringExtra(KEY_PARAMS_B0)
    				val paramsB1 = intent.getIntExtra(KEY_PARAMS_B1, -1)
    			}//执行B逻辑
    			MODEL_C->{}//执行C逻辑
    		}
    	}
    }
    

    上述方法在逻辑不复杂时,实现方便快捷。但是该方法存在如下问题:
    1)违反开闭原则:目前项目中存在A、B、C三种业务逻辑,如果后续需求迭代,需要添加新的业务逻辑D。则需要对DemoActivity页面进行修改才能满足要求
    2)每个业务逻辑都有可能有自己特定的输入参数,上述实现思路在调用时,需要在调用时根据不同的业务逻辑传递不同的参数,稍不谨慎可能会造成参数漏传
    3)多种业务逻辑的代码存在于同一个页面中,给后续代码维护带来相当大的麻烦,特别是在多种复杂业务逻辑的情况下。

    还有一种思路,是在onActivityResult方法中返回DemoActivity的通用结果,然后在onActivityResult中处理。这样实现仍然存在局限性。假设一个项目中有多个地方需要调用该DemoActivity,并执行A逻辑。那么就需要在多处实现onActivityResult并重复对A逻辑代码块的调用。给代码维护带来不便。

    设计思路

    解决多个业务逻辑分离的问题,我们很容易联想到策略模式。为每一种业务逻辑定义一个策略类,分别实现各个业务逻辑。又由于是Android开发,将一个自定义的策略类通过Intent发送给定义好的Activity,我们可以将策略类继承自Parcelable。

    撸代码

    策略类基类

    @UiThread
    class BaseAction() : Parcelable {
    
    	open fun onCreate(activity : ActionActivity) {}
    
    	open fun run(activity : ActionActivity, data : Any?)
    
    	open fun onDestroy(activity : ActionActivity) {}
    
    	constructor(parcel : Parcel)
    
    	override fun writeToParcel(parcel: Parcel, flags: Int) {}
    
        override fun describeContents(): Int {
            return 0
        }
    
        companion object CREATOR : Parcelable.Creator<BaseAction> {
            override fun createFromParcel(parcel: Parcel): BaseAction{
                return BaseAction(parcel)
            }
    
            override fun newArray(size: Int): Array<BaseAction?> {
                return arrayOfNulls(size)
            }
        }
    }
    

    onCreate、onDestroy方法分别于Activity的onDestroy方法和onDestroy方法绑定。使得Action可以获取Activity的生命周期。当然也可以实现onStart、onStop、onPause、onResum等Activity生命周期方法的绑定
    run方法的data参数由Activity传递进来。根据具体的情况可以定义成需要的数据类型,这里定义为Any?

    Activity实现

    class ActionActivity : AppCompatActivity {
    
    	private var action : BaseAction?
    	
    	onCreate(savedInstanceState : Bundle?) {
    		super.onCreate(savedInstanceState)
    		...
    		
    		action = intent.getParcelableExtra(KEY_ACTION)
    		action?.onCreate(this)
    	}
    
    	onStart() {
    		super.onStart()
    		doAction()
    	}
    	
    	onDestroy() {
    		super.onDestroy()
    		action?.onDestroy()
    	}
    	
    	private fun doAction() {
    		action?.run(this, null)
    	}
    }
    

    doAction方法根据具体的情况触发,例如用户点击某个按钮,或者其他操作后执行。这里为了说明方便,在Activity#onStart方法中触发

    具体业务A的Action

    class AModelAction(val value : Int) : BaseAction() {
    
    	override fun run(activity : ActionActivity, data : Any?) {
    		Log.i("action", "run in action A, value= $value")
    	}
    
    	constructor(parcel : Parcel) : this(parcel.readInt())
    
    	override fun writeToParcel(parcel: Parcel, flags: Int) {
    		super.writeToParcel(parcel, flags)
    		parcel.writeInt(this.value)
    	}
    
        companion object CREATOR : Parcelable.Creator<AModelAction> {
            override fun createFromParcel(parcel: Parcel): AModelAction{
                return AModelAction(parcel)
            }
    
            override fun newArray(size: Int): Array<AModelAction?> {
                return arrayOfNulls(size)
            }
        }
    }
    

    这里AModelAction有一个参数value,在实现parcelable时,需要实现该参数的读写过程。在run方法种调用打印一行log。注意CRATOR对象的方法一定要指定具体的Action类型,否则intent.getParcelableExtra方法返回的类型会与intent.putParcelableExtra的不一致

    同样可以实现BModelAction

    class BModelAction(val value0 : String, val value1 : Int) : BaseAction() {
    
    	override fun run(activity : ActionActivity, data : Any?) {
    		Log.i("action", "run in action B, value= $value0, $value1")
    	}
    
    	constructor(parcel : Parcel) : this(parcel.readString(), parcel.readInt())
    
    	override fun writeToParcel(parcel: Parcel, flags: Int) {
    		super.writeToParcel(parcel, flags)
    		parcel.writeString(this.value0)
    		parcel.writeInt(this.value1)
    	}
    
        companion object CREATOR : Parcelable.Creator<BModelAction> {
            override fun createFromParcel(parcel: Parcel): BModelAction{
                return BModelAction(parcel)
            }
    
            override fun newArray(size: Int): Array<BModelAction?> {
                return arrayOfNulls(size)
            }
        }
    }
    

    在BModelAction中传递一个String参数和一个Int参数。同样可以定义更多的BaseAction子类

    启动ActionActivity并执行AModelAction

    val intent(context, ActionActivity::java.class)
    intent.putExtra(KEY_ACTION, AModelAction(10))
    startActivity(intent)
    

    可以看大日志输出:
    run in action A, value= 10

    启动ActionActivity并执行BModelAction

    val intent(context, ActionActivity::java.class)
    intent.putExtra(KEY_ACTION, BModelAction("hello word", 12))
    startActivity(intent)
    

    调用后的日志输出:
    run in action B, value= hello word, 12

    可以看出,该实现方案,在启动页面和指定具体业务逻辑时非常的清晰。并且不同业务逻辑都分开定义在具体的策略类中。现在在Activity内仅提供一个触发条件的控制。我们也可以在Action的onCreate方法中修改触发条件,实现更加灵活的业务场景,例如:

    class CModelAction() : BaseAction() {
    
        override fun onCreate(activity : ActionActivity) {
        	activity.findViewById<Button>(R.id.btDoAction).setOnClickListener{
        		activity.doAction()
        	}
        }
    	override fun run(activity : ActionActivity, data : Any?) {
    		Log.i("action", "run in action C= $data")
    	}
    
    	constructor(parcel : Parcel) : this(parcel.readString())
    
    	override fun writeToParcel(parcel: Parcel, flags: Int) {
    		super.writeToParcel(parcel, flags)
    		parcel.writeString(this.value)
    	}
    
        companion object CREATOR : Parcelable.Creator<CModelAction> {
            override fun createFromParcel(parcel: Parcel): CModelAction{
                return CModelAction(parcel)
            }
    
            override fun newArray(size: Int): Array<CModelAction?> {
                return arrayOfNulls(size)
            }
        }
    }
    

    策略C添加了一个通过点击按钮的触发条件。
    我们在项目开发中,总是在不断的提炼自己的代码,使得代码越来越精简和可靠。针对上述的问题,小伙伴们是否还能够给出更加理想的解决方案呢,欢迎留言。

    展开全文
  • 【单选题】在进行计算机网络安全设计、规划时,运用系统工程的观点和方法,分析网络题,并制定具体措施,应遵循 A、多重保护原则 B、综合性、整体性原则 C、一致性原则 D、适应性、灵活性原则 参考答案:B 答案...

    【单选题】在进行计算机网络安全设计、规划时,运用系统工程的观点和方法,分析网络题,并制定具体措施,应遵循

    A、多重保护原则

    B、综合性、整体性原则

    C、一致性原则

    D、适应性、灵活性原则

    参考答案:B

    答案解析:暂无解析

    展开全文
  • 【平行志愿】关键词:分数排队所谓“平行志愿”就是在同一个录取批次的院校中,考生可填报若干个平行的院校,然后按“分数优先、遵循志愿”的原则进行投档录取。具体地说,就是投档时,在同一个批次中将考生按成绩从...

    今年,根据教育部的要求,我省一本批次实行平行一志愿改革,这项改革标志着我省一本批次投档录取原则的根本转变,即一本投档录取由“志愿优先”转变为“分数优先”的投档录取原则。

    【平行志愿】

    关键词:分数排队

    所谓“平行志愿”就是在同一个录取批次的院校中,考生可填报若干个平行的院校,然后按“分数优先、遵循志愿”的原则进行投档录取。具体地说,就是投档时,在同一个批次中将考生按成绩从高分到低分顺序排队,依次检索考生填报的A、B、C、D四个平行志愿,如果A志愿符合要求,则被投档到A志愿院校,如果分数不够,则继续检索B志愿,以此类推,直到档案投入符合条件的院校。

    ◆举例说明——考生小王的高考成绩是541分,4个平行志愿依次是A安徽理工大学,B长春中医药大学,C贵州财经学院,D哈尔滨师范大学。

    由于安徽理工大学的投档线是555分,小王的成绩不够线,因此不能投档。再看他平行志愿中第二顺序的学校长春中医药大学,该校的投档线是540分。于是,小王投档至长春中医药大学。此时,小王即已享受了平行志愿的投档机会。尽管按顺序接下来的两所院校的投档线都比小王的分数低,那也不能再投档。

    【投档】

    关键词:两步走

    第一步,根据高校最终确定的招生计划及投档比例,先对考生按总分从高到低排序,分数高的考生先投档。比如一位考生成绩排在全省理科第100名,需要前面99人投过了,才轮到这位考生。

    第二步,投档时按照排序逐个对考生的“平行一志愿”从A院校到D院校的顺序进行检索,被检索的志愿中一旦出现符合投档条件的院校,即向该院校投档。比如,先看A院校,如果A院校招200人,按照1:1.05的投档比例,假设A院校已经投档210人,A院校已满投不进,则往B院校投;假设B院校招500人,目前只投了400人,则投到B院校,以此类推。档案投出则完成该考生的投档,然后再处理下一位考生。在“分数优先”的原则下,永远是高分考生先于低分考生投档。

    ◆举例说明——以考生小贾为例。小贾的高考成绩是589分。在平行志愿模式下,他填报的5个平行志愿分别是:A郑州大学、B西南大学、C河北工业大学、D河北师范大学。郑州大学的投档线是610分,小贾不够,不能投档。再看西南大学,投档线是580分,且尚未满额。则小贾投档至西南大学。

    而假如按照往年一本实行一、二志愿,小贾的二志愿是西南大学,该校一志愿未满额,投档线为580分。因此,包括小贾在内的第二志愿填报该校的调档线上考生都可能被投档。但假如小贾的二志愿都已满额,小贾则要参加缺额填报或下一批次录取。

    关键词:同分考生

    在平行志愿投档过程中,还有一个同分考生的投档顺序问题,我省的规则是:总分相同的考生投档时按文史、理工类不同的单科顺序排序:

    (1)文史类的科目顺序依次为语文、外语、数学、文科综合。即总分相同,先看语文;若语文同分,则看外语;若外语同分,再看数学;若再同分,则看文科综合。

    (2)理科类的科目顺序依次为数学、外语、语文、理科综合。即总分相同,先看数学;若数学同分,则看外语;若外语同分,再看语文;若再同分,则看理科综合。

    只有总分相同且单科分数都相同时,才视为相同名次;否则总分相同名次并不相同。

    ◆举例说明——湖南大学在投档到541分时,还缺3个计划,现有小赵、小张、小刘、小李、小何五名考生的高考总成绩均是541分。他们分科成绩分别为:小赵语文109分,数学112分,外语89分,综合231分。小张语文106分,数学128分,外语98分,综合209分。小刘语文106分,数学128分,外语118分,综合189分。小李语文106分,数学128分,外语114分,综合193分。小何语文106分,数学135分,外语84分,综合216分。

    比较单科成绩时首先比较语文成绩,则109分为语文最高分。于是,小赵将被投档。

    投出小赵电子档案后,仍缺两个计划。此时,其余4人的语文成绩相同均为106分,于是来比较数学成绩,135分为数学最高分。于是,小何将被投档。

    此时,仍缺一个计划,却有3名总分相同的同学。比较语文、数学成绩发现,这3名同学的语文、数学成绩也都一样。按顺序该比较外语成绩了,此时可发现,118分为外语最高分。于是,小刘将被投档。

    【录取】

    关键词:专业级差

    成功投档并不意味着成功录取。投档时对应的是院校,录取时对应的是专业。专业录取过程不是“平行”的,遵循的仍然是“志愿优先,从高分到低分、设定专业级差”的原则,实行平行一志愿后,各高校进档考生的考分比较集中在较小的分数范围以内,差距不大。所以专业竞争十分激烈,投档线上低分段考生一旦填报的是热门专业且不愿服从专业调剂,就可能退档。因此,考生及家长不要盲目追求热门专业,一定要慎填第一专业志愿,同时,为了避免失误,其他四个专业志愿最好也要填满。

    ◆举例说明——考生小张高考成绩为660分。平行志愿填报了A天津大学、B山东大学、C浙江大学、D中国海洋大学。

    天津大学的投档线为658分。于是小张投档至该校。假设小张未达到填报的某专业的要求又不服从专业调剂,或是因为其他原因小张被天津大学退档,则小张不会再被投档至其他4所学校。■文/记者邱佩君

    本篇新闻热门关键词:热门 标志 一批 成功

    展开全文
  • 罗杰天际线1 本主题遵循Init,您在那里学习了一些基本命令以及系统和网络管理中的第一React。 这将是使用这些命令的具体示例,并使您可以启动自己的第一个Web服务器。 要求:虚拟机,Debian OS
  • 演讲手势遵循的原则 演讲的手势可以说是“词汇”丰富,千变万化,没有一个固定的模式,今天...手势动作只有在与口语表达密切相配合时,其含义才最为生动具体。演讲者的手势必须随演讲的内容、自己的情感和现场气氛自?..
  • 设计模式遵循原则

    2017-01-21 14:32:22
    具体的设计模式之前需要说一说设计模式遵循的几个原则 1.开闭原则 Open Close Principle 从字面理解是冲突的,但是所谓的开闭是不同方向的.对扩展开放,对修改关闭. 扩展开放:模块功能是可以扩展的,当需求发生变化...

    在具体的设计模式之前需要说一说设计模式遵循的几个原则

    1.开闭原则 Open Close Principle

    修改关闭:扩展系统行为时不允许修改现有模块的源码

    扩展开发:系统允许扩展,可以使新的行为加入系统中

    该原则基础在于抽象,把系统中的行为,流程尽可能的抽象。该抽象提供可所有实现必须提供的方法特征。在设计初期我们要尽可能的预见需要扩展的功能提前抽象出来。将来系统需要扩展时可以复用抽象同时我们的抽象也不需要发生任何变化。一个抽象可以有多个实现那么我们可以根据这个特性实现扩展。由于抽象没有发生任何变化那么系统原有的组件是稳定的

    2.里氏替换原则 Liskov Substitution Principle LSP

    任何基类可以出现的地方子类都可以出现,该原则是继承复用的基石,开闭原则核心是抽象,所以该原则是开闭原则的补充。基类和子类就是一个抽象和具体的关系。子类可以替换父类,功能单位不会受到影响,基类才可以被复用。子类可以改写父类的行为实现对行为的扩展,也可以实现自己特有的行为.子类中特有的行为具有可见性的问题。父类是没有办法看见子类自己定义的行为的

    3.依赖倒转原则 Dependence Inversion Principle

    任何时候都要依赖于抽象,不是依赖于具体。该原则的含义如下

    1.高层次的模块依赖于底层模块的抽象,不是依赖于底层模块的具体实现

    2.具体依赖抽象

    两层含义都是依赖于抽象,抽象就像规定一样他不属于抽象定义层也不属于抽象使用层,他约束了双方必须遵守的规则。只要提供的抽象不变不管使用方还是实现方如何变化彼此的影响都会很小甚至没有,因为双方都是基于抽象实现。整个过程中我们的抽象没有发生任何变化


    4.接口隔离原则 Interface Segregation Principle

    1.客户端的依赖应该建立在最小的接口上,由此可见使用多个接口比使用一个接口要好

    2.一个接口代表一个角色,不因该将不同的角色混合在一起,客户端不应该依赖他们不需要的接口

    3.不应该强迫客户端依赖或者实现它们不需要依赖或者实现的方法,如果这些方法发生改变那么客户端也需要改变

    4.接口不属于任何一方,接口属于接口定义端以及客户端,是彼此需要遵守的约定

    eg:订单系统

    1.普通用户只允许查询

    2.第三方用户只允许添加订单

    3.管理员允许CRUD

    public interface GeneralUser {
    
    	public Order searchOrder();
    }
    
    public interface ThridUser {
    
    	public Order createOrder();
    }
    
    public interface Admin extends GeneralUser, ThridUser{
    
    	public Order updateOrder();
    	public int deleteOrder();
    }
    
    public class Order implements Admin {
    	
    	//避免用户直接创建对象后,访问不该访问的方法
    	private Order() {
    	}
    	
    	public static GeneralUser getGeneralUser() {
    		return (GeneralUser)new Order();
    	}
    	
    	public static ThridUser getThridUser() {
    		return (ThridUser) new Order();
    	}
    	
    	public static Admin getAdmin() {
    		return (Admin) new Order();
    	}
    	
    	@Override
    	public Order searchOrder() {
    		System.out.println("search Order");
    		return null;
    	}
    
    	@Override
    	public Order createOrder() {
    		System.out.println("create Order");
    		return null;
    	}
    
    	@Override
    	public Order updateOrder() {
    		System.out.println("update Order");
    		return null;
    	}
    
    	@Override
    	public int deleteOrder() {
    		System.out.println("delete Order");
    		return 0;
    	}
    	
    }
    

    5.迪米特法则(最少知道原则)(Demeter Principle)

    1.软件单位与单位之间尽可能少的产生依赖,需要做到高内聚低耦合

    2.可以采用友元的方式使彼此之间产生依赖,此时会引入一个弊端:系统中存在大量的友元类,这些友元类起到了参数的传递,但是和具体的业务逻辑没有关系,导致系统复杂

    3.成员变量,参数,返回值以及当前对象所创建的其他对象都属于当前类的友元类.友元类具有可传递性

    4.可以采用访问权限的方式来实现该原则


    6.合成复用原则 Composite Reuse Principle

    1.尽量使用合成/聚合.避免继承.在新类中应该尽量使用关联关系采用现有的对象,使之成为新对象的一部分.达到现有功能复用的目的.

    2.通过合成聚合的原则可以降低类于类之间的依赖关系.被依赖的类的修改对其他类的影响相对小一些.

    3.合成/聚合原则是动态的.可以自由选择使用现有类的那些方法.而继承是静态的,失去了灵活性.如果父类改变有可能会影响子类的修改,同时破坏了父类的封装性,父类将会暴露不相关的方法给子类.

    7.单一职责原则 Single responsibility principle

    又叫单一功能原则,通俗的讲就是一个类或者一个方法只存在一个引起他改变的因子.应该只有一个职责.每一个职责的变化都是一个轴线.如果一个类或者一个方法存在多个引起他改变的因子.那么必然后承担过多的职责.这样就会产生耦合.那么这样的设计是脆弱的.后续也不好维护(存在多个可变因子),当一个因子发生变化时可能会影响其他职责.因为其他职责有可能依赖该因子.多个职责的耦合也会影响复用.

    单一职责备受争议,在设计时候应该优先考虑接口的单一职责(粗粒度),当接口确定后集体实现时候我们需要考虑方法的单一职责。

    总结:

    在设计的时候应该尽量抽象,从java的角度来看我们考虑的顺序是:接口,抽象类,具体实现.同时遵循高内聚低耦合的原则,

    展开全文
  • 设计数据库表遵循的规范: 第一范式:要求有主键,并且要求每一个字段原子性不可再分 第二范式:要求所有非主键字段完全依赖主键,不能产生部分依赖- 第三范式:所有非主键字段和主键字段之间不能产生传递依赖 关于...
  • 为实现J2EE各层以及层与层之 间的耦合,J2EE系统...但是,如果我们在结合具体商业需求的基础上,合理的应用好J2EE技术,其结果可想而知。本文试图从本人以往的项目经验入手,来探讨开发J2EE应用时应该遵循的几点准则。
  • 【示例】 对一个表按时间范围进行分区,则分区名称可定为:MONYYYY。 如,2006年1~12月的分区名字分别为: JAN2006、FEB2006、MAR2006、APR2006、MAY2006、JUN2006、 JUL2006、AUG2006、SEP2006、OCT2006、NOV...
  • 而在html5设计过程中遵循了一系列原则,才使得html5得以快速推广,本文将介绍html5遵循的6个设计原则,具体如下 原则一:避免不必要的复杂性 html4 <!DOCTYPE ...
  • Java设计所遵循的准则

    2019-03-30 19:24:22
    1 类的关系 1.1一般关系 主要是体现类的继承和实现 1.2关联关系 类之间是平级关系 ...一个设计者应力图遵循这些原则 具体类不是用来继承的 抽象类应该有尽可能多的共同代码 抽象类应该...
  • 但是,如果我 们在结合具体商业需求的基础上,合理的应用好J2EE技术,其结果可想而知。本文试图从本人以往的项目经验入手,来探讨开发J2EE应用时应该遵循的几点 准则。本文结合JBoss 3.2.1下的J2EE应用开发为例展开...
  • 在讨论面向对象编程和模式(具体一点来说,设计模式)的时候,我们需要一些标准来对设计的好还进行判断,或者说应该遵循怎样的原则和指导方针。 现在,我们就来了解下这些原则: 单一职责原则(S) 开闭原则(O)...
  • 根据我公司实际情况,大致列出在项目开发中应遵循的步骤原则。在各程序员遵循原则的情况下,方能开发出...在设计原型中,应该以需求为主,站在用户的立场进行设计,切忌牵扯到具体实现以及数据库等。在PM设计出原型...
  • 设计模式遵循的原则

    2019-09-26 02:23:13
    单一原则:负责类的粒度大小。...实际就是子类可以扩展父类的功能,但不能改变父类原有的功能依赖倒置原则:面向接口编程,依赖抽象而不是依赖具体的类接口隔离原则: 使用多个隔离的接口,比使用单个接口要好...
  • 说明二:如果lock方法在try代码块之内,可能由于其它方法抛出异常,导致在finally代码块中,unlock对未加锁的对象解锁,它会调用AQS的tryRelease方法(取决于具体实现类),抛出IllegalMonitorStat.
  • 企业想要从云计算的采用中获得成功,需遵循一定的实践原则。从行政角度提供支持这一优势适用于大部分具体项目。大型企业中的实践项目往往会在公司老总表示支持时获得更为理想的成功机率。大家用不着逼着自己在头几个...
  • 信息安全等级保护制度遵循以下基本原则: 一、明确责任,共同保护 通过等级保护,组织和动员国家、法人和其他组织、公民共同参与信息安全保护工作;各方主体按照规范和标准分别承担相应的、明确具体的信息安全保护...
  • Web设计需要遵循一些准则并有计划地去做。 Rule #1 : 先出设计图这是必须的。不要假设设计图在你的头脑中就开始设计web,必须要放到纸上。可以这样做:1, 拿尺子、笔和纸,按照具体的尺寸一行一行地画下来;2, ...
  • 本文讲述了编写JavaScript代码时应遵循的14条规律。分享给大家供大家参考,具体如下: 1. 总是使用 ‘var’ 在javascript中,变量不是全局范围的就是函数范围的,使用”var”关键词将是保持变量简洁明了的关键。当...
  • 买基金,你必须遵循的法则 1. 永远不要满仓操作,不管你是新手还是老手,因为你无法预测市场下一步会发生什么。可以把资金分成10份,每次只拿一份交易。 2. 不要轻易割肉,基金的好坏需要时间去验证,在你的...
  • 我们不打算讨论具体操作细节(比如,搜索框应该放在哪里),因为很多文章都已经对此有过描述;相反,我们会聚焦在网站设计的核心原则、启发式方法和入门上一如果这些方法运用得当,就能启发出更高级、更成熟的设计方案,简化...
  • 多用组合,少用继承 ...依赖抽象,不要依赖具体类 只和朋友交谈 别找我,我会找你 类应该只有一个改变的理由 来自headfirst设计模式 转载于:https://www.cnblogs.com/lgh344902118/p/10738127.html...
  • 00.传统的项目管理者这种按计划行事,尽量做到和计划没有出入;而敏捷项目领导者关注如何成功地区适应不可避免出现的变化。 01.以客户价值和质量为目标,计划就是实现这些目标... 《宣言》:响应变化胜过遵循计...
  • 1、开闭原则(Open Close Principle) ...想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。 2、里氏代换原则(Liskov Substitution Principle) 里氏代换原则是面...
  • 在面向对象的开发中,主要遵循的有以下6个设计原则: 单一职责 ,开放封闭 ,里氏代换,依赖倒转,迪米特法则,合成/聚合复用 下面将具体介绍这些设计原则: 单一职责原则:就一个类而言,应该仅有一个引起它发生...
  • 单一职责原则(SRP) 定义 一个对象只包含一个单一职责,而且该职责被完整地封装在一个类中。即只有一个原因可以使类变更。 意义 是实现高内聚、低耦合设计的指导方针。...具体实践中,找到系统...
  • oracle的sql也是遵循几点原则1.能用oracle自带函数,或者用他的函数可以实现的效果,尽量用oracle的函数,因为他的函数的算法和实现函数的语言都是效率非常高的,一般情况下比我们写的要高效。2. sql的关键字都大写...
  • 酒店设计需要遵循一定的规律和原则,这是酒店设计必须具备的素养,主要分四个方面,下面具体来介绍下。 1、环境意识 酒店环境包括建筑外部空间环境与内部空间环境两部分。需要外部空间环境设计效果不仅可以充当建筑...
  • 一、用来做什么?(解决什么问题) 二、怎么做?(具体代码、demo) 三、原理是什么? 转载于:https://www.cnblogs.com/pjhui/p/8527072.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,263
精华内容 1,705
关键字:

具体遵循