Java學習總結（三）——面向對象（上）（對單例模式有改進）

Java學習總結（三）—面向對象（上）

一．面向對象的概念及思考方式

1. 面向對象的理解：是一種編程思想，他將對象做爲解決問題的基本元素，利用對象與對象之間的相互做用來設計程序。

  2．面向對象的思考方式：（1）首先肯定問題域中的對象

                                            （2）肯定對象的特徵與功能

                                            （3）瞭解對象與對象之間的關係

例:設計一個五子棋遊戲的對象：·黑白雙方對象     ·繪製棋盤     ·輸贏規則

二．類與對象

1.對象：用來描述客觀事物的一個實體，由一組屬性和行爲構成。

2.類：（1）是一個模板，他描述一類對象的行爲和狀態。

（2）類定義對象將會擁有的特徵（屬性）和行爲（方法）

（3）類是對象的類型，和int類型不同

3.對比: · 類是抽象概念

· 對象是實例

三．類與對象的建立

1.定義類的語法：（加static屬於類）

格式：[訪問修飾符] class  類名{

            放屬性和方法的聲明

}

例：建立一個person類

   package org.west;

   public class Person {

        int age;

   public void say(){

       System.out.println("你們好，我今年"+age+"歲了");

       }

   }

2.定義成員變量的定義：

（1）成員變量的語法：

格式：[訪問修飾符]  數據類型  成員變量名 [=初始值]

（2）成員變量可使用Java中的任何數據類型（基本類型和引用類型）

（3）在定義成員變量是能夠對其進行初始化，若不進行初始化，編譯器會用默認的初值進行初始化

（4）成員變量的做用域是整個類體

3.成員變量與局部變量的對比：

比較	成員變量	局部變量
定義位置	直接在類中定義	定義在方法中
聲明賦值	能夠在聲明時賦初始值；若不賦值，會有默認初始值，引用類型的值爲null	在使用前須要賦值
做用域	在整個類內部都是可見的，全部成員方法均可以使用它，若是訪問權限容許，還能夠在類外部使用	僅限於定義它的方法，在該方法外沒法訪問它

*注意：（1）在同一個方法中，不容許有同名的局部變量。在不一樣的方法中，能夠有同名的局部變量 

            （2）局部變量能夠和成員變量同名，而且在使用時，局部變量具備更高的優先級

4.初始化與實例化：

初始化：有以後進行基本操做

實例化：一個從無到有從0~1的過程

5．類種方法的定義：

（1）語法：[訪問修飾符]  返回值類型  數據類型（行參列表）{

//  實現語句

}

例：在person類中定義一個say方法（紅色標記）

    package org.west;

    public class Person {

      int age;

    public void say(){

      System.out.println("你們好，我今年"+age+"歲了");

       }

    }

 6.對象的產生與使用：

（1）根據設計好的類來設計一個對象：利用類關鍵詞調用類的構造方法就能夠建立該類的一個對象

例：以上面的程序例子爲例建立一個對象

      Person  per=new  Person();

此例中咱們就建立了一個Person中的對象per

（2）構造方法：

·構造方法與類名相同，而且沒有返回值，不須要加void

·構造方法的做用在於構造並初始化對象

·每個類中至少包含一個構造方法

（3）構造方法分爲：默認構造方法（無參構造，如果不寫構造方法，編譯器會自動生成一個無參構造，Java都要求有構造方法），帶 參  數構造的方法

*注意：如果類中有咱們寫的構造方法時，編譯器就不會在自動生成無參構造

四．方法的重載（overloading）

1.方法重載：同一個類中，方法名相同，參數列表不一樣（參數類型不一樣、參數個數不一樣、參數順序不一樣）

2.方法重載與返回值類型無關

例：

1）public void study(String name){}

      public void study(int hours){} 

2）public void study(String name){}

      public String study(String n){}              

3）public void study(String name){}

      public void study(String name, int age){} 

4）public Student(String name){} 

      public Student(String name, int age){} 

#重載解析：

1. 方法名相同中參數類型不一樣，有返回值，因此是方法重載

2. 方法名相同，參數類型相同，返回值類型不一樣，可是方法重載與返回值類型無關，因此不是方法重載

3. 方法名相同，參數個數不一樣，有返回值類型，因此是方法重載

4. 方法名相同，參數個數不一樣，無返回值類型，因此是構造方法重載

5. This關鍵字

1.每一個類的每一個非靜態方法(沒有被static修飾)都會隱含一個this引用名稱，它指向調用這個方法的對象(當前對象)。 

2.當在方法中使用本類的非static屬性時，都會隱含地使用this名稱。 

3.this能夠看做是一個變量，它的值就是當前對象的引用 

4.this關鍵字的用法

