接口

最新推荐文章于 2022-04-05 16:32:26 发布
最新推荐文章于 2022-04-05 16:32:26 发布
阅读量221 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48496502/article/details/119650439
版权

目录

代码

接口：interface
接口和类是并列的两个结构

接口中定义全局常量
全局常量：public static final的，可省略不写public static final

class Untitled {
	public static void main(String[] args) {
		System.out.println(A.MAX);
		System.out.println(A.MIN);
		//同样不可以修改，报错
		//A.MIN = 1；
	}
}
interface A{
	//全局常量
	public static final int MAX = 10;
	//可省略不写 public static final
	int MIN = 0;
}

接口中定义抽象方法
抽象方法：public abstract 的，可省略不写public abstract

interface A{
	//全局常量
	public static final int MAX = 10;
	//可省略不写 public static final
	int MIN = 0;
	
	//抽象方法
	public abstract void m();
	//可省略不写 public abstract
	void s();
}

实现类可以实现多个接口
格式：class AA extends BB implements CC,DD,EE{}

interface A{
	int MIN = 0;
	public abstract void m();
	void s();
}
interface B{}
class C implements A,B{
	public void m(){}
	public void s(){}
}

接口与接口之间可以继承，而且是！！多继承！！此时实现类就必须重写所有的接口的抽象方法，否则就要声明成抽象类

interface A{
	int MIN = 0;
	public abstract void m1();
	void m2();
}
interface B{
	void m3();
}
interface C extends A,B{}
class D implements C{
	public void m1(){}
	public void m2(){}
	public void m3(){}
}

接口的使用也满足多态性，实现类与接口之间可以用多态

class Untitled {
	public static void main(String[] args) {
		Computer c = new Computer();
		Shubiao s = new Shubiao();
		c.m(s);      //实现了多态
	}
}
class Computer{
	public void m(USB b){   //USB b = new Shubiao();
		b.start();
		System.out.println("具体工作细节");
		b.stop();
	}
}
interface USB{
	public abstract void start();
	public abstract void stop();
}
class Shubiao implements USB{
	public void start(){
		System.out.println("鼠标开始工作");
	}
	public void stop(){
		System.out.println("鼠标结束工作");
	}
}
class Jianpan implements USB{
	public void start(){
		System.out.println("键盘开始工作");
	}
	public void stop(){
		System.out.println("键盘结束工作");
	}
}

接口中定义的静态方法只能通过接口来调用

class Untitled {
	public static void main(String[] args) {
		Sub s = new Sub();
		//接口中定义的静态方法只能通过接口来调用
		//s.m1();
		CompareA.m1();
	}
}
class Sub implements CompareA{
	
}
interface CompareA{
	public static void m1(){
		System.out.println("A的m1静态草莓");
	}
	public default void m2(){
		System.out.println("A的m2西瓜");
	}
	default void m3(){
		System.out.println("A的m3樱桃");
	}
}

接口中定义的默认方法通过实现类的对象来调用

若实现类中重写了接口中的默认方法，则输出的是实现类重写的方法

class Untitled {
	public static void main(String[] args) {
		Sub s = new Sub();
		//s.m1();
		CompareA.m1();
		s.m2();
		s.m3();
	}
}
class Sub implements CompareA{
	public void m3(){
		System.out.println("Sub的m3");
	}
}
interface CompareA{
	public static void m1(){
		System.out.println("A的m1静态草莓");
	}
	public default void m2(){
		System.out.println("A的m2西瓜");
	}
	default void m3(){
		System.out.println("A的m3樱桃");
	}
}

执行结果如下：
在这里插入图片描述

若父类和接口有同名方法，但是子类中没有重写，则子类调用时输出的是父类中的方法

class Untitled {
	public static void main(String[] args) {
		Sub s = new Sub();
		//s.m1();
		CompareA.m1();
		s.m2();
		s.m3();
	}
}
class Super{
	public void m3(){
		System.out.println("Super的m3哈密瓜");
	}
}
class Sub extends Super implements CompareA{
}
interface CompareA{
	public static void m1(){
		System.out.println("A的m1静态草莓");
	}
	public default void m2(){
		System.out.println("A的m2西瓜");
	}
	default void m3(){
		System.out.println("A的m3樱桃");
	}
}

