目的

學(xué)習(xí)代碼塊的原理，明白怎么使用它和理解它的加載順序，簡單了解；辨析內(nèi)部類和外部類，學(xué)習(xí)內(nèi)部類的基礎(chǔ)知識，掌握內(nèi)部類的使用方法和作用，剖析其具體體現(xiàn)；進(jìn)入Java三特性之一——繼承，學(xué)習(xí)其基礎(chǔ)特征，加深對繼承特性的理解

代碼塊

在程序編程中，可以直接使用“{}”定義一段語句。根據(jù)定義的位置以及聲明關(guān)鍵字的不同，可以分為四種：普通代碼塊、構(gòu)造代碼塊、靜態(tài)代碼塊和同步代碼塊。一般來說代碼塊是不能單獨運行的，它必須要有運行主體。其形式大致為：

修飾符 {
預(yù)先執(zhí)行的內(nèi)容，即預(yù)處理
  }

在對象創(chuàng)建之前，代碼塊就會被優(yōu)先調(diào)用

實例

class Person{
    int age;
    
    //普通代碼塊
    {
        age = 30;
        System.out.println("代碼塊 age="+age);
    }

    //靜態(tài)代碼塊
    static {
        //age = 20;靜態(tài)代碼塊里面不能調(diào)用成員變量和實例方法
        System.out.println("靜態(tài)代碼塊");
    }

    public Person(){
        System.out.println("無參構(gòu)造方法 age="+age);
    }

    public Person(int age){
        this.age = age;
        System.out.println("有參構(gòu)造方法");
    }
}

內(nèi)部類

概念

向?qū)ο蟪绦蛟O(shè)計中，可以在一個類的內(nèi)部定義另一個類，這種類稱為嵌套（nestedclasses）,它有兩種類型，即靜態(tài)嵌套類和非靜態(tài)嵌套類。靜態(tài)嵌套類使用很少，最重要的是非靜態(tài)嵌套類，也即是被稱作為內(nèi)部類(inner)。內(nèi)部類是JAVA語言的主要附加部分。內(nèi)部類幾乎可以處于一個類內(nèi)部任何位置，可以與實例變量處于同一級，或處于方法之內(nèi)，甚至是一個表達(dá)式的一部分。

定義一個類，可以在多個地方定義

1. 單獨創(chuàng)建一個文件管理一個類
2. 直接在文件里面，類A的上面和下面創(chuàng)建
3. 直接在某個類A內(nèi)部創(chuàng)建一個類

實例

class RelativeLayout{
    String view;

    //在顯示一個視圖前 必須告訴系統(tǒng)這個視圖的具體位置
    public void show(LayoutParams layout){
        System.out.println("視圖:"+view+"顯示出來了");
                System.out.println("left:"+layout.leftMergin+
                        "top:"+layout.topMergin+
                        "right:"+layout.rightMergin+
                        "bottom:"+layout.bottomMergin);
    }

    //定義一個內(nèi)部類 用于管理相對布局的具體布局屬性
    public static class LayoutParams{
        float leftMergin;
        float topMergin;
        float rightMergin;
        float bottomMergin;

        public LayoutParams(float leftMergin, float topMergin,
                            float rightMergin, float bottomMergin){
            this.leftMergin = leftMergin;
            this.topMergin = topMergin;
            this.rightMergin = rightMergin;
            this.bottomMergin = bottomMergin;
        }
    }
}

靜態(tài)內(nèi)部類的使用

class testLayout{
    public static void main(String[] args){
        //創(chuàng)建一個相對布局 容器視圖
        RelativeLayout rl = new RelativeLayout();

        rl.view = "分享按鈕";

        //顯示這個視圖
        //準(zhǔn)備好這個視圖的布局屬性
        //1.
//        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(20,20,
//                20,20);
//        rl.show(params);
        
        //使用匿名對象 只需要使用一次
        rl.show(new RelativeLayout.LayoutParams(20,20,
                20,20));
    }
}

運行結(jié)果

1.png

繼承

概念

繼承是面向?qū)ο笞铒@著的一個特性。繼承是從已有的類中派生出新的類，新的類能吸收已有類的數(shù)據(jù)屬性和行為，并能擴(kuò)展新的能力。Java繼承是使用已存在的類的定義作為基礎(chǔ)建立新類的技術(shù)，新類的定義可以增加新的數(shù)據(jù)或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。這種技術(shù)使得復(fù)用以前的代碼非常容易，能夠大大縮短開發(fā)周期，降低開發(fā)費用。比如可以先定義一個類叫車，車有以下屬性：車體大小，顏色，方向盤，輪胎，而又由車這個類派生出轎車和卡車兩個類，為轎車添加一個小后備箱，而為卡車添加一個大貨箱。

關(guān)鍵 獲得父類的方法和屬性，并需要添加自己的屬性和方法；Java里面只能單繼承，以及變相多繼承

需要關(guān)注點

