Java SE 08(接口的多实现、多继承、多态、final、权限修饰符)

接口的多实现：Java中是单继承多实现，一个类可以实现多个接口；一个类能继承一个父类同时实现多个接口。

多实现的格式：

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

多实现：
1.必须重写接口中所有的抽象方法
2.重写接口中的默认方法
多实现注意：
1.如果抽象方法有重名的，只需重写一次就可以

public interface Liveable {
    //多实现抽象方法重名
    public void show("Show()重写");
}

public interface Pet {
    // 多实现抽象方法重名
    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.如果默认方法有重名的，必须重写一次

public interface Liveable {
    //多实现默认方法重名
    public default void method() {
        System.out.println("Liveable!");
    }
}

public interface Pet {
    //多实现默认方法重名
    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.存在同名的静态方法不会冲突，因为只能通过接口名去访问静态方法
4.当一个类既继承了一个父类，又实现了多个接口，父类中的成员方法与接口中默认方法重名，子类就近执行父类的成员方法

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方法，执行输出为"DDDDDDDDDD"

    //重写method方法，执行C类的method方法
    public void method(){
        System.out.println("CCCCCCCCCC");
    }

}

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

接口的多继承

一个接口可以继承多个接口
如果父接口中默认方有重名的，那么子接口需要重写一次

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() {              //子接口继承父接口 接口默认方法是写default
    }
}

//public class K implements F,G {
//    @Override
 //   public  void method() {  //类接口默认方法是不能写default

//    }
//}

其他成员特点：

1.接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰
2.没有构造方法，所以不能创建对象，也就是不能被new
3.没有静态代码块

多态

1.同一种行为具有不同的表现形式

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) {
    //    多态形式
        Dog dog = new Dog();
     //   格式：父类类型 对象名 = new 子类对象
        Animal dog = new Dog();
        dog.eat();
        Animal cat = new Cat();
        cat.eat();
       }
}

多态的好处（接上面）：

public class DynamicTest {
    public static void main(String[] args) {
  //多态的好处
        Dog dog = new Dog();
        Cat cat = new Cat();
        //调用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.前提：

继承或者实现
方法的重写
父类引用指向子类对象

3.体现：格式：父类类型对象名 = new 子类对象
子类类型对象名 = （子类类型）new 父类对象

多态的转型：

1.向上转型:默认的；多态本身是子类类型向父类类型转化的过程格式：父类类型对象名 = new 子类对象（转成更大的类型）
2.向下转型：父类转成子类的类型（强制转化）格式：子类类型对象名 = （子类类型）new 父类对象
注：
1.instanceof 判断对象是或否属于某种类型是true 否 false
2.转型异常时会发生 ClassCastException

转型案例：

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) {
       //向上转型
        Animal cat = new Cat();
//        cat.eat();
        //向下转型
        //        格式：子类类型 对象名 = （子类类型）new 父类对象
//        Cat cat1 = new Cat();
//        cat1.eat();
        // 注：转型的异常   ClassCastException
        Dog dog = (Dog) cat;
        dog.eat(); //Dog 和 cat 属于Animal下的两个分支，不能强制转换
//instance of 判断对象属于某种类型
//        if (cat instanceof  Animal){
//            Cat c = (Cat) cat;
//            c.eat();
//        }else {
//            System.out.println("不是父类类型不能强制转换");
//        }
        Cat jiaFei = new JiaFei();
        if (jiaFei instanceof Cat){
            JiaFei fei = (JiaFei) jiaFei;
            fei.eat();
        }else {
            System.out.println("不是父类类型不能强制转换");
        }
    }
}

练习1：

练习1

public interface USB {
    void open(); //开启功能
    void close();//关闭功能
}

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标开启，小灯闪闪闪");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭，小灯熄灭");
    }
    public void click(){
        System.out.println("鼠标点击");
    }
}

public class KeyBoard implements USB {

    @Override
    public void open() {
        System.out.println("键盘开启，小彩灯闪闪闪");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭，小灯熄灭");
    }
    public void input(){
        System.out.println("键盘在疯狂的输入");
    }
}

public class Laptop  {
    public void run(){
        System.out.println("笔记本运行中");
    }
    public void useUSB(USB usb){
        //判断是否有usb设备
        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("笔记本关闭");
    }
}

public class LaptopTest {
    public static void main(String[] args) {
        Laptop laptop = new Laptop();
        //开启
        laptop.run();
//        使用鼠标
        USB mouse = new Mouse();
        laptop.useUSB(mouse);
        //使用键盘
        USB keyBoard = new KeyBoard();
        laptop.useUSB(keyBoard);

        //笔记本关闭
        laptop.shutDown();
    }
}

练习2：

练习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:太阳吸引着9大行星旋转");
    }

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

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();
    }
}

练习3：

练习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.开放扩展，关闭修改
2.用于修饰不可改变的内容格式：final class 类名（）
3.修饰对象 :
1）类：被修饰的类不能被继承 final class 类名（）目的是仅限使用，不允许修改
2）方法：被修饰的方法不能被重写 修饰符 final 返回值类型方法名（参数列表）{}
3）变量：被修饰的变量不能被重新赋值

final 修饰变量：

1.局部变量：
-基本类型 :

public class FinalDemo1 {
    public static void main(String[] args) {
        //声明一个变量，使用final修饰
        final int al;
        al = 40;
        System.out.println(al);
        //  al = 20; 报错 不可重新赋值
        final int b = 100;
//        b = 111; 报错 不可重新赋值
//        final int c = 0;
//        for (int i = 0; i < 10; i++) {
//            c = i;
//            System.out.println(c);
//        }
        //可以通过编译，可以运行，c是局部变量每次循环都是创建了一个新的变量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修饰，只能指向一个对象，地址值是不能改变的
        //但是，不影响对象内部成员变量值的修改
       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修饰，只能指向一个对象，地址值是不能改变的
    }
}

2.成员变量:
1)显示初始化

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

2)构造方法初始化

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

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

权限修饰符：

public
protected
default
private

权限修饰符修饰权限

权限使用建议:

1.成员变量使用 private 隐藏细节
2.构造方法使用 public 方便创建对象
3.成员方法使用 public 方便调用方法
注：权限使用建议符合JavaBean