Java学习【阶段一[04]】继承与多态（05接口）

最新推荐文章于 2023-01-20 19:06:47 发布

222100327赵振廷

最新推荐文章于 2023-01-20 19:06:47 发布

阅读量149

点赞数

分类专栏： Java学习路线

本文链接：https://blog.csdn.net/qq_41915980/article/details/102776048

版权

Java学习路线专栏收录该内容

35 篇文章 0 订阅

订阅专栏

一、接口定义的基本格式

接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法
如何定义一个接口：
格式
public interface 接口名称{
//接口内容
}

备注：换成了关键字interace之后，编译生成的字节码文件仍然是：.java-->.class

接口中可以包含的内容有：
1、常量
2、抽象方法
3、默认方法
4、静态方法
5、私有方法

二、接口的抽象方法定义

在任何版本的Java中都能定义抽象方法
public abstract 返回值类型方法名称（参数列表）；
【注意事项】
1、接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2、这两个关键字修饰符，可以选择性省略
3、方法的三要素可以随意定义

public interface MyInterfaceAbstract {
	//这是一个抽象方法
	public abstract void methodAbs();
	
	abstract void methodAbs1();
	
	public void methodAbs2();
	
	void methodAbs3();
	//以上几种都是抽象方法

}

三、接口的抽象方法使用

接口使用步骤：
1、接口不能直接使用，必须要有一个“实现类”来实现接口
格式：
public class 实现类名称 implements 接口名称{
//.....
}
2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
实现：去掉abstract关键字，加上方法体大括号
3、创建实现类的对象进行使用

【注意事项】

如果实现类没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就必须是抽象类。

步骤1&步骤2：创建实现类：并且覆盖重写所有的抽象方法

package Day10_Demo01;

public class MyInterfaceAbstractImpl implements MyInterfaceAbstract{
	@Override
    public void methodAbs() {
		System.out.println("这是第一个方法！");
	
    }
	@Override
	public void methodAbs1() {
		System.out.println("这是第二个方法！");
		
	}
	@Override
	public void methodAbs2() {
		System.out.println("这是第三个方法！");
			
	}
	@Override
	public void methodAbs3() {
		System.out.println("这是第四个方法！");
				
	}

}

步骤3：创建实现类的对象进行使用

public class Demo01Interface {
	public static void main(String[] args) {
		//错误写法！不能直接new接口对象使用
		// MyInterfaceAbstract inter=new MyInterfaceAbstract();
		//创建实现类的对象使用
		MyInterfaceAbstractImpl impl=new MyInterfaceAbstractImpl();
		impl.methodAbs();
		impl.methodAbs1();
	}

}
/*
这是第一个方法！
这是第二个方法！
*/

四、接口的默认方法定义

默认方法的定义格式
public default 返回值类型方法名称（参数列表）{
方法体//和抽象方法不一样
}
备注：接口当中的默认方法，可以解决接口升级的问题（接口升级就是接口进行更新，如果使用抽象方法，实现类都需要重写，不方便，为了解决这个矛盾，使用默认方法）

五、接口的默认方法使用

1、接口的默认方法，可以通过接口实现类对象，直接调用
2、接口的默认方法，也可以被接口实现类进行覆盖重写

package Day10_Demo01;
/*
1、接口的默认方法，可以通过接口实现类对象，直接调用
2、接口的默认方法，也可以被接口实现类进行覆盖重写
 */
public class Demo02Interface {
	public static void main(String[] args) {
		//创建了实现类对象
		MyInterfaceDefaultA a=new MyInterfaceDefaultA();
		a.methodAbs1();//输出：实现了抽象方法，AAA
		//调用抽象对象，实际运行的是右侧实现类。new的是谁，运行的就是谁
		//调用默认方法，如果实现类中没有，会向上找接口
		a.methodDefault();//输出：新添加的默认方法（没有重写默认方法
		
		MyInterfaceDefaultB b=new MyInterfaceDefaultB();
		b.methodAbs1();//输出：实现了抽象方法，BBB
		
		b.methodDefault();//输出：实现类B覆盖重写了接口的默认方法(重写了默认方法
	}

}

package Day10_Demo01;

public class MyInterfaceDefaultA implements MyInterfaceDefault {
	@Override
	public void methodAbs1() {
		System.out.println("实现了抽象方法，AAA");
	}

}

package Day10_Demo01;

public class MyInterfaceDefaultB implements MyInterfaceDefault {
	@Override
	public void methodAbs1() {
		System.out.println("实现了抽象方法，BBB");
	}
		@Override
	public void methodDefault() {
		System.out.println("实现类B覆盖重写了接口的默认方法");
	}

}

五、接口的静态方法定义

同类对象共享的内容：静态方法

静态方法定义格式
public static 返回值类型方法名称（参数列表）{
方法体
}
提示：就是将abstract或者default换成static即可，带上方法体

六、接口的静态方法的使用

注意：不能通过接口实现类的对象来调用接口当中的静态方法
接口一个类可以实现多个接口，多个接口中可能产生冲突
正确用法：通过接口名称直接调用其中的静态方法
格式
接口名称.静态方法名（参数）

