面向物件程式設計

構造器

構造器就是和類名相同但無返回型別的方法。

public class Person {

    //一個類即使什麼都不寫,它也會存在一個方法

    //顯示的定義構造器

    String name;

    //例項化初始值

    //1.使用new關鍵字,本質是在呼叫構造器

    //2.用來初始化值

    public Person(){

    }

    //有參構造:一旦定義了有參構造,無參構造就必須顯示定義

    public Person(String name){

        this.name = name;

    }

    //alt+insert自動生成構造器

    /*

    public static void main(String[] args) {

        Person person = new Person("Avirus");

        System.out.println(person.name);

    }

    構造器:

        1.和類名相同

        2.沒用返回值

    作用:

        1.new本質在呼叫構造方法

        2.初始化物件的值

    注意點:

        1.定義有參構造之後,如果想使用無參構造,就要顯示定義一個無參構造

     */

}

無參構造器

public class Pet {

    public String name;

    public int age;

    //無參構造

    public void shout(){

        System.out.println("叫了一聲");

    }

    /*

    1.類與物件

        類是一個模板:抽象,物件是一個具體的例項

    2.方法

        定義,呼叫!

    3.對應的引用

        引用型別:   基本型別(8)

        物件是通過引用來操作的: 棧-->堆

    4.屬性:欄位Field 成員變數

        預設初始化:

            數字:0    0.0

            char:u0000

            boolean:false

            引用:null

    5.物件的建立和使用

        -必須使用new 關鍵字創造物件,構造器 Person Avirus = new Person();

        -物件的屬性  Avirus.name

        -物件的方法  Avirus.sleep();

     */

}

如何訪問私有屬性

package oop.Demo04;

/*

1.提高了程式的安全性,保護資料

2.隱藏程式碼的實現細節

3.統一介面

4.系統可維護性增加了

 */

public class Student {

    //屬性私有

    private String name; //姓名

    private int id; //學號

    private char sex; //性別

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        if(age > 120 || age < 0){

            System.out.println("不合法");

        }else {

            this.age = age;

        }

    }

    private int age;

    //提供一些可以操作這個屬性的方法!

    //提供一些public的get,set方法

    //get獲取這個資料

    public String getName(){

        return this.name;

    }

    //set給這個資料設定值

    public void setName(String name){

        this.name = name;

    }

    //alt + insert

}

封裝

  • 該露的露,該藏得藏

    • 我們程式設計要追求"高內聚,低耦合".高內聚就說類得內部資料操作細節自己完成,不允許外部干涉;低耦合:僅暴露少量方法給外部使用
  • 封裝(資料得隱藏)
    • 通常,應禁止直接訪問一個物件中資料得實際表示,而應通過操作介面來訪問,這稱為資訊隱藏.
  • 記住一句話:屬性私有,get/set
package oop.Demo04;

/*

1.提高了程式的安全性,保護資料

2.隱藏程式碼的實現細節

3.統一介面

4.系統可維護性增加了

 */

public class Student {

    //屬性私有

    private String name; //姓名

    private int id; //學號

    private char sex; //性別

    public int getAge() {

        return age;

    }

    public void setAge(int age) {

        if(age > 120 || age < 0){

            System.out.println("不合法");

        }else {

            this.age = age;

        }

    }

    private int age;

    //提供一些可以操作這個屬性的方法!

    //提供一些public的get,set方法

    //get獲取這個資料

    public String getName(){

        return this.name;

    }

    //set給這個資料設定值

    public void setName(String name){

        this.name = name;

    }

    //alt + insert

}

繼承

  • 繼承得本質是堆某一批類得抽象,從而實現對現實世界更好得建模

  • extends得意思是"擴充套件".子類是父類得擴充套件

  • Java中類只有單繼承,沒有多繼承!

  • 繼承是類和類之間得一直關係.除此之外,類和類之間得關係還有依賴,組合,聚合等.

  • 繼承關係得兩個類,一個為子類(派生類),一個為父類(基類).子類繼承父類,使用關鍵字extands來表示

  • 子類和父類之間,從意義上講應該具有"is a"得關係

  • object類

  • super

  • 方法重寫

//所有類都繼承了Object類

public class Person {

    //private

    //protected

    //public

    private int money = 10000000;

    public int getMoney() {

        return money;

    }

    public void setMoney(int money) {

        this.money = money;

    }