执行结果如下
在这里插入图片描述

若多个接口内有同名方法，但是实现类中没有重写，则会报错：接口冲突

这时候就必须在实现类中重写该方法

在子类（实现类）中调用接口、父类中的被子类重写的方法

class Untitled {
	public static void main(String[] args) {
		new Sub().methon();
	}
}
class Super{
	public void m3(){
		System.out.println("Super的m3哈密瓜");
	}
}
class Sub extends Super implements CompareA,CompareB{
	public void m3(){
		System.out.println("Sub的m3草莓");
	}
	public void methon(){
		m3();                 //调用自己重写的方法
		super.m3();           //父类的方法
		CompareA.super.m3();  //接口的方法
		CompareB.super.m3();  //接口的方法
	}
}
interface CompareA{
	default void m3(){
		System.out.println("A的m3西瓜");
	}
}
interface CompareB{
	default void m3(){
		System.out.println("B的m3");
	}
}

执行结果如下
在这里插入图片描述

接口匿名实现类对象

和抽象类的匿名子类对象一样的写法

class Untitled {
	public static void main(String[] args) {
		Computer com = new Computer();
		//创建接口的非匿名实现类的非匿名对象
		Shubiao s = new Shubiao();
		com.m(s);
		
		//创建接口的非匿名实现类的匿名对象
		com.m(new Shubiao(););
		
		//创建接口的匿名实现类的非匿名对象
		USB phone = new USB(){
			public void start(){
				System.out.println("手机开始工作");
			}
			public void stop(){
				System.out.println("手机结束工作");
			}
		};
		com.m(phone);
		
		//创建接口的匿名实现类的匿名对象
		com.m(new USB(){
			public void start(){
				System.out.println("MP3开始工作");
			}
			public void stop(){
				System.out.println("MP3结束工作");
			}
		});
	}
}
class Computer{
	public void m(USB b){
		b.start();
		System.out.println("具体工作细节");
		b.stop();
	}
}
interface USB{
	public abstract void start();
	public abstract void stop();
}
class Shubiao implements USB{
	public void start(){
		System.out.println("鼠标开始工作");
	}
	public void stop(){
		System.out.println("鼠标结束工作");
	}
}

代理模式

代理模式就是为其他对象提供一种代理以控制对这个对象的访问

代理的对象在提供被代理对象的方法操作之前，进行了一些其他的操作

public class Test{
	public static void main(String[] args){
		ProxyServe p = new ProxyServe(new Serve());
		p.browse();
	}
}
interface NetWork{
	public abstract void browse();
}
class Serve implements NetWork{
	public void browse(){
		System.out.println("真实的服务器访问网络");
	}
}
class ProxyServe implements NetWork{
	private NetWork net;
	public ProxyServe(NetWork net){
		this.net = net;
	}
	public void check(){
		System.out.println("联网之前先检查");
	}
	public void browse(){
		check();
		net.browse();
	}
}

工厂模式

实现创建者和调用者的分离

无工厂模式

class Untitled {
	public static void main(String[] args){
		Car a = new Audi();
		a.run();
		Car b = new BYD();
		b.run();
	}
}
interface Car{
	public abstract void run();
}
class Audi implements Car{
	public void run(){
		System.out.println("奥迪跑");
	}
}
class BYD implements Car{
	public void run(){
		System.out.println("比亚迪跑");
	}
}

执行结果如下：

在这里插入图片描述

简单工厂模式

用来生产同一等级结构的任意产品，实现了调用者和创建者的分离

对于增加新的产品，需要修改已有代码

class Untitled {
	public static void main(String[] args){
		Car a = CarFactory.getCar("奥迪");
		a.run();
		Car b = CarFactory.getCar("比亚迪");
		b.run();
	}
}
//工厂类
class CarFactory{
	public static Car getCar(String s){
		if("奥迪".equals(s)){
			return new Audi();
		}else if("比亚迪".equals(s)){
			return new BYD();
		}
		return null;
	}
	//方式二：
	//public static Car getAudi(){
	//	return new Audi();
	//}
	//public static Car getBYD(){
	//	return new BYD();
	//}
}

