java面向对象 接口_27. java面向对象 - 接口

一、定义

/**

* @ Author HuQi

* @ Date 2020/2/1 17:05

* @ Version 1.0

* ---------------------------

*/

/*

* 1.接口的定义

* 2.java中，接口和类是并列结构

* 3.jdk8接口中可以定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

* 4.接口中不能定义构造器。意味着接口不可以实例化

* 5.接口通过让类去实现(implement)的方式来使用

* (1)如果实现类覆盖了接口中所有抽象方法，则此实现类就可以实例化

* (2)如果实现类没有覆盖了接口中所有抽象方法，则此实现类仍为一个抽象类

* 6.java类可以实现多个接口->弥补了java单继承行的局限性

* 7.接口和接口直接可以继承，而且可以多继承

* interface AA{}

* interface BB{}

* interface CC extends AA, BB{}

* */

public class InterfaceTest {

public static void main(String[] args) {

System.out.println(Flyable.Max_SPEED);

Plane plane = new Plane();

plane.fly();

}

}

interface Flyable{

//全局变量

public static final int Max_SPEED = 7990;

public static final int MIN_SPEED = 1;

public abstract void fly();

public abstract void stop();

}

//实现飞的功能，需要将所有抽象方法进行重写

class Plane implements Flyable{

@Override

public void fly() {

System.out.println("通过引擎起飞");

}

@Override

public void stop() {

System.out.println("驾驶员停止");

}

}

//如果未全部覆盖实现类方法，则需要加上abstract

abstract class Kite implements Flyable{

@Override

public void stop() {

System.out.println("放风筝");

}

}

二、示例

​接口使用上提现多态性；

/**

* @ Author HuQi

* @ Date 2020/2/1 17:32

* @ Version 1.0

* ---------------------------

*/

public class USBTest {

public static void main(String[] args) {

Computer computer = new Computer();

//1.创建接口的非匿名实现类的非匿名对象

Flash flash = new Flash();

computer.transferData(flash);

System.out.println("----------------------");

//2.创建了接口的非匿名实现类的匿名对象

computer.transferData(new Printer());

System.out.println("----------------------");

//3.创建接口的匿名实现类的非匿名对象

USB phone = new USB() {

@Override

public void start() {

System.out.println("手机开始工作");

}

@Override

public void stop() {

System.out.println("手机停止工作");

}

};

computer.transferData(phone);

System.out.println("------------------");

//4.创建接口的匿名实现类的匿名对象

computer.transferData(new USB() {

@Override

public void start() {

System.out.println("电视开始工作");

}

@Override

public void stop() {

System.out.println("电视停止工作");

}

});

}

}

class Computer{

//传输数据

public void transferData(USB usb){

usb.start();

System.out.println("具体传输细节");

usb.stop();

}

}

interface USB{

//定义了长、宽

void start();

void stop();

}

class Flash implements USB{

@Override

public void start() {

System.out.println("u盘开启");

}

@Override

public void stop() {

System.out.println("u盘关闭");

}

}

class Printer implements USB{

@Override

public void start() {

System.out.println("printer开启");

}

@Override

public void stop() {

System.out.println("printer关闭");

}

}

--------------------结果--------------------------

u盘开启

具体传输细节

u盘关闭

----------------------

printer开启

具体传输细节

printer关闭

----------------------

手机开始工作

具体传输细节

手机停止工作

------------------

电视开始工作

具体传输细节

电视停止工作

三、接口应用

>[package]Test

..>Circle.class

..>ComparableCircle.class

..>ComparableCircleTest.class

..>CompareObject.interface

1. Circle

package Test;

public class Circle {

private double radius;

public Circle(double radius) {

this.radius = radius;

}

public double getRadius() {

return radius;

}

public void setRadius(double radius) {

this.radius = radius;

}

}

2. CompareObject

package Test;

public interface CompareObject {

/*

* 0：相等

* 正数：当前对象大

* 负数：当前对象小

* */

public int compareTo(Object obj);

}

3. ComparableCircle

package Test;

/**

* @ Author HuQi

* @ Date 2020/2/1 18:14

* @ Version 1.0

* ---------------------------

* 定义一个ComparableCircle类，继承Circle类并实现CompareObject接口

* 在ComparableCircle类中给出接口中方法compareTo的实现体用来比较两圆半径大小

*/

public class ComparableCircle extends Circle implements CompareObject {

//继承父类构造器

public ComparableCircle(double radius){

super(radius);

}

@Override

public int compareTo(Object obj) {

if (this == obj) {

return 0;

}

if (obj instanceof ComparableCircle) {

ComparableCircle c = (ComparableCircle) obj;

if (this.getRadius() > c.getRadius()) {

return 1;

} else if (this.getRadius() < c.getRadius()) {

return -1;

} else {

return 0;

}

} else {

throw new RuntimeException("传入的数据类型不匹配");

}

}

}

4. ComparableCircleTest

package Test;

public class ComparableCircleTest {

public static void main(String[] args) {

ComparableCircle comparableCircleOne = new ComparableCircle(10);

ComparableCircle comparableCircleTwo = new ComparableCircle(10);

int compareValue = comparableCircleOne.compareTo(comparableCircleTwo);

System.out.println(compareValue );

}

}

1.抽象类

类的一种，用 abstract 关键字修饰的类。不能直接创建对象，但可以有构造器，用于子类继承后使用。

2.抽象方法

用 abstract 关键字修饰的方法，没有方法体，必须给子类重写

3.final关键字

>修饰变量：变为常量，接口中必须在声明时进行赋值，后续无法修改。类中可以在构造器中赋值，后续无法修改

>修饰方法：变为最终方法，子类只能调用，不能重写

>修饰类：变为最终类，不能被其他类继承，可以创建对象。例如String

4.接口 - 它和类是统一级别的存在，都是引用类型。

>接口没有构造器，不能直接new对象

>接口中的变量都是公开的静态的常量，默认被 public static final 修饰

>接口中的方法都是抽象方法(不考虑1.8新特性)，默认被 public abstract 修饰

>使用接口时，需要提供一个类去实现接口。关键字 implements 。实现类必须要重写接口中所有的抽象方法

>一个接口可以有多个实现类，一个类可以实现多个接口