（1）當類中某個非靜態方法的參數名跟類的某個成員變量名相同時，爲避免參數做用範圍覆蓋成員變量做用範圍，必須明確的使用this關鍵字來指定成員變量

（2）若是某個構造方法的第一條語句具備形式（this…..）,那麼這個構造方法將調用本類中其餘構造方法（調用其餘構造方法，須要在其餘構造方法中輸出）

例：

    package org.west;

    public class Person {

        String name;

        String sex;

        int age;

 

    public Person() {

        System.out.println("無參構造》》》》");

        System.out.println("調用了無參構造方法！！！！！");

    }    

 

    public Person(String name, String sex) {

        this();

        System.out.println("調用了 兩參構造方法！！！！！");

        this.name = name;

        this.sex = sex;

    }

 

    public Person(String name, String sex, int age) {

        this(name,sex);

        this.age = age;

    }

 

    public void say(){

        System.out.println("你們好，我叫"+this.name+"今年"+this.age+"歲了,性別"+this.sex);

    }

}

*解析:×××標記的是做用一，使用this關鍵字來指定成員變量

          藍色標記的是調用構造方法

二．Static關鍵字

1. 在類中，用static聲明的成員變量爲靜態成員變量，它是該類的公用變量，對於該類的全部對象來講，static成員變量只有一份。 

2.用static聲明的方法爲靜態方法，該方法獨立於類的實例，因此也叫類方法。 

（1）靜態方法中只能直接調用本類中其餘的靜態成員(變量和方法)。 

        （2）靜態方法中不能使用this和super關鍵字。 

3.靜態成員能夠經過類名(不須要實例化)或類的實例去訪問。

4.靜態代碼塊： 

（1）在類中可使用不包含在任何方法中的靜態代碼塊(static block)，當類被JVM載入時，靜態代碼塊被執行，且只被執行一次。 

        （2）靜態代碼塊常常用來初始化類的靜態成員變量。 

         格式： static{

                  // 靜態代碼塊內容 

                    }

例1：靜態變量與靜態方法

    package staticdemo;

    public class Person{

       String name;

       int age;

       static int count;  // 靜態成員變量屬於類的，對於全部該類的對象是公用的

    public Person(){

       count++;

    }

    public Person(String name,int age){

       count++;

    this.name=name;

    this.age=age;

    }

   

    public static int getStaticCount(){

       return count;

    }

    public void say(){

       System.out.println("我叫"+this.name+"；今年"+this.age+"歲了");

    }

}

例2.靜態代碼塊

    package staticdemo;

    public class StaticBlock {

        static String note;

        static int count;

        

        public StaticBlock(){

         System.out.println("無參構造...");

        }

     

        static{

            System.out.println("這是靜態代碼塊中的內容...");

        note="備註";

      count=2;

        System.out.println("初始化後的note的值爲："+note);

        System.out.println("初始化後的count的值爲："+count);

        }

     

        public static void main(String[] args) {

        System.out.println("這是main方法");

        }

    }

5.靜態區圖：

                    

 

三．封裝性

1.封裝：（1）對外部不可見，隱藏對象的屬性和實現細節

 （2）好處：隱藏實現類的細節，讓使用者只能經過程序員規定的方法來訪問數據，能夠方便的加入存取控制語句，限制不合理操做

2.封裝性的體現：

          （1）類的封裝(屬性、方法都存在於某個類中)

（2）對字段的封裝 

               ·字段設置爲私有(private)

               ·添加get /set 方法 

           （3）訪問修飾符的限制，保證數據的安全 

例：

        Student類部分：

        package org.west;

        public class Student {

            private String name;

            private int age;

         

        public String getName() {

            return name;

        }

        public void setName(String name) {

            this.name = name;

        }

        public int getAge() {

            return age;

        }

        public void setAge(int age) {

            if(age>=30){

            System.out.println("年齡有誤！！");

            }else{

            this.age = age;

            }

        }

        public void say(){

            System.out.println("你們好！我叫"+name+"，今年"+age+"歲了");

            }

        }

        # 利用private進行屬性私有化，再用get/set方法來獲取和設置屬性的值

        主函數部分：

        package org.west;

        public class StudentTest {

        public static void main(String[] args) {

            Student stu=new Student();

            stu.setName("張三");

            stu.setAge(18);

            stu.say();

            }

        }

利用主函數new對象，並調用方法

四．繼承性

1．<1>繼承是一個類繼承另外一個類的，這個類擁有父類能夠被繼承的成員

   <2>類的方法和屬性均可以被繼承

        ·私有的屬性和方法不能被繼承

        ·構造方法不能被繼承

   <3>繼承是面向對象的特徵之一

   <4>實現繼承的類被稱爲子類，被繼承的類被稱爲父類，也叫基類或超類

   <5>繼承的好處：（1）實現代碼的重現擴展。（2）模擬現實世界中的關係。