    public void say(){

        System.out.println("說了一句話");

    }

}


public class Student extends Person{

}

繼承了父類得子類,可以使用父類中得方法

public class Application {

    public static void main(String[] args) {

        Student student = new Student();

        student.say();

    }

}

這個地方值得注意的是被final關鍵字修飾的類,就不能被繼承

super

super關鍵字是用來呼叫父類的屬性和方法

public class Student extends Person{

    private String name = "test";

    public Student() {

        //隱藏程式碼super();

        super();//呼叫父類得構造器,必須在子類得第一行

        System.out.println("Student無參執行");

    }

    public void test(String name) {

        System.out.println(name);

        System.out.println(this.name);

        System.out.println(super.name);

    }

    public void test1() {

        print();

        this.print();

        super.print();

    }

    public void print(){

        System.out.println("Student");

    }

}

super注意點

super注意點:

    1.super呼叫父類得構造器方法,必須在構造器方法得第一個

    2.super必須只能出現在子類得方法或者構造方法中!

    3.super和this不能同時呼叫構造方法!

Vs this:

    代表得物件不同:

        this: 本身呼叫這個物件

        super: 代表父類物件得應用

    前提

        this:沒用繼承也可以使用

        super:只能在繼承條件下使用

    構造方法

        this():本類的構造

        super():父類的構造

在子類如果想呼叫父類的無參構造器時,父類要寫無參構造器,子類也可以直接呼叫父類的有參構造,在super裡面直接加引數.

如果父類裡面只有有參構造器,而沒有無參構造器,子類無法呼叫父類的無參構造器

方法重寫

//重寫是方法的重寫,與屬性無關

public class B {

    //靜態方法和非靜態方法區別很大

        //方法的呼叫之後,左邊定義的資料型別有關

    //非靜態:重寫

    public void test(){

        System.out.println("B-->test()");

    }

}


重寫:需要在繼承關係,子類重寫父類的方法!

    1.方法名必須相同

    2.引數列表必須相同

    3.修飾符:範圍可以擴大,但不可以縮小:public>protected>default>private

    4.丟擲的異常:範圍可以縮小,但是不能擴大

是在非靜態方法下的

重寫,子類的方法和父類必須要一致,方法體不同!

    1.父類的功能,子類不一定需要,也不一定滿足

    alt+insert: override

在自動生成的重寫方法上面會有一個註解

多型

  • 即同一方法可以根據傳送物件的不同而採用多種不同的行為方式。

  • 一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多

  • 多型存在的條件

    • 有繼承關係
    • 子類重寫父類方法
    • 父類引用指向子類物件

  • 注意:多型是方法的多型，屬性沒有多型性。

  • instanceof:是用來判斷兩個類是否有聯絡的

/*

多型注意事項:

1.  多型是方法的多型,屬性沒用多型

2.  父類和子類,有聯絡,沒有聯絡會型別轉換異常! ClassCastException!

3.  存在條件: 繼承關係,方法需要重寫,父類引用指向子類物件! Father f1 = new Son();

    1.static 方法,屬於類,它不屬於例項

    2.final 常量

    3.private方法

//一個物件的實際型別是確定的

        //可以指向的引用型別就不確定了: 父類的引用指向子類

        //子類 能呼叫的方法都是自己的或者繼承父類的!

        Student s1 = new Student();

        //父類 可以指向子類,但是不能呼叫子類獨有的方法

        Person s2 = new Student();

        Object s3 = new Student();

        //物件能執行哪些方法,主要看物件右邊的型別,和右邊關係不大

        s2.run(); //子類重寫了父類的方法,執行子類的方法

        s1.run();

 */

型別轉換

/*

1.父類引用指向子類的物件

2.把子類轉換為父類,向上轉型

3.把父類轉換為子類,向下轉型,強制轉換,可能會丟失一些方法(說的是丟失子類特殊的方法)

4.方便方法的呼叫,減少重複的程式碼

*/

/*//型別之間的轉換: 父      子

        //高                     低

        //student將這個物件轉換為Student型別,我們就可以使用Student型別的方法了!

        //子類轉換為父類,可能丟失自己的本來的一些方法!

        Student student = new Student();

        student.go();*/

static關鍵字

被static修飾過之後,與類一起載入,所以被第一個呼叫

public class Teacher {

    //2 賦初始值

    {

        System.out.println("匿名程式碼塊");

    }

