Gradle生命周期

Gradle构建系统有自己的生命周期，初始化、配置和运行三个阶段。

1.初始化阶段，会去读取根工程中setting.gradle中的include信息，决定有哪几个工程加入构建，
  创建project实例，比如下面有三个工程： include ':app', ':lib1', ':lib2

2.配置阶段，会去执行所有工程的build.gradle脚本，配置project对象，一个对象由多个任务组成，
  此阶段也会去创建、配置task及相关信息。

3.运行阶段，根据gradle命令传递过来的task名称，执行相关依赖任务


Gradle 构建任务

1.是在gradle的运行阶段打印出来的

task hello {
    doLast {
        println "hello"
    }
}


2.是在gradle的配置阶段打印出来的

task hello {
    println "hello"
}


根据不同的需求选择不同的加载方式;


  
另外task中有一个action list，task运行时会顺序执行action list中的action，doLast或者doFirst后面跟的闭包就是一个action，doLast是把action插入到list的最后面，而doFirst是把action插入到list的最前面。


脚本写多了，都挤在一个build.gradle里也不好，人长大了总要自己出去住，那可以把部分脚本抽出去吗？

当然可以，新建一个other.gradle把脚本抽离，然后在build.gradle中 
添加apply from ‘other.gradle’即可 

抽出去以后你会发现本来可以直接import的asm包找不到了，怎么回事？ 

根工程中配置的buildscript会传递到所有工程，但只会传到build.gradle脚本中， 

其他脚本可不管，所以你要在other.gradle中重新配置buildscript， 

并且other.gradle中的repositories不再包含m2repository目录， 

自己配置jcenter()又会导致依赖重新下载到~/.gradle/caches目录。如果不想额外下载，也可以在other.gradle中这么搞：  

buildscript {
    repositories {
        maven {
            url rootProject.buildscript.repositories[0].getUrl()
        }
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.2.3'
    }
}




获取AndroidManifest文件:

ApplicationId versus PackageName提到，gradle中的applicationid用来区分应用，manifest中packageName用来指定R文件包名，
并且各个productFlavor的manifest中的packageName应该一致。

applicationid只是gradle脚本中的定义，其实最后生成的apk中的manifest文件的packageName还是会被applicationid替换掉。

那获取R文件的包名怎么搞？要获取AndroidManifest中package属性，并且这个manifest要是起始的文件，
因为最终文件中的package属性会被applicationid冲掉，由于各个manifest中的package属性一样，
并且非主manifest可以没有package属性，所以只有获取主manifest的package属性才是最准确的。

def manifestFile = android.sourceSets.main.manifest.srcFile
def packageName = new XmlParser().parse(manifestFile).attribute('package')

先来看下官方文档的解释：每个vue实例在被创建时都要经过一系列的初始化过程。例如：数据、事件的监听、编译模板，同时在这个过程中，vue会在其中添加一些函数、运行，这些函数叫做生命周期钩子函数。

这里我分了三个阶段说下都有哪一些钩子函数：

阶段一：Vue实例创建阶段的生命周期函数

        beforeCreate：

Vue实例在内存中刚被创建，数据对象（data）和方法（methods）未初始化；

        created：

实例已经在内存中创建好，数据和方法已经初始化完成，但是模板还未编译，页面还是没有内容；（此时访问this.$el 和this.$refs.xxx都是undefined）

        beforeMount： 

找到对应的template模板，编译成render函数，转换成虚拟dom，此时模板已经编译完成，数据未挂载到页面，也就是说在这个阶段你可以看到标签间的双花括号，数据还未渲染到页面中；

补充：

        render : h=>h(App)

在beforeMounte之后和mounted之前，还有渲染render函数，它的作用是把模板渲染成虚拟dom。。。

        mounted：

模板编译好了，虚拟dom渲染成真正的dom标签，数据渲染到页面，此时Vue实例已经创建完毕，如果没有其他操作的话，Vue实例会静静的躺在内存中，一动不动。。。一般会在mounted中来渲染从后端获取的数据！！！！！(页面初始化时，如果有操作dom的事件一般也会放在mounted钩子函数中，当然，你也 可以放在create中，前提需使用this.$nextTick(function(){})，在回调函数中操作dom。)

        先来一个关于$nextTick(fn)的小例子：

