第一篇：java 問題匯總(總結(jié),重點)
在用到spring框架中時，場景如下
post 請求過去，對象接收不到參數(shù)的值(解決辦法:考慮到在參數(shù)上加個@RequestBody 注解即可,有些沒加的是框架幫忙處理了后默認接收的是json串)http://localhost:8080/xxxxxxxxxxx-xxxxxxx-api/xxxxxx/xxxxx/xxxxxxxxx/suggest/add.sgt
======================================== mapper.xml->@Repository{存儲數(shù)據(jù)層}->@Service{業(yè)務(wù)層}->@Controller{展示層}（spring注解可以理解為這樣的線性,任其項目結(jié)構(gòu)怎么變這樣的線性結(jié)構(gòu)是不會變的,萬變不離其宗）
@Repository @Service @Controller均是注冊在spring上下文中 @Autowired 在spring上下文中找bean
@Qualifier 配合 @Autowired使用 當(dāng)找到多個同一類型的bean，則會拋異常，此時可以使用 @Qualifier(“beanName”)，明確指定bean的名稱進行注入 @RequestMapping 配置連接
@Required 注冊在sett方法上,檢查有沒有被調(diào)用 @RequestParam 綁定參數(shù)
@RequestBody讀取Request請求的body部分數(shù)據(jù)，使用系統(tǒng)默認配置的HttpMessageConverter進行解析，然后把相應(yīng)的數(shù)據(jù)綁定到要返回的對象上
如果你也用過struts2.簡單介紹下springMVC和struts2的區(qū)別有哪些? springmvc的入口是一個servlet即前端控制器，而struts2入口是一個filter過慮器。
springmvc是基于方法開發(fā)(一個url對應(yīng)一個方法)，請求參數(shù)傳遞到方法的形參，可以設(shè)計為單例或多例(建議單例)，struts2是基于類開發(fā)，傳遞參數(shù)是通過類的屬性，只能設(shè)計為多例。
Struts采用值棧存儲請求和響應(yīng)的數(shù)據(jù)，通過OGNL存取數(shù)據(jù)，springmvc通過參數(shù)解析器是將request請求內(nèi)容解析，并給方法形參賦值，將數(shù)據(jù)和視圖封裝成ModelAndView對象，最后又將ModelAndView中的模型數(shù)據(jù)通過reques域傳輸?shù)巾撁?。Jsp視圖解析器默認使用jstl。2.Spring的事務(wù)是如何配置的？
先配置事務(wù)管理器TransactionManager,不同的框架有不同屬性。再配置事務(wù)通知和屬性,通過tx:advice。配置,設(shè)置那些方法或者類需要加入事務(wù)。
3.spring事務(wù)控制放在service層，在service方法中一個方法調(diào)用service中的另一個方法，默認開啟幾個事務(wù)？
spring的事務(wù)傳播方式默認是PROPAGATION_REQUIRED，判斷當(dāng)前是否已開啟一個新事務(wù)，有則加入當(dāng)前事務(wù)，否則新開一個事務(wù)（如果沒有就開啟一個新事務(wù)），所以答案是開啟了一個事務(wù)。4.spring 什么情況下進行事務(wù)回滾？
Spring、EJB的聲明式事務(wù)默認情況下都是在拋出unchecked exception后才會觸發(fā)事務(wù)的回滾
unchecked異常,即運行時異常runntimeException 回滾事務(wù);checked異常,即Exception可try{}捕獲的不會回滾.當(dāng)然也可配置spring參數(shù)讓其回滾.spring的事務(wù)邊界是在調(diào)用業(yè)務(wù)方法之前開始的，業(yè)務(wù)方法執(zhí)行完畢之后來執(zhí)行commit or rollback(Spring默認取決于是否拋出runtime異常).如果拋出runtime exception 并在你的業(yè)務(wù)方法中沒有catch到的話，事務(wù)會回滾。
一般不需要在業(yè)務(wù)方法中catch異常，如果非要catch，在做完你想做的工作后（比如關(guān)閉文件等）一定要拋出runtime exception，否則spring會將你的操作commit,這樣就會產(chǎn)生臟數(shù)據(jù).所以你的catch代碼是畫蛇添足。5.Spring支持的事務(wù)管理類型？ Spring支持兩種類型的事務(wù)管理：
編程式事務(wù)管理：這意味你通過編程的方式管理事務(wù)，給你帶來極大的靈活性，但是難維護。
聲明式事務(wù)管理：這意味著你可以將業(yè)務(wù)代碼和事務(wù)管理分離，你只需用注解和XML配置來管理事務(wù)。
6.Spring框架的事務(wù)管理有哪些優(yōu)點？
它為不同的事務(wù)API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一個不變的編程模式。
它為編程式事務(wù)管理提供了一套簡單的API而不是一些復(fù)雜的事務(wù)API如 它支持聲明式事務(wù)管理。
它和Spring各種數(shù)據(jù)訪問抽象層很好得集成。7.講下Spring的七大事務(wù)傳播？
Spring中通過Propagation來設(shè)置事務(wù)的傳播屬性的，在這個屬性中提供了我們其中關(guān)于事務(wù)傳播的特性：
PROPAGATION_REQUIRED：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就新建一個事務(wù)。這是最常見的選擇。
PROPAGATION_SUPPORTS：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就以非事務(wù)方式執(zhí)行。PROPAGATION_MANDATORY：支持當(dāng)前事務(wù)，如果當(dāng)前沒有事務(wù)，就拋出異常。PROPAGATION_REQUIRES_NEW：新建事務(wù)，如果當(dāng)前存在事務(wù)，把當(dāng)前事務(wù)掛起。PROPAGATION_NOT_SUPPORTED：以非事務(wù)方式執(zhí)行操作，如果當(dāng)前存在事務(wù)，就把當(dāng)前事務(wù)掛起。
PROPAGATION_NEVER：以非事務(wù)方式執(zhí)行，如果當(dāng)前存在事務(wù)，則拋出異常。PROPAGATION_NESTED：支持當(dāng)前事務(wù)，新增Savepoint點，與當(dāng)前事務(wù)同步提交或回滾。
8.事務(wù)并發(fā)會引起什么問題,怎么解決？
事務(wù)并發(fā)會引起臟讀,幻讀,不可重復(fù)讀等問題,設(shè)定事務(wù)的隔離級別就可以解決。
9.事務(wù)的安全問題：鎖機制的實現(xiàn)原理及在項目中的使用？
鎖有悲觀鎖和樂觀鎖,悲觀鎖一般假設(shè)每個人都會修改數(shù)據(jù),默認情況下把數(shù)據(jù)都鎖住,影響性能,但安全性高.樂觀鎖是假設(shè)每個人都只讀下數(shù)據(jù),不會修改數(shù)據(jù),性能比較高,但是安全性較低,一般通過增加類似于版本控制里面版本號來解決問題。10.講下BeanFactory和ApplicationContext的區(qū)別？
BeanFactory是Spring容器頂級核心接口,比較早,但功能比較少,getBean就是BeanFactory定義的。
ApplicationContext是Spring里面的另外一個容器頂級接口,它繼承于BeanFactory,但是提供的功能譬如校驗,國際化,監(jiān)聽,對Bean的管理功能比較多,一般使用ApplicationContext。11.簡單介紹下你對mybatis的理解？ mybatis配置
SqlMapConfig.xml，此文件作為mybatis的全局配置文件，配置了mybatis的運行環(huán)境等信息。mapper.xml文件即sql映射文件，文件中配置了操作數(shù)據(jù)庫的sql語句。此文件需要在SqlMapConfig.xml中加載。
通過mybatis環(huán)境等配置信息構(gòu)造SqlSessionFactory即會話工廠
由會話工廠創(chuàng)建sqlSession即會話，操作數(shù)據(jù)庫需要通過sqlSession進行。mybatis底層自定義了Executor執(zhí)行器接口操作數(shù)據(jù)庫，Executor接口有兩個實現(xiàn)，一個是基本執(zhí)行器、一個是緩存執(zhí)行器。
Mapped Statement也是mybatis一個底層封裝對象，它包裝了mybatis配置信息及sql映射信息等。mapper.xml文件中一個sql對應(yīng)一個Mapped Statement對象，sql的id即是Mapped statement的id。
Mapped Statement對sql執(zhí)行輸入?yún)?shù)進行定義，包括HashMap、基本類型、pojo，Executor通過Mapped Statement在執(zhí)行sql前將輸入的java對象映射至sql中，輸入?yún)?shù)映射就是jdbc編程中對preparedStatement設(shè)置參數(shù)。
Mapped Statement對sql執(zhí)行輸出結(jié)果進行定義，包括HashMap、基本類型、pojo，Executor通過Mapped Statement在執(zhí)行sql后將輸出結(jié)果映射至java對象中，輸出結(jié)果映射過程相當(dāng)于jdbc編程中對結(jié)果的解析處理過程。12.講下MyBatis和Hibernate的區(qū)別? MyBatis是JDBC的輕量級封裝,把Sql和java代碼獨立出來,性能相對比較高,寫SQL語句相對于比較靈活,并且容易調(diào)試,一般用在大型項目中.Hibernate是JDBC的重量級封裝,開發(fā)速度比較快,但是性能比較低,調(diào)試不方便,一般適合對進度要求的比較高的中小型項目.13.mybatis中#{}和${}的區(qū)別是什么？
${}是Properties文件中的變量占位符，它可以用于標(biāo)簽屬性值和sql內(nèi)部，屬于靜態(tài)文本替換，比如${driver}會被靜態(tài)替換為com.mysql.jdbc.Driver。#{}是sql的參數(shù)占位符，Mybatis會將sql中的#{}替換為?號，在sql執(zhí)行前會使用PreparedStatement的參數(shù)設(shè)置方法，按序給sql的?號占位符設(shè)置參數(shù)值，比如ps.setInt(0, parameterValue)，#{item.name}的取值方式為使用反射從參數(shù)對象中獲取item對象的name屬性值，相當(dāng)于param.getItem().getName()。14.mybatis中XML映射文件中，除了常見的select|insert|updae|delete標(biāo)簽之外，還有哪些標(biāo)簽？、、、、，加上動態(tài)sql的9個標(biāo)簽，trim|where|set|foreach|if|choose|when|otherwise|bind等，其中為sql片段標(biāo)簽，通過標(biāo)簽引入sql片段，為不支持自增的主鍵生成策略標(biāo)簽。15.MyBatis編程步驟是什么樣的？ 創(chuàng)建SqlSessionFactory 通過SqlSessionFactory創(chuàng)建SqlSession 通過sqlsession執(zhí)行數(shù)據(jù)庫操作 調(diào)用session.commit()提交事務(wù) 調(diào)用session.close()關(guān)閉會話
16.JDBC編程有哪些不足之處，MyBatis是如何解決這些問題的？
① 數(shù)據(jù)庫鏈接創(chuàng)建、釋放頻繁造成系統(tǒng)資源浪費從而影響系統(tǒng)性能，如果使用數(shù)據(jù)庫鏈接池可解決此問題。
解決：在SqlMapConfig.xml中配置數(shù)據(jù)鏈接池，使用連接池管理數(shù)據(jù)庫鏈接。②Sql語句寫在代碼中造成代碼不易維護，實際應(yīng)用sql變化的可能較大，sql變動需要改變java代碼。
解決：將Sql語句配置在XXXXmapper.xml文件中與java代碼分離。
③向sql語句傳參數(shù)麻煩，因為sql語句的where條件不一定，可能多也可能少，占位符需要和參數(shù)一一對應(yīng)。
解決： Mybatis自動將java對象映射至sql語句。
④對結(jié)果集解析麻煩，sql變化導(dǎo)致解析代碼變化，且解析前需要遍歷，如果能將數(shù)據(jù)庫記錄封裝成pojo對象解析比較方便。解決：Mybatis自動將sql執(zhí)行結(jié)果映射至java對象。17.使用MyBatis的mapper接口調(diào)用時有哪些要求？ Mapper接口方法名和mapper.xml中定義的每個sql的id相同
Mapper接口方法的輸入?yún)?shù)類型和mapper.xml中定義的每個sql 的parameterType的類型相同
Mapper接口方法的輸出參數(shù)類型和mapper.xml中定義的每個sql的resultType的類型相同
Mapper.xml文件中的namespace即是mapper接口的類路徑。18.簡單的說一下MyBatis的一級緩存和二級緩存？
Mybatis首先去緩存中查詢結(jié)果集，如果沒有則查詢數(shù)據(jù)庫，如果有則從緩存取出返回結(jié)果集就不走數(shù)據(jù)庫。Mybatis內(nèi)部存儲緩存使用一個HashMap，key為hashCode+sqlId+Sql語句。value為從查詢出來映射生成的java對象 Mybatis的二級緩存即查詢緩存，它的作用域是一個mapper的namespace，即在同一個namespace中查詢sql可以從緩存中獲取數(shù)據(jù)。二級緩存是可以跨SqlSession的。
19.Mybatis是否支持延遲加載？如果支持，它的實現(xiàn)原理是什么？
Mybatis僅支持association關(guān)聯(lián)對象和collection關(guān)聯(lián)集合對象的延遲加載，association指的就是一對一，collection指的就是一對多查詢。在Mybatis配置文件中，可以配置是否啟用延遲加載lazyLoadingEnabled=true|false。它的原理是，使用CGLIB創(chuàng)建目標(biāo)對象的代理對象，當(dāng)調(diào)用目標(biāo)方法時，進入攔截器方法，比如調(diào)用a.getB().getName()，攔截器invoke()方法發(fā)現(xiàn)a.getB()是null值，那么就會單獨發(fā)送事先保存好的查詢關(guān)聯(lián)B對象的sql，把B查詢上來，然后調(diào)用a.setB(b)，于是a的對象b屬性就有值了，接著完成a.getB().getName()方法的調(diào)用。這就是延遲加載的基本原理。
20.Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重復(fù)？ 不同的Xml映射文件，如果配置了namespace，那么id可以重復(fù)；如果沒有配置namespace，那么id不能重復(fù)；畢竟namespace不是必須的，只是最佳實踐而已。
原因就是namespace+id是作為Map的key使用的，如果沒有namespace，就剩下id，那么，id重復(fù)會導(dǎo)致數(shù)據(jù)互相覆蓋。有了namespace，自然id就可以重復(fù)，namespace不同，namespace+id自然也就不同。21.為什么說Mybatis是半自動ORM映射工具？它與全自動的區(qū)別在哪里？ Hibernate屬于全自動ORM映射工具，使用Hibernate查詢關(guān)聯(lián)對象或者關(guān)聯(lián)集合對象時，可以根據(jù)對象關(guān)系模型直接獲取，所以它是全自動的。而Mybatis在查詢關(guān)聯(lián)對象或關(guān)聯(lián)集合對象時，需要手動編寫sql來完成，所以，稱之為半自動ORM映射工具。22.SSM優(yōu)缺點、使用場景？
1.Mybatis和hibernate不同，它不完全是一個ORM框架，因為MyBatis需要程序員自己編寫Sql語句，不過mybatis可以通過XML或注解方式靈活配置要運行的sql語句，并將java對象和sql語句映射生成最終執(zhí)行的sql，最后將sql執(zhí)行的結(jié)果再映射生成java對象。
2.Mybatis學(xué)習(xí)門檻低，簡單易學(xué)，程序員直接編寫原生態(tài)sql，可嚴(yán)格控制sql執(zhí)行性能，靈活度高，非常適合對關(guān)系數(shù)據(jù)模型要求不高的軟件開發(fā)，例如互聯(lián)網(wǎng)軟件、企業(yè)運營類軟件等，因為這類軟件需求變化頻繁，一但需求變化要求成果輸出迅速。但是靈活的前提是mybatis無法做到數(shù)據(jù)庫無關(guān)性，如果需要實現(xiàn)支持多種數(shù)據(jù)庫的軟件則需要自定義多套sql映射文件，工作量大。3.Hibernate對象/關(guān)系映射能力強，數(shù)據(jù)庫無關(guān)性好，對于關(guān)系模型要求高的軟件（例如需求固定的定制化軟件）如果用hibernate開發(fā)可以節(jié)省很多代碼，提高效率。但是Hibernate的學(xué)習(xí)門檻高，要精通門檻更高，而且怎么設(shè)計O/R映射，在性能和對象模型之間如何權(quán)衡，以及怎樣用好Hibernate需要具有很強的經(jīng)驗和能力才行。
4.總之，按照用戶的需求在有限的資源環(huán)境下只要能做出維護性、擴展性良好的軟件架構(gòu)都是好架構(gòu)，所以框架只有適合才是最好。23.SpringMvc里面攔截器是怎么實現(xiàn)的？
有兩種方式,一種是實現(xiàn)接口,另外一種是繼承適配器類,然后在SpringMvc的配置文件中配置攔截器即可:
24.Spring中AOP的應(yīng)用場景、Aop原理、好處？
AOP--Aspect Oriented Programming面向切面編程；用來封裝橫切關(guān)注點，具體可以在下面的場景中使用: Authentication 權(quán)限、Caching 緩存、Context passing 內(nèi)容傳遞、Error handling 錯誤處理Lazy loading懶加載、Debugging調(diào)試、logging, tracing, profiling and monitoring 記錄跟蹤優(yōu)化 校準(zhǔn)、Performance optimization 性能優(yōu)化、Persistence 持久化、Resource pooling 資源池、Synchronization 同步、Transactions 事務(wù)
原理：AOP是面向切面編程，是通過動態(tài)代理的方式為程序添加統(tǒng)一功能，集中解決一些公共問題。優(yōu)點：
1.各個步驟之間的良好隔離性耦合性大大降低
2.源代碼無關(guān)性，再擴展功能的同時不對源碼進行修改操作。
第二篇：JAVA培訓(xùn)總結(jié),重點都有1
學(xué)習(xí)使人進步 第一課
一、java 語言簡介：
是由 sun 公司推出的新一代的純面向?qū)ο蟮木W(wǎng)絡(luò)編程語言，1995年問世的。
二、java語言的特性：
1、簡單的： { keep it simple and stupid(保持它的簡單性和可操作性)以人類正常的思維模式思考問題。java 是由c++語言 發(fā)展而來。
java 提供了非常豐富的內(nèi)置資源庫（API）}
2、安全的：健壯性 {
1、java 中沒有指針（指針，是一項能直接指向內(nèi)存地址的）
2、java 會內(nèi)存釋放--GC機制（垃圾回收器，自動釋放）
3、預(yù)檢索程序錯誤--在程序執(zhí)行前，會檢查程序是否有 語法 錯誤，有則不會允許執(zhí)行。
4、異常處理機制--}
3、可伸縮的： {
1、平臺：把軟件的語言，翻譯成硬件 所能識別的語言，即程序運行的硬件和軟件的環(huán)境。
2、java SE--java 標(biāo)準(zhǔn)版（實現(xiàn) 桌面應(yīng)用程序）
3、java EE--j2EE 企業(yè)級版本
4、java ME--java 微型版本（嵌入式 開發(fā)）}
4、跨平臺的： {
}
5、面向?qū)ο蟮模?{
1、現(xiàn)實世界是什么樣子的：（山川、河流、動物、植物。。分類組成的）
現(xiàn)實世界 就是對所有的事物進行分類，分類就代表一個群體。
分類就是將具有相同特征和行為的事物進行概括。
每個分類下面都有無數(shù)的個體，在java 語言中，和現(xiàn)實世界是一樣的，也是要先分類再去實現(xiàn)分類下的個體（java 中將 個體稱為：對象）
根據(jù)：特征（屬性）、行為 劃分的2、java 語言中，類和對象的關(guān)系：
java 語言中將現(xiàn)實世界中表示群體的分類稱之為類，而是將群體下面的每一個個體稱之為對象；
具有相同屬性和行為的 對象的集合 抽象為類或稱之為類型
對象是類的一個具體的實例，展示了類的不同屬性和行為
實例化：就是將抽象的類 轉(zhuǎn)化成具體的個體的過程
3、如何用java語言去描述類：
java 語言中類的描述分為兩部分：
1、要描述 他的屬性（特征、靜態(tài)屬性）
2、要描述的是行為（動態(tài)屬性、方法）語法格式：
class class_name{靜態(tài)屬性；動態(tài)屬性；}
類
類名
類體
靜態(tài)屬性：相當(dāng)于 字段 動態(tài)屬性：用方法描述 }
主控制類：
1、聲明對象
并對 對象 進行 實例化對象
類型名 對象名=new 類型名()//聲明部分
2、使用對象，即向?qū)嶓w類發(fā)送消息。
對象名.屬性名=“屬性值”-----字符串用“" 數(shù)值 不用
對象名.方法名()
第二課
跨平臺性：
*
一、java如何實現(xiàn)跨平臺的？
1、平臺：把軟件的語言翻譯成硬件所能識別的語言，即程序運行的軟件或硬件環(huán)境。
java 之所以能夠?qū)崿F(xiàn)跨平臺性，是因為 java 有屬于自己的平臺，不直接與操作系統(tǒng)或硬件環(huán)境交流。
java平臺系統(tǒng)由兩部分組成：
1、java開發(fā)工具包；
2、java運行的軟環(huán)境（java虛擬機--JVM---java virtual machine）
API：是一些已編寫好的程序的集合，他提供java 面對程序員的接口。
接口：很多內(nèi)置資源中，有一個數(shù)據(jù)包存儲對市面上已經(jīng)存在的各種操作系統(tǒng)進行解析。
java虛擬機：（JVM）就是一個小型的計算機，也可稱為 java的解釋器。作用：是翻譯、解釋java 的語言，只認識字節(jié)碼文件（.class文件）。
java 實現(xiàn)跨平臺的原理：
.java 是程序員所能夠識別的代碼，通過 編譯器 轉(zhuǎn)換成 解釋器 所能夠識別的.class字節(jié)碼文件，解釋器 將.class字節(jié)碼文件 轉(zhuǎn)換成目標(biāo)機器 代碼文件，以
上就是java 實現(xiàn)跨平臺的原理。
*面向?qū)ο蠛?面向過程 兩者之間的區(qū)別：
1、面向過程：是分析出解決問題所需要的步驟，然后用方法 把這些步驟一步一步的實現(xiàn)，當(dāng)使用的時候，一個一個 依次調(diào)用。缺點，代碼的可重用性和可維護性 較差。
2、面向?qū)ο螅菏前褬?gòu)成問題的每一個對象 進行分類，分類的目的不是為了解決某一個步驟，而是為了描述 某個事物在整個解決問題步驟中的行為。優(yōu)點：代碼的可重用性和可維護性較強。
分類--創(chuàng)建對象--發(fā)送消息
*作業(yè)1：用自己的語言 描述 類、對象、實例化，三者之間的關(guān)系。
類 就是擁有相同特征和行為 的 某一群體，而，對象就是 這一群體 中的某一個體，而實例化 是對群體聲明，使其從死的變成活的，使其從不占用系統(tǒng)內(nèi)存--到占用系統(tǒng)內(nèi)存。類--人 個體--王寧
實例化--王寧定義成人 的過程
作業(yè)2：使用 java 語言 描述 汽車類（品牌、顏色、車牌號、排氣量）行為：汽車運行。作業(yè)3：用java 語言，描述 門 類型（長、寬、材質(zhì)）行為：求面積、求周長
第二章
方法的設(shè)計
第一課
方法的語法規(guī)則：
[限定修飾詞] 返回值類型 方法名([形參列表])//方法頭 {
方法體;//方法所要執(zhí)行的一系列的語句（可以是一條或多條語句）}
只要是被稱之為 語句的都要 放在方法體中 執(zhí)行。
一、限定修飾詞 作用：對類的成員施以一定的 訪問權(quán)限限制，實現(xiàn)類中的成員一定范圍內(nèi)信息的隱藏。---限制方法被調(diào)用的范圍。
1、public 公共的，公有的，可以被 所有的類 進行訪問。對所有用戶開放，所有的用戶都可以直接進行調(diào)用。
可以被 當(dāng)前類下的程序訪問，同一包（同一文件夾）下的類訪問，子孫類訪問，其他包下的類訪問。
2、protected 受保護的，可以被 同一包下的類 訪問，父類 和 子類 的繼承關(guān)系中 也可以訪問。
3、friendly 友好的，默認的限定修飾詞，可以被當(dāng)前類或 同一包下的類訪問。
4、private
私有的，只能有本類 來進行訪問。
作用域
當(dāng)前類
同一包
子孫類
其他包 public
*
*
*
* protected *
*
*
x friendly *
*
x
x private
*
x
x
x
二、返回值 類型：
1、有返回值
⒈基本數(shù)據(jù)類型
整形的 byte（字節(jié)數(shù)據(jù)類型，1個字節(jié)）、short（短整型，2個字節(jié)）、int（4個字節(jié)，默認的整形）、long（長整形，8個字節(jié)）
浮點數(shù) float（單精度浮點數(shù)，4個字節(jié)）
double（雙精度浮點數(shù)，8個字節(jié)，默認的類型）
其他
char（字符數(shù)據(jù)類型，1個字節(jié)，用''號）
boolean（布爾數(shù)據(jù)類型，占1/8字節(jié)，只有
true/false）
⒉復(fù)合數(shù)據(jù)類型（引用數(shù)據(jù)類型）
類類型
數(shù)組
枚舉
接口
泛類型
標(biāo)注
（如果方法設(shè)定時，將其設(shè)定為有返回值類型的，那么，在方法體內(nèi) 必須有一條return 語句。return語句的作用:
1、返回給 調(diào)用者一個確切的值，而且該值的數(shù)據(jù)類型，必須與方法定義的返回值類型相一致。return語句 使用的注意事項：
1、一個方法體內(nèi)只能出現(xiàn)一條可執(zhí)行的return語句；
2、return語句后 可以是常量、變量或 表達式，但是 必須保證只能得到一個準(zhǔn)確值；
3、return語句 有結(jié)束方法體的作用，所以在return語句后 不允許出現(xiàn)任何的可執(zhí)行語句。）
2、無返回值 void
（如果是無返回值類型的，往往方法體內(nèi)描術(shù)的是一系列的動作，不需要給方法調(diào)用者 一個返回值。）
有返回值 與 無返回值 在執(zhí)行上的區(qū)別：
1、無返回值方法的調(diào)用步驟：傳遞參數(shù)、執(zhí)行方法體中的各條語句
2、有返回值方法的調(diào)用步驟：傳遞參數(shù)、執(zhí)行方法體中的語句、返回給調(diào)用者一個
確切的值
三、方法名
標(biāo)識符的命名規(guī)則和規(guī)范：
規(guī)則：
1、必須以字母、下劃線、或美元符號開頭，后面可以跟隨字母、下劃線、美元符號、或數(shù)字。
2、區(qū)分大小寫。
3、不可以單獨使用java中的關(guān)鍵字和保留字。
類名的規(guī)范：
1、簡單單詞做為類名，要求首字母大寫，其余字母小寫。
2、復(fù)合單詞作為類名，要求每一個單詞的首字母都要大寫，其余字母小寫。
變量名及方法名的規(guī)范：
1、簡單單詞作為變量名及方法名時，要求所有字符全部小寫。
2、復(fù)合單詞作為變量名及方法名時，要求第一個單詞所有字母小寫，從第二個單詞之后首字母大寫，其余字母小寫。
其他要注意的規(guī)范：
1、嚴(yán)格區(qū)分大小寫。
2、一個源文件中，只允許寫一個類。
3、源文件的名字要與類名字，相一致。
四、參數(shù)
參數(shù)：在調(diào)用方法的過程中，可以由參數(shù)對數(shù)據(jù)進行傳遞。參數(shù)的分類：
1、形式參數(shù)：是在方法定義時，所定義的變量，就稱之為形式參數(shù)，或簡稱為形
參?？梢砸淮味x多個，中間用，號分隔。
：是方法 接受參數(shù)的占位符。
2、實際參數(shù)：調(diào)用方法時，為形式參數(shù)所傳遞的具體值，就叫做實際參數(shù)。簡稱為 實參，實參可以有多個，中間用，號分隔。
形式參數(shù)在使用時的注意事項：
1、形式參數(shù)可以有一,個到多個，中間必須用，號分隔。
2、每一個形式參數(shù)就是聲明一個變量，但是不能為其賦值。
3、在我們的方法體內(nèi)，可以直接使用聲明的形式參數(shù)。
4、形式參數(shù) 只能在調(diào)用方法的時候，由方法的調(diào)用者為其賦值。實際參數(shù)在使用時的注意事項：
1、實際參數(shù)的數(shù)據(jù)類型 必須與形式參數(shù)的數(shù)據(jù)類型相一致 或相兼容。
2、實際參數(shù)的順序必須 與形式參數(shù)定義的順序相一致。
3、實際參數(shù)的個數(shù)必須與 形式參數(shù)的個數(shù)相一致。
參數(shù)傳遞的分類：
1、值傳遞：就是基本數(shù)據(jù)類型之間 數(shù)據(jù)的交互就稱之為 值傳遞
2、地址傳遞：就是對象 與 對象之間 數(shù)據(jù)的傳輸。
有三個類
男 女 中
男要向女
送一朵
玫瑰花
某男孩 喜歡 某女孩
送一朵 玫瑰花
第二課
一、事件委托機制
就是兩個類型不想做正面接觸，又想達到一定的目的，可以委托第三類完成。
方法體：就是程序功能的描述。通過運算符和表達式體現(xiàn)出來。
運算符 與 表達式：
運算：就是對數(shù)據(jù)進行的操作。
運算符：就是運算時所使用的符號，稱為運算符。操作數(shù)：參與運算的數(shù)據(jù)。
表達式：由操作數(shù)和運算符，按一定語法形式 組成的有意義的符號序列。結(jié)合性：左，從左到右 開始運算
右，從右向左 開始運算
運算符：
1、賦值運算符：
變量名 = 值;（= 是將右邊的值 賦給 左邊的變量）
復(fù)合賦值運算符： +=、-=、*=、/=、%=
2、算術(shù)運算符：
1、一元
---元：指操作數(shù)的個數(shù)（+正號，-負號，++自增1 符號，--自減1 符號）例：int a=3
int b=++a 前綴
int b=a++ 后綴
如果 自增或自減 運算符，在變量之前，那么 我們就先自加1 或 自減1 后在使用，如果自增 或 自減 運算符 在變量之后，那么 我們就先使用，后自加1 或 自減1 的操作。
2、二元（+、-、*、/、%）
如果兩個操作數(shù) 都為整數(shù)的情況下，/ 表示整除，那么得到的結(jié)果就是 整數(shù)。
+、-、*、/ 中 只要操作數(shù)是整數(shù)，的到的結(jié)果 就是整數(shù)，操作數(shù) 是浮點數(shù)，得到的結(jié)果就是浮點數(shù)。
% 取模 操作數(shù)1 和 操作數(shù)2 如果 是負數(shù)的話，看% 符號，左邊的 操作數(shù)符號 賦給最終結(jié)果。
如果操作數(shù)有一個負數(shù)，先忽略操作數(shù)的符號，進行運算，然后，將左邊操作數(shù)的符號 賦給 最終結(jié)果。
浮點數(shù)取模：a%b=a-((int a/b)*b)總結(jié)：
3、三元（表達式1？ 表達式2：表達式3；）
判斷表達式1 的結(jié)果（必須是 布爾類型）如果是 true 值 時，執(zhí)行--表達式2，如果是false 值，執(zhí)行--表達式3；
先算一元，再算二元，最后算三元。
3、其他運算符
編寫程序的三點原則：
1、就是保證程序運行速度快，每一條語句 盡量做到 優(yōu)化。
2、就是節(jié)省內(nèi)存資源。
3、保證程序運行的安全系數(shù)。
*** 如果一個類
是 public 來修飾的，類名 必須 與原文件名
相同。
第三課
一、關(guān)系運算符（>、<、>=、<=、==、!=）
任何一個 由關(guān)系運算符 鏈接的表達式，其返回值 一定是一個 布爾類型的值。
二、邏輯運算符（&& 與、|| 或、！非）
邏輯運算符 鏈接的表達式（前面或后面）
必須是一個布爾 數(shù)據(jù)類型的值，或能夠 獲得布爾值的表達式。
對“||”運算，如果左邊的表達式的值為true，則不必對運算符右邊的表達式再進行運算，整個表達式的結(jié)果就為true。
對“&&”運算，如果左邊的表達式的值為false，則不必對運算符右邊的表達式再進行運算，整個表達式的結(jié)果就為false。
（先算 非！，再算 與&&，最后算 或||）
位運算符：對二進制 數(shù)進行的運算。
~ 按位取反：對數(shù)據(jù)的每一個二進制位 取反運算，1--0,0--1
& 按位 與運算 ： 要求有兩個操作數(shù)進行運算，如果兩個相應(yīng)位均為一，則該位結(jié)果為1，否則結(jié)果為0。8&9--1000&1001
| 按位或 運算：
8|9 要求有兩個操作數(shù)進行 運算，只要 兩個相應(yīng)位 中 有1 個 為1，則該位 結(jié)果為 1，否則 該位結(jié)果 為 0。
^ 按位 異或 運算：相同數(shù)值 為假，不同數(shù)值 為真。
相同的數(shù)字 進行按位異或運算 得到的結(jié)果 及 為0，不同的數(shù)字 進行按位異或運算 得到的結(jié)果 及為 1。
<< 左移 運算：x<<，箭頭 指向 則是要 移的 方向。
x 左移 移動n 位，就相當(dāng)于 x*2的n次冪。
>> 右移 運算（算術(shù)右移--相當(dāng)于除法運算）：8>>2 === 8/2
x右移 n位，就相當(dāng)于 x/2的 n次冪。
>>> 邏輯右移 ： 不管正數(shù) 還是 負數(shù)，空出來的左側(cè) 的高位，全部補 0。
邏輯右移 又被稱為 不帶符號位的右移，x邏輯右移n 位，就是將x 的各位 右移n 位，移到右端的低位 舍棄，左移后 左邊 留下的空位 一律 補0.負數(shù)的二進制數(shù) 求法： 先忽略 符號，得到正數(shù) 的二進制數(shù)，在進行 按位取反，在在最后一位加一。
空出來的高位，正數(shù) 用 0 補，負數(shù) 用 1補。
邏輯與和或 與 按位與和或 的 區(qū)別：
1、&& 邏輯與 ||或運算符，& 按位與 |或 運算符。
2、邏輯與 ||或 的兩個操作數(shù) 都必須 是布爾數(shù)據(jù)類型，而 按位與 |或 的操作數(shù) 可以是任意的 基本數(shù)據(jù)類型。
3、邏輯與 ||或 有短路功能，而 按位與 無短路功能。
1、new 運算符
：就是對 對象 進行實例化。
2、對象名 instance Of 類名
判斷你所給出來 的 對象 是否 屬于這個類 得到的結(jié)果 是布爾類型值，返回值 為true 說明 該對象 屬于該類，如果 返回false 說明該對象 不屬于 該類。
第四課
一、復(fù)合語句：
1、流程控制語句：
循環(huán)語句---使用的時機，當(dāng)程序中 有一條 到多條 需要 重復(fù)執(zhí)行時，我們就要用到 循環(huán)語句。
1、當(dāng)型 while 循環(huán)
while（條件表達式）--當(dāng) 條件表達式 滿足的時候 進入 循環(huán)體
{
循環(huán)體；
}
工作流程：while 是當(dāng)?shù)囊馑?，?dāng)條件表達式的 內(nèi)容為真時，進入循環(huán)體，循環(huán)體 執(zhí)行結(jié)束后，再一次判斷循環(huán)條件，如為 真，繼續(xù)回到 循環(huán)體 執(zhí)行，直到循環(huán)條件為假 時，終止 循環(huán)。
在使用 while循環(huán)時要考慮的內(nèi)容：
1、什么時候進入循環(huán)體，什么時候退出循環(huán)體；
2、進入循環(huán)體之后做什么；
2、直到型循環(huán)（do……while 循環(huán)）
do
{
循環(huán)體；
}while();
do。。while 循環(huán)的工作流程：在沒有 判斷循環(huán)條件的情況下 進入循環(huán)體，循環(huán)體 執(zhí)行結(jié)束后，判斷 是否滿足 循環(huán)條件，如果 返回值 為 true，在一次 進入到 循環(huán)體，直到 返回 false 為止。
while 與 do。while 的區(qū)別：
1、while 是先 判斷條件 在 決定 是否 進入循環(huán)體。
do。while是先進入 循環(huán)體，然后在判斷條件，在決定 是否繼續(xù)進入循環(huán)。
2、使用 do while 循環(huán)時，循環(huán)體 至少被 執(zhí)行 一次。
3、for 循環(huán)
for(表達式1；表達式2；表達式3)
{
循環(huán)體；
} 表達式1：循環(huán)變量的初始值。
表達式2：循環(huán)條件，得到的 必須是一個 布爾 值。表達式3：循環(huán)步長，循環(huán)變量的增量值。
要注意的：
1、可同時為空，當(dāng)所有條件 都為空時，表示的是 死循環(huán)，2、表達式1，與表達式3 的位置 可以同時存放多個 表達式，中間用逗號，分隔。
3、表達式2 的位置，必須返回 一個布爾值。
4、循環(huán)體 可以為空。
工作流程：
1、執(zhí)行表達式1；
2、執(zhí)行表達式2，判斷條件是否成立；
3、執(zhí)行循環(huán)體；
4、執(zhí)行 表達式3；
5、回到 表達式2，判斷是否成立，成立3--4--5，不成立 退出循環(huán)；
第五課
Integer.parseInt(args[0])
// 轉(zhuǎn)換 成 int 類型
System.err.println(”請輸入一個值");//從標(biāo)準(zhǔn) 錯誤流
中 輸出 一句話。System.exit(-1);// 退出 java 虛擬機，exit 方法 需要 傳遞 一個int 類型的參數(shù)，此參數(shù)只能是 0 或-1。當(dāng)傳遞值為0 時，表示正常狀態(tài)退出 java虛擬機；當(dāng)參數(shù)為-1時，表示非正常狀態(tài) 退出java虛擬機。
}
1、命令行參數(shù)傳遞給誰？
傳遞給main方法中定義的String類型的args數(shù)組。
2、命令行出現(xiàn)多個參數(shù)由誰分隔？
多個參數(shù)通過空格分隔
3、命令行傳遞的值是什么數(shù)據(jù)類型？
String數(shù)據(jù)類型
4、令行參數(shù)如何進行數(shù)據(jù)類型的轉(zhuǎn)換？
1）轉(zhuǎn)換為int類型
Integer.parseInt();
2）轉(zhuǎn)換為double類型： Double.valueOf(args[0]).doubleValue();
5、String args[]中args是否可由其他名字來代替？
可以
6、String[]args和String args[]兩種寫法是否都是正確的?
兩種寫法都是正確的。
方法
分三類：
1、構(gòu)造方法：又叫做 構(gòu)造函數(shù)、構(gòu)造器，構(gòu)造方法名 與類名 相同。沒有 返回值，但是 不用 void 修飾。
一個類中，可以有一個到多個 構(gòu)造方法。如果 有多個構(gòu)造方法，那么 要求 每個構(gòu)造方法的參數(shù)類型、個數(shù) 一定不同。由此，決定調(diào)用哪一個構(gòu)造方法。
構(gòu)造方法 只能通過 new 運算符調(diào)用。
作用：
1、在內(nèi)存中分配一塊空間，給 實例化的對象；
2、為成員變量 初始化；
默認的構(gòu)造方法:參數(shù)體、方法體 為空，在一個類中，只要人為的 設(shè)置了 構(gòu)造方法，那么，默認的構(gòu)造方法就會被 銷毀。
2、實例方法：必須由對象 調(diào)用的方法。
3、靜態(tài)方法：又叫做 類方法，是由static 來修飾的方法?？梢杂?對象名 或 類名直接調(diào)用。
main 方法 由java 虛擬機 自動調(diào)用 而不是由 用戶顯示調(diào)用。
作業(yè)：
1、為什么 main 方法 必須由 static 來修飾？ main 作用：1聲明對象
2、傳遞信息
在main方法加載之前是沒有對象的，但 main方法 可以加載，就說明是由類名調(diào)用，main方法 是靜態(tài)方法，所以 必須 由 static 來修飾。
2、設(shè)計一個 三角形的類，構(gòu)造方法
為三角形的 三邊 初始化；返回 三角形的周長；面積，高 通過形參 獲得；在main 方法 中 判斷，同過 命令 行 傳遞的 三個值 是否能夠成 三角形。
第六課
嵌套：包含的意思。在一個完整的結(jié)構(gòu)內(nèi)，包含 另一個結(jié)構(gòu)。
循環(huán)嵌套：在一個完整的循環(huán)內(nèi) 包含另一個 循環(huán)。
外層循環(huán)；
// 在循環(huán)體內(nèi)，包含 另一個 完整的循環(huán) 語句，就叫做 外層循環(huán)。{ 內(nèi)層循環(huán)；
// 放在 另一個 循環(huán)語句體內(nèi) 的 循環(huán)，就叫做 內(nèi)層循環(huán)。
}
循環(huán) 可以嵌套 若干層。
for（表達式1；表達式2；表達式3）{
for（表達式4；表達式5；表達式6）
{
內(nèi)層循環(huán)體；
} }
工作 流程：
1、表達式1；
2、表達式2；
3、表達式4；
4、表達式5；
5、內(nèi)層循環(huán)體；
6、表達式6；
7、表達式5； 為真：4、5、6 直到表達式5不成立；
8、表達式3；
9、表達式2；
為真：2、3、4、5、6、7
口訣：外層循環(huán) 執(zhí)行一步，內(nèi)層循環(huán) 要執(zhí)行 滿足條件的 一輪。
第七課
流程 控制語句：
二、條件分支語句：
1、if 不帶else ：if（條件表達式）
{
語句體；
}
帶 else ： if（條件表達式）
{
語句體1；
}
else
{
語句體2；
}
if的嵌套使用： if（條件表達式1）
{
語句體1；
}
else if（條件表達式2）
{
語句體2；
}
......else
{
語句體n；
}
2、switch case
switch（表達式）// 他的 返回值 必須是 byte、short、int、char、enum（枚舉）
不可以 出現(xiàn)其他數(shù)據(jù)類型的返回值，而且 返回的 必須是 一
個常量值 { case 常量1： 語句體1；[break；] case 常量2： 語句體2；[break；].......default：語句體n；[break；] }
常量 可以有多個，但不可以出現(xiàn) 相同的常量值。
為什么 switch比 if 嵌套 執(zhí)行效率高？
：所有流程控制語句，都是由 cpu 內(nèi)部提供的運算器中的高速緩存來處理，高速緩存 處理if 語句時，先找到條件1，如果 判斷為turn，在找條件2，判斷為turn 在找條件3，以此類推，直到所有 條件都判斷完畢，才會 確定要執(zhí)行的 語句體。而，在執(zhí)行switch 語句時，先去找 滿足條件的 找到，就執(zhí)行相應(yīng) 的語句，沒找到 就退出。由此看來，switch 語句 比 if 嵌套語句的執(zhí)行 效率高。
第八課
跳轉(zhuǎn)語句（轉(zhuǎn)向語句）：
一、cantinue：作用：退出本次 循環(huán)。
1、不帶標(biāo)號的：語法：
循環(huán)
{
[條件判斷]
{continue；}
} 執(zhí)行過程：進入循環(huán)體內(nèi)，判斷 條件是否成立，成立執(zhí)行 continue；語句，從而 跳過continue；語句 后面的其他語句，完成 本次循環(huán)。繼續(xù) 進行下一次 循環(huán)的 條件判斷，已決定 是否 繼續(xù) 循環(huán)。
t：相當(dāng)于 table 位，及 4個 空格。
2、帶有標(biāo)號的：（goto）標(biāo)號：就是 給循環(huán) 起個名字。
結(jié)束 標(biāo)號 所指名的循環(huán)
本次循環(huán)，繼續(xù)
標(biāo)號 所指名循環(huán)的 下一次循環(huán)條件 判斷，繼而 決定 是否 執(zhí)行 下一次循環(huán)。
語法：
標(biāo)號：
循環(huán)
{
循環(huán)
{
[條件判斷]
{continue 標(biāo)號；}
}
}
使用標(biāo)號要注意內(nèi)容：
1、標(biāo)號的后面 應(yīng)該 緊隨 一個循環(huán) 結(jié)構(gòu)，否則 編譯出錯；
2、標(biāo)號單獨使用 沒有任何意義，要與 break 或 continue 一起使用；
3、標(biāo)號 對于單層循環(huán)來說 意義不大。
二、break：終止循環(huán)的作用。
1、不帶標(biāo)號的：作用：結(jié)束 break 所在循環(huán)，轉(zhuǎn)去執(zhí)行 該循環(huán)體 后的其他語句。
語法：
循環(huán)
{
[循環(huán)條件；]
{break；}
}
其他語句；
2、帶有標(biāo)號的：作用：終止 標(biāo)號 所標(biāo)示 的循環(huán)體，轉(zhuǎn)去 執(zhí)行 該循環(huán) 外的 其他語句。
語法：
標(biāo)號：
循環(huán)
{
循環(huán)
{
[循環(huán)條件；]
{break 標(biāo)號；}
}
}
continue 與 break 的 區(qū)別：
1、continue 是用來 跳出 某一次 循環(huán)。而
break 是終止循環(huán)。
2、continue 只能出現(xiàn)在循環(huán) 結(jié)構(gòu)中，而 break 除了可以出現(xiàn) 在循環(huán)結(jié)構(gòu) 中之外，還可以出現(xiàn) switch 開關(guān) 語句中。
作業(yè)：
1、輸出1-1000 能 被 3整除的 前10個 較小的數(shù)，每行 輸出 5個值。
2、找出1-100 之間，第 3個 既能被 4整除，又能 被7整除的 數(shù)。
第九課
算法：
1、算術(shù)模型算法
2、非算術(shù)模型算法：解決三方面：
1、代碼的重用性；
2、代碼的可擴展性；
3、代碼
的可維護性。
1、窮舉（枚舉）算法：定義：遍歷一個域，窮盡 該域 范圍內(nèi)的所有可能。
性能最差的一個算法。
使用時機：只有一個 查詢條件，可是要查詢的數(shù)據(jù) 是海量的，此時就要用
到 窮舉算法。
使用窮舉算法需要確定的三個因素：
1、需要確定 循環(huán)的范圍，將可能的范圍一一列舉出來，不重復(fù)，不遺漏；
2、確定篩選條件，根據(jù)條件對結(jié)果，逐一判斷，挑選出符合條件的；
3、優(yōu)化，殼體條件是在保證，不遺漏掉 解 的情況下，盡量減少 循環(huán)的層數(shù)和 循環(huán)的范圍。
2、迭代算法：由一個已知的值，不斷地去推出新值的過程。
使用時的要素：
1、確定迭代變量的初始值；
2、迭代公式：就是能夠從變量的當(dāng)前值，推出下個值得公式；
3、迭代的范圍，迭代的終止條件。
3、遞歸算法：就是方法的自調(diào)用。（兩部分：
1、遞推；
2、回歸）
1、迭代的公式；
2、終止的條件；
3、初始值的確定（確定每一次調(diào)用方法時的參數(shù)，及返回值）
重復(fù)：
1、每一次方法的調(diào)用，都是在規(guī)模上有所縮??；
2、相鄰兩次的調(diào)用有緊密的聯(lián)系，前一次要為后一次做準(zhǔn)備；
3、在問題規(guī)模極小 的情況下，必須用直接給出解答的方式，而不能在遞推調(diào)用，因此，每一次遞歸 調(diào)用 都是有條件的。無條件的遞歸 調(diào)用，終將成為死循環(huán)。
在一個類中，相互調(diào)用 靜態(tài)方法時，類名 可以不寫。
第二章總結(jié)：
在設(shè)計方法時 應(yīng)秉承的原則：
1、在一個方法體里，盡量少的書寫 代碼；一個方法體中 只完成一個功能。
2、要有好的 運行效率：
1、盡可能少的占用資源（內(nèi)存資源、和 cpu（中央處理器）資源）
第三章
數(shù)據(jù)的設(shè)計
第一課
一、變量的聲明語法：數(shù)據(jù)類型
變量名
聲明變量中 數(shù)據(jù)類型的作用：
1、開辟多大的空間；
2、存放 哪種類型的數(shù)據(jù)
二、數(shù)據(jù)類型
1、基本數(shù)據(jù)類型-----所聲明的叫
變量
{ byte、short、int、long
float、double
char、boolean
int a=3 ；----叫做 值引用
基本數(shù)據(jù)類型 在java 虛擬機 的運行原理：
java 虛擬機 看到 int 類型的 a 變量，就會 開辟一個 4 個字節(jié)的 空間，名字 叫做 a，每個 基本數(shù)據(jù)類型的變量 只能對應(yīng) 一個 準(zhǔn)確的 值，所以我們 將其 稱之為 值引用。
基本數(shù)據(jù)類型的兩大特點：
1、值引用
2、基本數(shù)據(jù)類型 可以參與 各大數(shù)據(jù)類型的運算。
2、復(fù)合數(shù)據(jù)類型------所聲明的叫
對象
{ 類類型、數(shù)組、標(biāo)注、泛類型、枚舉、接口
兩大特點：
1、可以實現(xiàn) 地址 引用；
2、復(fù)合數(shù)據(jù)類型 不可以 參與各大數(shù)據(jù)類型的運算，但是 可以 比較地址是否相同（==）。
三、變量的 初始化
分為：
1、直接初始化 ；//a=3
2、間接初始化 ；//b=a*2
一個基本數(shù)據(jù)類型的變量 在使用之前，一定要對其 進行 初始化，否則 該變量無法使用；成員變量的初始化 由構(gòu)造方法 實現(xiàn)；靜態(tài)方法的初始化 由 靜態(tài)初始化器實現(xiàn)；局部變量在使用之前 必須 賦值。
1、自動類型的轉(zhuǎn)換也成為 隱式轉(zhuǎn)換；
小空間 向 大空間 轉(zhuǎn)換時，可以自動（直接）進行轉(zhuǎn)換的叫做：自動數(shù)據(jù)類型的轉(zhuǎn)換 特例：
1、long 數(shù)據(jù)類型 可以自動 轉(zhuǎn)換成 float、或 double 數(shù)據(jù)類型
2、byte 數(shù)據(jù)類型 不能 自動轉(zhuǎn)換成 char 數(shù)據(jù)類型
3、布爾數(shù)據(jù)類型 不參與自動數(shù)據(jù)類型的轉(zhuǎn)換。byte---short---int---long---float----double
char---
自動類型 轉(zhuǎn)換的時機：
1、賦值時；
2、方法調(diào)用時；
3、算術(shù)運算時（一元運算中：
1、操作數(shù)的數(shù)據(jù)類型是byte、short、char 時，結(jié)果將自動轉(zhuǎn)換成int數(shù)據(jù)類型；
2、++ 或--運算 等到的結(jié)果，任然是操作數(shù)本身的數(shù)據(jù)類型，及++ 或--符號不參與 自動數(shù)據(jù)類型的轉(zhuǎn)換
二元運算中：
1、在大多數(shù)情況下，兩個操作數(shù)進行運算，會自動轉(zhuǎn)換成范圍 較大的數(shù)據(jù)類型；
2、假設(shè) 操作數(shù)類型為 byte、short、char 的情況下，運算結(jié)果會自動轉(zhuǎn)換成 int數(shù)據(jù)類型；
3、復(fù)合賦值運算符，不參與 自動數(shù)據(jù)類型的轉(zhuǎn)換）
2、強制類型的轉(zhuǎn)換也叫做 顯示轉(zhuǎn)換；
大空間 向 小空間 轉(zhuǎn)換，用到 強制數(shù)據(jù)類型的轉(zhuǎn)換；
語法格式：（目標(biāo)數(shù)據(jù)類型）常量、變量、表達式；
情況：
1、如果 被轉(zhuǎn)換的數(shù)據(jù)類型的值的大小 沒有超出 目標(biāo)數(shù)據(jù)類型的取值范圍，則值不發(fā)生任何改變；
2、如果要轉(zhuǎn)換的值，超出了目標(biāo)數(shù)據(jù)類型的取值范圍，那么，用該值 對目標(biāo)數(shù)據(jù)類型的值域變化范圍
進行 取模 的操作。（該值 大于 目標(biāo)數(shù)據(jù)類型 的最大取值，并且超出了其值域變化范圍）；
3、如果該值 大于 目標(biāo)數(shù)據(jù)類型 的最大取值，但是沒有超出了目標(biāo)數(shù)據(jù)類型值域變化范圍，則用 該值-值域變化范圍。
4、浮點數(shù) 轉(zhuǎn)換成 整數(shù)時，直接 舍去 小數(shù)部分，保留 整數(shù)部分。
5、布爾數(shù)據(jù)類型 不參與 強制數(shù)據(jù)類型 轉(zhuǎn)換。
第二課
自動綁定的三部曲：
1、加載 靜態(tài)初始化器
2、加載主方法
3、通過 new 關(guān)鍵字 調(diào)用構(gòu)造方法
局部變量：
如果 局部變量 與成員變量 同名的情況下，那么在局部變量的作用范圍內(nèi) 隱藏 成員變量，想要在 局部變量 作用范圍內(nèi) 引用 成員變量，那么 要用到
this 關(guān)鍵字 引用成員變量。
相同作用域內(nèi) 不允許 出現(xiàn)同名 變量，而不相同 的作用域范圍內(nèi)，可以出現(xiàn) 同名變量。
成員變量 與 局部變量的 區(qū)別：
1、聲明的位置不同，成員變量 在一個類的方法體外 聲明；而 局部變量 可以放在方法體內(nèi)、也可以作為 方法的參數(shù)、或 放在 語句塊內(nèi)。
2、作用域不同，一對花括號 就是一個作用域。
3、成員變量的初始化，可以由 靜態(tài)初始化器、或 構(gòu)造方法來完成；而 局部變量的初始化 只能由 直接 或者 間接 來完成，而不能由 靜態(tài)初始化器 或 構(gòu)造方法來完成。
最終變量：
它是指 在程序 運行過程中，其值 不變的 變量。最終變量在使用前
必須 為其 初始化。
語法：
1、final 數(shù)據(jù)類型 變量名=賦值；// 聲明最終 變量時 直接 初始化。
2、final 數(shù)據(jù)類型 變量名； // 先聲明，在使用之前 在為其 初始化。
變量名=賦值；
目的：防止 值發(fā)生 改變。
數(shù)組：就是具有 相同類型 名稱的 數(shù)據(jù)的集合。
1、聲明的語法格式：
數(shù)據(jù)類型 [] 數(shù)組變量名；
數(shù)據(jù)類型 數(shù)組變量名 []；
2、實例化
聲明的同時 對其實例化；// 數(shù)據(jù)類型[] 數(shù)組變量名=new 數(shù)據(jù)類型[數(shù)組長度]；
先聲明，在實例化； // 數(shù)組變量名=new 數(shù)據(jù)類型[數(shù)組長度]；
數(shù)組長度 只能是：byte、short、int 三種 數(shù)據(jù)類型，不能是其他數(shù)據(jù)類型。new 數(shù)據(jù)類型這樣的語句有兩個作用：
1、在內(nèi)存中開辟一塊 連續(xù)的存儲空間，每塊空間的大小 由 數(shù)據(jù)類型來 進行決定；
2、為每一個空間 進行 初始化。
作業(yè)：
1、為什么使用數(shù)組？ ：
2、聲明，實例化數(shù)組的語法？
3、什么是數(shù)組元素？
4、如何得到 數(shù)組最大下標(biāo)值？
5、如何為 數(shù)組元素賦值？
6、如何遍歷數(shù)組？
7、數(shù)組與 數(shù)組 變量區(qū)別？
第三課
數(shù)組對象的方法：
一、冒泡法排序：
兩個循環(huán)，外層控制 輪數(shù)，內(nèi)層 控制 每輪比較的 次數(shù)。
import java.util.Arrays;// 引包（冒泡法）Arrays.sort(a);
二、在一個數(shù)組 當(dāng)中 查找 元素 所在的位置； int pos=Arrays.binarySearch(sum,15*15);//
采用2分 查找法，先找中間值，小于中間值得向前找，大于中間值得先后找，只能 對有序的數(shù)組 進行查找。
三、數(shù)組復(fù)制
System.arraycopy(Object src,int src_pos,Object dst,int dsc_pos,int length)
Object src： 代表 元素組；
int src_pos：
代表
元素組的起始位置； Object dst： 目標(biāo)數(shù)組；
int dst_pos：
目標(biāo)數(shù)組的起始位置； int length： 要拷貝 數(shù)組元素的個數(shù)；
數(shù)組的特點：
1、數(shù)組的長度是固定的，必須在創(chuàng)建數(shù)組的時候指定數(shù)組長度，數(shù)組的長度一經(jīng)確定，就不能修改；
2、一個數(shù)組 只能用來保存 同一數(shù)據(jù)類型的數(shù)據(jù)；
第四課
多維數(shù)組：（二維數(shù)組）
聲明：數(shù)據(jù)類型[][] 數(shù)組變量名=new 數(shù)組類型[高維長度--必選][低維長度--可選]
高維--一維：行數(shù)
低維--二維：每行的個數(shù)
例：int[][] i1=new int[2][2];
靜態(tài)初始化：
int[][] i1={{0,1},{1,2,3},{2}};
第五課 向量：可以看做是 一個大小 可自由伸縮的數(shù)組。
三個構(gòu)造方法： public Vector()
---創(chuàng)建初始大小 為10，容量增加值為0（0代表 無限增加）的空Vector 對象。
public Vector(int initialCapacity)---創(chuàng)建初始容量 為initialCapacity，容量增加值為0 的空Vector 對象。
public Vector(int initialCapacity,int capacityIncrement)---創(chuàng)建初始容量為 initialCapacity，當(dāng)容量不足時 增加值為 capacityIncrement 的空 Vector 對象。
方法說明
public boolean add(Object o)將指定對象追加到當(dāng)前Vector對象的末尾。
public void add(int index, Object element)將指定對象element插入到當(dāng)Vector對象的指定位置處。
public int capacity()返回Vector對象的當(dāng)前容量。
public void clear()將所有的元素從當(dāng)前Vector對象中移去。
public boolean contains(Object elem)測試當(dāng)前Vector對象中是否包含指定的對象。
public void copyInto(Object[ ] anArray)將當(dāng)前Vector對象中的每一個元素復(fù)制到指定的數(shù)組中去。
public Object firstElement()返回當(dāng)前Vector對象中的第一個元素（其下標(biāo)值為0）。public Object lastElement()返回當(dāng)前Vector對象中的最后一個元素。public Object get(int index)返回當(dāng)前Vector對象中指定位置上的元素。
public int indexOf(Object elem)返回當(dāng)前Vector對象中指定對象elem首次出現(xiàn)的位置，找不到則返回-1。
public boolean isEmpty()測試當(dāng)前Vector對象是否為空。
public Object remove(int index)將指定位置的元素從當(dāng)前Vector對象中移去。public boolean remove(Object o)刪除當(dāng)前Vector對象中首次出現(xiàn)的指定對象，若當(dāng)前Vector對象包含該指定對象則返 回true。
protected void removeRange(int fromIndex, int toIndex)刪除當(dāng)前Vector對象中從fromIndex位置開始，到toIndex-1位置的所有元素。
public void removeAllElements()刪除Vector對象中的所有元素，并將其大小重置為0。public Object set(int index, Object element)將Vector對象中指定位置上的元素置換為指定對象element。
public int size()返回Vector對象中元素的數(shù)目。
public void trimToSize()將當(dāng)前Vector對象的容量調(diào)整為與其元素個數(shù)相同。相信能就一定能
第三篇：JAVA實習(xí)生問題
JAVA實習(xí)生問題：
1.我班只招三人。2.實習(xí)從現(xiàn)在開始，至于結(jié)束，暫時沒有時間限制，因為公司項目較多，缺乏人手，項目周期長。聽他們說他們現(xiàn)在接了一個安徽省的云平臺項目，這個就夠他們忙的了。如果最后你們能夠成長起來，并且愿意留下來，他們也很高興，也就相當(dāng)于培養(yǎng)自己的員工。
3.工作內(nèi)容：項目組帶著做項目。相當(dāng)于一邊學(xué)習(xí)一邊動手做。所以興趣很重要，如果很有興趣，具有一定的分析問題解決問題的能力，遇到問題，則是自己積極想辦法解決，而且覺得很有成就感，在有興趣的前提下，跟著項目組做項目也是學(xué)的最快的；但是如果興趣并不是很大，那么就變成了壓力、痛苦和無聊。
4.此次公司招實習(xí)生，對基礎(chǔ)沒什么要求（只要學(xué)過java就行），重要的是興趣。如果動手能力、自學(xué)能力較強，具有較強的分析問題、解決問題的能力，即使基礎(chǔ)不是很好，也應(yīng)該問題不大。有興趣，遇到問題就不會覺得難，而是自己積極的想辦法去解決。
5.對于女生來說，需要考慮的更多一些，比如安全問題，畢竟是在校外實習(xí)。這些問題你們自己要考慮到，也都是要讓你們自己負責(zé)的。要慎重，自己考慮清楚。
6.公司招實習(xí)生的目的是幫著項目組做項目。不是很想干的，最好別去。
7.工作有兩個方向，軟件開發(fā)or系統(tǒng)集成，方向自己選，看你們對哪一塊感興趣。如果基礎(chǔ)好一點，項目組就帶著你們做；如果基礎(chǔ)薄弱，不光帶著做，還會有培訓(xùn)。實際上帶著做項目，是學(xué)的最快的，但是前提是有興趣。至于具體做什么，要看是什么項目，是項目中的哪一部分。
第四篇：Java面試問題
1、引用CSS樣式有哪兩種方式？
Link,@import2、js怎么控制兩個文本框，當(dāng)選中的時候邊框變空，沒選中的變會原來的顏色。onFocus=“document.getElementById('text1').style.backgroundColor='#eee'”
onblur=“document.getElementById('text1').style.backgroundColor='#fff'”
3、查詢數(shù)據(jù)庫表顯示在頁面需要新建多少個class文件和xml文件？
4、spring有多少種注入方式？
注入方法1：構(gòu)造方法方式 2：屬性注入 3：靜態(tài)工廠方法參數(shù)注入 4: 接口注入
第五篇：java總結(jié)
調(diào)用父類構(gòu)造方法
? 在子類的構(gòu)造方法中可使用super(argument_list)語句調(diào)用父類的構(gòu)造方法
? 如果子類的構(gòu)造方法中沒有顯示地調(diào)用父類構(gòu)造方法，也沒有使用this關(guān)鍵字調(diào)用重載的其它構(gòu)造方法，則系統(tǒng)默認調(diào)用父類無參數(shù)的構(gòu)造方法
? 如果子類構(gòu)造方法中既未顯式調(diào)用父類構(gòu)造方法，而父類中又沒有無參的構(gòu)造方法，則編譯出錯
1public class Person {
3private String name;
4private int age;private Date birthDate;
7public Person(String name, int age, Date d){ 8this.name = name;
9this.age = age;
10this.birthDate = d;
11}
12public Person(String name, int age){ 13this(name, age, null);
14}
15public Person(String name, Date d){ 16this(name, 30, d);
17}
18public Person(String name){
19this(name, 30);}
21// ……
22}
1public class Student extends Person {
2private String school;
4public Student(String name, int age, String s){ 5super(name, age);
6school = s;
7}
8public Student(String name, String s){
9super(name);
10school = s;
11}
12public Student(String s){ // 編譯出錯: no super()13school = s;
14}
15}
對象構(gòu)造和初始化細節(jié)
? 分配存儲空間并進行默認的初始化
? 按下述步驟初始化實例變量
1.綁定構(gòu)造方法參數(shù)
2.如有this()調(diào)用，則調(diào)用相應(yīng)的重載構(gòu)造方法，然后跳轉(zhuǎn)到步驟5
3.顯式或隱式追溯調(diào)用父類的構(gòu)造方法(Object類除外)
4.進行實例變量的顯式初始化操作
5.執(zhí)行當(dāng)前構(gòu)造方法的方法體
==操作符與equals方法
==操作符與equals方法的區(qū)別：
? 引用類型比較引用；基本類型比較值；
? equals()方法只能比較引用類型，“==”可以比較引用類型及基本類型；
? 特例：當(dāng)用equals()方法進行比較時，對類File、String、Date及封裝類（Wrapper Class）來說，是比較類型及內(nèi)容而不考慮引用的是否是同一個實例；
? 用“==”進行比較時，符號兩邊的數(shù)據(jù)類型必須一致(可自動轉(zhuǎn)換的基本數(shù)據(jù)類型除外)，否則編譯出錯；
由裝箱引發(fā)的——Integer比較的來龍去脈
前置知識： 眾所周之，java是保留了int，char等基本數(shù)據(jù)類型的，也就是說int類型的并不是對象，然而有些方法卻需要object 類型的變量，所以java使用了裝箱機制，我們可一自豪的這樣聲明一個整型變量：Integer a = new Integer(10);那么整型的a也就是對象了，那這句是什么意思呢：Integer a= 10;java中可以這樣聲明一個對象嗎？當(dāng)然不是，從jdk1.5后，java實現(xiàn)了自動裝箱，也就是自動將Integer a =10 中的int類型的10轉(zhuǎn)化為了 Integer類型。好，有了前面的只是我們且先看一個題目：
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a==b);
System.out.println(c==d);
答案是什么呢？ 如果您回答true，false，那么很遺憾的告訴你，哈哈，其實你答對了??！
那我們暈了就相差1的兩個數(shù)為啥走向了“反目成仇”的地步呢？憑啥127等于127，我128就不等于128呢？且聽我慢慢道來，Integer a =127,Integer a=128。
127，128應(yīng)該不會造成什么差異吧，難道是自動裝箱的過程有貓膩？找下源碼看看：
private static class IntegerCache {
private IntegerCache(){}
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i128);
}
這是用一個for循環(huán)對數(shù)組cache賦值，cache[255] = new Integer(255-128),也就是newl一個Integer(127),并把引用賦值給cache[255],好了，然后是Integer b= 127,流程基本一樣，最后又到了cache[255] = new Integer(255-128),這一句，那我們迷糊了，這不是又new了一個對象127嗎，然后把引用賦值給cache[255]，我們比較這兩個引用（前面聲明a的時候也有一個）,由于是不同的地址，所以肯定不會相等，應(yīng)該返回false??！呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關(guān)鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當(dāng)我們Integer b = 127的時候，并沒有new出一個新對象
來，而是共享了a這個對象的引用，記住，他們共享了同一個引用?。?，那么我們進行比較a==b時，由于是同一個對象的引用（她們在堆中的地址相同），那當(dāng)然返回true了！！
然后我們在看Integer c = 128;Integer d = 128;這兩句?，F(xiàn)在不用我說就應(yīng)該能明白了吧，當(dāng)數(shù)據(jù)不再-128到127之間時，是不執(zhí)行return
IntegerCache.cache[i + offset];這句的，也就是不會返回一個static的引用，而是執(zhí)行了return new Integer(i);于是當(dāng) Integer d = 128 時，又會重新返回一個引用，兩個不同的引用
在做c==d 的比較時當(dāng)然返回false了！
下面附上本程序的字節(jié)碼以供喜歡底層的讀者參考：
Compiled from “CompareInteger.java”
public class CompareInteger extends java.lang.Object{
public CompareInteger();
Code:
0:aload_0
1:invokespecial#1;//Method java/lang/Object.“
public static void main(java.lang.String[]);
Code:
0:bipush 127
2:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
5:astore_1
6:bipush 127
8:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
11: astore_2
12: sipush 128
15: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
18: astore_3
19: sipush 128
22: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
25: astore 4
27: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
30: aload_1
31: aload_2
32: if_acmpne39
35: iconst_1
36: goto40
39: iconst_0
40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
46: aload_3
47: aload4
49: if_acmpne56
52: iconst_1
53: goto57
56: iconst_0
57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return
}
評論：呵呵，這么想你就錯了，請注意看for語句給cache[i]初始化的時候外面還一個{}呢，{}前面一個大大的static關(guān)鍵字大咧咧的杵在哪呢，對靜態(tài)的，那么我們就可以回想下static有什么特性了，只能初始化一次，在對象間共享，也就是不同的對象共享同一個static數(shù)據(jù)，那么當(dāng)我們Integer b = 127的時候，并沒有new出一個新對象來，而是共享了a這個對象的引用，記住，他們共享了同一個引用?。?/p>
呵呵，博主我被你這句話小小的誤導(dǎo)了一下，其實你這里說的原理沒錯，但是把位置說錯了，這段代碼只是初始化cache：
static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i-128);
}
但真正讓cache[i]為static變量的是這句代碼：
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];
點擊咨詢 