    //1 只執行一次

    static {

        System.out.println("靜態程式碼塊");

    }

    //3

    public Teacher(){

        System.out.println("構造程式碼塊");

    }

    public static void main(String[] args) {

        Teacher teacher = new Teacher();

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

        Teacher teacher2 = new Teacher();

    }

}

靜態匯入包

//靜態匯入包

import static java.lang.Math.random;

import static java.lang.Math.PI;

public class Test {

    public static void main(String[] args) {

        System.out.println(random());

        System.out.println(PI);

    }

}

抽象類

  • abstract修飾符可以用來修飾方法也可以修飾類,如果修飾方法,那麼該方法就是抽象方法;如果修飾類,那麼該類就是抽象類。
  • 抽象類中可以沒有抽象方法,但是有抽象方法的類一定要宣告為抽象類。
  • 抽象類,不能使用new關鍵字來建立物件,它是用來讓子類繼承的。
  • 抽象方法,只有方法的宣告,沒有方法的實現,它是用來讓子類實現的。
  • 子類繼承抽象類,那麼就必須要實現抽象類沒有實現的抽象方法,否則該子類也要宣告為抽象類。
//抽象類的所有方法,繼承了它的子類,都必須要實現它的方法  除非它自己也是一個抽象類

public class A extends Action{

    @Override

    public void doSomething() {

    }

}


//abstract抽象類  單繼承           {介面可以多繼承}

public abstract class Action {

    //約束~有人幫我們實現~

    //abstract ,抽象方法 ,只有方法名,沒用方法的實現

    public abstract void doSomething();

    //1.不能new這個抽象類,只能靠子類區實現它:約束!

    public void hello(){

    }//抽象類中有普通方法是可以的

    //2.抽象類中可以寫普通的方法

    //3.抽象方法必須在抽象類中

    //抽象的抽象:約束

    //思考? new,存在構造器麼?

    //抽象類是存在構造器的,不然子類無法重寫方法

            //存在的意義     抽象出來~提高開發效率

}

介面

  • 普通類:只有具體實現
  • 抽象類:具體實現和規範(抽象方法)都有!
  • 介面:只有規範!自己無法寫方法專業的約束!約束和實現分離:面向介面程式設計
  • 介面就是規範，定義的是- -組規則，體現了現實世界中“如果你...則必須能..的思想。如果你是天使,

    則必須能飛。如果你是汽車，則必須能跑。如果你好人，則必須幹掉壞人;如果你是壞人，則必須欺負好人。
  • 介面的本質是契約，就像我們人間的法律-樣。制定好後大家都遵守。
  • 00P的精髓，是對物件的抽象，最能體現這一 點的就是介面。為什麼我們討論設計模式都只針對具備了抽象

    能力的語言(比如C++、 java、 c#等) ,就是因為設計模式所研究的，實際上就是如何合理的去抽象。
  • 宣告類的關鍵字是class,宣告接[的關鍵字是interface

一個介面

//抽象的思維~ Java 架構

//interface定義的關鍵字,  介面都需要實現類

public interface UserService {

    //常量 public static final

    int AGE = 99;

    //介面中的所有定義的方法其實都是抽象的   public abstract預設

    void run();

    void add(String name);

    void delete(String name);

    void update(String name);

    void select(String name);

}

實現類

//抽象類: extends~

//類 可以實現介面 implements 介面

//實現了介面的類,就需要重寫介面中的方法~

//多繼承,利用介面實現多繼承

public class UserServiceImpl implements UserService,TimeService {

    @Override

    public void run() {

    }

    @Override

    public void add(String name) {

    }

    @Override

    public void delete(String name) {

    }

    @Override

    public void update(String name) {

    }

    @Override

    public void select(String name) {

    }

    @Override

    public void timer() {

    }

}

內部類

public class Outer {

    private int ID = 10;

    public void Outer(){

        System.out.println("Out!");

    }

    //區域性內部類

    public void method(){

        class test{

            public void tst(){

            }

        }

    }

    public class Inner{

        public void in(){

            System.out.println("In!");

        }

        //獲取外部類的私有屬性

        public void getID(){

            System.out.println(ID);

        }

    }

}

//一個java類中可以有多個class類,但是隻能有一個public類

class Apple {

    public void eat(){

        System.out.println("1");

    }

}

interface Avirus{

    void hello();

}