<script>
    //下边打印结果顺序： 1  2  3  11
    let vm =  new Vue({
        el:"#app",
        data:{
            name:"lxc"
        },
        beforeCreate(){
        },
        created(){
            console.log("1")
            this.$nextTick(function(){
                console.log("11")
            })
        },
        beforeMount(){
            console.log("2")
        },
        mounted(){
            console.log("3")
        }
    })
</script>

       上边代码充分说明了$nextTick()是在页面渲染完之后执行的一个异步方法。

总结下$nextTick使用场景：

第一：上边已经说了在created中操作dom；

第二：在数据变化后要执行某个操作，而这个操作需要随数据改变进而改变了dom时的操作，这个操作应该放入$nextTick中。

eg：

<div id="app">
   <p ref="op" v-for="i in num" v-if="num > 0">{{i}}</p>
   <button @click="oclick">click</button>
</div>
<script>
    //p标签文本是动态渲染出来的，下边如果想操作p标签文本，需把操作写在$nextTick中
    let vm =  new Vue({
        el:"#app",
        data:{
          num:0
        },
        methods:{
          oclick(){
            this.num = 4
            this.$nextTick(function(){
               this.$refs.op.forEach(ele=>ele.innerText=ele.innerText*2)
            })
          }
        }
    })

</script>

关于$nextTick这篇文章不错：https://www.jianshu.com/p/da2c68fe8aed。。。呃呃呃，有点扯远了，言归正传！！！

 

阶段二：Vue实例运行阶段的生命周期函数

       beforeUpdate：数据依赖改变或者用$forceUpdata强制刷新时，对象data中的 数据已经更改（虚拟dom已经重新渲                                               染），但是，页面中的值还是原来，未改变，因为此时还未开始渲染dom；

       update：此时data中的数据和页面更新完毕，页面已经被重新渲染。。。

     在实际开发中，一般会用watch来代替上边2个方法，因为watch会知道是哪一个数据变化。。。

 

阶段三：Vue实例销毁阶段的生命周期函数

       beforeDestroy：实例销毁前掉用，在此刻实例还是可用的

       destroyed：Vue实例被销毁，观察者、子组件、事件监听被清除（页面数据不会消失，只不过是响应式无效了）。。。

 

总结下：以上三个阶段就是Vue实例的一个完整的生命周期，从开始创建、初始化数据、编译模板、挂载dom、渲染、更新渲染、销毁一系列过程，成为vue生命周期。。。

  下边还是借助vue官方文档中生命周期图在通一遍：



 

第三章 信息系统集成专业基础知识


1.信息系统生命周期有哪几个过程

分四个阶段：产生，开发，运行和消亡阶段。

2.信息系统开发的方法有哪几种，各适用于什么情况的项目
系统开发的方法有六种：结构化方法，快速原型法，企业系统规划方法，战略数据规划法，信息工程方法，面向对象方法。
结构化方法：把系统看成一个大模块，再根据系统分析与设计进一步分解或组合。
快速原型法：快速建立并展示给用户。原型化方法不可以直接开发出最终产品。
企业系统规划法：提供一个信息系统规划，用以支持企业短期的和长期的信息需求。
战略数据规划方法：它是企业核心竞争力的重要构成因素，成为企业市场竞争中的制胜法宝。
信息工程方法：是企业系统规划方法和战略数据规划方法的一种交叉关系。是前两种方法的总结和提升。
面向对象方法：用于面向对象的软件开发。
瀑布模型的六个阶段：可行性分析，需求分析，软件设计，编码单测，测试，运行维护。
螺旋模型的四个象限：制定计划，风险分析，实施工程和客户评估。
结构化开发方法的特点：

遵循用户至上的原则

严格区分工作阶段

强调系统开发的整体性和全局性

系统开发过程工程化，文档资料标准化

结构化开发缺点：开发周期长，文档设计说明繁琐，工作效率低，要求在开发之初全面认识系统信息需求，充分预料各种可能发生的变化。