//下面都一样
interface Car{
	public abstract void run();
}
class Audi implements Car{
	public void run(){
		System.out.println("奥迪跑");
	}
}
class BYD implements Car{
	public void run(){
		System.out.println("比亚迪跑");
	}
}

执行结果如下：

在这里插入图片描述

工厂方法模式

用来生产同一等级结构的固定产品

支持增加任意产品

class Untitled {
	public static void main(String[] args){
		Car a = new AudiFactory().getCar();
		a.run();
		Car b = new BYDFactory().getCar();
		b.run();
	}
}
//工厂接口
interface Factory{
	Car getCar();
}
//两个工厂类
class AudiFactory implements Factory{
	public Audi getCar(){
		return new Audi();
	}
}
class BYDFactory implements Factory{
	public BYD getCar(){
		return new BYD();
	}
}


//下面都一样
interface Car{
	public abstract void run();
}
class Audi implements Car{
	public void run(){
		System.out.println("奥迪跑");
	}
}
class BYD implements Car{
	public void run(){
		System.out.println("比亚迪跑");
	}
}

执行结果如下：

在这里插入图片描述

抽象工厂模式

用来生产不同产品族的全部产品

对于增加新的产品，无能为力。支持增加产品族

练习题

若父类和接口有同名属性，但是子类没有，调用时会报错

但若是子类有同名的参数，则输出的是子类自己的参数

class Untitled {
	public static void main(String[] args){
		C c = new C();
		c.m();
	}
}
interface A{
	int x = 9;
}
class B{
	int x = 10;
}
class C extends B implements A{
	public void m(){
		//编译报错，因为x是不明确的
		//System.out.println(x);
		System.out.println(super.x);  //10
		System.out.println(A.x);      //9
	}
}

若父类和 父类的父类有同名参数，但是子类没有，则调用的是父类的，就近原则

class Untitled {
	public static void main(String[] args){
		C c = new C();
		c.m();
	}
}
class A{
	int x = 9;
}
class B extends A{
	int x = 10;
}
class C extends B implements A{
	int x = 11;
	public void m(){
		System.out.println(x);
	}
}

接口中可以存在的4个结构分别是：

全局常量、抽象方法、静态方法、 默认方法

interface A{
	void paly();
}
interface B{
	void paly();
}
interface C implements A,B{
	Ball ball = new Ball("草莓");
}
class Ball implements C{
	private String name;
	public Ball(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void play(){
		//会报错，因为是全局常量，不可修改
		//ball = new Ball("西瓜");
		System.out.println(ball.getName());
	}
}

小结

