學習心得

一、專業課

1、陣列

1.1、陣列可以看成是多個相同資料型別資料的組合，對這些資料的統一管理。

1.2、陣列變數屬引用型別，陣列也可以看成是物件，陣列中的每個元素相當於該物件的成員變量。

1.3、陣列中的元素可以是任何型別，包括基本型別和引用型別

2.一維陣列

//陣列

int[]arr = {1,2};

//引用型別物件

//==比較堆地址

/**

* equals 來自Object預設也是比較

* public boolean equals(Object obj) {

return (this ==obj);

}

但我們可以重寫hashCode與equals，使得equals可以比較數組裡的內容

hashCode相等不一定equals返回TRUE

equals不相等，hashCode不一定相等，因為重寫之後我們可以讓它們一方返回固定的值這麼狡猾

*/

Personperson = new Person("dd", 12);

Personperson2 = new Person("dd", 12);

System.out.println(person== person2);

System.out.println(person.equals(person2));

Objectobject = new Object();

Objectobject2 = new Object();

System

.out.println(object.equals(object2));

System.out.println(person.hashCode());

System.out.println(person2.hashCode());

之下結果為重寫了hashCode與equals

false

true

false

4533

4533

3.二維陣列

3.1arr.clone();可以實現陣列克隆但是值得注意的是

int[][]arr = new int[2][];

int[]a= arr[1].clone();

這時一維陣列需要先宣告空間

不然NullPointerException

3. 2. Arrays.

      deepEquals(arr,a);兩個都必須是二維或以上陣列

   3. Arrays.equals(a,a2);當兩個都是一維陣列時，才能準確比較出陣列內容是否相同

   4. System.arraycopy(src,srcPos,dest,destPos,length);可以實現陣列拷貝

4.異常

4.1Throwable：有兩個重要的子類：Exception（異常）和Error（錯誤）

4. 1. 1. Error（錯誤）:是程式無法處理的錯誤，表示執行應用程式中較嚴重問題。

      2. Exception（異常）:是程式本身可以處理的異常。

      3. Java的異常(包括Exception和Error)分為可查的異常（checkedexceptions）和不可查的異常（uncheckedexceptions）

      4. 執行時異常：都是RuntimeException類及其子類異常

5.捕獲異常

try{

//可能會發生異常的程式程式碼

}catch(Type1id1){

/捕獲並處置try丟擲的異常型別Type1

}

catch(Type2id2){

//捕獲並處置try丟擲的異常型別Type2

}

一旦某個catch捕獲到匹配的異常型別，將進入異常處理程式碼。一經處理結束，就意味著整個try-catch語句結束。其他的catch子句不再有匹配和捕獲異常型別的機會

上方的異常型別不能比上方的異常

try－catch-finally語句

try{

//可能會發生異常的程式程式碼

}catch(Type1id1){

/捕獲並處置try丟擲的異常型別Type1

}

catch(Type2id2){

//捕獲並處置try丟擲的異常型別Type2

}finally{

//無論是否發生異常，都將執行的語句塊

}

二、小組PK

1.我方題目

1.以下程式碼若能執行，請輸出執行結果，若不能執行，請說明原因：

publicclass Demo01 {

publicstatic void main(String[] args) {

Demo02demo = new Demo02(3);

Demo03demo1 = new Demo03(3);

demo.method();

demo1.method();

demo1.method(3);

System.out.println(demo.a);

System.out.println(demo1.a);

}

}

classDemo02{

inta;

publicDemo02(int a){ this.a = a;}

finalvoid method(){

for(inti=0;i<10;i++){

a=i;

}

}

}

classDemo03 extends Demo02{

inta;

publicDemo03(int a){ this.a = a;}

finalvoid method(int i){

for(intj=0;j<i;j++){

a+=j;

}

}

}

答案：編譯報錯，Demo03在例項化物件時，在它自身的構造方法的第一條語句預設呼叫super()；

這裡父類Demo02已經定義了帶引數的構造方法，不會自動生成無參構造方法，編譯報錯。

2.若能執行，請輸出執行結果，若不能執行，請說明原因

importjava.util.Arrays;

publicclass Test1 {

publicstatic void main(String[] args) {

int[]is = {1,2,3,4,5};

int[]is1 = is.clone();

is[1]= 10;

System.out.println(Arrays.deepEquals(is,is1));

Bugb = new Asd();

Asdc = new Asd();

b.fun1(2);

try{

c.fun("c");

}catch (Exception e) {

e.printStackTrace();

}

}

}

classBug{

Stringname;

intid;

privatevoid fun(String name) throws RuntimeException{

System.out.println("time:"+ this.name);

}

publicvoid fun1(int a){

System.out.println(a++);

}

}