3.软件需求的定义及其分类

软件需求基本特征是可验证性。目的是检测和解决需求之间的冲突，发现软件的边界，以及软件如何与外界交互；详细描述系统需求和软件需求。
分三类：业务需求，用户需求，功能需求（也包括非功能需求）
业务需求：产品高层次目标要求。
用户需求：文档描述用户使用产品必须要完成的任务。
功能需求：定义了开发人员必须实现的软件功能。
非功能需求：包括产品必须遵守的标准规范和合约。外部界面的具体细节，性能要求。



4.软件设计的基本原则是什么
信息隐蔽性和模块独立性。模块独立性比较强的模块应是高内聚低耦合的模块。



5.软件测试的基本方法有哪些？各种测试方法的定义，面向对象的测试分为哪些层次？性能测试和第三方测试的定义。
按内部结构和具体实现的角度划分：白盒，黑盒，灰盒。
按是否执行程序划分：静态和动态测试。
按开发过程阶段的角度划分为：单元测试，集成测试，确认测试，系统测试，验收测试。
性能测试：通过自动化的测试工具模拟多种正常，峰值以及异常负载条件来对系统的各项性能指标进行测试。负载测试和压力测试都属于性能测试。
第三方测试：也叫独立测试。指独立于软件开发方和用户方的测试，组织的测试也称为独立测试。一般都是拿来模拟用户使用的真实环境。
模糊测试（Fuzz Testing）：是一种通过向目标系统提供非预期的输入并监视异常结果来发现软件漏洞的方法，是用于系统安全漏洞的发掘的重要技术。模糊测试的测试用例通常是随机数据。

面向对象的测试包括四个层次：算法层，类层，模版层和系统层。



6.决定软件具有可维护性的三个因素，软件维护的分类。
三个因素：可理解性，可测试性，可修改性


软件维护从性质上分为四类：纠错性维护，完善性维护，适应性维护，预防性维护。
完善性维护：为扩充机能和改善性能而进行的修改。还包括对处理效率和编写程序的改进。它占整体维护工作的50%-60%。（锦上添花）。特点是功能新增，工作量最大。
适应性维护：软件适用信息技术变化和管理需求变化而进行的修改。人们常常为改善系统硬件环境和运行环境而产生系统更新换代的需求。（展望未来与时俱进）。特点是环境需求有变化。
纠错性维护：是指改正在系统开发阶段已发生而系统测试阶段尚未发现的错误。（历史遗留问题）特点是发现错误，如系统补丁。主要内容包括：设计错误，程序错误，数据错误，文档错误。
预防性维护：是指为了改进应用软件的可靠性和可维护性，为了适应未来的软硬件环境的变化，应主动增加预防性的新的功能，以使应用系统适应各类变化而不被淘汰。（未雨绸缪）。特点是担心将来有变化而进行的修改。
占比信息：一半在完善，四分之一在适应，百分之四在预防。（就是鱼丸）

适应性需求：软件产品交付后进行的修改，以保证软件产品能在变化后或变化情况的环境下可以继续使用。（系统移植）



7.CMM软件能力成熟度模型即SW-CMM的5个等级及各个等级的特征；CMMI能力成熟度模型集成的五个等级以及各个等级的特征。

CMM的五个等级：初始级，可重复级，已定义级，已管理级，优化级。
可重复级：已经建立了基本的项目管理过程，可用于成本，进度和功能特征进行跟踪。项目有章可循，并能重复以往所取得的成功。
已定义级：用于管理和工程的软件过程均已文档化，标准化，并形成整个软件组织的标准软件过程。裁剪出项目适宜的过程。
已管理级：软件过程和产品质量有详细的度量标准。量化控制将使软件开发真正变为一个工业生产活动。

CMMI是CMM模型的最新版本，CMMI也划分为5个成熟度级别：完成级，管理级，定义级，量化管理级，优化级。
完成级：同CMM的初始级，项目实施对实施人员有很大的依赖性。
管理级：有资源有培训有检测控制有管理程序。保证了企业的所有项目实施都会成功。
定义级：和CMM的已定义级一样，强调标准化制度化，企业能够根据自身的特殊情况以及自己的标准流程将管理体系化。
量化管理级：CMM已管理级提倡度量指标，而他是要实现数字化管理。对管理流程要做到量化和数字化。







 

