一起学JAVA 接口 面向接口开发

接口

1 接口的概念

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

2 接口格式

3 接口的特点:

1. 通过interface关键字来定义接口
2. 通过implements让子类来实现接口
3. 接口中的方法全部都是抽象方法(JAVA8)
4. 可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
5. 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
6. 接口突破了java单继承的局限性
7. 接口和类之间可以多实现,接口与接口之间可以多继承
8. 接口是对外暴露的规则,是一套开发规范
9. 接口提高了程序的功能拓展,降低了耦合性
   
   
   

4.1 练习-1:创建接口

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:创建接口实现类

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:创建接口测试类

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 练习: 接口之构造方法

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 练习:分析老师示例—面向接口编程

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 接口的多继承多实现

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. 类与类的关系

2. 类和接口的关系

3. 接口与接口的关系

4.接口与抽象类的区别

1. 接口是一种用interface定义的类型
   抽象类是一种用class定义的类型
   
   
2. 接口中的方法都是抽象方法,还有默认方法与静态方法
   抽象类中的方法不做限制
   
   
3. 接口中的都是静态常量
   抽象类中可以写普通的成员变量
   
   
4. 接口没有构造方法，不可实例化
   抽象类有构造方法，但是也不可以实例化
   
   
5. 接口是先天设计的结果，抽象是后天重构的结果
6. 接口可以多继承
   抽象类只能单继承