classAsd extends Bug{

privateint a;

publicvoid fun1(int c){

System.out.println(c+a);

}

voidfun(String name) throws Exception{

System.out.println("time:"+ this.name);

}

}

答案：編譯錯誤，deepEquals方法的引數是二維陣列所以編譯錯誤，父類的fun（）方法是私有的，所以子類的fun（）方法不算重寫不會報錯

3、以下程式碼若能執行，請輸出執行結果，若不能執行，請說明原因：

publicclass Test {

staticFloat f;

publicTest(Float f){

this.f= f++;

}

static{

f= 3.0f;

}

publicstatic void main(String[] args) {

Stringstr = "ABCDCDG";

char[]ch = str.toCharArray();

inti = 0;

for(;i >= 0.0 && i<(ch.length/2);i++){

if(ch[i]!= ch[ch.length-1-i]){

System.out.print(ch[i]);

continue;

}else{

System.out.print(ch[ch.length-2-i]);

break;

}

}

Testt1 = new Test(3.3f);

Testt2 = new Test(4.3f);

System.out.println(ch[i++]);

System.out.println(f);

}

}

答案：

ABDC

4.3

解析：0在計算機中和0.0相等，計算機中輸出float型別的值不會輸出字尾f。

4.以下程式能否執行

如果不能請指出錯在那裡,

如果可以請輸出程式結果:

publicclass TestA {

TestAbA = new TestA();

static{

System.out.println("static");

}

publicTestA() {

System.out.println("TestA");

}

publicstatic void main(String[] args) {

System.out.println("main");

TestAa = new TestA();

}

}

答案：

static

main

《程式死迴圈》//然後程式進入死迴圈，因為TestA的成員變數TestA bA =new TestA();從新再生成的類中又有成員變數TestAbA = new TestA();再次生成新的TestA，如此迴圈

5.程式是否能夠執行，如果能執行結果是什麼？不能請說明理由

注意輸出格式

publicclass Test04 {

staticint a;

publicstatic void main(String[] args) {

try{

System.out.println(fun(a));

}catch (Exception e) {

System.out.println(9);

}

}

static{

System.out.println(a);

}

publicstatic int fun(int a) throws Exception{

int[]arr = {1,2};

try{

for(inti=0;true;i+=3){

arr[i]/=i;

}

}catch (ArithmeticException e) {

System.out.println(2);

return3;

}catch(NullPointerException e) {

System.out.println(4);

return5;

}catch (ArrayIndexOutOfBoundsException e) {

System.out.println(6);

return7;

}finally{

System.out.println(8);

for(inti=0; i<arr.length;i++){

System.out.print(arr[i]);

}

}

}

}

答案：

0

2

8

123

2、對方題目

1、packagecom.day12;

publicclass Test extends Subject{

publicint b;

publicstatic void main(String arg[]){

Subjects = new Subject();

Testt = new Test();

Subjects1 = new Subject(1, 2);

int K;

//在此處插入選項中的的程式碼

}

}

classSubject {

privateint a;

int b=100;

public Subject(int a, int b) {

super();

this.a= a;

this.b= b;

}

publicSubject() {

super();

}

publicint test(int m){return m;}

}

//下面哪些放在“在此處插入選項中的的程式碼?”行是正確的？BC E

//A，K= s.a;

//B,K = s1.b;

//C,K = s.test(30);

//D,K = m;

//E,K = t.b;

答案:BCE

2、classE1 extends Exception{}

classE2 extends E1{}

classTestParent{

publicvoid fun(boolean f) throws E1{}

}

public class Testzi extends TestParent{

//here

}

不定項選擇

以下方法可以放在“//here”位置，而且通過編譯的是（AD）

A:publicvoid fun(boolean f) {}

B:publicvoid fun(boolean f) throws Exception{}

C:publicvoid fun(boolean f) throws E1{}

D:publicvoid fun(boolean f) throws E1,E2{}

E:publicvoid fun(boolean f) throws E2{}

正確答案

ACDE

3.publicclass Demo03 {

publicstatic void main(String[] args) {

intn = 9;

int[][]arr = new int[n][n];

for(int i = 0; i < n-1; i++) {

arr[i][0]= 1;

1. System.out.print(_arr[i][0]_+" "_______________);

2. for (int _j=0_______;___j<i_&& if(i == j){ arr[i][j] =1;System.out.print(arr[i][j] + " ");}___ ;j++ ) {

arr[i][j]= arr[i-1][j-1] + arr[i-1][j];

System.out.print(arr[i][j]+ " ");

}

System.out.println();

相關推薦