封裝

將事物的一些特點(diǎn)封裝成屬性 將行為封裝成方法 將字段私有化 并對(duì)外提供訪問方法

修飾符訪問權(quán)限:

• public>protected>無修飾符(默認(rèn)為default)>private

封裝步驟

1. 把類中的字段私有化

2. 給每一個(gè)字段都提供一組getter setter方法 (方法的規(guī)范寫法)；setXxx在測(cè)試類中嘗試創(chuàng)建對(duì)象,并通過調(diào)用getter setter方法完成 對(duì)字段的賦值和取值

3. 提供一個(gè)無參數(shù)的構(gòu)造方法

class Test5{
    public static void main(String[] args){
        Superman superman=new Superman();
        superman.setName("大便超人");
        System.out.println(superman.getName());
        superman.setAge(18);
        System.out.println(superman.getAge());
        superman.setSkill("大便轟炸");
        System.out.println(superman.getSkill());
    }
}

class Superman{
    //1.先將字段(屬性)私有化
    private String name;
    private int age;
    private String skill;
    //2.定義訪問方法
    public void setName(String n){
        name=n;
    }
    public String getName(){
        return name;
    }
    public void setAge(int a){
        age=a;
    }
    public int getAge(){
        return age;
    }
    public void setSkill(String s){
        skill=s;
    }
    public String getSkill(){
        return skill;
    }
}

• 方法名字：存值setName 取值getName : 特殊情況 布爾類型的字段get 變 is
• 參數(shù)：存值對(duì)應(yīng)字段類型，取值不需要參數(shù)

繼承

繼承可以把父類的所有功能都直接拿過來，這樣就不必重零做起，子類還可以新增自己特有的方法.

class A{ 
}
A 就是B的父類; B是A的子類
class B extends A{
}
//例子:
class Test1{
    public static void main(String[] args){
        Dog dog=new Dog();
        dog.run();
        System.out.println("hello");
    }
}

class Animal{//父類
    String name;
    int age;
    void run(){
        System.out.println("我在跑");
    }
}
class Dog extends Animal{   
}

可以繼承的

• 非私有的屬性和方法
• 特性

1. 私有的字段可以被繼承 不能直接訪問
2. 私有的方法可以被繼承 不能直接訪問
3. 構(gòu)造方法是不能被繼承的

不可繼承的

構(gòu)造方法不能被繼承

特點(diǎn)

1. Java中類的繼承只能夠是單繼承

2. 可以支持多重繼承

3. 每一個(gè)類都有一個(gè)直接父類,如果沒有看到顯式的繼承代碼,那么就隱式繼承就Object

方法覆寫

• 子類中出現(xiàn)了和父類名字一樣的成員(屬性和方法)，子類的成員就重寫了父類成員
• 子類對(duì)象如果存在相應(yīng)的成員就不會(huì)再去父類中查找

為什么要覆寫

• 當(dāng)父類的方法不能滿足子類的需求,就需要覆寫方法來實(shí)現(xiàn)功能
• 子類方法是否在覆寫父類的方法,可以通過注解@Override驗(yàn)證

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Bird bird=new Bird();
        bird.name="小花";
        bird.run();
    }
}
//子類方法是否在覆寫父類的方法,可以通過注解@Override驗(yàn)證
class Animal{//父類
    String name;
    void run(){
        System.out.println(name+"跑得飛起");
    }
}
class Bird extends Animal{
    @Override//判斷以下方法是否是方法重寫
    void run(){
        System.out.println(name+"飛得賊快");
    }
}

注意

1. 保證子類方法和父類方法的方法簽名(方法名+參數(shù)列表)一致;
2. 訪問權(quán)限 : 子類方法的訪問權(quán)限(修飾符)不能夠比父類方法的訪問權(quán)限更低;
3. 返回值類型 : 子類方法的返回值類型可以是父類方法的返回值類型的子類或者相等

Object類

Object是每一個(gè)類的，直接父類或者間接父類

