接口interface
基本介绍
接口就是一些没有实现的方法，封装到一起，到某个类要使用时，再根据具体情况把这些方法写出来
语法：interface 接口{ 属性；方法；必须实现的接口的抽象方法}
注意：jdk7.0以前接口中的所有方法都没有方法体（都是抽象方法）。jdk8.0后接口类可以有静态方法，默认方法，即接口中可以有方法的具体实现(需要default关键字修饰)。
在接口中抽象方法可以省略abstract关键字
TestInterface.java
public class TestInterface {
public static void main(String[] args) {
}
}
class A implements Interface{
@Override
public void say() {
System.out.println("hello");
}
}Interface.java
public interface Interface {
// 属性
public int age=18;
// 方法
public void say();
// default修饰。
default public void run(){
System.out.println("running");
}
// static修饰
public static void eat(){
System.out.println("eating");
}
}- 接口不能实例化
- 接口中所有方法是public方法，接口中的抽象方法可以不用abstract修饰，
- 普通类实现接口，必须把接口中所有方法都实现
- 光标放在 class C implements B 按【alt】+【Enter】（回车）快速实现
- 抽象类实现接口时可以不实现接口的抽象方法。
Interface01.java
public interface Interface01 {
public static void main(String[] args) {
System.out.println("这是一个接口的规范");
}
}
interface B{
void sayHi();
void How();
}
//普通类必须实现接口中所有的方法
class C implements B{ // 光标放在 class C implements B 按【alt】+【Enter】（回车）快速实现
@Override
public void sayHi() {
}
@Override
public void How() {
}
}
//class D implements B{}
abstract class D implements B{
// 可以不实现接口中的方法
} - 一个类可以同时实现多个接口
- 接口中的属性只能是final，而且是public static final修饰符（int a=1；实际上是public static final int a=1且必须初始化）
- 接口中属性的访问形式：接口名.属性名
- 接口不能继承其他类，但是可以继承多个接口
- 接口的修饰符只有public和默认
Interface01.java
public interface Interface01 {
public static void main(String[] args) {
System.out.println(A.num);//静态属性的功能
//A.num=13; 不能修改，final修饰符的功能
}
}
interface A{
int num=12;
void say();
void hi();
}
interface B{
void run();
}
class Person implements A,B {
@Override
public void say() {
}
@Override
public void hi() {
}
public void run() {
}
}
//class C extends B,A{}接口不能继承类，可以继承多个其他接口
interface C extends B,A{}实现接口与继承类
继承主要功能在于解决了代码的复用性和可维护性。
接口主要功能在于设计（规范）好各种方法，让其它类去实现这些方法。
Java提供的单继承机制是对单继承的一种补充。
- 当子类继承了父类，就自动拥有了父类的功能
- 如果子类需要扩展功能，可以通过实现接口的方式扩展更加灵活
- 接口在一定程度上可以实现代码解耦，即：接口规范化+动态绑定机制。
ExtendsAndInterface.java
public class ExtendsAndInterface {
public static void main(String[] args) {
AMonkey Wukong = new AMonkey("悟空");
Wukong.climbing();
Wukong.flying();
Wukong.swimming();
}
}
// 继承
class Monkey{
private String name;
public Monkey(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void climbing(){
System.out.println(name+"会爬树。。");
}
}
//class AMonkey extends Monkey{
class AMonkey extends Monkey implements Fishable,Birdable{// 接口多继承
public AMonkey(String name) {
super(name);
}
//实现从接口获得的能力
public void swimming(){
System.out.println(getName()+"通过继承接口Fishable，获得了游泳能力");
}
@Override
public void flying() {
System.out.println(getName()+"通过继承接口Birdable，获得了飞行能力");
}
}
// 接口（学习能力）
interface Fishable{
void swimming();
}
interface Birdable{
void flying();
}接口的多态性质
多态参数
既可以接受camera对象也可以接收phone对象；体现接口多态。
USB.java
public interface USB {
public void start();
public void stop();
}Phone.java
public class Phone implements USB{
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
}Camera.java
public class Camera implements USB{
@Override
public void start() {
System.out.println("相机开始工作");
}
@Override
public void stop() {
System.out.println("相机停止了工作");
}
}Computer.java
public class Computer {
public void work(USB usb){
usb.start();
usb.stop();
}
}TestUsb.java
public class TestUsb {
public static void main(String[] args) {
Phone phone = new Phone();
Camera camera = new Camera();
Computer computer = new Computer();
computer.work(camera);
computer.work(phone);
}
}接口多态体现
接口类型的变量a可以指向实现了接口A的对象实例
Test.java
public class Test {
public static void main(String[] args) {
A a = new B();
a = new C();
}
interface A {
}
static class B implements A {
}
static class C implements A {
}
}多态数组
接口类型数组
Test.java
public class Test {
public static void main(String[] args) {
A[] a = new A[2];
a[0]=new B();
a[1]=new C();
for (int i=0;i< a.length;i++){
a[i].doing();
// a[i].say(); 需要进行类型转换
if (a[i] instanceof B){
((B)a[i]).say();
}
}
}
interface A {
void doing();
}
static class B implements A {
public void say(){
System.out.println("这是一个实现了接口A的B类");
}
@Override
public void doing() {
System.out.println("B类正在实现中");
}
}
static class C implements A {
public void run(){
System.out.println("C类的run方法");
}
@Override
public void doing() {
System.out.println("C类正在实现中");
}
}
}多态传递
DemoPolyPass.java
public class DemoPolyPass {
public static void main(String[] args) {
Inter02 i2=new Person();
// Inter01 i1=new Person(); Inter02未继承Inter01时无法使用
// 如果Inter02继承了Inter01，而Person类实现了Inter02，实际上Person类也实现了Inter01接口
Inter01 i1=new Person();
}
}
interface Inter01{}
interface Inter02 extends Inter01{}
class Person implements Inter02{}属性冲突
Demo.java
public class Demo {
public static void main(String[] args) {
new C().show();
}
}
interface A{
int x=1;
}
class B{
int x=2;
}
class C extends B implements A{
public void show(){
// System.out.println(x);
// 不明确x是指的是哪一个
// 访问接口的x用A.x
System.out.println("接口的x="+A.x);
// 访问父类的x用super.x
System.out.println("父类的x="+super.x);
}
}