定义一个接口的静态方法

package Day10_Demo01;
/*
静态方法定义格式
public static 返回值类型 方法名称（参数列表）{
方法体
}
提示：就是将abstract或者default换成static即可，带上方法体
 */
public interface MyInterfaceStatic {

	public static void methodStatic() {
		System.out.println("这是接口的静态方法");
	}
}

通过接口直接调用静态方法

package Day10_Demo01;

/*
注意：不能通过接口实现类的对象来调用接口当中的静态方法
接口一个类可以实现多个接口，多个接口中可能产生冲突
正确用法：通过接口名称直接调用其中的静态方法
格式
接口名称.静态方法名（参数）
 */
public class Demo03Interface {
	public static void main(String[] args) {
		//创建了实现类对象
		MyInterfaceStaticImpl impl=new MyInterfaceStaticImpl();
		
		//错误写法
		//impl.methodStatic();
		
		//直接通过接口名称调用静态方法
		MyInterfaceStatic.methodStatic();//输出：这是接口的静态方法
		
	}

}

七、接口的私有方法定义

问题描述：
我们需要抽取一个共有的方法，用来解决两个默认方法之间重复代码的问题
但是这个共有方法不应该让实现类使用，而应该是私有化
解决方案：
从Java9开始，接口中允许定义私有方法
1、普通私有方法：解决多个默认方法之间重复代码问题
格式：
private 返回值类型方法名称（参数列表）{
方法体
}
2、静态私有方法，解决多个静态方法之间重复代码的问题
格式：
private static 返回值类型方法名称（参数列表）{
方法体
}

八、接口的私有方法使用

普通私有方法

public interface MyInterfacePrivateA {
	
	public default void methodDefault1() {
		System.out.println("默认方法1");
		methodCommon();
	}
	public default void methodDefault2() {
		System.out.println("默认方法2");
		methodCommon();
	}
	private void methodCommon() {//只有上面两个方法可以使用
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
	}

}

静态私有方法

package Day10_Demo01;


public interface MyInterfacePrivateB {
	