8.软件开发的工具有哪些，包括软件需求工具，软件设计工具，软件构造工具，软件测试工具，软件维护工具，软件配置管理工具，软件工程管理工具等。

9.软件复用，软件元素，软件构件的定义
软件复用：又名软件重用，是指在两次或多次不同的软件开发过程中重复使用相同或相近软件元素的过程。
软件元素：程序代码，测试用例，设计文档，设计过程，需求分析文档。
软件构件：通常把上面的可重用的元素简称为构件。

可重用的软件元素越大，就说重用的粒度越大。



10.面向对象的分析和设计中涉及的一些基本概念，如类，对象，继承，多态，消息通信等。

类是对象的抽象，对象是类的具体实例。

继承：使用已存在的定义作为基础建立新的定义。

多态：类中具有相似功能的不同函数是用同一个名称来实现。
面向对象的分析步骤：
1.确定问题域;
2.确定对象和类;
3.确定结构
4.确定主题
5.确定属性
6.确定方法



11.UML2.0的13种图，清楚各种图是用来干什么的。
类图：描述类，类的特征以及类之间的关系。
对象图：描述一个时间点上系统中各个对象的快照。
包图：对语义联系紧密的事物进行分组。
用例图：描述用例参与者及其关系。
构件图：构件的结构与连接，隐藏内部细节对外提供一组接口。
复合结构图：显示结构化类的内部结构。
顺序图：对象之间顺序交互。
通信图：描述对象之间的交互，重点在于连接。
定时图：也是对象交互，但重点在于给出消息经过不同对象的具体时间。
部署图：描述各个节点上的部署。
交互概观图：顺序图和活动图的混合。
活动图：描述过程行为与并行行为。
状态机图：描述对象状态的迁移。

顺序图，通信图，交互浏览图和时序图这四种图统称交互图。
UML图可以表示为系统静态结构和静态模型，以及表示系统动态结构的动态模型。
静态模型包括：类图，对象图，构建图，部署图。
动态模型包括：顺序图，协作图，状态图，活动图。

12.常用的几种软件体系结构风格，如分层系统，C2风格，C/S风格，三层C/S风格，B/S风格等。
C/S架构：胖客户机，瘦服务器
3层C/S架构：将应用功能分成表示层，功能层，数据层三部分。能提高软件的可维护性金额可扩展性。
B/S浏览器服务器架构：是C/S架构的一种变化或者改进。但主要的事物逻辑还是在服务器端实现，它是一种瘦客户端。所以不需要安装客户端软件，因此可以大大减轻客户端载荷。
分层模式：采用层次化的组织方式，每一层都是为上一层提供服务，并使用下一层提供的功能。例如：OSI七层模型就是网络模型。
事件驱动模式的基本原理是构件并不直接调用过程。而是触发一个或多个事件，事件的触发者并不知道哪些构件会受到事件的影响，且不能假定构建的处理顺序，甚至不知道会调用哪些过程。其典型系统包括各种图形界面工具。
知识库模式采用两种不同的构件。中央数据结构构件说明当前状态，独立构建在中央数据存储上执行。中央数据结构构件和独立的外部构件的相互作用是系统的主要问题，知识库的典型应用是信号处理领域，如语音和模式识别。



13.软件中间件的定义及常见软件中间件的认知。

定义：中间件屏蔽了底层操作系统的复杂性，使程序开发人员面对一个简单而统一的开发环境，减少程序设计的复杂性，以及系统维护运行管理的工作量。
中间件主要分四类：远程过程调用，面向消息的中间件，对象请求代理，事务处理监控。

目前面向消息的中间件产品有：IBM的MQSeries和BEA的MessageQ

Tomcat和Apache是Web中间件软件。



