day19-interface02

weixin_40821126

于 2020-04-10 00:31:40 发布

阅读量80

点赞数

分类专栏：菜鸟学Java

本文链接：https://blog.csdn.net/weixin_40821126/article/details/105424519

版权

菜鸟学Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本节内容：

1.接口

A.啥是接口？

接口就是一种能力和约定。一种协议，一种规则。

B.接口的内容

A：接口中，包含静态常量，默认的(缺省)修饰符：public static final
B：接口中，包含抽象方法，默认的(缺省)修饰符：public abstract

C.接口的语法

//1.定义一个接口
interface 接口名{
    //静态常量
    //抽象方法
}
//2.需要实现类来实现接口：类比子类继承抽象类。
class 实现类 implements 接口名{
    //重写接口中的抽象方法
}
//3.创建实现类的对象

D.接口引用

同父类一样，接口也可以声明为引用，指向实现类的对象。其实就是一种接口的多态。

接口类型的引用 = new 实现类的对象

那么只能调用接口中所声明的方法。不能调用实现类中新增的方法。可以强制转回实现类的类型，就可以调用新增的方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RhvzkWpd-1586449852638)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203122904.png)]

E.接口的注意点：

1、接口可以多实现：一个实现类可以同时实现多个接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6yneeR7g-1586449852639)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203136262.png)]

package com.qf.demo02_interface;
//定义一种规则：
interface A{
	public void testA();//
	public void fun();
}
//定义另一种规则
interface B{
	public void testB();
	public void fun();
}
//实现类，实现接口A。满足接口的规则：其实就是要实现接口中所有的抽象方法。
class DemoA implements A,B{
	@Override
	public void testA() {
		System.out.println("DemoA类，满足接口A的规则。。。");
	}
	
	@Override
	public void testB() {
		System.out.println("DemoA类，也满足接口B的规则。。。");
	}
	
	@Override
	public void fun() {
		System.out.println("DemoA类，实现类fun方法。。。");
	}
}

public class Test1Interface {

	public static void main(String[] args) {
		A a = new DemoA();
		a.testA();
		a.fun();
		
		
		B b = new DemoA();
		b.testB();
		b.fun();
		
		DemoA demoA = new DemoA();
		demoA.testA();
		demoA.testB();
	}

}

2、接口可以多继承

类中的方法：有声明有实现的方法。

接口中方法：有声明，没有实现。将功能的描述，和功能的实现，分离开。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Lmj7fVnK-1586449852640)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203150678.png)]

package com.qf.demo03_interface;
//一种规则
interface C{
	public void testC();
}
//另一种规则
interface D{
	public void testD();
}

//接口可以继承多个父接口
interface E extends C,D{
	public void testE();
}


//实现类，实现接口E
class DemoB implements E{

	@Override
	public void testC() {
		System.out.println("C协议。。");
	}

	@Override
	public void testD() {
		System.out.println("D协议。。");
	}

	@Override
	public void testE() {
		System.out.println("E协议。。。");
	}
	
}
public class Test3Interface {

	public static void main(String[] args) {
		C c = new DemoB();
		c.testC();
		
		D d = new DemoB();
		d.testD();
		
		E e = new DemoB();
		e.testC();
		e.testD();
		e.testE();
	}

}

3、一个类如果实现接口了，还能继承其他的父类吗？可以的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K0eLZPrh-1586449852640)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203205382.png)]

意味着，一个类继承了一个父类：那么就可以直接使用父类的非私有化的属性和方法。
同时，还实现接口某个接口规则。
这个类即作为一个父类的子类，又作为了一个接口的实现类。
package com.qf.demo04_interface;
//表示一种协议，一种规则
interface H{
	public void testH();
	public void fun();
}
//继承？is - a，子类是一个特殊的父类
class M{
	public void testM(){
		System.out.println("我是M类的方法。。");
	}
	
	public void fun(){
		System.out.println("M类中的fun方法。。。");
	}
}
//定义一个类：N
//继承了父类M：意味着N这个类可以直接使用父类的非私有化的属性和方法。
//同时实现接口H：意味着满足接口H中的所有规则：抽象方法。。
class N extends M implements H{

	@Override
	public void testH() {
		System.out.println("满足了接口H的协议规则。。");
	}
	
	//父类的fun方法，一旦存在继承关系，相当于子类也有一份。
//	public void fun(){
//		System.out.println("M类中的fun方法。。。");
//	}
}
public class Test4 {