• 每一個(gè)類都有一個(gè)直接父類,如果沒有看到顯示的繼承代碼,那么就隱式繼承就Object
• Object所有類的根類,是一個(gè)非常重要的類,所有類的重要的公共的靜態(tài)屬性，及動(dòng)態(tài)行為[方法]都被提取到了Object

Object中的方法

1. String toString() 返回調(diào)用此方法的當(dāng)前對(duì)象的字符串表示形式(把當(dāng)前對(duì)象轉(zhuǎn)成字符串)
2. boolean equals(Object obj) 比較兩個(gè)對(duì)象是否相等(比較調(diào)用此方法的對(duì)象是否和傳入的obj”相等”)
3. int hashCode() 通過對(duì)象結(jié)合算法得到一個(gè)int值
4. Class<?> getClass() 返回此 Object 的運(yùn)行時(shí)類(獲得一個(gè)對(duì)象的真正的類型)

覆寫toString方法

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Car car =new Car();
        car.name="寶馬";
        car.price=250;
        System.out.println(car);
    }
}

class Car{
    String name;
    double price;
    //覆寫toString
    public String toString(){
        return name+","+price;
    }
}

覆寫equals方法

class Test{
    public static void main(String[] args){
        System.out.println("hello");
        Animal ani1= new Animal("小黑",2);
        Animal ani2=new Animal("小白",1);
        //比較兩個(gè)對(duì)象的屬性是否一致
        System.out.println(ani1.equals(ani2));
    }
}

class Animal{
    String name;
    int age;
    Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    //覆寫equals方法
    public boolean equals(Object obj){
        //obj編譯器只看類型不看值：obj為Object類型，沒有name，age屬性,所以進(jìn)行強(qiáng)行轉(zhuǎn)換
        Animal animal=(Animal) obj;
        return this.name.equals(animal.name)&&this.age==animal.age;
    }
}

==和equals的區(qū)別

• == (比較運(yùn)算符)

  • 基本數(shù)據(jù)類型變量: 比較的就是值是否相等;
  • 引用數(shù)據(jù)類型變量: 比較的是對(duì)象的地址是否一樣;（排除特殊 String）

• equals 方法[最初定義在根類Object中的,比較對(duì)象是否相等]

  • 基本數(shù)據(jù)類型 : 不能夠使用! 基本數(shù)據(jù)類型不是對(duì)象,不能夠調(diào)用Object中的方法
  • 引用數(shù)據(jù)類型 : 但是在Object的源碼中定義的就是 == 進(jìn)行比較比較

訪問權(quán)限修飾符

• 訪問權(quán)限從大到小: public> protected>默認(rèn)不寫(default)>private
• 主要是用來控制類和類中成員的訪問權(quán)限

修飾范圍

1. public和默認(rèn)不寫(default)可以修飾類(內(nèi)部類和外部類)
2. private 和protected 不能夠修飾類外部類
3. 都不能修飾局部變量

訪問權(quán)限

應(yīng)該怎么去用權(quán)限修飾符

1. 如果不希望別訪問，私有化private權(quán)限

2. 如果希望別人訪問，提供公共的權(quán)限public

3. 如果特殊情況：權(quán)限由小到大設(shè)置

多態(tài)

一種事物多種形態(tài)

編譯的數(shù)據(jù)類型和運(yùn)行的數(shù)據(jù)類型不一致的情況

語法

A a=new B();//多態(tài)

class A{}
class B extends B{}

多態(tài)實(shí)例

• 編譯看左邊,運(yùn)行看右邊,有static修飾運(yùn)行也看左邊
• 傳遞的參數(shù)類型可以是本類或本類的子類
• 返回值的類型可以為方法的返回值類型的子類

class Test{//多態(tài)
    public static void main(String[] args){
        System.out.println("hello");
        Animal one=new Person();
        one.eat();
    }
}
class Animal{
    void eat(){
        System.out.println("吃肉吃草吃自己");
    }
}
class Person extends Animal{
    void eat(){
        System.out.println("吃啥都行");
    }
}