14.数据仓库技术的整体把握以及涉及的相关术语，如ETL提取转换加载，OLAP联机分析处理等。
ETL：用户从数据源抽取出所需的数据，经过数据清洗，转换，最终按照预先定义好的数据仓库模型，将数据加载到数据仓库中。
OLAP联机处理分析：对分析需要的数据进行有效集成，以便进行多角度多层次的分析，并发现趋势。
数据源：是数据仓库的基础。
数据集市：小型的面向部门或工作组级数据仓库。比如企业级数据仓库和部门级数据仓库通常都成为数据集市。
ODS操作数据存储：能支持企业日常全局应用的数据集合。不同于DB的一种新的数据环境。是DW扩展后得到的一个混合形式。
分割：结构相同的数据被分成多个物理单元。
粒度：保存数据的细化或综合程度的级别
元数据：数据仓库表的结构，表的属性，数据模型的规格说明，抽取日志和访问数据的公用例行程序。是关于数据的数据。

目录

下列叙述错误的是（ ）

在java7中，下列不能做switch()的参数类型是？

volatile关键字的说法错误的是

有如下一段代码，请选择其运行结果（）

在 hibernate 开发中，关于 POJO 类对象的状态说法正确的是（）。

以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值(  )

Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。

以下多线程对int型变量x的操作，哪几个不需要进行同步（    ）

下述说法正确的是（）

由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（）

面向对象程序设计方法的优点包含：

以下那些代码段能正确执行

下列叙述错误的是（ ）

正确答案: C   你的答案: C (正确)

java程序的输入输出功能是通过流来实现的

java中的流按照处理单位可分成两种：字节流和字符流

InputStream是一个基本的输出流类。

通过调用相应的close（）方法关闭输入输出流


来源：https://www.nowcoder.com/questionTerminal/1bb5f20d8b004560a2dfc27ef8116b0c

C.InputStream是一个基本的输出流类

这里"基本的"，其实就是将流分为节点流和处理流，而“基本的”是表示节点流

所以C选项可以看成：InputStream是属于节点输出流；

所以我们就要判断InputStream是节点流还是处理流，是输出流还是输入流

这就涉及到哪些是节点流，哪些是处理流了，而且很明显，他是一个输入流

节点流：

FileInputStream，FileOutputStrean，FileReader，FileWriter

StringReader，StringWriter

ByteArrayInputStream ，ByteArrayOutputStream ，CharArrayReader

PipedInputStream PipedOutputStream PipedReaderPipedWriter

处理流：

BufferedInputStrean，BufferedOutputStream，BufferedReader，BufferedWriter 

InputStreamReader，OutputStreamReader

DataInputStream，DataOutputStream

PrintWriter

 

节点流的前缀都是名词，如File，String，Char等；处理流的前缀都是动词，如input，print，bufferd等等


 

在java7中，下列不能做switch()的参数类型是？

正确答案: D   你的答案: D (正确)

int型

枚举类型

字符串

浮点型


来源：https://www.nowcoder.com/questionTerminal/8be1ad1273b944128d04cf9e831cce16

switch支持 int及以下（char， short， byte），String， Enum


 

volatile关键字的说法错误的是

正确答案: A   你的答案: A (正确)

能保证线程安全

volatile关键字用在多线程同步中，可保证读取的可见性

JVM保证从主内存加载到线程工作内存的值是最新的

volatile能禁止进行指令重排序


来源：https://www.nowcoder.com/questionTerminal/521a37038afc4dd49f3d92a12b9a5907

1.java的内存模型

java 内存模型规定了所有的变量都存储在主内存中，但是每个线程会有自己的工作内存，线程的工作内存保存了该线程中使用了的变量（从主内存中拷贝的），线程对变量的操作都必须在工作内存中进行，不同线程之间无法直接访问对方工作内存中的变量，线程间变量值传递都要经过主内存完成



 

2.什么是原子性

一个操作是不可中断的，要么全部执行成功要么全部执行失败，比如银行转账

 

3.什么是可见性

当多个线程访问同一变量时，一个线程修改了这个变量的值，其他线程就能够立即看到修改的值

 

4.什么是有序性

