首页 > 代码库 > JAVA学习第十四课(接口:implements)

JAVA学习第十四课(接口:implements)

接口:

我们知道抽象类中可以定义抽象方法,也可以定义非抽象方法,当一个抽象类中的方法都是抽象方法的时候,我们就可以定义另一种表现方式:接口(interface),所以接口是一种特殊的抽象类

接口的出现将“多继承”通过另一种形式表示出来,即“多实现”。

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

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

接口中常见的成员:(全部是固定的修饰符)

1.全局常量(public static final)
2.抽象方法(public abstract)
3.当然还有别的

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

由此得出结论:接口里的成员是公共的,->权限最大

如果是类的话,会用继承,如果用接口的话,就不用继承了,用另外一种更加直观的表述方式,叫实现(implements)


为什么叫实现?

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


所以:类与类之间是继承关系,类与接口之间是实现关系


接口实现的特点:

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
	}
}

接口的优点:

java不直接支持多继承,因为会出现调用的不确定性(存在隐患),所以java将C++的多继承机制,进行了改良,在java中变成了多实现(一个类实现多个接口)

多继承:同是继承一个或两个父类,一个父类有A,B两功能,一个父类有C,D两个功能,子类一继承就具备A,B,C,D四个功能
多实现:一个父类有A,B两抽象功能,一个父类有C,D两个抽象功能,一个子类实现就具备这4个功能
(与多继承的小区别)
我们注重的是事物的功能,至于功能该怎么用,由子类明确,如果父类的功能已经符合子类的需求,子类直接用就可以了,如果不符合,子类还是具备这个功能,但是要重写,但是功能干什么,子类说的算

为什么java的多实现称为改良的多继承?


多继承的弊端就是如果两个的父类的方法名相同,就会出现不确定性,而多实现呢?就不存在了,因为show()的方法体是子类自己写的,而多继承,继承的是方法体,java改良后,没有方法体,方法体是子类决定的

多实现,小练习:

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));
	}
}

故:多实现,对多继承实现了改良

当然,以下两种test的代码方式,是java不能忍受的

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();
	}
}

类与类之间是继承关系,类与接口之间是实现关系,接口与接口之间呢?

java不支持多继承的原因,就在于方法体


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)