一繼承

1.1概念

繼承就是子類（派生類）繼承父類（基類）的屬性和行為，使得子類對象具有父類相同的屬性(成員變量)和行為（成員方法）狈谊，子類還可以訪問父類中非私有的屬性和行為喜命。

class 父類{}
class 子類 entends 父類{}

1.2 繼承的特點

1.Java只支持單繼承，不是多繼承（C++河劝，Python),一個類只有一個父類
2.Java支持多層繼承壁榕，頂級父類是Object類，所有的類默認都繼承Object類赎瞎，作為父類
3.子類和父類是一種相對的概念

繼承可以提高代碼的復用性

案例一：發(fā)紅包

// 用戶類
public class User {
    private String name;
    private int money;
    public User(){

    }
    public User(String name, int money){
        this.name = name;
        this.money = money;
    }
    //顯示當前用戶有多少錢
    public void show(){
        System.out.println("我叫" + this.name + "牌里，我有" + this.money + "錢");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

// 成員類
public class Member extends User {
    public Member() {
    }

    public Member(String name, int money) {
        super(name, money);
    }
    // 收紅包
    public void receive(ArrayList<Integer> list){
        // 從眾多的紅包中隨機選一個 ，獲取隨機索引
        int index = new Random().nextInt(list.size());
        // 根據(jù)索引务甥，從集合中刪除領(lǐng)完的那個紅包
//        int receiveMoney = list.get(index);
//        list.remove(index);
        int delMoney = list.remove(index);
        // 查看當前會員有多少前
        int money = super.getMoney();
        // 重新設(shè)置一個余額
        super.setMoney(money+delMoney);
    }
}

// 群主類
public class Manager extends User{
    public Manager(){

    }
    public Manager(String name, int money){
        super(name, money);
    }
    //定義發(fā)紅包
    public ArrayList<Integer> send(int totalMoney, int count){
        int lastRedBag = 0;
        ArrayList<Integer> list = new ArrayList<>();
        //查看群主有多少錢二庵，余額不足要告訴一下
        int leftMoney = super.getMoney();
        if(totalMoney > leftMoney){
            System.out.println("您的余額不足");
            return list;
        }
        //扣錢
        super.setMoney(this.getMoney() - totalMoney);
        //發(fā)紅包將紅包分成count份
        int oneRedBag = totalMoney/count;
        //如果除不開贪染，將零頭放到最后一個紅包里
        if(totalMoney % count != 0){
            lastRedBag = totalMoney - (count - 1) * oneRedBag;
        }else{
            lastRedBag = oneRedBag;
        }
        //將余額一個一個放到集合中
        for (int i = 0; i < count; i++) {
            if(i != count-1){
                list.add((int)oneRedBag);
            }else{
                list.add(lastRedBag);
            }
        }
        return list;
    }
}

測試類
public class MainRedPacket {
    public static void main(String[] args) {
        System.out.println("============");
        System.out.println("當前顯示群里所有人的余額");
        // 一個群主100缓呛，三個成員0催享，0，0
        Manager manager = new Manager("群主", 100);
        Member member1 = new Member("一號成員", 0);
        Member member2 = new Member("二號成員", 0);
        Member member3 = new Member("三號成員", 0);
        manager.show();
        member1.show();
        member2.show();
        member3.show();
        System.out.println("============");
        System.out.println("請群主輸入要發(fā)紅包的金額"); //20  //8哟绊，6因妙，6
        int money = new Scanner(System.in).nextInt();
        //發(fā)紅包
        ArrayList<Integer> list = manager.send(money, 3);
        //收紅包
        member1.receive(list);
        member2.receive(list);
        member3.receive(list);
        //顯示余額
        manager.show();
        member1.show();
        member2.show();
        member3.show();
    }
}

1.3 子類中訪問父類的內(nèi)容

語法結(jié)構(gòu) ：
1: super(當前類名稱,self).你要調(diào)的父類的屬性或方法
2： super().你要調(diào)的父類的屬性或方法
3: 你要調(diào)的父類的屬性或方法(self)

1.4 繼承后子類和父類的變化

繼承相關(guān)圖示

成員變量不重名：
如果子類父類中出現(xiàn)不重名的成員變量，訪問時沒有影響的
成員變量重名:
有影響票髓，new子類時候調(diào)用的是子類的成員變量攀涵，想要調(diào)用父類的，要用super關(guān)鍵字洽沟，就像本類使用this一樣以故。（父類中成員變量私有，我們可以通過get裆操，set方法訪問父類的成員變量）

案例二：

// 父類
public class Fu {
     int num = 5;
     }
}

// 子類
public class Zi extends Fu {
    int num = 6;
    public void show(){
        //想調(diào)用父類的成員變量怒详，需要在前面加 super，不加super的話num = 6
        System.out.println("Fu num =" + num); //num = 6  , super.num = 5
        System.out.println("Zi num =" + num); // num = 6  , this.num = 6
    }
}

// 測試類
public class ExtendDemoTest02 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show();
    }
}

