当前位置： 首页 > news >正文

11 Java接口（语法、规范、微观宏观接口）

news 来源：原创 2024/11/16 3:01:21

接口

      • 11.1 接口语法
        • 11.1.1 基本使用
        • 11.1.2 和抽象类区别
      • 11.2 微观接口
      • 11.3 接口规范
      • 11.4 接口实现多态
      • 11.5 接口常见关系
      • 11.6 常量接口
      • 11.7 宏观接口
        • 11.7.1 概念
        • 11.7.2 回调原理
        • 11.7.3 接口好处
      • ==补充面向对象的七大设计原则==
      • 接口小结：

11.1 接口语法

11.1.1 基本使用

概念：接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。使用interface关键字定义接口。

特点：

  • 没有构造方法，不能创建对象。
  • 只能定义：公开静态常量、公开抽象方法。

案例演示：自定义接口。

public interface MyInterface {	
	//接口中：只能定义公开的静态常量和公开抽象方法
	//       没有构造方法、动态、静态代码块
	public static final int a = 10;
	public abstract void show();
}

11.1.2 和抽象类区别

相同点：

  • 可编译成字节码文件。
  • 不能创建对象。
  • 可以作为引用类型。
  • 具备Object类中所定义的方法。

不同点：

  • 所有属性都是公开静态常量，隐式使用public static final修饰。
  • 所有方法都是公开抽象方法，隐式使用public abstract修饰。
  • 没有构造方法、动态代码块、静态代码块。

11.2 微观接口

微观概念：接口是一种能力和约定。

  • 接口的定义：代表了某种能力。
  • 方法的定义：能力的具体要求。

经验：

  • Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。
  • 接口支持多实现，可为类扩充多种能力。

案例演示：实现类实现多个接口。

public interface Flyable {
	void fly();
}


public interface Fireable {
	void fire();
}

实现类：Person

public class Person implements Flyable,Fireable{
	String name;
	int age;
	public Person() {
		// TODO Auto-generated constructor stub
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public void eat() {
		System.out.println(name+"吃东西...");
	}
	public void sleep() {
		System.out.println(name+"睡了...");
	}
	@Override
	public void fly() {
		System.out.println(name+"开始飞了...");
	}

	@Override
	public void fire() {
		System.out.println(name+"可以喷火了...");
	}
}

测试类：

public class TestPerson1 {
	public static void main(String[] args) {
		Person xiaoming=new Person("小明",20);
		xiaoming.fly();
		xiaoming.fire();
		
	}
}

11.3 接口规范

  • 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
  • 实现接口中的抽象方法时，访问修饰符必须是public。
  • 同父类一样，接口也可声明为引用，并指向实现类对象。
public class TestPerson2 {
	public static void main(String[] args) {
		
		Flyable flyable=new Person("小张",22);
		flyable.fly();


		Fireable fireable=new Person("小李", 15);
		fireable.fire();
	}
}

11.4 接口实现多态

不同的引用类型，仅可调用自身类型所定义的方法。

案例演示：

public class Test {
	public static void main(String[] args) {
		//抽象类作为引用
		Animal a = new Dog();//将狗当做动物看
		a.eat();
		a.sleep();
		
		//接口作为引用   
		Runnable r = new Dog();//将狗当做能跑的看
		r.run();
		
		//接口作为引用   
		Swimmable s = new Dog();//将狗当做能游泳的看
		s.siwm();
		
		Dog dog = new Dog();//将狗当做狗的看
		dog.eat();
		dog.sleep();
		dog.run();
		dog.siwm();
	}
}

11.5 接口常见关系

类与类：

  • 单继承
  • extends 父类名称

类与接口：

  • 多实现
  • implements 接口名称1 , 接口名称2 , 接口名称n

接口与接口：

  • 多继承
  • extends 父接口1 , 父接口2 , 父接口n

案例演示：接口多继承。

public interface Runnable extends Serializable ,Cloneable{
	//跑
    void run();
}

11.6 常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理，提高代码可读性。

补充 标记接口接口没有任何成员,仅仅是一个标记。Serializable、Cloneable

public interface Constants {
	//QQ的状态    接口常量 --- > 枚举类型
	public static final int ZAI_XIAN = 100; //在线
	public static final int	YIN_SHEN = 200; //隐身
	public static final int LI_XIAN = 300;  //离线
	public static final int Q_WO = 400;     //Q我
	public static final int MANG_LU = 500;  //忙碌
}

int num = 100;
switch (num) {
    case Constants.ZAI_XIAN:
        System.out.println("在线的代码");
        break;
    case Constants.YIN_SHEN:
        System.out.println("隐身的代码");
        break;
    case Constants.LI_XIAN:
        System.out.println("离线的代码");
        break;
    default:
        break;
}

11.7 宏观接口

11.7.1 概念

宏观概念：接口是一种标准、规范。

案例演示：

public interface BookInterface {
	/**
	 * 增删改查
	 */
	public boolean addBook(Book book);
	
