Java SE 08(接口的多實(shí)現(xiàn)、多繼承、多態(tài)、final、權(quán)限修飾符)

接口的多實(shí)現(xiàn)：Java中是單繼承 多實(shí)現(xiàn)，一個(gè)類可以實(shí)現(xiàn)多個(gè)接口 ；一個(gè)類能繼承一個(gè)父類同時(shí)實(shí)現(xiàn)多個(gè)接口。

多實(shí)現(xiàn)的格式：

    class 類名 [extends 父類名] implements 接口1，接口2.。。。{
         }

多實(shí)現(xiàn)：
1.必須重寫接口中所有的抽象方法
2.重寫接口中的默認(rèn)方法
多實(shí)現(xiàn)注意：
1.如果抽象方法有重名的，只需重寫一次就可以

public interface Liveable {
    //多實(shí)現(xiàn)抽象方法重名
    public void show("Show()重寫");
}

public interface Pet {
    // 多實(shí)現(xiàn)抽象方法重名
    public void show();
    }
}


public class Dog extends Animal implements Liveable,Pet {
    @Override
    public void show() {
        System.out.println("show()重寫");
    }
}

public class InterfaceTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
       dog.show();
    }
}

2.如果默認(rèn)方法有重名的，必須重寫一次

public interface Liveable {
    //多實(shí)現(xiàn)默認(rèn)方法重名
    public default void method() {
        System.out.println("Liveable!");
    }
}

public interface Pet {
    //多實(shí)現(xiàn)默認(rèn)方法重名
    public default void method() {
        System.out.println("Pet");
    }
}


public class Dog extends Animal implements Liveable,Pet {
 @Override
    public void method() {
        System.out.println("Dog");
    }
}


public class InterfaceTest {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.method();
    }
}

3.存在同名的靜態(tài)方法不會(huì)沖突，因?yàn)橹荒芡ㄟ^(guò)接口名去訪問(wèn)靜態(tài)方法
4.當(dāng)一個(gè)類既繼承了一個(gè)父類，又實(shí)現(xiàn)了多個(gè)接口，父類中的成員方法與接口中默認(rèn)方法重名，子類就近執(zhí)行父類的成員方法

public interface A {
    public default void method(){
        System.out.println("AAAAAAAAAAAAA");
    }
}

public class D {
    public void method() {
        System.out.println("DDDDDDDDD");
    }
}

public class C extends D implements A {
    //未重寫method方法，執(zhí)行輸出為"DDDDDDDDDD"

    //重寫method方法，執(zhí)行C類的method方法
    public void method(){
        System.out.println("CCCCCCCCCC");
    }

}

public class InterfaceTest1 {
    public static void main(String[] args) {
        C c = new C();
        c.method();
    }
}

接口的多繼承

  • 一個(gè)接口可以繼承多個(gè)接口
  • 如果父接口中默認(rèn)方有重名的，那么子接口需要重寫一次
public interface F {
    public default void method(){
        System.out.println("FFFFFFFFFF");
    }
}

public interface G {
    public default void method(){
        System.out.println("GGGGGGGGGGG");
    }
}

public interface H extends F,G{
    @Override
    default void method() {              //子接口繼承父接口 接口默認(rèn)方法是寫default
    }
}

//public class K implements F,G {
//    @Override
 //   public  void method() {  //類接口默認(rèn)方法是不能寫default

//    }
//}

其他成員特點(diǎn)：

1.接口中，無(wú)法定義成員變量，但是可以定義常量，其值不可以改變，默認(rèn)使用public static final修飾
2.沒(méi)有構(gòu)造方法，所以不能創(chuàng)建對(duì)象，也就是不能被new
3.沒(méi)有靜態(tài)代碼塊

多態(tài)

1.同一種行為具有不同的表現(xiàn)形式

public abstract class Animal {
    public  abstract void eat();
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog 在造狗糧");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat 在喵喵的吃貓糧");
    }
}

  public class DynamicTest {
    public static void main(String[] args) {
    //    多態(tài)形式
        Dog dog = new Dog();
     //   格式：父類類型 對(duì)象名 = new 子類對(duì)象
        Animal dog = new Dog();
        dog.eat();
        Animal cat = new Cat();
        cat.eat();
       }
}
多態(tài)的好處（接上面）：
public class DynamicTest {
    public static void main(String[] args) {
  //多態(tài)的好處
        Dog dog = new Dog();
        Cat cat = new Cat();
        //調(diào)用showCatEat
        showCatEat(cat);
        showDogEat(dog);
                  等于||
        showAnimalEat(dog);
        showAnimalEat(cat);
    }



