接口

public interface Paintable {
    void draw();        // 定义接口方法可省略 public abstract 关键字
}
javaCopied!

public class Parallelogram extends Quadrangle implements Paintable {
    ...
}
javaCopied!

interface Paintable { // 可绘制接口
	public void draw(); // 绘制抽象方法
}

class Quadrangle { // 四边形类
	public void doAnything() {
		System.out.println("四边形提供的方法");
	}
}

//平行四边形类,继承四边形类，并实现了可绘制接口
class Parallelogram extends Quadrangle implements Paintable {
	public void draw() { // 由于该类实现了接口，所以需要覆盖draw()方法
		System.out.println("绘制平行四边形");
	}
}

//正方形类,继承四边形类，并实现了可绘制接口
class Square extends Quadrangle implements Paintable {
	public void draw() {
		System.out.println("绘制正方形");
	}
}


//圆形类,仅实现了可绘制接口
class Circular implements Paintable {
	public void draw() {
		System.out.println("绘制圆形");
	}
}

public class Demo7 {
	public static void main(String[] args) {
		Square s = new Square();
		s.draw();
		s.doAnything();

		Parallelogram p = new Parallelogram();
		p.draw();
		p.doAnything();

		Circular c = new Circular();
		c.draw();
	}
}
javaCopied!

     绘制正方形
     四边形提供的方法
     绘制平行四边形
     四边形提供的方法
     绘制圆形
bashCopied!

class 类名 implements 接口1,接口2,...,接口n {
  ...
}
bashCopied!

interface DadLike {        // 爸爸喜欢的
    void watchTV();        // 看电视
    void fish();
}
javaCopied!

interface MonLike {       // 妈妈喜欢的
    void shop();          // 购物
    void draw();
}
javaCopied!

public class ChildLike Things implements MomLike,DadLike {
    // 继承了爸爸喜欢的
    @Override
    public void watchTV() {
        System.out.println("我喜欢看动画片");
    }

    @Override
    public void fish() {
        System.out.println("我爱掉鱼缸里的鱼");
    }

    // 继承了妈妈喜欢的
    @Override
    public void shop() {
        System.out.println("我爱去逛超市");
    }

    @Override
    public void draw() {
        System.out.println("我爱画大房子");
    }
}
javaCopied!

interface 接口1 extends 接口2 {
  ...
}
bashCopied!

interface FatherLike {        // 父接口
    void fatherMethod();      // 父接口方法
}

interface ChildLike extends FatherLike {  // 子接口，继承父接口
    void ChildLikeMethod();   // 子接口方法
}

class interfaceExtends implements ChildLike { // 实现子接口，但必须重写所有方法
    @Override
    public void fatherMethod() {
        System.out.println("实现父接口方法");
    }

    @Override
    public void ChildLikeMethod() {
        System.out.println("实现子接口方法");
    }
}
javaCopied!

interface 子接口 extends 父接口1,父接口2,父接口3,... {
  ...
}
bashCopied!

interface A {
    void a();
}

interface B {
    void b();
}

interface C {
    void c()
}
javaCopied!

interface Letter extends A,B,C {

}
javaCopied!

class LetterImp implements Letter {
    @Override
    public void a() {
        System.out.println("A 接口中的抽象方法");
    }

    @Override
    public void b() {
        System.out.println("B 接口中的抽象方法");
    }

    @Override
    public void c() {
        System.out.println("C 接口中的抽象方法");
    }
}
javaCopied!

<接口>.super.<方法名>([参数])
bashCopied!

public interface DefaultMethods {
    default void defaultMethod() {
        System.out.println("default方法");
    }
    static void staticMethod() {
        System.out.println("static方法");
    }
}
javaCopied!

public class Test implements DefaultMethods {
    @Override
    public void defaultMethod() {
        DefaultMethods.super.defaultMethod();
    }
}
javaCopied!