/**
* 1.什么是接口?
* (1).就是多个类之间的公共规范
* (2)接口就是一个特殊的抽象类型,接口里面的方法都是抽象方法
* (3).接口解决了java单继承的鸡肋
*
* 2.怎么定义一个接口
* public interface 接口名{
*
* }
*
*3.接口的特点
*(1)接口里面的属性都是常量,默认会给你加上“public static final”修饰
*(2)接口里面的方法都是抽象方法,默认会给你加上“public abstract”进行修饰
*(3)接口不能够实例化。
*(4)抽象类是继承,接口是用来实现的
*(5)一个类实现一个接口,必须实现这个接口里面所有的抽象方法(前提这个类不是抽象类)
*(6)一个类可以实现多个接口,中间使用逗号隔开
*(7)接口里面不能定义普通方法
*(8)接口没有构造方法
*(9)接口也可以继承接口,并且可以继承多个接口,接口不能继承普通类,抽象类可以实现接口。
*
*4.实现类
*(1)实现接口的类叫做实现类 class A implements B
*(2)如果一个类继承了一个父类同时需要实现一个接口,继承一定是在实现接口前面
* class E extends D implements C
*/
//交通工具类
public interface Traffic {
// int age=10;//常量
// public static final int Age1=10;
public abstract void start();//这是一个抽象方法
abstract void add();//这也是一个重新方法
public void run();//这是一个抽象方法
void stop();//这也是一个抽象方法
}
public class TestTraffic {
public static void main(String[] args) {
// Traffic t=new Traffic();接口没有构造方法,接口内的方法全部都是抽象方法,只有定义需要继承实现接口,JAVA中一个类可以实现多个接口,接口间用逗号阁开,而且必须实现接口中的每个抽象方法。一个接口也可以有多个类实现,每个实现类都必须要实现接口内的抽象方法,接口可以继承一个或多个接口。
}
}
//交通工具类
public interface Traffic {
// int age=10;//常量
// public static final int Age1=10;
public abstract void start();//这是一个抽象方法
abstract void add();//这也是一个重新方法
public void run();//这是一个抽象方法
void stop();//这也是一个抽象方法
}
Oil是一个接口。
//针对于加油交通工具的接口
public interface Oil {
void addOil();//加油
}
Car实现两个接口
//汽车类
public class Car implements Traffic,Oil {
@Override
public void start() {
System.out.println("汽车启动了....");
}
@Override
public void add() {
System.out.println("汽车加速了....");
}
@Override
public void run() {
System.out.println("汽车开始跑了........");
}
@Override
public void stop() {
System.out.println("汽车停止了...........");
}
@Override
public void addOil() {
System.out.println("汽车加油...........");
}
}
Evs只实现Traffic接口
//电动汽车类
public class Evs implements Traffic {
@Override
public void start() {
System.out.println("电动汽车启动了.......");
}
@Override
public void add() {
System.out.println("电动汽车加速了........");
}
@Override
public void run() {
System.out.println("电动汽车开始跑了.......");
}
@Override
public void stop() {
System.out.println("电动汽车停止了............");
}
}
TestTraffic调用实现接口的类
public class TestTraffic {
public static void main(String[] args) {
// Traffic t=new Traffic();
//多态:接口的引用指向实现类的实例
Traffic car=new Car();
car.start();
car.add();
car.run();
car.stop();
//电动汽车
Traffic evs=new Evs();
evs.add();
evs.start();
evs.run();
evs.stop();
}
}
接口继承接口(可以多个)以及实现类对接口的实现和继承抽象类的Demo
接口A
public interface A {
void f1();
}
接口B
public interface B {
void f2();
}
接口C继承接口A,B
public interface C extends A,B {
void f3();
}
抽象类D
public abstract class D {
public abstract void f4();
}
实现类E
//我想让这个类去继承抽象类并且实现C接口
public class E extends D implements C {
@Override
public void f1() {
// TODO Auto-generated method stub
}
@Override
public void f2() {
// TODO Auto-generated method stub
}
@Override
public void f3() {
// TODO Auto-generated method stub
}
@Override
public void f4() {
// TODO Auto-generated method stub
}
}
比较圆半径的Demo,输出的结果为1
public interface CompareObject {
//比较两个对象
public int compareTo(Object o);
}
public class Circle {
private double radius;//半径
public Circle(double radius) {
super();
this.radius = radius;
}
public Circle() {
super();
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
}
public class ComparableCircle extends Circle implements CompareObject {
public ComparableCircle(double r){
super(r);
}
//实现两个对象的比较
@Override
public int compareTo(Object o) {//o传过来的实参c2
ComparableCircle c2=(ComparableCircle) o;//向下转型
if(this.getRadius()>c2.getRadius()){//this代表当前对象,c1
return 1;//代表当前对象大
}else if(this.getRadius()<c2.getRadius()){
return -1;//代表当前对象小
}else{
return 0;
}
}
}
public class TestInterface {
public static void main(String[] args) {
//创建两个对象
ComparableCircle c1=new ComparableCircle(5);
ComparableCircle c2=new ComparableCircle(4);
int result=c1.compareTo(c2);
System.out.println(result);
}
}
电脑USB识别的Demo,接口的多态
//usb接口
public interface USB {
//打开USB
void open();
//关闭USB
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 void doubleClick(){
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 Computer {
//电脑开机
public void poweron(){
System.out.println("电脑开机.....");
}
//电脑关机
public void poweroff(){
System.out.println("电脑关机.....");
}
//电脑使用usb接口
public void use(USB usb){
//1.打开usb接口
usb.open();
//判断usb接口插入是键盘还是鼠标
if(usb instanceof Mouse){
Mouse mouse=(Mouse)usb;
mouse.click();
mouse.doubleClick();
}else if(usb instanceof KeyBoard){
KeyBoard kb=(KeyBoard)usb;
kb.input();
}
//2.关闭usb接口
usb.close();
}
}
public class TestComputer {
public static void main(String[] args) {
//创建电脑对象
Computer computer=new Computer();
//电脑开机
computer.poweron();
//执行usb的操作
USB mouse=new Mouse();//创建鼠标对象
USB keyBoard=new KeyBoard();//创建键盘对象
computer.use(mouse);
//电脑关机
computer.poweroff();
}
}
- Mouse和Keyboard类都实现了USB接口(接口是不能被实例化的,不同的接口实现类就是多态的表现)
- 在TestComputer测试类中将USB接口引用指向了usbMouse和usbKeyboard对象,其实就是实现多态的描述
- 在Computer类的Use对传入的具体对象作instantceof对象类型判断,这就是运行时多态