  1. 接口中可以定义的结构：
    1. 全局常量：public static final的，可省略不写public static final
    2. 抽象方法：public abstract 的，可省略不写public abstract
    3. 静态方法：通过接口来调用 接口.静态方法
    4. 默认方法（权限修饰符为 default ）：通过实现类的对象来调用
  2. 接口中不可以定义构造器（抽象类有构造器以方便子类继承），意味着接口不可以实例化。开发中，会提供实现类去实现implements接口
    1. 实现类实现了一个接口，要么必须重写其中所有的抽象方法，则实现类可以实例化
    2. 要么，就把自己声明成抽象类。二者必选其一
  3. 实现类可以实现多个接口，解决了单继承的局限
    格式：class AA extends BB implements CC,DD,EE{}
  4. 接口与接口之间可以继承，而且是！！多继承！！此时实现类就必须重写所有的接口的抽象方法，否则就要声明成抽象类
  5. 接口的使用也满足多态性
  6. 接口匿名实现类对象和抽象类的匿名子类对象一样的写法，都用到多态
  7. 工厂模式：注意方法的重写，子类方法返回值可以是父类方法返回值的子类
  8. 练习题：若父类和接口有同名属性，但是子类没有，调用时会报错
  9. 若父类和接口有同名方法，但是子类没有，调用时用的是父类的方法
磊哥的小迷妹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
接口测试报告接口测试报告
07-28
接口测试报告是软件测试过程中的一个重要环节，主要针对系统中不同组件或服务之间的交互进行验证。这份报告详细记录了接口测试的过程、工具、人员以及测试结果，以确保系统的稳定性和功能完整性。 1. **系统接口...
Java面向对象继承多态相关知识
weixin_44838502的博客
06-28 116
Java面向对象继承多态相关知识 一、继承 ​ 继承是Java面向对象编程技术的一块基石，因为它允许创建等级层次的类。 ​ 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 1.1 格式 class 父类{ } class 子类 extends 父类{ } 1.2 限制 ​Java中只有单继承，多重继承，没有多继承。 1.3 super关键字 ​ 通过super，可以访问父类的构造方法 ​ 调用super构造方法的代
Java 类、接口、内部类详解 10章
Sunblogy的博客
04-05 485
Java学习中的类、接口、内部类的详解以及练习，从了解到精通~~~
面向对象总结
那就不能叫远方
07-18 641
接口Teaching(包含方法: 备课prepareLessons,上课teach,批改作业homeworkCorrecting,…) 接口Sports (包含方法: 跑步running, 打球playBall,…) 接口Drinking(包含方法: drink, throwup,playMad,…) 抽象类Person(包含抽象方法:getMoney,…) 子类(实现类)Student,T
java创建person接口_Java 常用函数式接口 —— Supplier接口
weixin_39650139的博客
02-28 691
JDK提供了大量的函数式接口，方便我们开发的时候无需自己编写接口，这些接口都比较通用，学会他们并且在工作中使用，不仅方便的解决问题，而且十分优雅。1、接口概述Supplier接口的源码比较简单，只有一个方法。@FunctionalInterfacepublic interface Supplier{/*** Gets a result.** @return a result*/T get();}g...
接口的定义与使用
zyj497863419的博客
04-14 336
接口的定义与使用 ​ 抽象类与普通类相比最大的特点是约定了子类的实现要求，即抽象类的产生原因是：普通类无法限制子类覆写哪些方法。但抽象类的局限性在于，很多事物不满足is-a原则，且抽象类只能实现单继承，若想多继承必须使用多层继承。而接口就可以实现多继承。接口是更纯粹的抽象类–融合。 接口优先原则：9在一个操作既可以使用抽象类和接口的时候，优先考虑使用接口。 1.接口的基本概念 1.1 接口...
ukey开票接口电子发票接口文档发票接口文档
12-24
《电子发票接口文档——以增值税发票税控开票软件数据接口规范3.0为例》 在信息化日益发达的今天，企业对于财务自动化的需求越来越高，其中，电子发票接口的使用成为了关键一环。本文将深入解析“ukey开票接口”与...
QQ常用接口
04-30
QQ接口是QQ应用程序提供的一系列API，用于与QQ平台进行交互和数据交换。这些接口广泛应用于社交应用开发、自动化工具和数据分析中。以下是对QQ常用接口的详细解释： 1. 获取群验证消息接口：这个接口允许开发者获取...
东北大学接口实验报告.zip
08-07
在IT行业中，接口技术是软件开发中的重要组成部分，特别是在分布式系统、网络通信和微服务架构中扮演着核心角色。东北大学的接口实验报告显然旨在帮助学生深入理解和掌握接口设计、实现与测试的关键概念。以下是对这...
定义一个抽象类Person，其中有一个公共的抽象方法work()。
weixin_45634936的博客
04-05 6529
定义一个抽象类Person，其中有一个公共的抽象方法work()。定义Person的子类：Student(学生)、Teacher(教师)。学生的工作是“预习、学习、复习、写作业”；教师的工作是“备课、上课、辅导、批改作业”。编写Test类，分别对学生和教师的工作方法进行测试，体现多态性。 package dame; public abstract class Person { void work...
C#精挑整理知识要点8 接口（建议收藏）
Mr、黄
08-25 4229
1.定义接口 在 C# 语言中，类之间的继承关系仅支持单重继承，而**接口是为了实现多重继承关系**设计的。 一个类能同时实现多个接口，还能在实现接口的同时再继承其他类，并且接口之间也可以继承。 接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分。 接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构 多重继承的概念： 多重继承指的是一个类可以同时继承多个类。（
java学习笔记——抽象类和接口
weixin_46271306的博客
02-14 359
一、抽象类 类的设计应该保证父类和子类能够共享特征，有时将一个父类设计的非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。 1 抽象类：在class前面加 abstract 特点： 抽象方法所在的类必须是抽象类 抽象类不能实例化 抽象类是用来被继承的，如果要实现抽象类，必须创建一个子类去继承抽象类 子类继承一个抽象类，必须重写抽象类中所有的抽象方法（子类也是抽象类除外），重写父类方法的快捷
java学习笔记Day5：面向对象
至臻至善
04-07 219
1.面向对象 1.1定义类和创建对象 1.1.1量化 对一个事物进行量化，分为连续型和离散型 连续型：一个连续的值，数不过来 离散型：一个可以数的过来的值 1.1.2类 是一个抽象的概念，是对事物的划分，不是具体的东西，是具有相同属性和方法的一组对象的集合 分类的过程 属性：（特征）是可以用纸条写出来的 方法：（行为）是无法量化的一个过程 1.1.3对象 是一个实实在在存在的东西，是一个你能看得见摸得着的东西，是一个你能指名道姓的东西，是一个一说你就知道具体是什么的东西。 1.1.4类和对象的关系 类是对象
java中的serializable_java基础---->Serializable的使用
weixin_42132352的博客
02-16 1540
本次讲解中我们建立一个Java的项目去体会一下序列化Serializable的使用，序列化的原理以及序列化的自定义请参见我的另外一篇博客(java高级---->Serializable序列化的源码分析)目录导航Serializable序列化的简要说明一、 持久化的简单介绍：“持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对...
接口的java编程题_Java 接口编程题练习
weixin_30270715的博客
02-27 910
题目1：创建Person接口(即“人”)，它有setData()和getData()方法对“人”属性name、sex和birthday赋值和获得这些属性组成的字符串信息。创建类Student实现Person接口，并对自己的“学生”属性的成员变量sID、speciality设置值和获得它们值所组成的字符串信息。代码：People.java(接口)package com.interfaces;publ...
TypeScript 学习笔记（三）--- 接口（interfaces）
weixin_45092437的博客
04-02 1479
一、概念 ​ 在TypeScript中，我们可以使用接口来定义对象的类型。在面向对象的语言中，接口是一个很重要的概念，是对行为的一种抽象。但在TS中，接口是一个灵活的概念，除了可以表达对行为的抽象，也可以表示对象的形状（属性和方法）。 // 定义一个接口 interface Person { name: string; age: number; } // 定义对象的类型为上面的接口 let tom: Person = { name: 'Tom', age:
Java 面向对象（上）
在人间负债^
12-13 2638
1. Java 学习面向对象的三条主线 2. 面向过程与面向对象 3. Java 语言的基本元素：类和对象 4. 类中属性的使用 5. 类中方法的声明和使用 6. 练习 7. 类中对象的声明 8. 再谈方法 9. 封装和隐藏 10. 构造器（构造方法、constructor） 11. 总结属性赋值 12. 拓展知识：JavaBean 13. this 的使用 14. 关键字：package、import的使用 15. MVC 设计模式
Educoder–Java面向对象（第二章）- 封装、继承和多态【笔记+参考代码】
热门推荐
fuhanghang的博客
03-06 4万+
Educoder–Java面向对象（第二章）- 封装、继承和多态【笔记+参考代码】 第一关 编程要求 根据提示，在右侧编辑器Begin-End处补充代码： 声明一个Person类，私有化属性name和age，并将字段封装起来； 在Person类中定义一个talk()方法，打印姓名和年龄信息； 在main方法中声明并实例化一Person对象p，给p中的属性赋值，调用talk()方法打印 我是...
快递100企业版API接口全面指南：实时查询、信息推送与智能判断
"快递100企业版快递查询接口技术文档详细介绍了如何通过API进行高效、便捷的第三方物流信息管理。该接口适用于电子商务平台、移动应用、网页商城以及各类PC端软件系统，特别适合需要实时监控和推送物流状态的场景。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值