java接口(Interface)学习笔记
接口(Interface),在java编程语言中是一个抽象类型,是抽象方法的集合,通常用interface来声明,一个类可以通过继承接口的方式,从而来继承接口的抽象方法。一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的类实现,而这些实现可以具有不同的行为
需要注意的是,接口并不是类,编写接口的方式和类很相似,但是他们属于不同的概念,类描述对象的属性和方法,接口则包含要实现的方法。
如下面这是一个典型的类
public class Dog{
//类的属性,接口的属性只能是final static的属性,不能是变量
String name;
int size;
String colour;
int age;
//类的构造函数,接口没有构造函数
public Dog(String name){
this.name = name;
}
/*类的方法 方法有方法体,而接口的方法是抽象的,不能有方法体,必须由要实现它的类来定义这些方法*/
void setSize(int size){
this.size;
}
void setColour(String colour){
this.colour = colour;
}
void setAge(int age){
this.age = age;
}
}
接口与类相似点:
- 一个接口可以有多个方法。
- 接口文件保存在 .java 结尾的文件中,文件名使用接口名。
- 接口的字节码文件保存在 .class 结尾的文件中。
- 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别:
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法。
- 接口不能包含成员变量,除了 static 和 final 变量。
- 接口不是被类继承了,而是要被类实现。
- 接口支持多继承。
抽象类和接口的区别
- 抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
- 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
- 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
- 一个类只能继承一个抽象类,而一个类却可以实现多个接口。
接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。总而言之,实现接口的类除非是抽象类,否则该类要定义接口中的所有方法。
接口的声明语法格式如下
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
下面是个接口声明的简单例子
public interface NameOfInterface
{
//任何类型 final, static 字段
//抽象方法
}
接口有以下特性:
- 接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
- 接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。
- 接口中的方法都是公有的。
- 接口指明了一个类必须要做什么和不能做什么,相当于类的蓝图。
实例
interface Animal{
public void eat();
public void travel();
}
接口的实现
当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
实现一个接口的语法,可以使用这个公式:
...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...
实例(抽象类实现接口)
抽象类和接口都是java中用来实现多态的方法,在java一般的用法中,如果要用普通类来实现接口,则必须实现该接口中的所有方法,这样就会导致需要实现多余的方法;
采用抽象类来实现方法,可以实现该接口中的部分方法,而且当其他类继承该抽象类时,只需要实现抽象类中未实现的方法即可。
例:
抽象类B只实现了接口A中的方法a、b,
当类C继承类B时,只需要实现B中为实现的接口c即可。
一般情况下,类C中的方法a、b都是调用父类B的方法a、b。
接口代码
public interface Action {
public void jump();
public void eat();
public void run();
}
抽象父类
public abstract class Animal implements Action{
public String name;
public int age;
public Animal() {
}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public abstract void fly();
@Override
public void jump() {
System.out.println(name+"在跳高");
}
//没有实现public void run()和public void eat();
}
子类:
public class Cat extends Animal /*implements Jumpping*/ {
public Cat() {
}
public Cat(String name, int age) {
super(name, age);
}
//只需实现了抽象类的抽象方法public abstract void fly();
public void fly() {
System.out.println("猫在飞");
}
public static void main(String args[]){
Cat cat = new Cat("wyq", 12);
cat.fly;
cat.jump();//can run, ok!
cat.fly();//can run, ok!
cat.run();//会报错,抽象父类中并没有实现这个方法
}
}
实例(普通类类实现一个接口)
需要实现接口中的所有方法
public class Dog implements Animal{
//类的属性,接口的属性只能是final static的属性,不能是变量
String name;
int size;
String colour;
int age;
//类的构造函数,接口没有构造函数
public Dog(String name){
this.name = name;
}
/*类的方法 方法有方法体,而接口的方法是抽象的,不能有方法体,必须由要实现它的类来定义这些方法*/
void setSize(int size){
this.size;
}
void setColour(String colour){
this.colour = colour;
}
void setAge(int age){
this.age = age;
}
/*需要实现的接口的方法*/
@Override
public void eat(){
System.out.println("Dog eats");
}
@Override
public void travel(){
System.out.println("Dog travels");
}
public static void main(String args[]){
Dog dog = new Dog("wyq");
dog.eat();
dog.travel();
}
}
实例(普通类实现多个接口)
如现在有两个接口如下
public interface Interface1{
public void method1();
}
public interface Interface2{
public void method2();
}
那么一个类可以一并实现上面两个接口
public class A implements Interface1, Interface2{
public A(){
}
@Override
public void method1(){
System.out.println("method1");
}
@Override
public void method2(){
System.out.println("method2");
}
}
重写接口中声明的方法时,需要注意以下规则:
- 类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。
- 类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
- 如果实现接口的类是抽象类,那么就没必要实现该接口的方法。
在实现接口的时候,也要注意一些规则:
- 一个类可以同时实现多个接口。
- 一个类只能继承一个类,但是能实现多个接口。
- 一个接口能继承另一个接口,这和类之间的继承比较相似。
接口的继承(extends关键字)
java类的多继承是不合法,但接口是支持多继承的。
语法如下
...extends 接口名称, 其他接口名称, 其他接口名称..., ... ...
如现在有两个接口如下
public interface Interface1{
public void method1();
}
public interface Interface2{
public void method2();
}
那么第三个接口可以同时继承上面两个接口
public interface Interface3 extends Interface1, Interface2{
public void method3();
}
实现类,A类实现了Interface3,需要将Interface3的方法和它继承的Interface1和Interface2的方法一并实现。
public class A implements Interface3{
@Override
public void method1(){
System.out.println("method1");
}
@Override
public void method2(){
System.out.println("method2");
}
@Override
public void method3(){
System.out.println("method3");
}
public static void main(String[] args) {
method1();
method2();
method3();
}
}