（3）結構更加清晰

 

<6>繼承具備傳遞性

<7>單繼承性：

（1）在java中一個類只能有一個父類，這就是Java的「單繼承性」。 

    （2）java.lang.Object類是全部類的父類

2.使用繼承：

<1>要繼承一個類，可使用extends關鍵字，意味着擴展父類的功能。

<2>類繼承的基本語法：

  [修飾符]   <子類name> class extends <父類name>(){

          語句…………..

}  

例：動物類

        package org.west;

        public class Animal {

            String name;

        public void shout(){

            System.out.println("動物發出叫聲！！！！");

            }

        }

        狗類繼承動物類：

        package org.west;

        public class Dog extends Animal{

        public void printName(){

            System.out.println("此狗的名字是"+name);

            }

        }

        測試類：

        package org.west;

        public class ExdentsTest {

        public static void main(String[] args) {

            Dog dog=new Dog();

            dog.name="Tom";

            dog.shout();

            dog.printName();

            }

        }

*此例中是爲Dog類繼承Animal類

五.super關鍵字

1.在Java類中用super來引用父類的成員

·super可用於訪問父類中定義的屬性 

·super可用於調用父類中定義的成員方法 

Super.成員變量

Super.成員方法（參數1，參數2….）

例：定義動物類

        package org.west;

        public class Animal {

            String name="動物";

        public void shout(){

            System.out.println("動物發出叫聲！！！！");

            }

        }

定義狗類繼承動物類：

        package org.west;

        public class Dog extends Animal{

            String name="犬類";

         

        public void shout (){

            super.shout();

        }

        public void printName(){

            System.out.println("此狗的名字是"+super.name);

            }

        }

  定義測試類：

        package org.west;

        public class ExdentsTest {

        public static void main(String[] args) {

            Dog dog=new Dog();

            dog.shout();

            dog.printName();

            }

        }

        此例中super調用了父類的方法和屬性

        ·super(…)可用於在子類構造方法中調用父類的構造方法 

        Super.(參數1，參數2……)

        Class Father{

            private int n;

        public Father(){

            System.out.println(「父類無參構造」);

        }

        public Father(int n){

            this.n=n;

            System.out.println(「父類中帶參構造」+n);

            }

        }

        class Child extends Father{

            private int n;

        public Child(){

            super(300);

            System.out.println(「子類無參構造」);

        }

        public Child(int n){

            this.n=n;

            System.out.println(「子類帶參構造」+n);

            }

        }

*注意：（1）當子類和父類中都有同名的屬性時，在子類中若要使用父類的屬性時，可使用super.屬性。（2）super只能應用在成員方法和構造方法中。

2.使用super關鍵字注意事項：

  （1） 當子類和父類都有同名的屬性時，在子類中若是要使用父類的屬性 super.屬性

 （2） super只能應用在成員方法和構造方法中，不能應用在靜態方法中（和this是同樣的）

 （3） 若是在構造方法中使用必須放在第一行

 （4） 在構造方法中this()和super()不能同時出現 

 

補充：super和this對比

No                        對比點                   this             super

1	訪問屬性	首先在子類中查找，若是沒有就在 父類中查找	直接查找父類
2	訪問方法	先在子類在中找，若是沒有就去父類中查找	直接訪問父類中方法
3	調用構造	調用本類中的其餘構造方法	調用父類的構造方法
4	特殊	指自身的對象	沒有
5	做爲參數	能夠做爲參數	沒有

 

1. 四種訪問權限

1對類中屬性和方法的可見度

2.訪問修飾符： 

    private

    [default]:包級別訪問權限 

    protected

    public

3.類的訪問修飾符

 ·public:任何包中的類均可以訪問

 ·默認值：同一個包中的類能夠訪問

4.成員訪問修飾符:

 ·private：只對自己類可見

 ·默認值:同一包中的類可見

 ·Protected:對全部子類和統一包中的類可見

 ·Public：對一切類可見

5.在java中能夠對類，類的屬性以及類的方法前加一個修飾符來對類進行一些訪問上的控制

**default，public等能夠用來修飾一個類

表格解釋：

修飾符	同一個類中	同一個包中	子類中  (不一樣包)	全局
private	Yes
default	Yes	Yes
Protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

 例：

right類：

        package right;

         

        public class Person {

            String name;

            int age;

            protected String sex;

        }

測試類：

        package right;

        public class TestDefault {

        public static void main(String[] args) {

            Person per=new Person();

            per.name="朱可夫";

            per.age=20;

            }

        }

 