	public static void main(String[] args) {
		//课间思考题：一个类可以继承父类的同时，再实现接口吗？
		
		M m = new N();//父类引用，指向子类的对象：一种对象的多态
		m.testM();
		m.fun();
		
		System.out.println("-----------------");
		
		H h = new N();//接口引用，指向实现类对象：一种接口的多态
		h.testH();
		h.fun();

	}

}

4、如果一个类没有实现接口中的所有的方法，那么它是抽象的

一个实现类可以实现接口，但是如果没有实现全部的方法， 那么该类是抽象的。等待子类继承，并且实现抽象方法。
package com.qf.demo05_interface;
interface K{
	public void test1();
	public void test2();
}

abstract class KImpl implements K{
	@Override
	public void test1() {
		
	}
}

class L extends KImpl{

	@Override
	public void test2() {
		
	}
	
}
public class Test5 {

	public static void main(String[] args) {

	}

}

5、接口中的两个特殊的方法

1、静态方法：
2、默认的方法：jdk1.8版本出现的新特性。
	目的：不强制一定要实现某个功能。

2.关于接口和抽象类

Java中类都是单继承的。如果父类的方法种类无法满足子类的需求，可以通过实现接口来扩充子类的功能。而且接口支持多继承，多实现的。更灵活一些。
概念：
抽象类：讲究的是继承。
接口：讲究的是规范，规则。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q3MPwcWi-1586449852640)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203224654.png)]

A.接口的好处

A：降低了程序的耦合性。代码的关联程度。
	接口中只做功能的声明，没有具体的实现。
	面向接口编程：关心功能有哪些
B：定义的都是规则，对外暴露的功能是一致。
C：接口可以多继承，以及多实现，使用更灵活。

B.接口回调

首有个接口A，和它实现类。然后在另一个类B中，持有A的引用，那么在B类中可以调用接口A的方法。这就是一种回调。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2AqwsnIY-1586449852641)(C:\Users\徐嘟嘟\AppData\Roaming\Typora\typora-user-images\image-20200409203237172.png)]

3.类和类的关系

Java中的数据了类型：两大类(基本类型和引用类型)

基本类型：又叫简单类型。直接赋值数值即可。4类8种

byte，short，int，long，float，double，char，boolean
引用类型：存储的地址。操作引用。默认值都是null

String，数组，Person类，Student，Cat，接口类型。。。

Exception in thread "main" java.lang.NullPointerException
空指针异常：对象是null，没有，非要访问它的属性或方法。
Book book = null;
null.属性：赋值取值
null.方法()，表示调用

1、继承关系

继承是指一个类继承另一个类。一个作为子类，另一个是父类。子类可以使用父类的内容，还可以扩展自己的内容。(类，接口)

public class Animal{}
public class Cat extends Animal{}

2、实现关系

实现是指一个类，实现接口中所有的抽象方法。一个类可以同时实现多个接口。

public interface A{}
public class AImple implements A{}

3、依赖关系

一个类依赖另一个类。两个类之间的耦合度不大。代码层面体现：一个类作为另一个类的方法的参数。

public class Pet{}
public class Girl{
    public void play(Pet pet){
        
    }
}

4、关联关系

两个类之间的依赖关系比较强。代码层面体现：一个类作为另一个类的属性。

public class Book{}
public class Person{
	Book book;
}

特殊的关联关系：聚合，组合。。。

总结内容：

接口的使用

1、接口的语法
2、接口的关键字
3、接口的概念：表示的意图：定义一组规则。
4、接口的使用点：
	多继承：一个接口可以继承其他的接口。
	多实现：一个实现类，可以同时实现多个接口。A，B
	一个类可以继承父类的同时，再实现其他的接口。
	一个类如果没有实现接口中的所有的抽象方法，那么这个类要抽象的。
5、接口中的两个特殊方法：了解
	static静态方法。
	JDK1.8之后，提供了基本的实现。default方法，允许有方法体。不强制实现类必须实现。
6、和抽象类的比较：
	抽象类：本质是个类。作为父类，讲究的是继承：is - a
		受到单继承的限制
	接口：本质是个规则。实现类满足这个规则。
		没有这个限制。

weixin_40821126

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day19-interface02

本节内容：1.接口A.啥是接口？接口就是一种能力和约定。一种协议，一种规则。B.接口的内容A：接口中，包含静态常量，默认的(缺省)修饰符：public static finalB：接口中，包含抽象方法，默认的(缺省)修饰符：public abstractC.接口的语法//1.定义一个接口interface 接口名{ //静态常量 //抽象方法}//2.需要实...
复制链接

扫一扫