java作业接口类案例_java入门(二十五) | OOP(十二)之接口

接口

1.1 概念

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。

Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。

OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性.

就必须是面向接口的编程，面向抽象的编程，

正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。

interface 接口名{ 代码… }

1.2 特点

接口中都是抽象方法

通过interface关键字创建接口

通过implements让子类来实现 class Student implements Person

可以理解成，接口是一个特殊的抽象类，特殊在，接口中都是抽象方法

接口突破了java的单继承的局限性class Student implements Person,Human

接口和类之间可以多实现，接口和接口之间可以多继承interface A extends B,C

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

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

1.3 入门案例

package cn.qile.interfacedemo;

//1、通过interface关键字来定义接口

public interface Inter {

//2、接口里都是抽象方法，不能有普通方法

abstract public void eat();

//public void play() {}

}

interface Inter2{

abstract public void add();

}

//5、接口的多继承

//Inter3想用Inter2的功能，接口和接口之间是继承关系，还可以多继承，多个接口间逗号隔开

interface Inter3 extends Inter2,Inter{

abstract public void delete();

}

//创建接口的实现类

//3、子类想要使用接口里的功能，用implements关键字表示实现关系

//4、子类实现接口后，子类可以是抽象子类 也可以 把接口里的所有抽象方法都重写

//abstract class InterImpl implements Inter{

//5.1、子类实现了最全的接口Inter3，就要把所有抽象方法都重写，否则还是一个抽象子类

class InterImpl implements Inter3{

//6、子类和接口之间是实现关系，而且可以多实现，实现了接口，就要把接口里的所有抽象方法都重写

//class InterImpl implements Inter,Inter2{

@Override

public void eat() {

System.out.println("InterImpl...eat()");

}

@Override

public void add() {

System.out.println("InterImpl...add()");

}

@Override

public void delete() {

System.out.println("InterImpl...delete()");

}

}

//7、子类可以继承的同时多实现

class InterImpl2 extends InterImpl implements Inter,Inter2{

}

接口的用法

2.1 构造方法

接口里是没有构造方法的。

在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。

2.2 成员变量

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

public static final

2.3 成员方法

口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。

例如：public abstract void save

2.4 测试

创建接口

package cn.qile.interfacedemo;

public interface UseInter {

// 构造方法

//1、接口里 不能 有构造方法

// public UseInter() {}

//2、成员变量 --接口里根本就没有变量，都是静态常量

//接口会为变量会自动拼接public static final

// public static final int sum = 10;

int sum = 10;

//方法可以简写，接口会为方法自动拼接public abstract

// public abstract void eat();

void eat();

}

创建接口的实现类

package cn.qile.interfacedemo;

public class UseInterImpl implements UseInter {

int count = 10;

public UseInterImpl() {

super();//访问了Object里的无参构造

}

@Override

public void eat() {

System.out.println("我吃了一大碗米饭");

}

public static void main(String[] args) {

//创建多态对象测试

UseInter u = new UseInterImpl();

u.eat();

// u.sum=20;

System.out.println(UseInter.sum);

}

}

总结

1、类和类的关系

-- 是继承关系，而且是单继承 class A extends B

-- 其中A是子类，B是父类。

-- A可以无偿使用B的功能(除了私有成员)

-- 如果想要修改B的功能，需要发生方法的重写：方法声明和父类一模一样

-- 重写后，父类的功能并没影响，改变的是子类自己的功能

2、类和接口的关系

-- 是实现关系，而且可以多实现 class A implements B,C

-- 其中A是实现类，B和C是接口

-- A需要把B和C接口中的所有抽象方法都重写，否则A是抽象类

3、接口和接口的关系

-- 是继承关系，而且可以多继承 interface A extends B,C

-- 其中A是子接口,B和C是父接口

-- A接口同时拥有了B和C的所有功能

-- 子类实现A接口 class M implements A

-- M必须重写A B C 接口的所有抽象方法，否则M就是抽象类

3.1、 类可以继承的同时多实现

-- class A extends B implements C,D

-- 其中 A是子类/实现类 ，B是父类，C和D是父接口

-- 这时A必须重写C和D接口里的所有抽象方法，否则A就是抽象子类

-- 至于父类B的功能，看需求，需要重写就重写

4、抽象类

-- 抽象类是一个特殊的类，特殊在抽象类中可以包含抽象方法

-- 抽象类不能被实例化

-- 抽象类中有构造方法,，目的，是为了给子类创建对象

-- 抽象类中可以有常量也可以有变量

-- 抽象类中可有普通方法，也可以都是普通方法

-- 如果都是普通方法，这个类还是被声明是一个抽象类，目的就是不让外加new

5、接口

-- 是一个特殊的抽象类，特殊在接口里都是抽象方法

-- 接口没有构造方法，子类创建对象时调用Object的构造方法

-- 接口里没有变量，会为变量自动拼接public static final变成常量

-- 接口里都是抽象方法，会为方法自动拼接public abstract

程序设计

有两个事物：初中生、大学生

共性：上课、做作业、王者荣耀

测试：创建多态对象测试

提示：利用面向抽象和面向接口思想完成程序设计

4.1 面向抽象编程

package cn.qile.interfacedemo;

public class Test1 {

public static void main(String[] args) {

Student s = new CzsStudent();

s.study();

s.work();

s.play();

Student s2 = new DxsStudent();

s2.study();

s2.work();

s2.play();

}

}

//有两个事物：初中生、大学生

//共性：上课、做作业、王者荣耀

abstract class Student {

// 上课

abstract public void study();

// 做作业

abstract public void work();

// 玩

public void play() {

System.out.println("王者荣耀");

}

}

class CzsStudent extends Student {

// 上课

@Override

public void study() {

System.out.println("早八晚九");

}

// 做作业

@Override

public void work() {

System.out.println("天天high起来，其乐无穷");

}

}

class DxsStudent extends Student {

// 上课

public void study() {

System.out.println("随个人喜好，自学");

}

// work

public void work() {

System.out.println("作业？笔都没有");

}

}

4.2 面向接口编程

package cn.qile.interfacedemo;

public class Test2 {

public static void main(String[] args) {

Student s = new CzsStudent();

s.study();

s.work();

s.play();

// Student s2 = new DxsStudent();

// s2.study();

// s2.work();

// s2.play();

}

}

//有两个事物：初中生、大学生

//共性：上课、做作业、王者荣耀

interface Student{

//上课

void study();

//做作业

void work();

//王者荣耀

void play();

}

class CzsStudent implements Student{

@Override

public void study() {

}

@Override

public void work() {

}

@Override

public void play() {

}

}

abstract class DxsStudent implements Student{

}

扩展

5.1 abstract注意事项

抽象方法要求子类继承后必须重写。那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。

1、 private：被私有化后，子类无法重写，与abstract相违背。

2、 static：静态的，优先于对象存在。而abstract是对象间的关系，存在加载顺序问题。

3、 final：被final修饰后，无法重写，与abstract相违背。

5.2 接口和抽象类的区别

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

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

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。