程序执行的顺序按照代码的先后顺序执行


			
1

			
2
			
			

			
int a = 0; //1

			
int b = 2; //2
			
		
像这2句代码1会比2先执行，但是jvm在正真执行时不一定是1在2之前，这里涉及一个概念叫做指令重排，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。比如上面的代码语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

在指令重排时会考虑指令之间的数据依赖性，比如2依赖了1的数值，那么处理器会保证1在2之前执行。

但是在多线程的情况下，指令重排就会有影响了。

 

5.volatile到底做了什么

禁止了指令重排
	
保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量值，这个新值对其他线程是立即可见的
	
不保证原子性（线程不安全）


 

有如下一段代码，请选择其运行结果（）

public class StringDemo{
  private static final String MESSAGE="taobao";
  public static void main(String [] args) {
    String a ="tao"+"bao";
    String b="tao";
    String c="bao";
    System.out.println(a==MESSAGE);
    System.out.println((b+c)==MESSAGE);
  }
}

正确答案: C   你的答案: D (错误)

true true

false false

true false

false true


来源：https://www.nowcoder.com/questionTerminal/10afeae4a5c24a35898c0771fb5995b1

public static void main(String[] args) {

    String a = "tao" + "bao";

    String b = "tao";

    String c = "bao";

    //true, taobao在字符串常量池已经存在，因此String a = "tao" + "bao";执行后，a也指向常量池中该字符串，因此引用相同

    System.out.println(a == MESSAGE);

    /*

     * false

     * 1. Java对String的相加是通过StringBuffer实现的，先构造一个StringBuffer里面存放"tao"，然后调用append()方法追加"bao"，然后将值为"taobao"的StringBuffer转化成String对象。

     * 2. 很明显新返回的对象和MESSAGE不是指向同一个地方，返回的对象指向堆中String对象，MESSAGE指向常量区中字符串，即两者引用不同

     */

    System.out.println((b + c) == MESSAGE);

}



这题是在考编译器的优化，hotspot中 编译时"tao"+"bao"将直接变成"taobao"，b+c则不会优化，因为不知道在之前的步骤中bc会不会发生改变，而针对b+c则是用语法糖，新建一个StringBuilder来处理


 

在 hibernate 开发中，关于 POJO 类对象的状态说法正确的是（）。

正确答案: A B C   你的答案: A B C D (错误)

自由状态（Transient）：实体在内存中自由存在，与数据库中的记录无关

持久状态（Persistent）：实体处于由Hibernate框架所管理的状态，对应了数据库中的一条记录，同时与某个session实例发生了关联

游离状态（Detached）：在session 关闭之后,可以使对象从持久状态转换到游离状态。

不能将对象从游离状态转换成持久态


来源：https://www.nowcoder.com/questionTerminal/569d3a78e488437d95c160ce644e0673

Hibernate Pojo的三态分别为transient（瞬时态）,persistent（持久态）,detached（游离态）

 

1、官方给出的三态与Session的关系如下：

短暂的： 从来没有执着，没有关联的任何会话
持久性： 具有唯一的会话相关的
分离： 以前执着，不与任何Session关联

 

2、三种状态间相互转换关系，及他们在数据库、session中的状态如下：

a.当我们new一个pojo时，它处于瞬时态，此时与session、数据库均无任何关联。

b.此后，我们获得session并开启hibernate事务，调用save(),persist(),saveOrUpdate()方法，将pojo转变为持久态，此时session中存有这个pojo，但直到transaction.commit()被调用时，sql语句才会执行，此后数据库中也才有此条数据。

c.但当commit()并且session.close()执行过后，pojo就变为了游离态，也就是说，数据库中有该记录，但session中不再有。

d.持久化状态的实例，也可以重新变成瞬时态，那就是调用delete()方法。

e.通过get()或load()方法得到的pojo是持久态的。

f.游离态的pojo可以通过update(),saveOrUpdate(),lock()和replicate()方法重新成为持久态。

g.调用merge()方法后，pojo维持原态，但内容会被更新到数据库


 

以下哪种JAVA得变量声明方式可以避免程序在多线程竞争情况下读到不正确的值(  )

