接口(interface)可理解为一种特殊的类,里面有
1)全局常量 2)公共的抽象方法
接口中没有构造方法,所以不能被实例化
public interface A{
public A(){...} //错,接口没有构造方法
}
interface A{
public static final String name= "isaac";
//String name = "isaac";
public abstract void print();
//void print();
public abstract String getInfo();
//String getInfo();
}
两种声明方法其实是一样的,由于接口里的属性都是static和final的,所以可以很方便地声明一些常量,使用时可以直接用A.name这样的方式来引用
接口的实现:
class 子类 implements 接口A,接口B{...}
一个子类可实现多个借口,并且将其中所有抽象方法全部实现,除非这个子类是抽象的
接口不可以被实例化,但是可以定义一个引用实例来引用实现该接口的类的实例
public class B implements A{...}
A a=new B();正确 A a =new A();错误,接口不可被实例化
一个子类可同时继承抽象类与实现接口,这在java中是十分常见的,关于抽象类与接口的区别将在后面讨论
eg:class A extends B implements C,D{...}(当然这样就要将父类和实例中的全部抽象方法都实现啦!)
另外,接口也是可以被继承的!
interface A{
public void printA();
}
interface B{
public void printB();
}
interface C extends A,B{
public void printC();
}
class D implements C{
public void printA(){
System.out.println("helloa");
}
public void printB(){
System.out.println("hellob");
}
public void printC(){
System.out.println("helloc");
}
}
D实现了继承A,B的C,就要将A,B,C中的抽象方法全部实现了!
举一个上课时的例子:
interface USB{ // 定义USB接口
public void start() ; // USB设备开始工作
public void stop() ; // USB设备结束工作
}
class Computer{
public static void plugin(USB usb){ // 只要是USB的设备就都可以向此地方插入
usb.start() ; // 让USB设备开始工作
System.out.println("======= USB 设备工作 =======") ;
usb.stop() ; // 让USB设备停止工作
}
};
class Flash implements USB{ // U盘
public void start(){ // 覆写start()方法
System.out.println("U盘开始工作。") ;
}
public void stop(){ // 覆写stop()方法
System.out.println("U盘停止工作。") ;
}
};
class Print implements USB{ // 打印机
public void start(){ // 覆写start()方法
System.out.println("打印机开始工作。") ;
}
public void stop(){ // 覆写stop()方法
System.out.println("打印机停止工作。") ;
}
}
关键在于computer中的函数参数是一个接口,这样做有很大好处。
下面谈谈接口与抽象类的区别:
1)抽象类中可以有自己的数据成员,也可以有非抽象成员方法(例如构造函数),但在接口中所有成员都为同一类型(即public
static final,不过在interface中一般不定义数据成员),且所有方法都为抽象方法。可以说interface是一种特殊的abstract class。
2)一个类只可以继承一个父类,但却可以实现多个接口。
3)继承关系为“is a”,接口为“like a”,例如我们要声明一个类为alarmdoor,那我们把哪些方法放入父类,哪些方法放入接口呢,这时就要考虑到alarmdoor实际上还是door,只不过因为拥有了alarm的功能而像是alarm,也就是说"is a door like a alarm",这时我们就可以声明了 class alarmdoor extends door implements alarm{...}
接口中也可以声明静态方法:
public interface Calculator{
static Calculator getInstance{
return new BasicCalculator;
}
int add(int first,int second);
}
class BasicCalculator implements Calculator{
public int add(int first,int second){
return first+second;
}
}
public class TestStatic{
public static void main(String []args){
Calculator t=Calculator.getInstance();
int i=t.add(1,2);
System.out.println(i);
}
}
向上转型与向下转型:
向上:子类->父类 (程序会自动完成
向下:父类->子类(必须声明要转型的子类类型,否则会报错
class A{
public void fun1(){
System.out.println("A->fun1");
}
public void fun2(){
this.fun1();
}
}
class B extends A{
public void fun1(){
System.out.println("B->fun1");
}
public void fun3(){
System.out.println("B->fun3");
}
}
public class Demo{
public static void main(String []args){
B b=new B();
A a=b;
a.fun1();
}
}
A a = b ;为向上转型,而a.fun1();调用的是B中的函数,因为子类覆写了父类
A a=new B();
B b=(B)a;
这里为向下转型,即先向上转型再向下转型,如果直接向下转型则会报错:对象转换异常
csdn自带的换行太垃圾了啊啊啊啊啊!!!考虑下次写用markdown了OVO