	public static void methodStatic1() {
		System.out.println("静态方法1");
		methodCommon();
	}
	public static void methodStatic2() {
		System.out.println("静态方法2");
		methodCommon();
	}
	private static void methodCommon() {//只有上面两个方法可以使用
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
	

}

package Day10_Demo01;

public class Demo04Interface {
	public static void main(String[] args) {
		MyInterfacePrivateB.methodStatic1();
		MyInterfacePrivateB.methodStatic2();
		//错误写法
		//MyInterfacePrivateB.methodCommon();
	}
}

九、接口的常量定义和使用

接口当中也可以定义”成员变量“，但是必须使用public static final三个关键字进行修饰
从效果上看其实就是接口的【常量】
格式：
public static final 数据类型常量名称=数据值；
备注：
一旦使用final关键字进行修饰，说明不可改变

【注意事项】
1、接口当中的常量可以省略public static final三个关键字。但是不写也一样
2、接口当中的常量必须进行赋值
3、接口当中的常量名称使用完全大写并且用下划线进行分割【推荐的命名规则】

package Day10_Demo01;
/*
接口当中也可以定义”成员变量“，但是必须使用public static final三个关键字进行修饰
从效果上看其实就是接口的【常量】
格式：
public static final 数据类型 常量名称=数据值；
备注：
一旦使用final关键字进行修饰，说明不可改变

【注意事项】
1、接口当中的常量可以省略public static final三个关键字。但是不写也一样
2、接口当中的常量必须进行赋值
3、接口当中的常量名称使用完全大写并且用下划线进行分割【推荐的命名规则】
 */

public interface MyInterfaceConst {
	//这就是一个常量，一旦赋值不可以修改
	public static final int MUM_OF_MYCLASS=10;
	//public  大家都能随便用
	//static  可以直接用接口名称.常量名称进行调用
	//final   说明赋值后不可改变

}

调用常量：接口.常量名称

package Day10_Demo01;

public class Demo05Interface {
	public static void main(String[] args) {
		//访问接口当中的常量
		System.out.println(MyInterfaceConst.MUM_OF_MYCLASS);//输出：10
	}
}

十、接口的内容小结

接口的内容可以有：

1、成员变量其实是常量，格式：

[public] [static] [final ]数据类型常量名称 =数据值；public static final三个关键字可以省略。[ ]代表可以省略

【注意】接口当中的常量必须进行赋值
接口当中的常量名称使用完全大写并且用下划线进行分割

2、接口中最重要的就是抽象方法，格式：

[ public] [abstract]返回值类型方法名称（参数列表）；

【注意】实现类必须覆盖重写接口的所有抽象方法，除非实现类是抽象类

3、定义默认方法，格式：

[public] default 返回值类型方法名称（参数列表）{方法体}

【注意】默认方法也可以被覆盖重写

4、定义静态方法，格式：

[public] default 返回值类型方法名称（参数列表）{方法体}

【注意】应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

5、定义私有方法，格式：

普通私有方法：private 返回值类型方法名称(参数列表）{方法体}

静态私有方法：private static 返回值类型方法名称(参数列表）{方法体}

【注意】：private的方法只有接口自己才能调用，不能被实现类或者其他调用

十一、继承父类并实现多个接口

使用接口的时候，需要注意
1、接口是没有静态代码块或者构造方法的
2、一个类直接父类是唯一的，但是一个类可以同时实现多个接口
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{//两个接口
//覆盖重写所有抽象方法
}
3、如果实现类所实现的多个接口当中存在重复的抽象方法，那么只需要覆盖重写一次即可
4、如果要是实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是抽象类
5、如果实现类所实现的多个接口当中存在重复的默认方法，到底听哪个方法体，解决办法，必须对重复的默认方法进行重写
6、如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法(java中继承优先于接口）

代码示例：

1、接口是没有静态代码块或者构造方法的

package Day10_Demo02;

public interface MyInterface {
	//错误写法！接口不能有静态代码块
	//static {
	//
//	}
//错误写法，接口不能有构造方法
	//public MyTnterface() {
	//	
	//}
}

如果实现类所实现的多个接口当中存在重复的抽象方法，那么只需要覆盖重写一次即可
如果要是实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是抽象类
如果实现类所实现的多个接口当中存在重复的默认方法，到底听哪个方法体，解决办法，必须对重复的默认方法进行重写

定义接口A

package Day10_Demo02;

public interface MyInterfaceA {
	//错误写法！接口不能有静态代码块
	//static {
	//
//	}
//错误写法，接口不能有构造方法
	//public MyTnterface() {
	//	
	//}
	public abstract void methodA();
	
	public abstract void methodAbs();
	
	public default void methodDefault() {
		System.out.println("默认方法AAA");
	}
}

定义接口B

package Day10_Demo02;

public interface MyInterfaceB {
	//错误写法！接口不能有静态代码块
	//static {
	//
//	}
//错误写法，接口不能有构造方法
	//public MyTnterface() {
	//	
	//}
	public abstract void methodB();
	
	public abstract void methodAbs();//与A接口相同，那么只需要重写一次
	
	public default void methodDefault() {
		System.out.println("默认方法BBB");
	}
}

实现类：

package Day10_Demo02;

public class MyInterfaceImpl implements/* extends Object*/ MyInterfaceA,MyInterfaceB{
	@Override
	public void methodA() {
		System.out.println("覆盖重写了A方法");
		
	}
	@Override
    public void methodB() {
		System.out.println("覆盖重写了B方法");	
    }
	@Override
	public void methodAbs() {
		System.out.println("覆盖重写了AB接口都有的抽象方法，只需要重写一次");
		
	}
	
	@Override//必须对多个接口中重复的默认方法进行重写
		public void methodDefault() {
			System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
		}
}

如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法(java中继承优先于接口）

定义父类

package Day10_Demo02;

public class Fu {
	public void method() {
		System.out.println("父类方法");
		
	}

}

定义接口

package Day10_Demo02;

public interface MyInterface {
	public default void method() {
		System.out.println("接口的默认方法");
	}

}

定义子类继承父类并且实现接口

package Day10_Demo02;

public class Zi extends Fu implements MyInterface {

}

进行子类实现调用

public class Dem01Interface {
	public static void main(String[] args) {
		Zi zi=new Zi();
		zi.method();//输出：父类方法

	}
}

十二、接口之间的多继承

1、类与类之间是单继承的。直接父类只有一个
2、类与接口之间是多实现的。一个类可以实现多个接口
3、接口与接口之间是多继承的。

【注意事项】：
1、多个父接口当中的抽象方法如果重复没有关系，因为没有方法体
2、多个父接口当中的默认方法如果重复，有关系，方法体冲突，那么子接口必须进行默认方法的覆盖重写【而且必须带着default关键字】

父接口A：

package Day10_Demo03;

public interface MyInterfaceA {
	
	public abstract void methodA();
	
	public abstract void methodCommon();
	
	public default void methodDefault() {
		System.out.println("AAA");
	}
}

父接口B：

package Day10_Demo03;

public interface MyInterfaceB {
	
	public abstract void methodB();

	public abstract void methodCommon();
	
	public default void methodDefault() {
		System.out.println("BBB");
	}
}

子接口：

package Day10_Demo03;
/*
这个子接口当中有几个方法？5个
methodA  来源于接口A
methodB  来源于接口B
methodCommon  同时来源于接口A和B
method  来源于我自己
methodDefault   来源我自己  并且进行了重写

 */
public interface MyInterface extends MyInterfaceA,MyInterfaceB{
	
	public abstract void method();

	@Override
	default void methodDefault() {
		System.out.println("进行默认方法的覆盖重写");
	}

}

222100327赵振廷

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习【阶段一[04]】继承与多态（05接口）

一、接口定义的基本格式接口就是多个类的公共规范接口是一种引用数据类型，最重要的内容就是其中的：抽象方法如何定义一个接口：格式public interface 接口名称{ //接口内容}备注：换成了关键字interace之后，编译生成的字节码文件仍然是：.java-->.class接口中可以包含的内容有：1、常量2、抽象方法3、默认方法4、静态方法5、...
复制链接

扫一扫