java之面向對象3

代碼塊

代碼塊
1.局部代碼塊

局部變量位置:方法中 和 方法聲明中

作用:限定了局部變量的生命週期(作用域問題)

2.構造代碼塊

位置：在類中 方法外

調用順序:在你創建對象的時候 如果你有構造代碼塊

系統會幫你先調用構造代碼塊 再調用構造方法

作用：如果每個對象都有相同方法去執行

可以在構造代碼中調用(開發中機會沒有這樣的場景)

3.靜態代碼塊(使用static來修飾)

位置:在類中方法外

特點:只加載一次 並且隨着類的加載而加載

應用場景：加載驅動(JDBC 數據庫連接)

4.同步代碼塊(多線程)

public class Demo01 {
    static {
        System.out.println("我是Demo01 靜態代碼塊");
    }
    public static void main(String[] args) {
        // 局部代碼塊
        {
            int num = 10;
            System.out.println(num);

        }
        // 用午餐構造  創建一個Person對象
        // 用有參 創建一個Person
        //都調用 sayH方法
        Person p= new Person();
    }


}
class Person{
    String name;
    int age;

    //
    public  Person() {
        System.out.println("我是無參的構造方法");
    }
    public Person(String name,int age) {
        this.name = name;
        this.age  = age;
        System.out.println("我是有參的構造方法");
    }

    public void sayHi() {
        System.out.println(name+"-----"+age);
    }
    // 構造代碼塊
    {
        System.out.println("我是構造代碼塊");
    }
    //靜態代碼塊
    static {
        System.out.println("我是靜態代碼塊");
    }
}

輸出結果

繼承

繼承特點：
1.減少重複的代碼

2.減少你的工作量

3.可以把類中相同的代碼抽取出來

繼承不繼承 要具體問題具體分析

什麼時候使用繼承？符合繼承邏輯

舉一個動物類的繼承

class Animal{
    String color;
    int leg;
    String name;

    public void sayHi() {
        System.out.println(color+"-----"+leg);
    }
}
class Cat extends Animal{




}
class Dog extends Animal{



}

繼承的規則

java中的繼承

1.java中 值允許 單繼承 不允許多繼承(可以寄接口來實現多繼承效果)

2.java中 允許 多層繼承(屬性方法會傳遞繼承)

如果我想得到類中共有的方法和屬性 使用哪個類

使用繼承鏈最頂端的類

如果我想的到類中 特有的方法和屬性 使用哪個類 使用最末端的類

如果一個類沒有寫繼承那個類 實際上是繼承了系統的類 Object類

Object類 是java 最頂端的類(基類)

多層繼承的例子：

class DemoA extends Object{
    String name;
    public void sayHi() {
        System.out.println(name);
    }
}
class DemoB extends DemoA{

}
class DemoC extends DemoB{

}

繼承中的構造方法

繼承中的 構造方法

注意：構造方法是不能被繼承的

1.爲什麼會打印爸爸無參構造方法？

要有兒子 先有爹 要初始化兒子類的對象 需要先去爸爸類中

調用構造方法

2.爲什麼兒子有參創建對象 也會打印爸爸無參構造方法？

下面的代碼中會解釋這個問題

class Father{
    String name;
    public void sayHi() {
        System.out.println(name);
    }
    public Father(){

        System.out.println("我是爸爸的 無參構造方法");
    }
    public Father(String name){
        this.name = name;
        System.out.println("我是爸爸的 有參構造方法");
    }
}
class Son extends Father{
    public Son() {
        // 如果你沒有調用 父類的構造方法
        // name系痛會在這裏幫你調用一下父類無參構造方法
        super();
        //調用父類無參構造方法
        System.out.println("我是兒子 無參的構造方法");
    }
    public Son(String name) {
        // 不管你有參無參的構造方法
        // 只要你沒有調用父類的構造方法 系統都會幫你調用
        // 保證繼承完整性
        super();
        this.name = name;
        System.out.println("我是兒子 有參的構造方法");
    }

}

繼承中方法的同名變量調用的優先級

首先 說明下子類中 this super的區別
1. this 在 類中代表的是本類的對象(當前類的對象)