right2類：

        package right2;

        import right.Person;

        public class Student extends Person{

           public void say(){

           // 在子類中能夠跨包訪問父類的protected屬性

           System.out.println("性別是："+this.sex);   

           }

        }

   測試類：

        package right2;

        import right.Person;

        public class TestDefault {

            public static void main(String[] args) {

                Person per=new Person();

            }

        }

七.方法重寫（override）

1. 當子類繼承父類時，能夠從父類繼承它的屬性和方法，若是從父類繼承的方法不能知足子類的需求，能夠對其進行改寫，這個過程叫作方法的重寫(override)

2.方法重寫規則：

                （1）只能用於子類和父類之間

                （2）子類的方法名稱、輸入參數和返回值類型徹底一致或子類方法返回值類型是父類方法返回值類型的子類。

                （3）子類的權限不能比父類的更加嚴格

                *注意：重寫的前提是子類先繼承了父類的方法

例1：

Student類：

            package org.show;

            public class Student {

                String name;

              String sex;

                double Sorce;

            public Student() {

                super();

            }

            public Student(String name, String sex, double sorce) {

                    super();

                this.name = name;

              this.sex = sex;

                Sorce = sorce;

            }

            public void show(){

                    System.out.println("同窗一：");

                    System.out.println("我叫"+this.name+"，性別"+this.sex+"，考了"+this.Sorce+"分!!!!!");

                }

            }

Student02類;

            private int age;

            public Student02 exdents Student() {

                super();

            }

            public Student02(int age) {

                super("張三","男",99);

                this.age = age;

            }

             

            public void show(){

                System.out.println("同窗二:");

                    System.out.println("我叫"+name+"，性別"+sex+"，年齡"+this.age+"，考了"+Sorce+"分!!!!!");

                }

             

            }

             

StudentTest類：

        package org.show;

         

        public class StudentTest {

         

        public static void main(String[] args) {

            Student stu=new Student("李四","男",78);

            Student02 st2=new Student02(18);

            stu.show();

            System.out.println("~~~~~~~~~~~~~");

            st2.show();

            } 

        }

此例中實現了show方法的重寫

**補充-單例設計模式（重要）

1.單例模式分類：

（1）「餓漢式「單例：當類加載到JVM時，單例對象直接建立

（2）懶漢式」單例模式:當類加載到JVM時，並不直接建立單例對象，用戶請求單例對象時(用戶須要使用時)，才實例化該單例對象；

2.私有化構造方法

3.在類的內部實例化該類的對象（該類的對象必須是static全局變量）

例1：餓漢式單例模式：

       

        package single;
        /*
         * 「餓漢式」單例模式:當類加載到JVM時，單例對象直接建立
         * */
        public class HungrySingleInstance {
  
         // 在該類內部實例化對象
         private static HungrySingleInstance single=new HungrySingleInstance();
 
         // 私有化構造方法，防止外部實例化該類的對象
         private HungrySingleInstance(){
  
         }

                     // 靜態方法，獲取單例對象
         public static HungrySingleInstance getSingleInstance() {
                          return single;
             }
 
 
        }

 例2：懶漢式單例模式

        package single;

        /*

         * 「懶漢式」單例模式:當類加載到JVM時，並不直接建立單例對象，用戶請求單例對象時(用戶須要使用時)，才實例化該單例對象

         * */

        public class LazySingleInstance {     

        // 在該類內部實例化對象

        private static LazySingleInstance single;

        // 私有化構造方法，防止外部實例化該類的對象

        private LazySingleInstance();

        }

    // 靜態方法，獲取單例對象
     public static synchronized LazySingleInstance getSingleInstance() {
      if(single==null){
       System.out.println("第一次訪問單例，建立......");
       single=new LazySingleInstance();
      }
      return single;
     }
 
    }

測試類：

    

    package single;

    public class Test {

     public static void main(String[] args) {
      HungrySingleInstance single1=HungrySingleInstance.getSingleInstance();
      HungrySingleInstance single2=HungrySingleInstance.getSingleInstance();
      System.out.println("餓漢式單例："+(single1==single2));
  
      LazySingleInstance lazy1=LazySingleInstance.getSingleInstance();
      LazySingleInstance lazy2=LazySingleInstance.getSingleInstance();
      System.out.println("懶漢式單例"+(lazy1==lazy2));

     }

    }

小結：

    ·面向對象的已學的特徵有：封裝性，繼承性

    ·單例設計模式分爲:餓漢式設計模式,懶漢式設計模式

    ·關鍵字：this，super，static

    ·四大訪問權限：默認值，public，Protected,private

    ·類與對象的關係及意義

    ·方法對的重寫及方法的重載

                    【2017.12,12】