此時子類和父類的成員變量重名踪区，調(diào)用show（）方法昆烁，輸出的num都是子類的成員變量。想要調(diào)用父類的缎岗，要用super關(guān)鍵字静尼，例 super.num。

成員方法不重名沒影響传泊，對象在調(diào)用方法時鼠渺，會在子類中查找有沒有對應的方法。沒有就會去父類中找相應的方法去執(zhí)行
成員方法重名子類中出現(xiàn)與父類一模一樣的方法（返回值類型眷细，方法名拦盹，參數(shù)列表都相同）---》會出現(xiàn)覆蓋效果（也叫復寫）----》聲明不變，重新實現(xiàn)薪鹦。

案例一：

// 父類
public class Fu {
     int num = 5;
     public void show(){
         System.out.println("父類的show方法執(zhí)行");
     }
}

// 子類
public class Zi extends Fu {
    int num = 6;
    //重寫 父類的方法建議使用該注解進行標識
    @Override
    public void show(){
        //想調(diào)用父類的成員變量掌敬，需要在前面加 super，不加super的話num = 6
        System.out.println("子類show方法被執(zhí)行");
    }
}

// 測試類
public class ExtendDemoTest04 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.show(); //子類show方法被執(zhí)行
    }
}

案例二：新手機添加來電顯示功能和頭像顯示功能

// 手機類
public class Phone {
    public void sendMessage(){
        System.out.println("發(fā)短信");
    }
    public void call(){
        System.out.println("打電話");
    }
    public void showNum(){
        System.out.println("來電顯示");
    }
}

// 新型手機
public class NewPhone extends Phone{
    //重寫父類的來電顯示功能池磁，并且增加自己的的顯示姓名和圖片功能
    @Override
    public void showNum(){
        //調(diào)用父類已經(jīng)存在的功能使用super
        super.showNum();
        System.out.println("顯示來電姓名");
        System.out.println("顯示頭像");
    }
}

構(gòu)造方法
因為構(gòu)造方法的名字和類名一致奔害，所以子類無法繼承父類的構(gòu)造方法。構(gòu)造方法的作用是初始化成員變量地熄，所以子類初始化的過程中华临，必須先執(zhí)行父類的初始化動作，子類的構(gòu)造方法默認有一個super()端考，表示調(diào)用父類的構(gòu)造方法雅潭，父類成員變量初始化后揭厚，才可以給子類使用。

案例一：

// 父類
public class FuGou {
    private int n;
    FuGou(){
        System.out.println("FuGou()");
    }
}

// 子類
public class ZiGou extends FuGou {
    ZiGou(){
        // 子類構(gòu)造方法默認調(diào)用父類構(gòu)造方法
//        super();
        System.out.println("ZiGou()");
    }
}

測試類
public class ExtendDemoTest07 {
    public static void main(String[] args) {
        FuGou fuGou = new FuGou(); // FuGou()
        ZiGou ziGou = new ZiGou(); // FuGou() ZiGou()
    }
}

案例二：

// 父類
public class Animal {
    Animal(){
        System.out.println("Animal()");
    }
    public void eat(){
        System.out.println("animal:eat");
    }
}

// 子類
public class Cat extends Animal{
    private String name;
    //無參構(gòu)造函數(shù)
    Cat(){
        super();
        System.out.println("Cat()");
    }
    Cat(String name){
        // super();子類中每個均右super()扶供，用來調(diào)用父類空參構(gòu)造
        //手動調(diào)用父類的super()筛圆，會覆蓋默認的super()
        //super()和this()都必須在構(gòu)造方法的第一行
        super();
        //調(diào)用本來的構(gòu)造方法
        // this()
        this.name = name;
        System.out.println("Cat" + name);
    }
    @Override
    public void eat(){
        System.out.println("cat:eat");
    }
    public void eatTest(){
        this.eat(); // this 調(diào)用本類的方法
        super.eat();
    }
}

