新手小白学JAVA 接口 面向接口开发

接口

1 接口的概念

与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.

2 接口格式

3 接口的特点:

通过interface关键字来定义接口

通过implements让子类来实现接口

接口中的方法全部都是抽象方法(JAVA8)

可以把接口理解成一个特殊的抽象类(但接口不是类!!!)

类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法

接口突破了java单继承的局限性

接口和类之间可以多实现,接口与接口之间可以多继承

接口是对外暴露的规则,是一套开发规范

接口提高了程序的功能拓展,降低了耦合性

4.1 练习-1:创建接口

创建包: cn.tedu.inter

创建接口:Inter.java

package cn.tedu.inter;

/*本接口用于创建接口测试*/

/*1.我们通过interface关键字来定义接口*/

public interface Inter {

/*2.接口中可以定义普通方法吗？--不可以！*/

//public void eat(){}

/*3.接口中可以定义抽象方法吗？--可以，接口中的方法都是抽象方法！*/

public abstract void eat();

public abstract void play();

}

4.2 练习-2:创建接口实现类

创建包: cn.tedu.inter

创建接口实现类:InterImpl.java

package cn.tedu.inter;

/*本类作为Inter接口的实现类*/

/*1.实现类如果想要实现接口定义的功能，需要与接口建立实现关系

* 通过关键字implements来建立实现类 实现 接口的关系*/

/*2.1 方案一：如果实现类与接口建立实现关系以后

可以选择不实现接口中的抽象方法，把自己变成一个抽象类*/

//abstract public class InterImpl implements Inter{//方案一

/*2.2方法二：如果实现类与接口建立实现关系以后

* 还可以选择实现接口中的所有抽象方法，把自己变成一个普通子类*/

public class InterImpl implements Inter{

@Override

public void eat() {

System.out.println("吃火锅");

}

@Override

public void play() {

System.out.println("玩代码");

}

}

4.3 练习-3:创建接口测试类

创建包: cn.tedu.inter

创建接口测试类:InterTests.java

package cn.tedu.inter;

/*本类用于运行测试接口实现类*/

public class InterTests {

public static void main(String[] args) {

/*接口可以实例化吗？--不可以！！！*/

//Inter i = new Inter();

//创建多态对象进行测试--不常用

Inter i = new InterImpl();

i.eat();

i.play();

//创建纯纯的接口实现类对象进行测试--推荐使用

InterImpl i2 = new InterImpl();

i2.eat();

i2.play();

}

}

5 接口的用法

5.1 练习: 接口之构造方法

创建包: cn.tedu.inter2

创建类:TestUserInter.java

package cn.tedu.inter2;

/**本类用于进一步测试接口的使用*/

public class TestUserInter {

//5.创建入口函数main()

public static void main(String[] args) {

/**查看类的继承结构:Ctrl+O*/

Inter2 i = new Inter2Impl();

}

}

//1.创建接口

interface UserInter{

//2.测试接口中是否包含构造方法

//public UserInter(){}

/*1.接口里没有构造方法*/

}

//3.创建接口的实现类

class UserInterImpl implements UserInter{

//4.创建实现类的构造方法

public UserInterImpl(){

/*2.如果一个类没有明确指定它的父类，那么它默认继承顶级父类Object*/

super();/*3.此处调用的父类的无参构造是Object的无参构造*/

System.out.println("我是子实现类的无参构造");

}

}

总结:接口里是没有构造方法的

如果一个类没有明确指定它的父类，那么它默认继承顶级父类Object，调用的super()是Object的无参构造

5.2 练习: 接口之成员变量

package cn.tedu.inter2;

/*本类用于进一步测试接口的使用*/

public class TestUserInter {

public static void main(String[] args) {

//6.测试接口中的静态常量

System.out.println(UserInter.age);//静态，因为可以被接口名直接调用

//UserInter.age = 37;//final,因为值不可以被修改

}

}

//1.创建接口

interface UserInter{

//5.测试接口中是否可以定义成员变量

/*4.接口中的是静态常量，实际上的写法是public static final int age = 20;

* 只不过接口中可以省略不写，会默认拼接，所以写成 int age = 20;也可以*/

public static final int age = 20;

}

//3.创建接口的实现类

class UserInterImpl implements UserInter{

}

总结:接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final

5.3 练习: 接口之成员方法

package cn.tedu.inter2;

/*本类用于进一步测试接口的使用*/

public class TestUserInter {

public static void main(String[] args) {

UserInterImpl u = new UserInterImpl();

u.eat();

u.play();

}

}

//1.创建接口

