//串行硬盘接口
public interface SataHdd{
 //连接线的数量
 public static final int CONNECT_LINE=4;
 //写数据
 public void writeData(String data);
 //读数据
 public String readData();
}

public interface SataHdd{
 //连接线的数量
 public int connectLine; //编译出错，connectLine被看做静态常量，必须显式初始化
 //写数据
 protected void writeData(String data); //编译出错，必须是public类型
 //读数据
 public static String readData(){ //编译出错，接口中不能包含静态方法
  return "数据"; //编译出错，接口中只能包含抽象方法，
 }
}

//串行硬盘接口
public interface SataHdd extends A,B{
 // 连接线的数量
 public static final int CONNECT_LINE = 4;
 // 写数据
 public void writeData(String data);
 // 读数据
 public String readData();
}
interface A{
 public void a();
}
interface B{
 public void b();
}

import static java.lang.System.*;
public class Demo{
 public static void main(String[] args) {
  SataHdd sh1=new SeagateHdd(); //初始化希捷硬盘
  SataHdd sh2=new SamsungHdd(); //初始化三星硬盘
 }
}
//串行硬盘接口
interface SataHdd{
 //连接线的数量
 public static final int CONNECT_LINE=4;
 //写数据
 public void writeData(String data);
 //读数据
 public String readData();
}
// 维修硬盘接口
interface fixHdd{
 // 维修地址
 String address = "北京市海淀区";
 // 开始维修
 boolean doFix();
}
//希捷硬盘
class SeagateHdd implements SataHdd, fixHdd{
 //希捷硬盘读取数据
 public String readData(){
  return "数据";
 }
 //希捷硬盘写入数据
 public void writeData(String data) {
  out.println("写入成功");
 }
 // 维修希捷硬盘
 public boolean doFix(){
  return true;
 }
}
//三星硬盘
class SamsungHdd implements SataHdd{
 //三星硬盘读取数据
 public String readData(){
  return "数据";
 }
 //三星硬盘写入数据
 public void writeData(String data){
  out.println("写入成功");
 }
}
//某劣质硬盘，不能写数据
abstract class XXHdd implements SataHdd{
 //硬盘读取数据
 public String readData() {
  return "数据";
 }
}

public class Demo{
 public void test1(A a) {
  a.doSth();
 }
 public static void main(String[] args) {
  Demo d = new Demo();
  A a = new B();
  d.test1(a);
 }
}
interface A {
 public int doSth();
}
class B implements A {
 public int doSth() {
  System.out.println("now in B");
  return 123;
 }
}

now in B

public abstract class A{
 public abstract void method1();
 public void method2(){
  //A method2
 }
}
public class B extends A{
 public void method1(){
  //B method1
 }
}
public class C extends A{
 public void method1(){
  //C method1
 }
}

public interface A{
 public void method1();
 public void method2();
}
public class B implements A{
 public void method1(){
  //B method1
 }
 public void method2(){
  //B method2
 }
}
public class C implements A{
 public void method1(){
  //C method1
 }
 public void method2(){
  //C method2
 }
}

interface A{
 public void method2();
}
interface B{
 public void method1();
}
class C implements A,B{
 public void method1(){
  //C method1
 }
 public void method2(){
  //C method2
 }
}
//可以如此灵活的使用C，并且C还有机会进行扩展，实现其他接口
A a=new C();
B b=new C();
abstract class A{
 public abstract void method1();
}
abstract class B extends A{
 public abstract void method2();
}
class C extends B{
 public void method1(){
  //C method1
 }
 public void method2() {
  //C method2
 }
}