正确答案: A B   你的答案: A C (错误)

volatile

static volatile

synchronized

static


来源：https://www.nowcoder.com/questionTerminal/5a9e81d22a6a491aac1b6bac5d4d6036

synchronized不是修饰变量的 它修饰方法或代码块或对象


 

Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。

正确答案: A C D   你的答案: A B C D (错误)

加载Servlet类及.class对应的数据

创建servletRequest和servletResponse对象

创建ServletConfig对象

创建Servlet对象


来源：https://www.nowcoder.com/questionTerminal/3dfd72f89070415185f09aebecd0e3f7

Servlet的生命周期一般可以用三个方法来表示：

init()：仅执行一次，负责在装载Servlet时初始化Servlet对象
	
service() ：核心方法，一般HttpServlet中会有get,post两种处理方式。在调用doGet和doPost方法时会构造servletRequest和servletResponse请求和响应对象作为参数。
	
destroy()：在停止并且卸载Servlet时执行，负责释放资源
初始化阶段：Servlet启动，会读取配置文件中的信息，构造指定的Servlet对象，创建ServletConfig对象，将ServletConfig作为参数来调用init()方法。所以选ACD。B是在调用service方法时才构造的




 

以下多线程对int型变量x的操作，哪几个不需要进行同步（    ）

正确答案: D   你的答案: D (正确)

x=y;

x++;

++x;

x=1;


来源：https://www.nowcoder.com/questionTerminal/11a7d8d366d54ff9a07c1fa054d6541b

A.由于y的值不确定，所以要加锁；

B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；

D 原子操作，所以不需要加锁

    原子性：指该操作不能再继续划分为更小的操作。

    Java中的原子操作包括：     

        1、除long和double之外的基本类型的赋值操作

        2、所有引用reference的赋值操作

        3、java.concurrent.Atomic.* 包中所有类的一切操作


 

设有下面两个赋值语句：

a = Integer.parseInt("1024");

b = Integer.valueOf("1024").intValue();

下述说法正确的是（）

正确答案: D   你的答案: A (错误)

a是整数类型变量，b是整数类对象。

a是整数类对象，b是整数类型变量。

a和b都是整数类对象并且它们的值相等。

a和b都是整数类型变量并且它们的值相等。


来源：https://www.nowcoder.com/questionTerminal/049f3c3b41024630887a7f596e7b450f

Integer对象的方法

Integer.parseInt("");是将字符串类型转换为int的基础数据类型

Integer.valueOf("")是将字符串类型数据转换为Integer对象

Integer.intValue();是将Integer对象中的数据取出，返回一个基础数据类型int


 

由3 个“1”和 5 个“0”组成的 8 位二进制补码，能表示的最小整数（）

正确答案: B   你的答案: D (错误)

-126

-125

-32

-3


来源：https://www.nowcoder.com/questionTerminal/12d5a40a4456400fad8d3f400bc5e5cc


既然求最小整数，那肯定先想到负数，则最高位（符号位）一定为1，

原码中肯定是1所在的位数越高，值越小，

而补码是由原码取反加1得到的，

则在补码中1所在的位数一定要越低，

即补码为1000 0011；

由补码求得原码：1111 1101=-(64+32+16+8+4+1)=-125;


 

面向对象程序设计方法的优点包含：

正确答案: A B C   你的答案: A B (错误)

可重用性

可扩展性

易于管理和维护

简单易懂


 

以下那些代码段能正确执行

正确答案: C D   你的答案: A C (错误)

public static void main(String args[]) {byte a = 3;byte b = 2;b = a + b;System.out.println(b);}

public static void main(String args[]) {byte a = 127;byte b = 126;b = a + b;System.out.println(b);}

public static void main(String args[]) {byte a = 3;byte b = 2;a+=b;System.out.println(b);}

public static void main(String args[]) {byte a = 127;byte b = 127;a+=b;System.out.println(b);}


来源：https://www.nowcoder.com/questionTerminal/72bdefc94545490eaad894ad89817580

byte类型的变量在做运算时被会转换为int类型的值，

故A、B左为byte，右为int，会报错；

而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。