interface UserInter{

//7.测试接口中有抽象方法吗？

/*5.接口中抽象方法的定义可以简写，会自动给方法拼接public abstract*/

public abstract void eat();

void play();

}

//3.创建接口的实现类

class UserInterImpl implements UserInter{

@Override

public void eat() {

System.out.println("实现接口中的抽象方法1");

}

@Override

public void play() {

System.out.println("实现接口中的抽象方法2");

}

}

总结:接口里的方法，默认都是抽象的，方法上会默认拼接public abstract。例如：public abstract void save();

6 练习:分析老师示例—面向接口编程

具体事物: 培优班老师 高手班老师

共性: 讲课 备课

创建包: cn.tedu.inter2

创建类:TestTeacherInter.java

package cn.tedu.inter2;

/*本类用于面向接口编程*/

public class TestTeacherInter {

public static void main(String[] args) {

CGBTeacher ct = new CGBTeacher();

ct.ready();

ct.teach();

}

}

//1.创建老师接口--接口是先天设计的结果，最先设计的就是接口，要制定规则

interface Teacher{

//2.定义接口里的方法

void teach();//授课方法

void ready();//备课方法

}

class CGBTeacher implements Teacher{

@Override

public void teach() {

System.out.println("授课电商项目");

}

@Override

public void ready() {

System.out.println("备课电商项目");

}

}

class ACTTeacher implements Teacher{

@Override

public void teach() {

System.out.println("正在授课基础加强+框架加强");

}

@Override

public void ready() {

System.out.println("正在备课基础加强+框架加强");

}

}

abstract class SCDTeacher implements Teacher{

@Override

public void ready() {

System.out.println("正在研发新课程。。。");

}

}

7 接口的多继承多实现

创建包: cn.tedu.inter2

创建类:TestRelation.java

package cn.tedu.inner2;

import cn.tedu.inter.Inter;

/*本类用于测试接口与类之间的复杂关系*/

public class TestRelation {

public static void main(String[] args) {

//创建对象进行功能测试

Inter3Impl i = new Inter3Impl();

i.save();

i.delete();

i.update();

i.find();

}

}

//1.创建接口1

interface Inter1{

void save();//保存功能

void delete();//删除功能

}

//2.创建接口22

interface Inter22{

void update();//更新功能

void find();//查询功能

}

//3.创建接口1的实现类

class Inter1Impl implements Inter1{

@Override

public void save() { }

@Override

public void delete() { }

}

//4.创建接口3,同时继承两个接口

/*1.接口可以继承接口，并且可以多继承，多个接口之间用逗号隔开*/

interface Inter3 extends Inter1,Inter22{ }

//5.创建接口3的实现类

/*2.接口与实现类是实现的关系，并且可以多实现，多个接口之间用逗号隔开

* 对于Java中的类而言，遵循：单继承 多实现

* 一个类只能有一个父类，但是一个类可以实现多个接口*/

//class Inter3Impl implements Inter3{//写法1

class Inter3Impl implements Inter1,Inter22{//写法2

@Override

public void save() {

System.out.println("稍等...正在努力保存中...");

}

@Override

public void delete() {

System.out.println("删除成功！");

}

@Override

public void update() {

System.out.println("小二正在马不停蹄的更新~");

}

@Override

public void find() {

System.out.println("客官，马上就查询好啦，稍等一丢丢~");

}

}

8 总结

1. 类与类的关系

继承关系,只支持单继承

比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源和构造方法)

子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)

2. 类和接口的关系

实现关系.可以单实现,也可以多实现

class A implements B,C{}

其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类

3. 接口与接口的关系

是继承关系,可以单继承,也可以多继承

interface A extends B,C{}

其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)

class X implements A{}

X实现类需要重写ABC接口的所有方法,否则就是抽象类

class A extends B implements C,D{}

其中A是实现类,也是B的子类,同时拥有CD接口的所有功能

这时A需要重写CD接口里的所有抽象方法

4. 抽象类与接口的区别

抽象类是一个特殊的类,特殊在,抽象类中可以包含没有方法体的方法(抽象方法)

接口可以理解成一个特殊的抽象类,特殊在,接口里的都是抽象方法,没有普通方法

接口会为方法自动拼接public abstract,还会为变量自动拼接public final static

抽象类可以有成员变量成员常量 接口只能有静态常量

抽象类可以有构造方法–用来给子类创建对象,接口中没有构造方法

抽象类和接口都不能实例化(创建对象)

接口可继承接口，并可多继承接口，但类只能单继承

抽象方法只能声明，不能实现，接口是设计的结果 ，抽象类是重构的结果

————————————————

版权声明：本文为CSDN博主「程序媛 泡泡」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

原文链接：新手小白学JAVA 接口 面向接口开发