JAVA学习第十四课（接口：implements）

注意：接口的定义不是class，而是interface,当然最后编译时还是class文件

interface Demo
{
	abstract void show();
	abstract void show1();
	
}

interface Demo
{
	public static final int num = 4;//num终身为4
	public int num = 4;//不写，会自动加上去，默认的，最好写上，否则阅读性差
	public abstract void show();
}

为什么叫实现？

接口里的方法都是抽象的，所以必要要全实现，对于抽象类里，有一些不是抽象的，子类拿过来直接用的。继承可以拿过来一些我不需要做，直接可以用的东西，而实现是我全部都要用的，都要覆盖，都要自己重写。

所以：类与类之间是继承关系，类与接口之间是实现关系

接口实现的特点：

import java.util.Scanner;

interface Demo
{
	public abstract void show();
	public abstract void show1();
	public static final int num = 4;
}
 //类与类是继承关系，类与接口之间是实现关系(implements)
/*
 * 接口不可以实例化
 * 只能由实现了接口的子类，并且覆盖了接口中所有的抽象方法后才可以实例化
 * 否则，这个子类只是一个抽象类
 * */
class Demo1_Imple implements Demo
//一个类实现接口后，必须覆盖接口里所有的方法，才能实现类implements接口
{
	public void show()
	{
		System.out.println("show打印"+num);
	}
	public void show1()
	{
		System.out.println("show1打印"+num);
	}
}
public class Main 
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		Demo1_Imple BLF = new Demo1_Imple();
		BLF.show();
		BLF.show1();
		BLF.num = 5;//错误，num是final修饰的
		System.out.println(BLF.num);//对象用num
		System.out.println(Demo.num);//接口的静态成员
		System.out.println(Demo1_Imple.num);//实现接口的子类的静态成员num
	}
}

多实现，小练习：

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}
class C implements A,B
{
	public void show()
	{
		System.out.println("你好");
	}
	public int add(int a,int b)
	{
		return a+b+10;
	}
}

public class Main 
{
	public static void main(String[] args)
	{
		C BLF = new C();
		BLF.show();
		System.out.println(BLF.add(1, 3));
	}
}

interface A
{
	public abstract void show();
}
interface B
{
	public abstract int show();
}
Test 1：
class C implements A,B
{
	public void show()//如果这样写的C还是一个抽象类，因为没有覆盖所以的方法
	{
		System.out.println("你好");
	}
}
Test 2：


class C implements A,B
{
	public void show()
	{
	    System.out.println("你好");
	}
	
	public int show()
	{
	    System.out.println("你好,世界");//C中已经定义了show，调用show，返回值确定不了，int还是void
	}


}

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}
class D
{
	public void  print() 
	{
		System.out.println("你好好");
	}
}
//很猛！！！
class E extends D implements A,B//E继承了D，实现了A和B，这样E的功能就丰富多了
{
	//E单继承了D中的print功能，但是还想用A,B中的功能，但是这些功能无发通过继承了，
	//那么就同时实现接口的方式，来扩展E中的功能
	public void show()
	{
		System.out.println("你好");
	}
	public int add(int a,int b)
	{
		return a+b+10;
	}
	public void test()
	{
		System.out.println("测试");
	}
}
/*
 * 接口的出现，避免了单继承的局限性*/
public class Main 
{
	public static void main(String[] args)
	{
		E BLF = new E();
		BLF.show();
		System.out.println(BLF.add(1, 3));
		BLF.test();
		BLF.print();
	}
}

interface A
{
	public abstract void show();
}
interface B
{
	public abstract void show();
	public abstract int add(int a,int b);
}

interface E extends A,B//继承关系，且可以多继承，更猛！！！
{
	//多继承，差就差在方法体上，接口没方法体，所以可以多继承
	public abstract void test();
	
	
}
class G implements E
{
	public void show()
	{
		System.out.println("你好好啊");
	}
	public int add(int a,int b)
	{
		return 250;
	}

	public void test()
	{
		System.out.println("你不好");
	}

}
public class Main 
{
	public static void main(String[] args)
	{
		
	G BLF = new G();
		System.out.println(BLF.add(3, 4));
		BLF.show();
	}
}

哥们只能说，java真的特别猛！！！
以上为接口的基本实现。。。

未完。。。

JAVA学习第十四课（接口：implements）

原文：http://blog.csdn.net/wjw0130/article/details/39405275