當前位置：首頁 > 编程语言 > java >内容正文

java

20155314 2016-2017-2 《Java程序设计》第4周学习总结

發布時間：2024/1/8 java 23 豆豆

生活随笔收集整理的這篇文章主要介紹了 20155314 2016-2017-2 《Java程序设计》第4周学习总结小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

20155314 2016-2017-2 《Java程序設計》第4周學習總結

教材學習內容總結

理解封裝、繼承、多態的關系
理解抽象類與接口的區別
掌握S.O.L.I.D原則
了解模式和設計模式
能正確覆蓋方法
了解垃圾回收機制
掌握Object類
掌握enum

get到的重點

第六章繼承與多態

相關概念：
- 繼承：避免多個類間重復定義共同行為
- 子類與父類：
  - 父類：
    - 對有著共同特性的多類事物，進行再抽象成一個類，這個類就是多類事物的父類
    - 父類的意義在于可以抽取多類事物的共性
  - 子類既可以是一個子類，也可以是一個父類；父類既可以是一個父類，也可以是一個子類
  - 在Java中只有單一繼承，即子類只能繼承一個父類
  - 子類與父類間會有is-a的關系（子類 is a 父類）
- is-a
- 多態：
  - 繼承可以復用代碼，更大的用處是實現「多態」
  - 封裝是繼承的基礎，繼承是多態的基礎
  - 「用父類聲明對象引用，用子類生成對象」就有了多態
- 覆蓋：子類中有和父類中可訪問（可繼承到子類）的同名同返回類型同參數表的方法，就會覆蓋從父類繼承來的方法
- 抽象方法、抽象類：
  - Java中有抽象方法的類一定是抽象類，但抽象類中的方法不一定都是抽象方法
  - 抽象類不能使用new生成對象
關鍵字：
- extends：
  - 繼承父類的行為，再擴充父類原本沒有的行為
  - 繼承時使用extends關鍵字，private成員也會被繼承，但子類無法直接存取，必須通過父類提供的方法來存取（父類愿意提供訪問方法的話）
- 權限關鍵字：
  - public：權限最大
  - protected：被聲明為protected的成員，相同包中的類可以直接存取，不同包中的類可以在繼承后的子類直接存取
  - private：權限最小
    
    但實際上有四個權限范圍（未定義權限關鍵字時默認為包范圍）：
    關鍵字類內部相同包類不同包類
    public 可存取可存取可存取
    protected 可存取可存取子類可存取
    無可存取可存取不可存取
    private 可存取不可存取不可存取
    設計時使用權限需根據經驗或團隊討論而定，通常先使用private，以后視需求再放開權限。
- super：
  - 取得父類中的方法定義
  - 執行父類中某構造函數
  - 與this只能擇一調用，而且一定要在構造函數第一行執行
- final：
  - 定義類：表示這個類是最后一個，不會再有子類，不能被繼承
  - 定義方法：表示最后一次定義方法，子類不可以重新定義final方法
- abstract：如果某方法區塊中沒有任何程序代碼操作，可以用abstract標示該方法為抽象方法，該方法不用寫{}區塊，直接;結束即可

教材學習中的問題和解決過程

問題一：關于println與printf函數參數問題

問題二：關于關鍵詞abstract的使用

課后習題

所謂“實踐是檢驗認識真理性的唯一標準”，我在IntelliJ IDEA上把教材第三章課后練習題又敲了一遍，給出了自己的答案，并加上了一些自己的分析，通過逐題進行代碼調試實踐的方式來深入對java類與對象的理解。小白在此懇請大家積極指出錯誤的地方(>_<)

6.4.1 選擇題

C 分析：

class Some641 {void doService() {System.out.println("some service");}}class Other641 extends Some641 {@Overridevoid doService() {System.out.println("other service");}}public class Exercise641 {public static void main(String[] args) {Other641 other=new Other641();other.doService();}}

C 分析：

class Some6412 {void doService() {System.out.println("some service");}}class Other6412 extends Some6412 {@Overridevoid doService() {System.out.println("other service");}}public class Exercise6412 {public static void main(String[] args) {Some6412 some6412=new Other6412();some6412.doService();}}

B 分析：

class Some6413 {String ToString() {return "Some instance";}}public class Exercise6413 {public static void main(String[] args) {Some6413 some6413=new Some6413();System.out.println(some6413);}}

D 分析：

class Some6414 {int hashCode() {return 99;}}public class Exercise6414 {public static void main(String[] args) {Some6414 some6414=new Some6414();System.out.println(some6414.hashCode());}}

