abstract class MyAbstractClass{
    public static final int VALUE1 = 100; //属性是公开静态常量
    public static final int VALUE2 = 200; //第二个属性
    public abstract void m1(); //方法是公开抽象方法
    public abstract void m2(int n); //第二个方法
}
class MySubClass extends MyAbstractClass{#公开抽象方法
    public void m1(){}
    public void m2(int n){}
}
interface MyInterface{#接口
    public static final int VALUE1 = 100;
    public static final int VALUE2 = 200;
    public abstract void m1();
    public abstract void m2(int n);
}

interface MyInterface{
    int VALUE1 = 100;
    int VALUE2 = 200; 
    void m1();
    void m2(int n); 
}
implements。使用这个关键字表示“实现”，类似于抽象类中子类继承父类的关系。
class MyImpl implements MyInterface{
    public void m1(){}
    public void m2(int n){}
}

interface IA{
    void ma();
}
interface IB extends IA{
    void mb();
}

class IAIBImpl implements IB{
    public void ma(){}
    public void mb(){}
}
1.2

interface IA{
    void ma();
    }
interface IB{
    void mb();
    }
interface IC extends IA, IB{ //IC 同时继承 IA 和 IB 两个接口
    void mc();
    }

interface IA{
    void ma();
}
interface IB(){
    void mb();
}
//IC 继承自 IA，IB 接口。这里是接口的多继承
interface IC extends IA, IB{
    void mc();
}
interface ID{
    void md();
}
abstract class ClassE{
    public abstract void me();
}
    /*
    一个类可以继承自一个类，并实现多个接口
    MyImpl 继承自 ClassE 类，实现了 IC 和 ID 接口
    注意，先写继承自哪个类，再写实现了哪些接口
    */
class MyImpl extends ClassE implements IC, ID{
    //IC 接口中包含 ma、mb、mc 方法
    public void ma(){}
    public void mb(){}
    public void mc(){}
    //ID 接口中包含 md 方法
    public void md(){}
    //ClassE 中包含 me 方法
public void me(){}
}

public class TestMyImpl{
public static void main(String args[]){
    IA ia = new MyImpl();
    System.out.println(ia instanceof IA);//true
    System.out.println(ia instanceof IB);//true
    System.out.println(ia instanceof IC);//true
    System.out.println(ia instanceof ID);//true
    System.out.println(ia instanceof ClassE);//true
    System.out.println(ia instanceof MyImpl);//true
    }
}

lass RedBulb {
    public void shine(){
    System.out.println(“Shine in Red”);
    }
}
class YellowBulb{
    public void shine(){
    System.out.println(“Shine in Yellow”);
    }
}
class GreenBulb{
    public void shine(){
        System.out.println(“Shine in Green”);
    }
}
class Lamp{
    private RedBulb bulb;
    public void setBulb(RedBulb bulb){
        this.bulb = bulb;
    }
    public void on(){
    bulb.shine();
    }
}
public class TestLamp{
    public static void main(String args[]){
    Lamp lamp = new Lamp();
    RedBulb rb = new RedBulb();
    lamp.setBulb(rb);
    lamp.on();
    }
}

interface Bulb{//首先，定义 Bulb 接口
    void shine();
}
class RedBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Red”);
    }
}
class YellowBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Yellow”);
    }
}
class GreenBulb implements Bulb{
    public void shine(){
        System.out.println(“Shine in Green”);
    }
}
class Lamp{
    private Bulb bulb;
    public void setBulb(Bulb bulb){
        this.bulb = bulb;
    }
    public void on(){
        bulb.shine();
    }
}
public class TestLamp{
    public static void main(String args[]){
    Lamp lamp = new Lamp();
    Bulb b1 = new RedBulb();
    lamp.setBulb(b1);
    lamp.on();
    Bulb b2 = new GreenBulb();
    lamp.setBulb(b2);
    lamp.on();
    }
}