Java 08 （接口、多态、final、权限修饰符）

一、接口

1.1接口的多实现

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

  • 多实现格式：
 格式：class 类名 [extends 父类名] implements 接口1，接口2.。。。{
         }
// 必须重写接口中所有的抽象方法，默认方法可重写可不重写
public class dog extends Animal implements Livable,pat{
}

1.如果抽象方法有重名的，重写一次即可（例Livable和pat抽象方法重名，dog类只需重写一次）
2.如果默认方法有重名，必须重写一次
3.当一个类，即继承了父类，又实现了多个接口，父类中的成员方法与接口中默认方法重名（就近原则，继承）
4.存在同名的静态方法不会冲突，因为只能通过接口名去访问静态方法

  • 1.如果抽象方法有重名的，只需重写一次就可以
public interface Liveable {
    //多实现抽象方法重名
    public void show("Show()重写");
}
===================================================
public abstract class Animal implements Liveable{
    @Override
    public void 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();
    }
}

1.2接口的多继承

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

  • 案例：
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
//    }
//}
  • 接口的特点
    接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰
    没有构造方法，所以不能创建对象----------》也就是不能被new
    没有静态代码块

二、多态

  • 概念：同一种行为具有不同的表达形式
  • 前提：
    1.继承或方法的实现
    2.方法的重写
    3.父类引用指向子类对象
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();
    }
}
  • 多态的向上（下）转型

1.向上转型（范围扩大，转成更大类型）
默认的：多态本身是子类类型向父类类型转化的过程
格式：父类类型 对象名 = new 子类对象

int a = 100;
// 变成double类型
double b = a; // b = 100.00
=======================================
Animal cat = new Cat();
cat.eat();

2.向下转型： 父类转成子类的类型（强制转化） 格式：子类类型 对象名 = （子类类型）new 父类对象

double a = 99.9;
int b = (int)a;  //b=99
===================================================
Animal cat = new Cat();
if (cat instanceof Animal){
            Cat c = (Cat) cat;
            c.eat();
}

注意：
1.instanceof 判断对象是或否属于某种类型 是true 否 false
2.转型异常时会发生 ClassCastException

Dog dog = (Dog) cat;
        dog.eat();
  • 转型例子
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("不是父类类型不能强制转换");
        }
    }
}

  • 三、综合案例

案例一：使用笔记本（鼠标，键盘）


public interface USB {
    // 功能:开启，关闭
    void open();//开启功能
    void close();//关闭功能
}
===================================================
public class KeyBoard implements USB{
    //实现USB，输入功能
    public void input(){
        System.out.println("键盘输入");
    }
    @Override
    public void open() {
        System.out.println("键盘开启");
    }
    @Override
    public void close() {
        System.out.println("键盘关闭");
    }
}
=================================================
public class Mouse implements USB{
    //实现USB，点击方法
    public void click(){
        System.out.println("鼠标点击");
    }
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }
    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}
==============================================
public class NoteBookComputer{
    // 功能：运行，关机，使用USB
    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 open() {
        System.out.println("电脑运行");
    }
    public void close() {
        System.out.println("电脑关机");
    }
}
===================================================
public class NoteBookComputerTest {
    public static void main(String[] args) {
        NoteBookComputer noteBookComputer = new NoteBookComputer();
        //开启
        noteBookComputer.open();
        //使用鼠标
        USB mouse = new Mouse();
        noteBookComputer.useUSB(mouse);
        //使用键盘
        USB keyBoard = new KeyBoard();
        noteBookComputer.useUSB(keyBoard);
        // 笔记本关闭
        noteBookComputer.close();
    }
}

案例二：


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:太阳吸引着九大行星旋转");
    }
    @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 star1 = (Sun)sun;
        star1.shine();
    }
}

四、final

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

  • 被修饰的变量不能被重新赋值

1.基本数据类型不能重新赋值

public class FinalDemo1 {
    public static void main(String[] args) {
        //声明一个变量，使用final修饰
        final int a;
        a = 10;
        System.out.println(a);
        /*报错不可重新赋值
        a = 11;
        */
    }
}

2.引用数据类型地址值不能改变

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修饰，只能指向一个对象，地址值是不能改变的
    }
}
  • 成员变量:

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

五、权限修饰符

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。