接口

interface InterA     //接口A
{
	public abstract void show1();            //有方法，没有主体，不能实现
}
interface InterB     //接口B
{
	public abstract void show2();             //有方法，没有主体，不能实现
}

class InterfaceA_B implements InterA,InterB     //  接口继承
{
	public void show1()                       // 对show1()进行覆盖
	{
		System.out.println("InterA   show1 ...");
	}
	public void show2()                        // 对show2()进行覆盖
	{
		System.out.println("InterB    show2 ...");
	}
	public void show()
	{
		System.out.println("InterfaceA&B show");
	}
}
class InterfaceDemo
{
	public static void main(String[] args) 
	{
		InterfaceA_B in = new InterfaceA_B();
		in.show1();
		in.show2();
		in.show();
	}
}

接口的另外用法：

interface Inter                               //接口：只提供方法的入口而不具体的实现
{
	public abstract void show1();            //有方法，没有主体，不能实现
}
class Fu     
{
	public void show()
	{
		System.out.println("Fu show...");
	}             
}

<span style="color:#ff0000;">class Inter_Fu extends Fu implements Inte</span>r     
{
	public void show1()                      //     对接口方法的具体实现      
	{
		System.out.println("Interface   show1 ...");
	}
}
class InterfaceDemo
{
	public static void main(String[] args) 
	{
		Inter_Fu in = new Inter_Fu();
		in.show();
		in.show1();
	}
}

接口之前的相互继承和实现细节

//本例演示接口之间也可以相互继承和实现的细节
interface Inter1                              
{
	public abstract void show1();            
}
interface Inter2  extends Inter1  
{
	public abstract void show2();
	public abstract void show3();
}
 
class Inter1_2 implements Inter1,Inter2      
{
	//必须要实现接口程序中所有的抽象列接口
	public void show1()                      
	{
		System.out.println("Interface1   show1 ...");
	}
	public void show2()                    
	{
		System.out.println("Interface2   show2 ...");
	} 
	// 似然不需要show3的功能但是还是要实现其主体
	public void show3(){}
	
}
class InterfaceDemo
{
	public static void main(String[] args) 
	{
		Inter1_2 in = new Inter1_2();
		in.show1();
		in.show2();
	}
}

但是需要每个接口都要实现，但是又不用，相当的繁琐，代码的复用性很差，这时我们想到了覆盖的思想--没有抽象方法的抽象类，仅为创建inter接口的子类对象。

interface Inter     
 {
	public abstract void show1();
	public abstract void show2();
	public abstract void show3();
	public abstract void show4();
 }

 abstract class InterA implements Inter //没有抽象方法的抽象类
 {                                      //（该类不允许被创建对象，所以被限制为abstract）
	public void show1(){}
	public void show2(){}
	public void show3(){}
	public void show4(){}
 }

 class InterDemo extends InterA
 {
	 public void show1()
	 {
		System.out.println("InterDemo   show1....");
	 }
 }

class InterfaceDemo
{
	public static void main(String[] args)
	{
		InterDemo in = new InterDemo();
		in.show1();
	}
}