	public boolean updateBook(Book book);
	
	public boolean deleteBook(String bookId);
	
	public Book selectOne(String bookId);
	
	public Book[] selectAll();
}

public class BookInterfaceImpl implements BookInterface{
	
	@Override
	public boolean addBook(Book book) {
        return false;
	}
	@Override
	public boolean updateBook(Book book) {
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public boolean deleteBook(String bookId) {
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public Book selectOne(String bookId) {
		// TODO Auto-generated method stub
		return null;
	}
	@Override
	public Book[] selectAll() {
		// TODO Auto-generated method stub
		return null;
	}
}

11.7.2 回调原理

接口回调：先有接口的使用者，后有接口的实现者。

​ （程序员） (接口的使用者)

​ ④工具的调用者---------→→→> ②工具

​ ↓

  														↓

③接口的实现者 <-←←------------ ①接口

​ （程序员） （标准）

①接口

//此接口的作用是判断数字是否是质数
interface MyInterface{
	boolean isZS(int num);
}

②工具

//此方法已经调用了接口中的方法
public static void gdbh(int num,MyInterface mi) {
    for (int i = 3; i <= num/2; i++) {
        if(mi.isZS(i) && mi.isZS(num-i)) {
            System.out.println(num+"="+i+"+"+(num-i));
        }
    }
}

③接口的实现者

//这是接口的实现者，在调用工具前，需要有接口的实现
class MyInterfaceImpl implements MyInterface{
	@Override
	public boolean isZS(int num) {
		for (int i = 2; i < num; i++) {
			if(num % i == 0) {
				return false;
			}
		}
		return true;
	}
}

④工具的调用者

public static void main(String[] args) {
    //使用工具
    gdbl(14, new MyInterfaceImpl() );
}

接口回调的编码顺序①②③④

11.7.3 接口好处

  • 程序的耦合度降低。
  • 更自然的使用多态。
  • 设计与实现完全分离。
  • 更容易搭建程序框架。
  • 更容易更换具体实现。

补充面向对象的七大设计原则

  1. 总则：开闭原则（Open Close Principle，OCP）
    • 开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。
  2. 单一职责原则（Single Responsibility Principle，SRP）
    • 不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。
  3. 里氏替换原则（Liskov Substitution Principle，LSP）
    • 里氏替换原则中说，任何基类可以出现的地方，子类一定可以出现。里氏替换原则中，子类对父类的方法尽量不要重写和重载。因为父类代表了定义好的结构，通过这个规范的接口与外界交互，子类不应该随便破坏它。
  4. 依赖倒置原则（Dependence Inversion Principle，DIP）
    • 面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。
  5. 接口隔离原则（Interface Segregation Principle，ISP）
    • 每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。使用多个隔离的接口，比使用单个接口（多个接口方法集合到一个的接口）要好。
  6. 迪米特法则（最少知道原则）（Demeter Principle，DP）
    • 一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。
    • 只和朋友通信，不和陌生人说话。
  7. 合成/聚合复用原则（Composite Reuse Principle，CRP）
    • 原则是尽量首先使用合成/聚合的方式，而不是使用继承。
  8. 开口里合最单依

接口小结：

  1. 什么是接口：
    1. 微观：接口是一种能力和约定。
    2. 宏观：接口是一种标准。
  2. 接口的特点：
    1. 没有构造方法，不能创建对象，可以声明变量。
    2. 只能包含公开静态常量与公开抽象方法。
  3. 接口的规范
    1. 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
    2. 实现接口中的抽象方法时，访问修饰符必须是public。
  4. 什么是常量接口、标记接口
    1. 将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理。
  5. 什么是接口回调
    1. 先有接口的使用者，后有接口的实现者。
  6. 面向对象七大设计原则

相关文章：

  • 国外商业网站设计/外贸营销网站建站
  • wap网站如何做/最新网站发布
  • 做衣服上哪些网站/手机端搜索引擎排名
  • 没有网站域名是否需要备案/百度如何推广广告
  • 网站打不开怎么做/app关键词排名优化
  • 怎么看得出网站是哪个公司做的/提高搜索引擎检索效果的方法
  • 前端学习路线(包括计算机基础，算法，项目开发等学习路径)
  • 实战18：基于深度学习的人脸识系统（完整代码+数据+报告+可作为毕设)
  • Vue 2.x源码学习：数据响应式改造
  • OpenJudge NOI 2.2 9273:PKU2506Tiling | 2.3 9273:PKU2506Tiling
  • 【微信小程序】动态设置导航栏标题
  • day49 业务逻辑水平垂直越权访问控制脆弱验证
  • 超详解通讯录，保姆式教学 ，轻松学会实现通讯录的功能【c语言】
  • 表达式求值【NOIP2013普及组】
  • java 常见函数 和 mapper
  • 命名空间！C++之路扬帆起航
  • N+1终于等到了 但却放弃了
  • 小程序样式和组件基础