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

接口

1 接口的概念

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

2 接口格式

3 接口的特点:

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

4.1 练习-1:创建接口

创建包: cn.tedu.inter
创建接口:Inter.java

package cn.tedu.inter;
/**本接口是创建接口测试*/
/**1.通过interface关键字来定义接口*/
public interface Inter {
	/**2.接口中可以有普通方法吗?--不可以!!*/
	//public void eat() {}
<span class="token comment">/**3.接口中可以有抽象方法吗?--可以,接口中的方法都是抽象方法!!!*/</span>
<span class="token keyword">public</span> <span class="token keyword">abstract</span> <span class="token keyword">void</span> <span class="token function">eat</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">public</span> <span class="token keyword">abstract</span> <span class="token keyword">void</span> <span class="token function">play</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

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{
<span class="token annotation punctuation">@Override</span> <span class="token comment">//作为标记,表示实现了父接口的抽象方法</span>
<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">eat</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
	System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"吃火锅"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

<span class="token annotation punctuation">@Override</span><span class="token comment">//作为标记,表示实现了父接口的抽象方法</span>
<span class="token keyword">public</span> <span class="token keyword">void</span> <span class="token function">play</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
	System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"玩代码"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

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

创建包: cn.tedu.inter
创建接口测试类:InterTests.java

package cn.tedu.inter;
/**本类用于测试接口的实现类*/
public class InterTests {
	//6.创建入口函数main()
	public static void main(String[] args) {
		//7.测试接口创建对象
		/**接口可以创建对象吗?--不可以!!!*/
		//Inter i = new Inter();
	<span class="token comment">//8.创建多态对象进行测试</span>
	Inter i <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">InterImpl</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	<span class="token comment">//9.通过对象调用方法测试</span>
	i<span class="token punctuation">.</span><span class="token function">eat</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	i<span class="token punctuation">.</span><span class="token function">play</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	
	<span class="token comment">//10.创建子类对象并进行测试</span>
	InterImpl i2 <span class="token operator">=</span> <span class="token keyword">new</span> <span class="token class-name">InterImpl</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	i2<span class="token punctuation">.</span><span class="token function">eat</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	i2<span class="token punctuation">.</span><span class="token function">play</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

5 接口的用法

5.1 练习: 接口之构造方法

创建包: cn.tedu.inter2
创建类:TestUserInter.java

package cn.tedu.inter2;
/**本类用于进一步测试接口的使用*/
public class TestUserInter {
	//5.创建入口函数main()
	public static void main(String[] args) {
		//6.创建多态对象进行测试
		/**问题:子类创建对象时,默认会调用父类的构造方法
		 * 目前接口实现类的父级是一个接口,而接口没有构造方法
		 * 那实现类构造方法中的super()调用的是谁呢?
		 * 结论:如果一个类没有明确指定父类,那么默认继承顶级父类Object
		 * 所以super()会自动调用Object类中的无参构造
		 * */
		/**查看类的继承结构:Ctrl+T*/
		Inter2 i = new Inter2Impl();
	}
}

//1.创建接口
interface Inter2{
/**1.接口中有构造方法吗?–不可以!!!*/
//2.测试接口是否可以有构造方法
// public Inter2() {}

}

//3.创建接口的实现类
//class Inter2Impl extends Object implements Inter2{
class Inter2Impl implements Inter2{
//4.创建实现类的构造函数
public Inter2Impl() {
super();
System.out.println(“我是Inter2Impl的无参构造”);
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

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

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

5.2 练习: 接口之成员变量

package cn.tedu.inter2;
/**本类用于进一步测试接口的使用*/
public class TestUserInter {
	//5.创建入口函数main()
	public static void main(String[] args) {
		//6.创建多态对象进行测试
		/**问题:子类创建对象时,默认会调用父类的构造方法
		 * 目前接口实现类的父级是一个接口,而接口没有构造方法
		 * 那实现类构造方法中的super()调用的是谁呢?
		 * 结论1:如果一个类没有明确指定父类,那么默认继承顶级父类Object
		 * 所以super()会自动调用Object类中的无参构造
		 * */
		/**查看类的继承结构:Ctrl+T*/
		Inter2 i = new Inter2Impl();
		/**结论2:接口中的变量实际上都是静态常量,可以通过类名直接调用*/
		System.out.println(Inter2.age);
		/**结论3:接口中的变量实际上都是静态常量,值不可以被修改*/
		//Inter2.age = 200;
	}
}

//1.创建接口
interface Inter2{
/**1.接口中有构造方法吗?–不可以!!!*/
//2.测试接口是否可以有构造方法
// public Inter2() {}
/**2.接口里可以有成员变量吗?–没有!!!
* 是一个静态常量,实际上的写法是public static final int age = 10;
* 只不过在接口中可以省略不写
* */
int age = 10;

}

//3.创建接口的实现类
//class Inter2Impl extends Object implements Inter2{
class Inter2Impl implements Inter2{

<span class="token comment">//4.创建实现类的构造函数</span>
<span class="token keyword">public</span> <span class="token function">Inter2Impl</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
	<span class="token keyword">super</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
	System<span class="token punctuation">.</span>out<span class="token punctuation">.</span><span class="token function">println</span><span class="token punctuation">(</span><span class="token string">"我是Inter2Impl的无参构造"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44

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

5.3 练习: 接口之成员方法

package cn.tedu.inte2r;
/**本类用于进一步测试接口的使用*/
public class TestUserInter {
	public static void main(String[] args) {
		//3.在main()中创建多态对象进行测试
		/**问题:子类创建对象时,会自动调用父类的构造方法,但是现在的父级是个接口
		 * 接口里没有构造方法,那子类中super()调用的是什么呢?
		 * 结论1:子类默认继承了顶级父类Obejct,super()会自动调用Object的无参构造
		 */
		Inter2 in = new Inter2Impl();
		/**结论2.1:接口中的变量实际上都是静态常量,可以通过类名直接调用*/
		System.out.println(Inter2.age);
		/**结论2.2:接口中的变量实际上都是静态常量,不能被重新赋值*/
		//Inter2.age = 20;
	}
}

//1.创建接口
interface Inter2{
/*1.接口里有构造方法吗?–没有!!!,连普通方法都没有/
//public Inter2() {}
/**2.接口里可以有成员变量吗?–没有!!!/
int age = 10;//静态常量,实际上:final static int age = 10;
/**3.接口中可以有抽象方法吗?–可以!!!/
abstract public void eat2();
void eat();//可以简写–会自动拼接public abstarct
}
//2.创建接口的实现类
class Inter2Impl implements Inter2 {
public Inter2Impl() {
super();//默认先调用顶级父类Object的无参构造方法
System.out.println(“我是Inter2Impl的无参构造”);
}
/*4.如果接口中添加了抽象方法,实现类中需要实现所有未实现的抽象方法/
@Override
public void eat2() {
}
@Override
public void eat() {
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41

总结:接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。例如：public abstract void save

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

具体事物: 培优班老师 高手班老师
共性: 讲课 备课
创建包: cn.tedu.design
创建类:TestDesignInter.java

package cn.tedu.design;
/**本类用于改造老师设计案例,采用面向接口编程*/
public class TestDesignInter {
	public static void main(String[] args) {
		CGBTeacher2 ct = new CGBTeacher2();
		ct.ready();
		ct.teach();
	}
}
//1.创建接口Teacher2--抽取共性,形成抽象层-体现接口-定义的是规则
/**1.通过interface关键字定义接口*/
interface Teacher2{
	/**2.接口中的方法都是抽象方法,可以简写public abstract*/
	//2.定义接口中的抽象方法
	//2.1备课方法
	void ready();
	//2.2上课方法
	void teach();
}
/**3.如果实现类想要使用接口的功能,就需要与接口建立实现关系*/
//3.创建接口的实现类并添加所有未实现的方法
class CGBTeacher2 implements Teacher2{
	@Override
	public void ready() {
		System.out.println("正在备课...电商项目");
	}
	@Override
	public void teach() {
		System.out.println("正在上课...电商项目");
	}
}
//4.创建接口的抽象子类
abstract class SCDTeacher2 implements Teacher2{}

//5.创建接口的抽象子类2
abstract class ACTTeacher2 implements Teacher2{
@Override
public void ready() {
System.out.println(“正在备课…基础加强…框架加强…高新技术”);
}
public abstract void teach() ;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42

7 接口的多继承多实现

创建包: cn.tedu.design
创建类:TestRelation.java

package cn.tedu.design;
/**本类用于测试接口与类之间的复杂关系*/
public class TestRelation {
	//5.创建入口函数
	public static void main(String[] args) {
		//6.创建实现类对象进行测试
		Inter3Impl i3 = new Inter3Impl();
		i3.update();
		//7.创建多态对象进行测试
		Inter3 i4 = new Inter3Impl();
		i4.find();
	}
}
//1.创建接口1
interface Inter1{
	void save();//保存功能
	void delete();//删除功能
}
//2.创建接口2
interface Inter2{
	void update();//更新功能
	void find();//查询功能
}
//3.创建接口3用来测试接口与接口的继承关系
/**1.接口之间可以建立继承关系,而且还可以多继承
 * 接口与接口之间用逗号隔开
 * */
interface Inter3 extends Inter1,Inter2{

}
//4.创建Inter3接口的实现类并添加未实现的方法
/**2.接口和实现类之间可以建立实现关系,通过implments关键字来完成

• 注意,java类是单继承,而接口不限,写接口时,我们一般先继承再实现
• */
  class Inter3Impl implements Inter3{
  @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(“小二正在马不停蹄的查询~~~”);
  }
  }

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52

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
抽象类可以有构造方法–用来给子类创建对象,接口中没有构造方法
抽象类和接口都不能实例化(创建对象)
接口可继承接口，并可多继承接口，但类只能单继承
抽象方法只能声明，不能实现，接口是设计的结果 ，抽象类是重构的结果