D 分析：

class Some6415 {@OverrideString ToString() {return "Some instance";}}public class Exercise6415 {public static void main(String[] args) {Some6415 some6415=new Some6415();System.out.println(some6415);}}

A 分析：

class Some6416 {abstract void doService();}class Other6416 extends Some6416 {@Overridevoid doService() {System.out.println("other service");}}public class Exercise6416 {public static void main(String[] args) {Some6416 some6416=new Other6416();some6416.doService();}}

class Some6417 {protected int x;Some6417(int x) {this.x=x;}}class Other6417 extends Some6417 {Other6417(int x) {this.x=x;}}

public class IterableString extends String {public IterableString(String original) {super(original);}public void iterate() {//...}}

AC 分析：

class Some6419 {Some6419() {this(10);System.out.println("Some()");}Some6419(int x) {System.out.println("Some(int x)");}}class Other6419 extends Some6419 {Other6419() {super(10);System.out.println("Other()");}Other6419(int y) {System.out.println("Other(int y)");}}public class Exercise6419 {public static void main(String[] args) {new Other6419();new Other6419(10);new Some6419();}}

class Some64110 {Some64110() {System.out.println("Some()");this(10);}Some64110(int x) {System.out.println("Some(int x)");} } class Other64110 extends Some64110 {Other64110() {super(10);System.out.println("Other()");}Other64110(int y) {System.out.println("Other(int y)");} } public class Exercise64110 {public static void main(String[] args) {new Other64110();} }

代碼調試中的問題和解決過程

關于課本P86和P185偽隨機數（根本不隨機）的問題

哼只需要改一個小小的地方就行啦(>_<)

代碼托管

運行statistics：

上周考試錯題總結

Java中，=與==并沒有在基本類型和類類型的不同。（OK）
兩個Integer對象比較大小，可以使用（comareTo()）方法。
“30”轉化為byte類型的30的語句是（Byte.parseByte(“30”);）。
public void someMethod(int i)和public int someMethod()是方法重載。（OK）
Java中方法內可以定義類。（OK）

學習心得

別睡懶覺啦，快去蹭Java課啦

偶然聽43班一哥們說我們系江智宇學霸經常來他們班蹭Java課（震驚！！這么好的利用教學資源的機會我怎么沒想到！），自學有困難的我也立刻萌生了前去蹭課的想法，順便感受一下43班的小班教學嘿嘿～于是適逢雙周一天沒課的這周四下午，為了蹭課干脆不睡午覺的我早早地潛伏在617教室后排，終于順利地蹭了人生第一節課（還是Java課(>_<)）

由于43班用的教材跟我們不一樣，關于Java知識體系的敘述順序不同，我也事先沒有弄清他們班的教學進度，可以說真的是毫無準備地蹭課:(好在老師這節課重點講解類和對象的使用、方法重載，恰好是我看教材五六兩章最搞不懂犯迷糊的地方，帶著問題去聽，認真做好筆記，因此一節課聽下來還是有不少收獲的( ?? ?)

關于對象的清除

由于周四那會兒還沒看到教材第六章垃圾收集機制呢，這段內容當時其實聽得一知半解，但在周六看完書之后，特別是將課上做的筆記與書上的圖結合起來看一對照就恍然大悟啦～

蹭課所得：

??Java運行時系統通過垃圾收集器周期性地釋放無用對象所使用的內存，完成對象的清除。當不存在對一個對象的引用時，該對象成為一個無用對象。Java的垃圾收集器自動掃描對象的動態內存區，對被引用的對象加標記，然后把沒有引用的對象作為垃圾收集起來并釋放。垃圾收集器作為一個線程運行，當系統的內存用盡或程序中調用System.gc()要求進行垃圾收集時，垃圾收集線程與系統同步運行，否則垃圾收集器在系統空閑是異步地執行。在對象作為垃圾被收集器釋放前，Java運行時系統會自動調用對象的方法finalize()（老師PPT上竟打錯成finialize，噗），使它清除自己所使用的資源。

??在類的定義中，除了必須定義創建類實例等方法外，還可以在定義中提供用于對象清除的方法finalize()，它的格式如下：

??protected void finalize() throws Throwable { //撤銷對象 }

??finalize()方法是類java.long.Object中最基本的方法。

??前面已經講過，Java提供自動內存垃圾收集和處理程序，然而，在某些情況下，當一個類被破壞后，需要親自執行一些垃圾收集器不能處理的特殊清理工作。

結合教材：

說到Java的垃圾回收機制，就不得不說到讓很多人頭疼的Android手機越用越卡的問題。眾所周知，Android手機上的程序都是在JVM上跑的，而JVM即使具有垃圾回收機制也無法避免內存泄露的問題，就會不斷產生垃圾、消耗內存，Android手機會隨著安裝的APP越多，cpu能耗越大，從而越來越卡，且時間一長，這種卡頓體驗會越來越明顯(>_<)TOO BAD:(而最新推出的Android7.0據說通過優化精簡代碼來改進運行效率，極大提升了軟件運行速度和應用安裝速度，可謂是Android陣營的福音～據說基于Android7.0的華為P10快要發售了喲嘻嘻～

關于方法重載

老師舉的幾個例子非常恰當，看完代碼就差不多就明白怎么回事了～

蹭課所得：

重載：一個方法的不同版本
- 關于成員方法重載的例子：
  //DemoOverload.javaclass Demo2 {int a,b;int method(){ //成員方法一return a+b;}int method(int c){ //成員方法二return a+b+c;}int method(int c,int d){ //成員方法三return a+b+c+d;}Demo2(int a,int b){ //構造方法this.a=a;this.b=b;}}public class DemoOverload {public static void main(String args[]) {Demo2 aDemo2=new Demo2(1,2); //實例化int a=aDemo2.method(); //調用成員方法一System.out.println(a);int b=aDemo2.method(3); //調用成員方法二System.out.println(b);int c=aDemo2.method(3,4); //調用成員方法三System.out.println(c);}}
  上面程序的運行結果為：
  
  其實在敲老師給的代碼的過程中，我發現了這樣一個問題：

關于實例方法和類方法

蹭課所得：

實例方法可以對當前對象的實例變量進行操作，也可以對類變量進行操作，但類方法不能訪問實例變量。實例方法必須由實例對象來調用，而類方法除了可由實例對象調用外，還可以由類名直接調用。

關于類方法對使用，有如下一些限制：

(1)在類方法中不能引用對象變量；

(2)在類方法中不能使用super、this關鍵字；

(3)類方法不能調用類中的對象方法。

如果違反這些限制，程序就會導致編譯錯誤。

與類方法相比，實例方法幾乎沒有什么限制：

(1)實例方法可以引用對象變量（這是顯然的），也可以引用類變量；

(2)實例方法中可以使用super、this關鍵字；

(3)實例方法中可以調用類方法。

翻出塵封已久的C語言書，現在...封印解除～！

上了幾周的數據結構課，張巖老師已經將六大排序算法用C語言定義順序表的實現方式全部講完了，老實說光聽下來自己不動手實踐對這門課十分無感，對排序算法更是吃不消。回寢室，從破舊的書柜中扒出了塵封已久的C語言書，望著滿是塵埃早已泛黃的讓人失望的記憶，感慨萬千，無限傷感……

不過一翻開這本再熟悉不過的C語言書時我的腦海中突然閃過“敲代碼”這個沖動，便立即聯系起java課上婁老師傳授給我們的“做中學”理論，有了繼續接觸C的動力。

于是這周上完數據結構課后我馬上跑去圖書館，帶著C語言教材，慢慢地想、慢慢地寫，不斷地調試，花了一個下午加一個晚上的時間終于將除了基數排序之外的排序算法（冒泡、選擇、插入、快速、堆、歸并、計數）全部用C語言數組（鏈表實在是太難了:(還沒搞懂）分別寫進多個函數的形式實現了一遍（數組下標什么的最討厭了）～在沒有考慮優化和防止非法輸入的情況下不知不覺又寫了近300行(>_<)：

#include <stdio.h> #include <stdlib.h> #define N 5 void BubbleSort(int a[]); void SelectionSort(int a[]); void InsertionSort(int a[]); void QSort(int a[],int s,int t); int Partition(int R[],int low,int high); void CountingSort(int a[],int k); int max(int a[]); void HeapSort(int a[]); void MaxHeapify(int a[],int s,int m); void BuildMaxHeap(int a[]); void MergeSort(int a[],int s,int t); void Merge(int a[],int i,int m,int n); void main() {int i,j,temp;int a[N],b[N];printf("請輸入%d個整數：",N);for(i=0;i<N;i++){scanf("%d",&a[i]);}BubbleSort(a); //冒泡排序/*for(i=0;i<N;i++) //冒泡排序{for(j=0;j<N;j++){if(a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}*///冒泡排序SelectionSort(a);//InsertionSort(a); //插入排序/*for(i=0,j=1;i<N,j<N+1;i++,j++) //將下標改為從1開始{b[j]=a[i];}QSort(b,1,N);for(i=1;i<N+1;i++){printf("%d ",b[i]);}*/ //快速排序//CountingSort(a,max(a)); //計數排序//HeapSort(a); //堆排序/*for(i=0,j=1;i<N,j<N+1;i++,j++) //將下標改為從1開始{b[j]=a[i];}MergeSort(b,1,N);for(i=1,j=0;i<N+1,j<N;i++,j++) //將數組下標還原為從0開始{a[j]=b[i];}*/ //歸并排序for(i=0;i<N;i++){printf("%d ",a[i]);} }void BubbleSort(int a[]) //冒泡排序 {int i,j,temp;for(i=0;i<N-1;i++){for(j=i+1;j<N;j++){if(a[i]>a[j]){temp=a[i];a[i]=a[j];a[j]=temp;}}} }void SelectionSort(int a[]) //選擇排序 {int i,j,k,temp;for(i=0;i<N-1;i++){k=i; //從下標為0處開始記錄for(j=i+1;j<N;j++){if(a[j]<a[k]){k=j; //記錄最小數下標位置}}if(k!=i) //優化處理：若最小數所在的下標位置不在下標位置i，則交換{temp=a[k];a[k]=a[i];a[i]=temp;}} }void InsertionSort(int a[]) //插入排序 {int i,j,b[N];for(i=0,j=1;i<N,j<N+1;i++,j++) //將下標改為從1開始，便于設置監視哨a[0]{b[j]=a[i];}for(i=2;i<=N;i++){if(b[i]<b[i-1]){b[0]=b[i]; //復制為監視哨for(j=i-1;b[0]<b[j];j--){b[j+1]=b[j];}b[j+1]=b[0];}}for(i=1,j=0;i<N+1,j<N;i++,j++) //將數組下標還原為從0開始{a[j]=b[i];} }void QSort(int a[],int s,int t) //快速排序 {int pivotloc;if(s<t-1) //長度大于1{pivotloc=Partition(a,s,t); //對a[]進行一次劃分QSort(a,s,pivotloc-1); //對左子序列遞歸排序，pivotloc是軸位置QSort(a,pivotloc+1,t); //對右子序列遞歸排序}} int Partition(int R[],int low,int high) {int pivotkey;R[0]=R[low];pivotkey=R[low]; //"軸"while (low<high){while (low<high&&R[high]>=pivotkey)high--;R[low]=R[high];while (low<high&&R[low]<=pivotkey)++low;R[high]=R[low];}R[low]=R[0];return low; }void CountingSort(int a[],int k) //計數排序 {int i,j;int C[N]; //引入索引數組Cint R[N]; //新建存儲數組Rfor(i=0;i<=k;i++){C[i]=0; //初始化數組c}for(i=0;i<N;i++){C[a[i]]++; //c[i]中存值等于i的元素個數}for(i=1;i<=k;i++){C[i]=C[i]+C[i-1]; //c[i]中存值小于等于i的元素個數}for(j=N-1;j>=0;j--){R[C[a[j]]]=a[j];C[a[j]]--; //下一個值為a[j]的元素被放到a[j]的前一個位置}for(i=0;i<N;i++){a[i]=R[i+1];} } int max(int a[]) {int i;int max;max = a[0];for(i=1;i<N;i++){if (max<a[i])max=a[i];}return max; }void HeapSort(int a[]) //堆排序 {int temp,i;BuildMaxHeap(a); //建大頂堆for(i=N;i>1;i--){temp=a[0]; //將堆頂元素和當前未經排序子序列a[0...i-1]中最后一個元素交換a[0]=a[i-1];a[i-1]=temp;MaxHeapify(a,0,i-2); //調整a[0...i-2]使其成為大頂堆} } void MaxHeapify(int a[],int s,int m) //維護堆的性質 {int rc,j;rc=a[s]; //暫存a[s]for(j=2*s;j<=m;j*=2){if(j<m&&a[j]<a[j+1]) j++; //左右"孩子"之間先進行相互比較，令j指示較大的關鍵字所在位置if(rc>=a[j]) break; //再作"根"和"孩子"之間比較，若">="成立，則說明已找到rc的插入位置s，不需繼續向下調整a[s]=a[j];s=j; //否則關鍵字上移，仍需繼續向下調整}a[s]=rc; //將調整前的堆頂插入到s位置 } void BuildMaxHeap(int a[]) //建堆 {int i;for(i=N/2-1;i>=0;i--){MaxHeapify(a,i,N); //建大頂堆} }void MergeSort(int a[],int s,int t) //歸并排序 {int m;if(s<t){m=(s+t)/2; //分解MergeSort(a,s,m); //解決MergeSort(a,m+1,t);Merge(a,s,m,t); //合并} } void Merge(int a[],int i,int m,int n) //歸并有序序列a[i...m]和a[m+1...n] {int j,k,p,q;int R[N];for(j=i;j<=n;j++){R[j]=a[j]; //復制}for(j=m+1,k=i;i<=m&&j<=n;k++){if(R[i]<=R[j]) a[k]=R[i++];else a[k]=R[j++];}if(i<=m){for(p=i,q=k;p<=m,q<=n;p++,q++){a[q]=R[p];}}if(j<=n){for(p=j,q=k;p<=n,q<=n;p++,q++){a[q]=R[p];}} }

一提到防止非法輸入，就不得不提到我比較熟練運用的C語言實現，說到C語言實現，那就一定要安(xuan)利(yao)一下加入了防止非法輸入功能的比較完備的具有獨立知識產權的中國剩余定理的C語言實現～不說廢話直接上圖～哼誰敢欺負我我就拿代碼砸死你(｡･ω･｡)

（下周更）

學習進度條

代碼行數（新增/累積）博客量（新增/累積）學習時間（新增/累積）重要成長

目標	5000行	20篇	300小時
第一周	34/34	1/4	12/12
第二周	360/394	1/5	16/28
第三周	701/1018	1/6	19/ 47	代碼量激增( ?? ?)
第四周	608/1375	1/7	18/55	①蹭了一節張健毅老師的Java課；②自己將數據結構課上所學的排序算法除了基數排序之外全部用C語言實現了一遍(｀_′)ゞ；③本次博客史無前例的長:)

感想具體見上一條「學習心得」

任何學習都是沒有捷徑的。

這周高估了自己的理解能力，不說回看第五章理解得如何，沒想到光看第六章就耗費了我大量的時間和精力，只得馬馬虎虎地把第七章簡單翻了一遍，合上書就啥也不知道了:(導致這周考試沒考好還是有些遺憾的:(不過自己通過動手實踐加深了對數據結構這門課的理解，也算是一大收獲吧嗯！

有學霸學長學姐建議我說不要把過多時間浪費在寫博客上，我一想確實自己每周每天都要花很多時間來完善我的博客而不去真正搞懂Java中的有些問題，的確有失偏頗，在這里感謝學長學姐的批評指正！但其實我認為，這幾周下來，我已經將寫博客全然當成了一種發朋友圈、發說說一類的日常習慣，隨時記錄自己的學習情況、隨時markdown自己的感想，我覺得自己將寫博客從任務到習慣的蛻變，也可以算是一種進步吧( ?? ?)

這周老師開創性地采用了「藍墨云班課」的教學方式，令人耳目一新。其中老師回復盛照宗同學說我們Java課采用「翻轉課堂」的方式，可以根據自己的學習進度來安排學習任務，這也一定程度上啟發了我。實際上老師的教學方式確實是比較靈活的，提問和答疑的方式也變得越來越便捷和高效，所以，每個人可以根據自己的程度完全量身定做自己的學習方式，哪里不懂就學哪里吧！

計劃學習時間:20小時
實際學習時間:18小時

參考資料

JavaScript備忘錄(1)——內置類型
父類、子類與接口
深入理解子類和父類之間關系
Java垃圾回收機制
Java內存泄露原因詳解
Android 7.0 效率史上最高：運行速度飆升600%
為什么軟件工程師應該養成寫作的習慣？
鄒欣老師SoftwareTeacher的教學博客：現代軟件工程第一章【概論】練習與討論
代碼作業1 - 2016024281李郭鵬 - 博客園
Java學習筆記(第8版)
《Java學習筆記(第8版)》學習指導

轉載于:https://www.cnblogs.com/crazymosquito/p/6580190.html

總結

以上是生活随笔為你收集整理的20155314 2016-2017-2 《Java程序设计》第4周学习总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇：微信视频号100w播放收入1000+的变
下一篇： java 去除时间中的PM_在Java中