1.所有類都是直接或間接繼承于Object類
2.當(dāng)調(diào)用子類的一個方法時，如果沒有就會到父類里面去查找
3.如果子類里面需要調(diào)用父類的方法，或者顯示調(diào)用父類的屬性的時候，使用super

    @Override
    public void walk() {
        super.walk();
    }

4.如果一個方法需要完成一個功能，又不能單獨完成，必須要父類做相應(yīng)工作，就需要調(diào)用super的對應(yīng)方法
父類做完之后，子類再操作

2.png

3.png

5. 如果子類里面需要重新實現(xiàn)父類的方法，就需要使用@Override重寫

    @Override
    public void walk() {
        System.out.println("學(xué)生走路");
    }

6. 如果父類有自定義構(gòu)造方法,子類的構(gòu)造方法里必須顯示調(diào)用父類的構(gòu)造方法
7. 如果父類有內(nèi)部類,子類中有同名的內(nèi)部類,那么父類中的內(nèi)部類就被屏蔽了;如果非要使用父類中的內(nèi)部類,只能使用全類名

實例

父類

class Person1{
    protected String name;
    protected int age;

    public Person1(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void walk(){
        System.out.println(name+"走路");
    }

    public void eat(){
        System.out.println(name+"吃飯");
    }
}

子類

class Student extends Person1{
    int id;
    String school;

    public Student(String name, int age, int id, String school){
        super(name, age);
        this.id = id;
        this.school = school;
    }

    public void study(){
        System.out.println("name:"+name);
    }

    //方法的重寫
    @Override
    public void walk() {
        System.out.println("學(xué)生走路");
    }

    @Override
    public void eat() {
        System.out.println("學(xué)生吃飯");
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                " name='" + name + '\'' +
                ", age=" + age +
                ", school='" + school + '\'' +
                '}';
    }
}

運用

class TestExtends{
    public static void main(String[] args){
        //Student xw = new Student();
        //xw.name = "Jack";
        //xw.age = 20;
        //xw.id = 001;
        //xw.school = "西南大學(xué)";

        Student xw = new Student("Jack",20,001,"西南大學(xué)");

        xw.walk();

        System.out.println(xw);
    }
}

多態(tài)

多態(tài)是同一種方法，有多種實現(xiàn)的能力；相同于一個方法在不同的子類中有不同的實現(xiàn)

多態(tài)的存在有三個前提：
1.要有繼承關(guān)系
2.子類要重寫父類的方法
3.父類引用指向子類對

實例

class A{
    public void info(){
        System.out.println("in A");
    }
}

class B extends A{
    @Override
    public void info(){
        System.out.println("in B");
    }
}

class C extends A{
    @Override
    public void info(){
        System.out.println("in C");
    }
}

運用

4.png

demo

5.png

public class Person2 {
    protected String name;
    protected int age;

    public Person2(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void walk(){
    }

    public void eat(){
    }
}

class CivilServant extends Person2{
    private int salary;
    private int count;

    public CivilServant(String name, int age,
                        int salary, int count){
        super(name, age);
        this.salary = salary;
        this.count = count;
    }

    @Override
    public void walk() {
        System.out.println("慢慢地走");
    }

    @Override
    public void eat() {
        System.out.println("大吃大喝");
    }


    public void cShow() {
        System.out.println("CivilServant{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", count=" + count +
                '}');
    }
}

class Worker extends  Person2{
    private int salary;
    private String tec;

    public Worker(String name, int age, int salary,
                  String tec){
        super(name, age);
        this.salary = salary;
        this.tec = tec;
    }

    @Override
    public void walk() {
        System.out.println("快跑呢");
    }

    @Override
    public void eat() {
        System.out.println("急匆匆吃");
    }

    public void wShow() {
        System.out.println( "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                ", tec='" + tec + '\'' +
                '}');
    }
}

class Test3{
    public static void main(String[] args){
//        Person[] peoples = new Person[6];
        ArrayList<Person2> peoples = new ArrayList<>();

        Person2 c1 = new CivilServant("小王", 30, 5000, 30);
        Person2 c2 = new CivilServant("小李", 32, 7000, 34);
        Person2 c3 = new CivilServant("張三", 33, 2000, 32);

        //peoples.add((Person2)c1);
        peoples.add(c1);
        peoples.add(c2);
        peoples.add(c3);

        Person2 w1 = new Worker("Jack",23,8922, "Android開發(fā)");
        Person2 w2 = new Worker("Rose",22,10323, "iOS開發(fā)");
        Person2 w3 = new Worker("Merry",20,8123, "web開發(fā)");

        peoples.add(w1);
        peoples.add(w2);
        peoples.add(w3);

        for (Person2 p: peoples){
           //找到p到底是哪個類型的對象
            if(p instanceof CivilServant){
                //公務(wù)員
                CivilServant c = (CivilServant)p;
                c.cShow();
                c.walk();
                c.eat();
            }else{
                //員工
                Worker w = (Worker)p;
                w.wShow();
                w.walk();
                w.eat();
            }
        }
    }
}

心得體會

今天學(xué)習(xí)了子類、父類，明白了繼承是怎么一回事，為以后減少了不少事；但是還是對內(nèi)部類不太明白，還需要消化