 public static void showCatEat(Dog dog){
        dog.eat();
    }
    public static void showDogEat(Cat cat){
        cat.eat();
    }
              等于||
    public static void showAnimalEat(Animal animal){
        animal.eat();
    }
}

2.前提：

  • 繼承或者實(shí)現(xiàn)
  • 方法的重寫
  • 父類引用指向子類對(duì)象

3.體現(xiàn)：格式：父類類型 對(duì)象名 = new 子類對(duì)象
子類類型 對(duì)象名 = （子類類型）new 父類對(duì)象

多態(tài)的轉(zhuǎn)型：

1.向上轉(zhuǎn)型:默認(rèn)的；多態(tài)本身是子類類型向父類類型轉(zhuǎn)化的過(guò)程 格式：父類類型 對(duì)象名 = new 子類對(duì)象 （轉(zhuǎn)成更大的類型）
2.向下轉(zhuǎn)型： 父類轉(zhuǎn)成子類的類型（強(qiáng)制轉(zhuǎn)化） 格式：子類類型 對(duì)象名 = （子類類型）new 父類對(duì)象
注：
1.instanceof 判斷對(duì)象是或否屬于某種類型 是true 否 false
2.轉(zhuǎn)型異常時(shí)會(huì)發(fā)生 ClassCastException

轉(zhuǎn)型案例：
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat 在喵喵的吃貓糧");
    }
}

public class JiaFei extends Cat{
    @Override
    public void eat() {
        System.out.println("JiaFei 大口的吃貓糧");
    }

}

public class DynamicTest2 {
    public static void main(String[] args) {
       //向上轉(zhuǎn)型
        Animal cat = new Cat();
//        cat.eat();
        //向下轉(zhuǎn)型
        //        格式：子類類型 對(duì)象名 = （子類類型）new 父類對(duì)象
//        Cat cat1 = new Cat();
//        cat1.eat();
        // 注：轉(zhuǎn)型的異常   ClassCastException
        Dog dog = (Dog) cat;
        dog.eat(); //Dog 和 cat 屬于Animal下的兩個(gè)分支，不能強(qiáng)制轉(zhuǎn)換
//instance of 判斷對(duì)象屬于某種類型
//        if (cat instanceof  Animal){
//            Cat c = (Cat) cat;
//            c.eat();
//        }else {
//            System.out.println("不是父類類型不能強(qiáng)制轉(zhuǎn)換");
//        }
        Cat jiaFei = new JiaFei();
        if (jiaFei instanceof Cat){
            JiaFei fei = (JiaFei) jiaFei;
            fei.eat();
        }else {
            System.out.println("不是父類類型不能強(qiáng)制轉(zhuǎn)換");
        }
    }
}

練習(xí)1：

練習(xí)1
public interface USB {
    void open(); //開啟功能
    void close();//關(guān)閉功能
}

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠標(biāo)開啟，小燈閃閃閃");
    }

    @Override
    public void close() {
        System.out.println("鼠標(biāo)關(guān)閉，小燈熄滅");
    }
    public void click(){
        System.out.println("鼠標(biāo)點(diǎn)擊");
    }
}

public class KeyBoard implements USB {

    @Override
    public void open() {
        System.out.println("鍵盤開啟，小彩燈閃閃閃");
    }

    @Override
    public void close() {
        System.out.println("鍵盤關(guān)閉，小燈熄滅");
    }
    public void input(){
        System.out.println("鍵盤在瘋狂的輸入");
    }
}

public class Laptop  {
    public void run(){
        System.out.println("筆記本運(yùn)行中");
    }
    public void useUSB(USB usb){
        //判斷是否有usb設(shè)備
        if (usb != null){
            usb.open();
            if (usb instanceof Mouse){
                Mouse mouse = (Mouse) usb;
                mouse.click();
            }else if (usb instanceof KeyBoard){
                KeyBoard keyboard = (KeyBoard) usb;
                keyboard.input();
            }
            usb.close();
        }
    }
    public void shutDown(){
        System.out.println("筆記本關(guān)閉");
    }
}

public class LaptopTest {
    public static void main(String[] args) {
        Laptop laptop = new Laptop();
        //開啟
        laptop.run();
//        使用鼠標(biāo)
        USB mouse = new Mouse();
        laptop.useUSB(mouse);
        //使用鍵盤
        USB keyBoard = new KeyBoard();
        laptop.useUSB(keyBoard);

        //筆記本關(guān)閉
        laptop.shutDown();
    }
}