2.super 在類中代表的是 父類的對象

this.屬性 可以調用到當前類的屬性(現在當前類找這個屬性)

(沒找到的話 回去父類裏找)

super.屬性：可以調用到父類的屬性

this.(); 調用本類的構造方法

super.(); 調用父類的構造方法

下面舉一個 同名變量調用的例子

class Fruit{
    int num1 = 10;
     int num2 = 20;



}
class Apple extends Fruit{
    int num2 = 30;
    public void print() {
        System.out.println(num1);
        System.out.println(num2);//這裏會輸出 子類中的30 而不是20
        System.out.println(super.num2);//這裏會輸出父類中的20
    }
}

兩個類繼承中子類構造函數調用的情況

兩個類繼承關係
父類 沒 有無參構造方法 ( 有 有參的構造方法)

子類的構造方法如何去寫？

可以指定調用構造方法

class Car{
    String name;

    public Car(String name) {
        this.name= name;
        System.out.println("Car我是有參數的構造方法");
    }
}
class Audi extends Car{

    public Audi() {
        // 只要你在構造方法的第一行 調用構造方法
        // 這時系統將不再給你指定調用默認的無參構造方法
        super("A8");
        System.out.println("Audi 我是無參構造方法");
    }

    public Audi(String name) {
        // 你不寫父類構造 默認系統給你調用無參構造
        // 你可以指定一個構造方法去調用
        super(name);// 調用弗雷有參的構造方法
        System.out.println("Audi 我是有參構造方法");
    }
    public void sayHi() {
        System.out.println(name);
    }
}

繼承中的重寫

當父類和子類有相同 成員方法時

class GlassCup extends Cup{
    public void print() {
        // Override和Overload有什麼區別？
        // Override 重寫
        // Overload 重載
        // 當父類和子類方法完全一致時 叫做 方法重寫
        // super點 方法 可以調用父類的方法
        // 重寫的應用場景 當子類的方法 相對於父類的方法 有了升級
        // 這是你可以使用方法的重寫
        // ios7 siri 只能英文
        // ios8 siri 可以說英文 也能說中文
        super.print();

        System.out.println("我是玻璃杯");
    }
}
class IOS7{
    public void siri() {
        System.out.println("我能說中文");
    }
}

class IOS8 extends IOS7{
    // 這個方法標識 重寫父類方法
    @Override
    public void siri() {
        // TODO Auto-generated method stub
        // 這裏調步調父類 要根據實際情況來寫
        super.siri();
        System.out.println("功能升級 我能說中文了");
    }
}

繼承中 父類成員私有化 子類該如何修改

舉個例子

父類是人 子類是老師

class Man{
    // 注意：私有屬性 是不能被繼承的(不是很準確)
            // 私有屬性 可以繼承下來 的 但是沒有訪問的權限
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    //注意 私有屬性是不能被繼承的(不是很準確)
    private String name;
    private int age;
    public Man() {

    }
    public Man(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public void eat() {
        System.out.println("吃飯");
    }
}
class Teacher extends Man{

    public Teacher() {

    }
    public Teacher(String name, int age) {
        //調用父類有參構造
        super(name,age);

    }
    public void teach() {
        System.out.println(getName()+"教書");
    }

    //繼承set get方法 
    // 能不能通過 set/get 取訪問和修改屬性呢
}

總結一下就是 父類中成員變量私有化之後

如果子類想修改就得通過 get的方法。

final關鍵字

final 關鍵字(絕育流)
1.修飾類 不能被繼承

2.修飾變量 不能被修改

3.修飾方法 修飾方法時不能被重寫

 class Team{
    // final 修飾的變量 相當於 常量(不能被修改的量)
    // 命名規則 名字全部大寫 多單詞用下劃線分開
    public static final double PIPI = 3.14;


    final int num; // 無效默認值
    // final 賦值初值的兩種方法
    // 1，直接給初值
    // 2. 從構造方法中賦值

    public final void sayHi() {


        System.out.println(PIPI);
    }
}
 class A extends Team{

     public void sayHi() { //這裏方法重寫是報錯的

    }
 }