Java常見關鍵字及其用法（下）

1. extends
2. abstract
3. interface
4. implement

1.extends關鍵字

繼承：已有類派生新的類，子類繼承父類屬性和行爲，並能夠擴展

class 子類 extends 父類 {}

package com.day3;

/**
 * @author SFJ
 * @date 2019/11/9
 * @time 22:15
 **/
public class Test1 {
    public static void main(String[] args) {
        Student student = new Student(); // 實例化的是子類
        student.setName("桑鳳嬌"); //        Person類的方法（父類方法）
        student.setAge(21); //               Person類定義
        System.out.println("姓名：" + student.getName() + "，年齡：" + student.getAge());
        student.setSchool("聊城大學");
        System.out.println(student.getSchool());
    }
}
class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return this.name;
    }
    public int getAge() {
        return this.age;
    }
}
class Student extends Person { // Student類繼承了Person類
    private String school; // 子類的屬性
    public void setSchool(String school) {
        this.school = school;
    }
    public String getSchool() {
        return this.school;
    }
}

子類繼承父類，將父類定義更加具體化，即父類表示範圍大，子類表示的範圍小

繼承使用時的限制：

1.單繼承：一個子類只能繼承一個父類，但一個父類可被多個子類繼承

1.1錯誤：（不能多重繼承）

class A {}
class B {}
class C extends A,B {}          // 一個子類繼承了兩個父類

1.2正確：(C實際是（孫）子類，實現多層繼承)

class A {}
class B extends A{}            // B類繼承A父類
class C extends B {}          //  C子類繼承B類

2.私有屬性沒法直接訪問： 父類私有屬性，子類沒法直接進行訪問，可是卻發現能夠經過setter、getter方法間接的進行操做。

package com.day3;

/**
 * @author SFJ
 * @date 2019/11/9
 * @time 22:38
 **/
public class Test2 {
    public static void main(String[] args) {
        B b = new B();
        b.setM("sangfnegjiao");
        System.out.println(b.getM());
    }
}
class A {
    private String m;
    public void setM(String msg) {
        this.m = msg;
    }
    public String getM() {
        return this.m;
    }
}
class B extends A {
    public void print() {
        System.out.println(m); // 錯誤: m定義爲private，不可見
    }
}

3.傳遞性： 在繼承關係之中，實例化子類對象，會默認先調用父類構造，爲父類之中的屬性初始化，以後再調用子類構造，爲子類之中的屬性初始化，即：默認狀況下，子類會找到父類之中的無參構造方法。

package com.day3;

/**
 * @author SFJ
 * @date 2019/11/9
 * @time 22:44
 **/
public class Test3 {
    public static void main(String[] args) {
        B1 b1 = new B1();
    }
}
class A1 {
    public A1() {         // 父類無參構造
        System.out.println("父類無參構造方法") ;
    }
}
class B1 extends A1 {
    public B1() {         // 子類構造
        System.out.println("子類構造方法");
    }
}

   默認調用的是無參構造，而若是這個時候父類沒有無參構造，則子類必須經過super()調用指定參數的構造方法:

package com.day3;

/**
 * @author SFJ
 * @date 2019/11/9
 * @time 22:44
 **/
public class Test3 {
    public static void main(String[] args) {
        B1 b1 = new B1();
    }
}
class A1 {
    public A1(String s) {         // 父類無參構造
        System.out.println("父類有參構造方法"+s) ;
    }
}
class B1 extends A1 {
    public B1() {
        super("hello");// 子類構造，super調用父類構造時，必定要放在構造方法的首行上
        System.out.println("子類構造方法");
    }
}

 

2.abstract關鍵字（抽象方法，抽象類）

1. 抽象類：包含抽象方法的類就是抽象類。經過abstract定義規範，而後要求子類必須定義具體實現，經過抽象類，嚴格限制子類的設計，使子類之間更加通用。

2. 抽象方法：使用abstract修飾的方法，無方法體，只聲明。定義的是一種「規範」，就是告訴子類必需要給抽象方法提供具體的實現

注意事項：

1.在抽象方法的類只能定義成抽象類。
2.抽象類不能實例化，即不能用new來實例化對象
3.抽象類可包含屬性、方法、構造方法，但構造方法不能new實例，只能被子類調用。
4.抽象類只能用來被繼承
5.抽象方法必須被子類實現。   

abstract class Bird {// 抽象類:有抽象方法的類必定是抽象類
	
	public abstract void play();// 不要{}的方法,只寫方法的聲明   抽象方法---做用:作了 一個簡單的規則
	public void run() {// 普通方法
		System.out.println("run");
	}
}
 abstract class BadBird extends Bird {// 能夠將子類變成抽象類,可是要想使用當前的類就必須再建立子類,由於抽象類不能直接建立對象
	public void piay() {
		// 重寫方法,寫抽象方法的實現
	}
}

3. interface&& 4.implements

接口是抽象方法和常量值的定義的集合，是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，而沒有變量和方法的實現。

public interface Study{ 
   int id = 1
   public void start()
   public void run()
   public void stop(）    
}

一個抽象類能夠繼承一個抽象類，一個接口卻能夠使用extends同時繼承多個接口（可是接口不能繼承抽象類，由於若是繼承抽象類的話就必須實現其中的抽象方法，而接口中只能是抽象方法）：

package com.day3;

/**
 * @author SFJ
 * @date 2019/11/9
 * @time 23:20
 **/
public class Test4 {
    public static void main(String[] args) {
        C4 c = new C4();
        c.print();	//調用子類實現的方法
        c.info();
    }
}
interface B4 {
    public void info();//定義抽象方法
}
interface A4{
    public void print();
}
class C implements A4 {

    @Override
    public void print() {
        System.out.println("實現接口A4的抽象方法");
    }
}
 class C4 implements A4,B4{
    @Override
    public void print() {
        System.out.println("實現接口A4的抽象方法");
    }
    @Override
    public void info() {
        System.out.println("實現接口B4的抽象方法");
    }
}