Java 基礎_06_繼承、重寫、多態

1：繼承

Java的一大特色：

   跨平臺。

代碼的三個特色：

   繼承，多態、封裝。

1.1、Java對象的組成部分

package cn.domain;

 

public class Person {

    private String name;//這成員變量>屬性

    private Integer age;

    private String skinColor;

    public void say() { //方法對外公開提供的服務

        System.err.println("Hello..");

    }

}

1.2、對象之關係

組合：

//計算機類

class Computer{//組合- DIY

    private Cpu cpu;

    private Screen screen;

}

 

class Cpu{

   

}

class Screen{

   

}

 

依賴：

//計算機類

class Computer{//組合- DIY

    private Cpu cpu;

    private Screen screen;

    public void run(){

        //若是一個類，在方法裏，使用了另外一個類，此時就是叫：Computer依賴於USB這個類。

        USB usb = new USB();

    }

}

2：繼承

   在Java裏面一個類繼承另外一個類用的是 extends 關鍵字：

 

從父類中繼承的是public、protected的方法與屬性：

class Father{

    public String name = "Jack";

    protected String addr = "濟南";

    String hobby = "Football";

    private String tel = "12899";

   

    public void say(){

        System.err.println("hi im father..");

    }

   

    protected void hi(){

        System.err.println("hi im father.222.");

    }

   

}

class Child extends Father{

   

}

繼承	public	protected	默認
同一個包中	繼承	繼承	繼承
不一樣的的包中	繼承	繼承	不能繼承

//若是子類擁有相同 的父類的成員屬性與方法則在調用時先調用子類的

class Child extends Father{

    public String name = "Mike";

    protected String addr = "山東";

    String hobby = "MATV";

   

    public void say(){

        System.err.println("hi im child..");

    }

   

    protected void hi(){

        System.err.println("hi im child.222.");

    }

}

3：重寫 Overried

子類的方法與父類的方法重名：

  要求：

   1：子類與父類方法重名。

   2：了類的方法與父類的方法的參數類型，順序，個數 徹底同樣。

   3：子類權限修飾符號，不縮小，但能夠放大。

4：多態

1：類型轉換

   public class Demo03 {

    @Test

    public void test1(){

        //本身的類型=本身的對象

        Dog dog = new Dog();

        //讓dog對象賦值給Animal

        Animal a1 = dog;//能夠

        //讓大類型賦值給小類型,在編譯時a1是Animal類型 dog2是Dog小類型，但a1本質就是dog

        Dog dog2 = (Dog)a1;

       

        System.err.println("Over..");

    }

}

class Animal{

   

}

class Dog extends Animal{

   

}

class Cat extends Animal{

   

}

--

    @Test

    public void test1() {

        //父類型的變量= 子類型的實例

        Animal a1 = new Dog();

        Dog dog2 = (Dog)a1;

        System.err.println("over..");

       

        //a2本質是一個動物

        Animal a2 = new Animal();

        //此時會出現運行時錯誤 - 由於a2本質 是指向的Animal的實例

        Dog dog3 = (Dog) a2;

       

        System.err.println("若是運行出錯，則此行代碼不顯示");

    }

 

2：動態調用

   是指在運行時動態的調用子類的非靜態的方法。

 

package cn.demo;

 

import javax.sound.midi.SysexMessage;

 

import org.junit.Test;

 

public class Demo03 {

    @Test

    public void test1() {

        //類型  變量   對象

        Animal a = new Dog();

        a.say();//實例方法【非靜態的方法】與對象綁定-動態綁定

        System.err.println(a.name);//Jack - 成員變量 與類型綁定 - 靜態綁定

        a.hi();//靜態的方法與變量的類型綁定

    }

}

 

class Animal {

    public String name = "Jack";

    public void say(){

        System.err.println("不知道是什麼動物");

    }

    public static void hi(){

        System.err.println("hi11111......");

    }

}

 

class Dog extends Animal {

    public String name = "Mary";//成員變量不會覆蓋

    @Override

    public void say() {//重寫覆蓋 - 只有實例方法纔會有多態的概念

        System.err.println("wwwwww......");

    }

   

    public static void hi(){

        System.err.println("hi2..............");

    }

}

5：繼承與Object類

在Java代碼中，java.lang.Object是全部類的最高父類。全部類默認都是這個類的子類。

 

能夠經過

   Instanceof – 是否是某種類型

public class Demo03 {

    @Test

    public void test1() {

        Dog xy = new Dog();

        System.err.println("xy是DOg類型的嗎："+(xy instanceof Dog));//true

        System.err.println("xy是animal類型的嗎："+(xy instanceof Animal));//true

        System.err.println("xy是東西："+(xy instanceof Object));//true

        //在比較時，instanceof比較的對象必需要有繼承的關係，不然出錯

        System.err.println("xy是cat嗎："+(xy instanceof Cat));

    }

}

 

class Animal {

}

 

class Dog extends Animal {

}

class Cat{

   

}

6：從Obejct裏面都繼承的什麼方法

 

全部類，都擁有toString方法，它們是Object類裏面繼承的。

若是子類沒有重寫toString方法則調用父類。

 

默認的ObObject類裏面的toString顯示的是：

   public String toString() {

         類的名稱                         @      轉成16進制            內部地址值

        return getClass().getName() + "@" + Integer.toHexString(hashCode());

    }

 

對於toString:

  1:全部類都擁有這個方法，繼承的。

  2：若是將一個類與字符串串聯，默認就調用這個方法。或是輸出某個對象默認也調用個方法

 

7：equals

比較兩個對象的內部內容是否同樣

=-= 是比較兩個對象的內存地址是否同樣。

 

public class Demo03 {

    @Test

    public void test1() {

        String str1 = new String("Hello");

        String str2 = new String("Hello");

        System.err.println("內存地址是否同樣:"+(str1==str2));//false

        System.err.println("裏面的內容是否同樣："+str1.equals(str2));//true

 

    }

}

 

開發一個本身的對象：

 

在Object類裏面源代碼是：

     */

    public boolean equals(Object obj) {

        return (this == obj);   - 內部默認依然是比較內存地址

    }

 

  s1.equals(s2);

 

如何才能夠比較裏面的內容：

package cn.demo;

 

import org.junit.Test;

 

public class Demo04 {

    @Test

    public void test1() {

        Student s1 = new Student("Jack",23);

        Student s2 = new Student("Jack",33);//做業：當age,name徹底 同樣纔是true不然就false

        System.err.println("兩個學生的內存是否同樣:" + (s1 == s2));// false

        boolean boo = s1.equals(s2);

        System.err.println("兩個學生的內容同樣:" + boo);// true

 

        Dog dog = new Dog();

        boo = s1.equals(dog);

        System.err.println(boo);// true | false

    }

}

 

class Student {

    private String name;

    private Integer age;

 

    public Student(String name,Integer age) {

        this.name = name;

        this.age=age;

    }

 

    @Override

    public boolean equals(Object obj) {

        // 1:比較兩個對象地址是否同樣，若是地址同樣，則內容必定同樣

        if (this == obj) {

            return true;

        } else {// 再比較裏面的內容

            if (obj instanceof Student) {

                Student s2 = (Student) obj;

                if (this.name.equals(s2.name)) {

                    return true;

                } else {

                    return false;

                }

            }else{

                return false;

            }

        }

    }

}

 

class Dog {

 

}