練習(xí)2：

練習(xí)2
public interface Universe {
    void doAnything();
}

public class Star {
    public void shine(){
        System.out.println("star:星星一閃一閃亮晶晶");
    }
}

public class Sun extends Star implements Universe {

    @Override
    public void doAnything() {
        System.out.println("sun:太陽(yáng)吸引著9大行星旋轉(zhuǎn)");
    }

    @Override
    public void shine() {
        System.out.println("sun:光照八分鐘，到達(dá)地球");
    }
}

public class Test {
    public static void main(String[] args) {
        Star star = new Star();
        star.shine();
        System.out.println("==================");
        Universe sun = new Sun();
        sun.doAnything();

        Sun sun1 = (Sun)sun;
        sun1.shine();
    }
}

練習(xí)3：

練習(xí)3
public interface A {
   public abstract void showA();
   private static void show10(String str){
       for (int i = 0; i < 10; i++) {
           System.out.print(str + " \t");
       }
   }
   public static void showB10(){
       System.out.println("static BBBB");
       show10("BBBB");
       System.out.println();
   }

    public static void showC10(){
        System.out.println("static CCCC");
        show10("CCCC");
    }
}

public class B implements A {

    @Override
    public void showA() {
        System.out.println();
        System.out.println("AAA");
    }
    public static void showD(){
        System.out.println("DDDD");
    }
}

public class Test  {
    public static void main(String[] args) {
        A.showB10();
        A.showC10();
        B b = new B();
        b.showA();
        B.showD();
    }

}

final :

1.開放擴(kuò)展，關(guān)閉修改
2.用于修飾不可改變的內(nèi)容 格式：final class 類名（）
3.修飾對(duì)象 :
1）類：被修飾的類不能被繼承 final class 類名（） 目的是僅限使用，不允許修改
2）方法：被修飾的方法不能被重寫 修飾符 final 返回值類型 方法名（參數(shù)列表）{}
3）變量：被修飾的變量不能被重新賦值

final 修飾變量 ：

1.局部變量：
-基本類型 :

public class FinalDemo1 {
    public static void main(String[] args) {
        //聲明一個(gè)變量，使用final修飾
        final int al;
        al = 40;
        System.out.println(al);
        //  al = 20; 報(bào)錯(cuò) 不可重新賦值
        final int b = 100;
//        b = 111; 報(bào)錯(cuò) 不可重新賦值
//        final int c = 0;
//        for (int i = 0; i < 10; i++) {
//            c = i;
//            System.out.println(c);
//        }
        //可以通過(guò)編譯，可以運(yùn)行，c是局部變量每次循環(huán)都是創(chuàng)建了一個(gè)新的變量c
        for (int i = 0; i < 10; i++) {
            final int c = i;
            System.out.println(c);
        }

    }
}

-引用類型:

public class User {
    private String name = "張三";

    public String getName() {
        return name;
    }

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

public class FinalDemo2 {
    public static void main(String[] args) {
        //引用類型的局部變量，被final修飾，只能指向一個(gè)對(duì)象，地址值是不能改變的
        //但是，不影響對(duì)象內(nèi)部成員變量值的修改
       final User user1 = new User(); //user1地址值不能改變
        System.out.println(user1.getName());
////         user1 = new User();
        user1.setName("李四");
        System.out.println(user1.getName());
//        User user = new User();
//        User user1 = new User();
//        System.out.println(user == user1); //false 被final修飾，只能指向一個(gè)對(duì)象，地址值是不能改變的
    }
}

2.成員變量:
1)顯示初始化

public class UserF {
    //顯示初始化
    final String USERNAME = "張三"; //常量所有字母大寫
    private int age;
}

2)構(gòu)造方法初始化

public class UserF2 {
    final String USERNAME;
    private int age;

    public UserF2(String username,int age) {
        this.USERNAME = username;
        this.age = age;
    }
}

權(quán)限修飾符：

  • public
  • protected
  • default

  • private


    權(quán)限修飾符修飾權(quán)限
權(quán)限使用建議:

1.成員變量使用 private 隱藏細(xì)節(jié)
2.構(gòu)造方法使用 public 方便創(chuàng)建對(duì)象
3.成員方法使用 public 方便調(diào)用方法
注：權(quán)限使用建議符合JavaBean

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

友情鏈接更多精彩內(nèi)容