黑馬程序員Java培訓、Android培訓-Java 學習過程記錄_面向對象下

1.類的繼承

1.1Java只支持單繼承,不允許多重繼承。

1.2可多層繼承,即一個類可以繼承某一個類的子類

1.3子類不繼承父類的構造方法。可用語句super(參數列表) 調用父類的構造方法。

1.4子類的構造方法中沒有顯式地調用父類構造方法,也沒有使用this關鍵字調用重載的其它構造方法,則在產生子類的實例對象時,系統默認調用父類無參數的構造方法。 

2.子類對象的實例化過程 6個階段;

 

思考:1).爲什麼super(…)this(…)調用語句不能同時在一個構造函數中出現?

       2).爲什麼super(…)this(…)調用語句只能作爲構造函數中的第一句出現?

答:以上兩個問題都是一個原因,super(…)this(…)具有優先性,誰先出現就執行誰的操作,另外一個即時再出現也會被跳過。

3覆蓋父類的方法

3.1覆蓋方法必須和被覆蓋方法具有相同的方法名稱、參數列表和返回值類型。

3.2如果在子類中想調用父類中的那個被覆蓋的方法,我們可以用super.方法的格式

3.3覆蓋方法時,不能用比父類中被覆蓋的方法更嚴格的訪問權限

4.final關鍵字

4.1Java中聲明類、屬性和方法時,可使用。

4.2final標記的類不能被繼承。

4.3final標記的方法不能被子類重寫。

4.3final標記的變量(成員變量或局部變量)即成爲常量,只能賦值一次。

4.4方法中定義的內置類只能訪問該方法內的final類型的局部變量,用final定義的局部變量相當於是一個常量,它的生命週期超出方法運行的生命週期,將一個形參定義成final也是可以的,這就限定了我們在方法中修改形式參數的值。

4.5public static final共同標記常量時,這個常量就成了全局的常量。

5.抽象類

5.1定義:java中可以定義一些不含方法體的方法,它的方法體的實現交給該類的子類根據自己的情況去實現,這樣的方法就是抽象方法,包含抽象方法的類就叫抽象類。

5.2抽象類必須用abstract關鍵字來修飾;抽象方法也必須用abstract來修飾。

5.3抽象類不能被實例化,也就是不能用new關鍵字去產生對象。

5.4抽象方法只需聲明,而不需實現。

5.5含有抽象方法的類必須被聲明爲抽象類,抽象類的子類必須覆蓋所有的抽象方法後才能被實例化,否則這個子類還是個抽象類。

6接口(interface)

6.1如果一個抽象類中的所有方法都是抽象的,我們就可以將這個類用另外一種方式來定義,也就是接口定義。接口是抽象方法和常量值的定義的集合,從本質上講,接口是一種特殊的抽象類,這種抽象類中只包含常量和方法的定義,而沒有變量和方法的實現。

6.2接口中的成員都是public訪問類型。接口裏的變量默認用public static final標識。

6.3我們可以定義一個新的接口用extends關鍵字去繼承一個已有的接口

6.4我們也可以定義一個類用implements關鍵字去實現一個接口中的所有方法,我們還可以去定義一個抽象類用implements關鍵字去實現一個接口中定義的部分方法。

6.5一個類可以繼承一個父類的同時,實現一個或多個接口,extends關鍵字必須位於implemnets關鍵字之前

7對象的類型轉換

7.1子類對象可以自動轉換成父類

7.2父類轉換成子類必須使用強制轉換。

7.3nstanceof 操作符可以用它來判斷一個實例對象是否屬於一個類。

7.4Object類及equals方法

8面向對象的多態性

1).應用程序不必爲每一個派生類(子類)編寫功能調用,只需要對抽象基類進行處理即可。這一招叫以不變應萬變,可以大大提高程序的可複用性。

2). 派生類的功能可以被基類的引用變量引用,這叫向後兼容,可以提高程序的可擴充性和可維護性。以前寫的程序可以被後來程序調用不足爲奇,現在寫的程序(如callA方法)能調用以後寫的程序(以後編寫的一個類A的子類, 如類D)就了不起了。

演示的代碼備份1

//類與繼承的演示

class Person

{                  

