接口

接口(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

你可能感兴趣的:(java)