面向对象---接口

一、接口的概念

接口:体现的是事务的扩展性功能(额外动作,后天经过学习等等)
 
接口格式(标识符:类,接口:见名知意)
   interface  接口名{
//抽象功能
   public abstract void jump() ;
}
接口的特点:不能实例化
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{

  }

接口的子类如果是抽象类:没有意义,不能实例化

举个具体的例子大家体会一下:

//定义一个接口
interface AniamlTrain{
	//接口中的方法不能有方法体,只能是抽象方法
	public abstract void jump() ;
	public abstract void speak() ;
}
class Cat{}
//具体实现类
class JumpCatImpl extends Cat implements AniamlTrain{

	@Override
	public void jump() {
		System.out.println("部分猫就可以跳高了...");
	}

	@Override
	public void speak() {
		System.out.println("猫开口说话了...");
	}
}
public class Demo {
	
	public static void main(String[] args) {
		//创建对象
		AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)
		at.jump();
		at.speak(); 
	}
}

二、接口的成员特点

接口成员的特点:

   成员变量:是一个常量,不能更改,并且默认的修饰符:public static final

  构造方法:接口不存在构造方法

  成员方法:都是抽象方法,默认的修饰符:public abstract

接口和接口之间的关系:继承关系

interface Inter{
	public int num = 10 ;
	int num2 = 20 ;//默认的修饰符 public static final
	public static final int num3 = 200 ;
	//不能有无参构造
		//public Inter() {
		//		
		//}
	
	void method(); //默认的修饰符 public abstract
	
	public abstract void eat();
}

//子实现类
class InterImpl implements Inter{
	
	public void show() {
		System.out.println("show interimpl....");
	}

	@Override
	public void eat() {
		
	}

	@Override
	public void method() {
		
	}
}
//测试类
public class InterfaceDemo {

	public static void main(String[] args) {
		//创建实现类对象
		//接口多态
		Inter i = new InterImpl() ;
//		i.num = 100 ; //不能赋值:说明当前这个变量是一个常量:被final修饰
		System.out.println(Inter.num2); //这句话能调用,说明当前变量默认的修饰 static
		System.out.println(Inter.num);
	}
}

三、接口与抽象类的区别

1、成员的区别:

    成员变量:

            抽象类中的成员变量既可以是变量,也可以是常量

            接口中的成员变量只能是常量,默认修饰符:public static final

    构造方法:

            抽象类中有构造方法,可以是有参构造,也可以是无参构造(目的是对对象的初始化)

            接口中没有构造方法

    成员方法:

            抽象类中既可以有抽象方法,也可以有非抽象的方法

            接口中只能是抽象方法,默认修饰符:public abstract

2、类与类和类与接口的关系:

    类与类之间是继承关系,且只能实现单继承,不能多继承,但可以实现多层继承

    类和接口之间是实现关系,一个类继承的同时还可以实现多个接口

    接口和接口之间是继承关系,可以实现单继承,也可以实现多继承

3、设计原则的区别:

    抽象类:有继承关系,体现的是一种“is a”的关系,A是B的一种,或B是A的一种

    接口:类和接口之间是实现关系,体现的是一种“like a”的关系,是功能的拓展

四、接口和抽象类的综合案例

还是之前的猫狗案例,这次我们在之前的基础上给猫狗加入跳高的功能,那么由于跳高的功能不是所有的猫和狗都会跳高,所以显然在父类里加入跳高功能让子类继承是不太合适的,于是想到用接口(额外的拓展功能)来实现跳高功能

//抽象的动物类
public abstract class Animal {

	private String name ;
	private int age ;
	public Animal() {
		super();
	}
	public Animal(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	//吃
	public abstract void eat();
	
	//睡
	public abstract void sleep() ;
}
public class Cat extends Animal {

	public Cat() {
		super();
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("猫吃鱼....");
	}

	@Override
	public void sleep() {
		System.out.println("猫趴着睡觉....");
	}
	
	public void playGame() {
		System.out.println("猫玩游戏...");
	}

}
public class Dog extends Animal {
	
	public Dog() {
		super();
	}

	public Dog(String name, int age) {
		super(name, age);
	}

	@Override
	public void eat() {
		System.out.println("狗吃猫...");
	}

	@Override
	public void sleep() {
		System.out.println("狗躺着睡觉...");
	}
	
	public void lookDoor() {
		System.out.println("狗躺着睡觉...");
	}
}
/**
 * 这是一个跳高的接口
 * @author Administrator
 *
 */
public interface Jump {
	
	//提供一个抽象功能
	public abstract void jump() ;
}
//跳高猫
public class JumpCat extends Cat implements Jump {
	
	public JumpCat() {
		super();
	}

	public JumpCat(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("猫可以跳高了...");
	}
}
//跳高狗
public class JumpDog extends Dog  implements Jump {

	public JumpDog() {
		super();
	}

	public JumpDog(String name, int age) {
		super(name, age);
	}

	@Override
	public void jump() {
		System.out.println("狗可以跳高了...");
	}
}
//测试类
public class AnimalTest {
	
	public static void main(String[] args) {
		//可以使用功能最多的类
		//创建具体类对象
		//猫类
		JumpCat jc = new JumpCat("tom", 5) ;
		System.out.println(jc.getName()+"---"+jc.getAge());
		jc.eat();
		jc.sleep();
		jc.playGame();
		jc.jump(); 
		
		System.out.println("------------------");
		
		//狗类
		JumpDog jd = new JumpDog("bob", 2) ;
		System.out.println(jd.getName()+"---"+jd.getAge());
		jd.eat();
		jd.sleep();
		jd.lookDoor();
		jd.jump(); 
	}
}
至此,跳高猫和跳高狗的功能就实现了。

阅读更多
文章标签: Java
上一篇面向对象---抽象类
下一篇面向对象---形式参数和返回值的问题
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