       public static final String x = "abc";       //變量剛開始時候初始賦值是可以的,也可以在構造方法中賦值,只能賦值一次;

       public String name = "unknown"; //final後就不能賦值;

       public int age = -1;

       public Person()

       {

              //x = "abc";

       }

       public Person(String name,int age)

       {    

              //x = "abc";    

              this.name = name;

              this.age = age;

       }

       public void getInfo()             //改爲private後,無法讓子類調用的;加final後,子類就不能覆蓋;

       {

                            System.out.println("name="+name+",age="+age);

                            System.out.println(x);

       }

}

class Student extends Person

{

       public String school = "unkown";

       public Student()

       {

              super();

              //super("zhangsan",15);

       }

       public Student(String name,int age)

       {

                     super(name,age);                        

       }

       public Student(String name,int age,String school)

       {

              this(name,age);

              this.school = school;     

              //super.getInfo();                  //調用父類的函數

       }

      

       public void getInfo()     //改爲private時候會報錯,覆蓋時不能降低父類函數的訪問權限;

       {

              System.out.println("school="+school+",name="+name+",age="+age);

              //super.getInfo();

       }

       public void study()

       {

       }

}

class TestStudent

{

       public static void main(String [] args)

       {

              Student st = new Student("張三",20,"清華大學");

              /*st.name = "zhangsan";

              st.age = 20;*/

              st.getInfo();          

              System.out.println(Float.MAX_VALUE);

       }

}

演示的代碼備份2

//抽象類和接口定義的演示體會

interface Runner

{

       int ID = 1;

       void run();

}

interface Animal extends Runner

{

       void breathe();

}

class Fish implements Animal

{

       public void run()

       {

              System.out.println("fish is swiming");

       }

       public void breathe()

       {

              System.out.println("fish is bubbing");

       }

       public static void main(String [] args)

       {

              Fish f = new Fish();

              int j = 0;

              j = Runner.ID;

              j = f.ID;        

              j = Fish.ID;

              //f.ID = 2;

       }

}

abstract class LandAnimal implements Animal //注意要加abstract定義爲抽象類

{

       public void breathe(){};

}

interface Flyer

{

       void fly();

}

class Bird implements Runner,Flyer

{

       public void run(){}

       public void fly(){}

}

class Student extends Person implements Runner

{

       public void run(){};

}

      

interface A                   //都是公共訪問類型的,省略了public

{

       int ID = 1;                    //省略了public static final

       int aa(int x,int y);     //抽象類不能實例化;

       void bb();

       /*public static void main(String [] args)

       {

              A a = new A();

       }     */

}

/*class B extends A

{

       int aa(int x,int y){return 1;}

}*/

演示的代碼備份3

// 強制類型轉換和equals()方法的覆蓋

class A

{

       public void func1()

       {

              System.out.println("A func1 is calling");

       }

       public void func2()

       {

              func1();

       }

}

class B extends A

{

       public void func1()

       {

              System.out.println("B func1 is calling");

       }

       public void func3()

       {

              System.out.println("B func3 is calling");

       }

}

class C

{

       public static void main(String []args)

       {

              B b = new B();      

              callA(b);

              /*A a = b;

              callA(new B()); */         //轉換

       }

       public static void callA(A a)

       {

              /*if(a instanceof B)               //做出類型判斷,能萬無一失;

              {

                     B b = (B)a;                   //強制類型轉換後纔行

                     b.func1();

                     b.func2();

                     b.func3();

         }*/

         a.func1();

         a.func2();

       }

}

class Student //extends Object

{

       private String name;

       private int age;

       public Student(String name,int age)

       {

              this.name = name;

              this.age = age;

       }

public boolean equals(Object obj) //覆蓋纔有意義;

       {

              Student st = null;

              if(obj instanceof Student)

              {

                     st = (Student)obj;

                     if(st.name == name && st.age == age)

                                   return true;

                     else

                                   return false;

              }

              else

                            return false;

       }

       public static void main(String [] args)

       {

              Student st1 = new Student("zhangsan",20);

              Student st2 = new Student("zhangsan",20);

              if(st1.equals(st2))

                     System.out.println("equals");

              else

                     System.out.println("not equals"); //如無覆蓋的equals方法,仍然會顯示“equals”的結果;

       }

}

 

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章