final关键字与接口

一.final关键字

1.基本介绍

final可以修饰类、属性、方法和局部变量。

1）final修饰的类不可以被继承

2）修饰的父类方法不可以被子类重写

注：如果final没有修饰的类，但是类中方法有被修饰，虽然不可以被重写，但是可以被继承使用。

3）修饰类的属性值不可以被修改

4）修饰的局部变量不可以被修改

2.注意事项和使用细节

1）final修饰的属性又叫常量

2）final修饰的属性在定义时必须赋值，并且以后不可以被修改

3）如果final修饰的属性是静态的，则初始化的位置只能是定义时和静态代码块中，不能在构造器中赋值

4）final类不能继承，但是可以实例化。

5)一般来说，final已经修饰类了，就没有必要再修饰类中的方法了；

6）不能修饰构造器；

7）final和static搭配使用效率更高；

8）包装类（Integer Double Float Boolean）都是final类，String也是final类。

二.接口interface

1.基本介绍

接口就是给出一些实现的方法，封装到一起，当某个类在使用的时候，再根据具体情况把这些方法写出来。

语法：interface 接口名{

属性

抽象方法（接口中的抽象方法不用关键字声明）

}

class 类名 implements 接口{

自己属性；

自己方法；

必须实现的接口的抽象方法

}

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低耦合的设计思想。

2.注意事项和细节

1）接口不能被实例化。

2）接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰。

3）一个普通类实现接口，就必须将该接口的所有方法都实现。

4）抽象类实现接口，可以不用实现接口的方法。

5）一个类同时可以实现多个接口。

6）接口中的属性，只能是final的，而且是public static final 修饰符。

7）接口中属性的访问形式：接口名.属性名。

8）接口不能继承其它的类，但是可以继承多个别的接口。

9）接口的修饰符 只能是public 和默认，这点和类的修饰符是一样的。

package com.study.interface_;

public interface Usb {
    public void start();
    public void stop();
}

首先我们有了接口，规定了两个方法

package com.study.interface_;

public class Camera implements Usb{

    @Override
    public void start() {
        System.out.println("相机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("相机结束工作");
    }
}

package com.study.interface_;

public class Phone implements Usb{
    @Override
    public void start() {
        System.out.println("手机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("手机结束工作");
    }
}

定义了两个类，把接口方法都进行了完善

package com.study.interface_;

public class Interface01 {
    public static void main(String[] args) {
        Camera camera = new Camera();
        Phone phone = new Phone();
        Computer computer = new Computer("联想小新");
        computer.work(camera);
        computer.work(phone);
    }
}
class Computer{
    private String name;

    public Computer(String name) {
        this.name = name;
    }
    public void work(Usb usb){
        usb.start();
        usb.stop();
    }
}

实例化对象调用接口方法

3.实现接口vs继承类

实现接口相当于继承类的一个拓展。

接口比继承更加灵活，继承是满足is-a的关系，而接口只需要满足like-a的关系。

接口在一定程度上实现了代码解耦【即：接口规范性+动态绑定机制】

package com.study.interface_;

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LitterMonkey litterMonkey = new LitterMonkey("小猴子");
        litterMonkey.climbing();
        litterMonkey.swimming();
        litterMonkey.fiying();
    }
}
class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }
    public void climbing(){
        System.out.println(name + "会爬树,继承的大猴子技能");
    }

    public String getName() {
        return name;
    }
}
class LitterMonkey extends Monkey implements Fishable,Birdable{

    public LitterMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName()+"通过学习，学会了游泳");
    }

    @Override
    public void fiying() {
        System.out.println(getName()+"通过学习，学会了飞翔");
    }
}
interface Fishable{
    public void swimming();
}
interface Birdable{
    public void fiying();
}

 

 接口引用可以指向实现了接口的类的对象

package com.study.interface_;

public class InterfacePolyArr {
    public static void main(String[] args) {
        Usb_[] usb_s = new Usb_[2];
        usb_s[0] = new Camera_();
        usb_s[1] = new Phone_();
        for (int i = 0; i < usb_s.length; i++) {
            usb_s[i].work();
            if (usb_s[i] instanceof Phone_){
                ((Phone_) usb_s[i]).call();
            }
        }
    }
}

class Camera_ implements Usb_{
    @Override
    public void work() {
        System.out.println("相机开始工作");
    }
}
class Phone_ implements Usb_{
    @Override
    public void work() {
        System.out.println("手机开始工作");
    }
    public void call(){
        System.out.println("接电话888");
    }
}
interface Usb_{
    public void work();
}

接口存在多态传递现象，举例如下：

package com.study.interface_;

public class InterfacePolyPass {
    public static void main(String[] args) {
        Wolf wolf = new Teacher();
        AG ag = new Teacher();
    }
}

interface AG {
    void hi();
}

interface Wolf extends AG{
}

class Teacher implements Wolf {

    @Override
    public void hi() {

    }
}