// 測試類
public class ExtendDemoTest08 {
    public static void main(String[] args) {
//        Animal animal = new Animal();
//        animal.eat();
        Cat cat1 = new Cat("淘氣貓"); //Animal()  Cat淘氣貓
//        cat.eatTest();
    }
}

子類中每個均有super()，用來調(diào)用父類空參構(gòu)造
手動調(diào)用父類的super()椿浓，會覆蓋默認的super()
super()和this()都必須在構(gòu)造方法的第一行太援，所以兩者不能同時出現(xiàn)

1.5 抽象類

定義

1.抽象方法：沒有方法主體的方法（沒有{}
2.抽象方法的格式：使用abstract修飾的方法，就成了抽象方法扳碍，抽象方法只包含一個方法名提岔，而沒有方法體。
3.格式：修飾符 abstract 返回值類型方法名（參數(shù)列表）;

public abstract void run();

抽象類： 如果一個類包含抽象方法笋敞，那么該類必須是抽象類

public abstract class AnimalAb {
    //定義格式
    public abstract void run();
}

抽象類的使用： 繼承抽象類的子類必須重寫父類的所有抽象方法碱蒙，否則該子類也必須是抽象類。最終必須有子類實現(xiàn)父類的抽象方法夯巷，否則從最初的父類到最終的子類都不能被new（創(chuàng)建）赛惩，失去了意義。

二接口（Interface）

概述： Java中的一種引用類型鞭莽，是方法的集合
接口主要封裝了方法

1.JDK1.7及以前包含抽象方法
2.JDK8 默認方法和靜態(tài)方法
3.JDK9 私有方法

定義

1.與類定義相似坊秸，使用interface修飾，也會編譯成.class文件澎怒，但是接口不是類褒搔，而是另外一種引用數(shù)據(jù)類型
2.使用：不能被創(chuàng)建，但是可以被實現(xiàn)（implements,類似于extends）一個接口可以多實現(xiàn)
3.一個實現(xiàn)接口的子類需要實現(xiàn)接口所有的抽象方法喷面，否則它就必須是一個抽象類

類與接口的實現(xiàn)關(guān)系

類實現(xiàn)接口星瘾，該類成為接口的實現(xiàn)類，也可以稱為接口的子類惧辈，使用implements關(guān)鍵字

public class B implements A {
    //重寫所有的抽象方法【必須】
    ///重寫默認方法【可選】
}

接口格式

public interface 接口名{
  //抽象方法
 //默認方法
 //靜態(tài)方法
 //私有方法
}

public interface A {
    //抽象方法
      public abstract void method();

    //默認方法 使用default修飾琳状，不可以省略
    //功能是供子類調(diào)用或者子類重寫
      public default void method(){
          //執(zhí)行語句
     }

     //靜態(tài)方法 使用static修飾，供接口直接調(diào)用
   public static void method2(){
        //執(zhí)行語句
    }

    //私有方法
//含有私有方法和私有靜態(tài)方法 ： 使用private修飾盒齿，供接口中的默認方法或者靜態(tài)方法調(diào)用
    private void method(){
    }

}

案例一：

public interface Livable {
    //定義抽象方法
    public abstract void eat();
    public void sleep();
}

public class AnimalLivable implements Livable{
    @Override
    public void eat() {
        System.out.println("吃");
    }

    @Override
    public void sleep() {
        System.out.println("睡");
    }
}

public class InterfaceDemoTest {
    public static void main(String[] args) {
        AnimalLivable animalLivable = new AnimalLivable();
        animalLivable.eat();
        animalLivable.sleep();
    }
}

案例二：

public interface Livable1 {
    public default void fly(){
        System.out.println("天上飛");
    }
}

public class AnimalLivable1 implements Livable1{
    @Override
    public void fly(){
        System.out.println("驕傲的飛飛飛");
    }
}

public class InterfaceDemoTest01 {
    public static void main(String[] args) {
        AnimalLivable1 animalLivable1 = new AnimalLivable1();
        animalLivable1.fly();
    }
}

Java七（繼承埠况，接口，抽象類）

Java七（繼承棵癣，接口辕翰，抽象類）

一繼承

1.1概念

1.2 繼承的特點

1.3 子類中訪問父類的內(nèi)容

1.4 繼承后子類和父類的變化

1.5 抽象類

二接口（Interface）

Java七（繼承棵癣，接口辕翰，抽象類）

一 繼承

1.1概念

1.2 繼承的特點

1.3 子類中訪問父類的內(nèi)容

1.4 繼承后子類和父類的變化

1.5 抽象類

二 接口（Interface）

一繼承

二接口（Interface）