java接口interface

最新推荐文章于 2024-07-22 14:15:06 发布
最新推荐文章于 2024-07-22 14:15:06 发布
阅读量97 收藏 1
点赞数
分类专栏： java基础 语法 文章标签： java 算法 eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wsfhdhjs/article/details/120850370
版权

例子1

/**
 * 
 */
package com.atguigu.java1;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午5:02:07
 *
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
	}
}

interface Flyable{
	
	//全局常量  下面这些都是全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;		//这个是省略掉public static final的
	
	//抽象方法
	public abstract void fly();
	
	//省略public abstract
	void stop();
	
	
}

例子2

/**
 * 
 */
package com.atguigu.java1;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午5:02:07
 *
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
		
		//下面这个就是实现类可以实例化
		Plane plane = new Plane();
		
		plane.fly();
		plane.stop();
		
		
	}
}

interface Flyable{
	
	//全局常量  下面这些都是全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;		//这个是省略掉public static final的
	
	//抽象方法
	public abstract void fly();
	
	//省略public abstract
	void stop();
	
}

class Plane implements Flyable{


	//*** 这个就是实现类覆盖了接口中的所有方法
	public void fly() {
		System.out.println("通过引擎起飞");
		
	}


	public void stop() {
		System.out.println("驾驶员减速停止");
		
	}
	
	
	
}

例子3

/**
 * 
 */
package com.atguigu.java1;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午5:02:07
 *
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
		
		//下面这个就是实现类可以实例化
		Plane plane = new Plane();
		
		plane.fly();
		plane.stop();
		
		
	}
}

interface Flyable{
	
	//全局常量  下面这些都是全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;		//这个是省略掉public static final的
	
	//抽象方法
	public abstract void fly();
	
	//省略public abstract
	void stop();
	
}

interface Attackable{
	
	public abstract  void attack();
	
}

class Plane implements Flyable{


	//*** 这个就是实现类覆盖了接口中的所有方法
	public void fly() {
		System.out.println("通过引擎起飞");
		
	}


	public void stop() {
		System.out.println("驾驶员减速停止");
		
	}
}

//可以实现多个接口
class Bullet implements Flyable,Attackable{


	public void fly() {
		// TODO Auto-generated method stub
		
	}


	public void stop() {
		// TODO Auto-generated method stub
		
	}



	public void attack() {
		
		
	}
	
	
	
	
}

例子4

/**
 * 
 */
package com.atguigu.java1;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午5:02:07
 *
 */
public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
		
		//下面这个就是实现类可以实例化
		Plane plane = new Plane();
		
		plane.fly();
		plane.stop();
		
		
	}
}

interface Flyable{
	
	//全局常量  下面这些都是全局常量
	public static final int MAX_SPEED = 7900;
	int MIN_SPEED = 1;		//这个是省略掉public static final的
	
	//抽象方法
	public abstract void fly();
	
	//省略public abstract
	void stop();
	
}

interface Attackable{
	
	public abstract  void attack();
	
}

class Plane implements Flyable{


	//*** 这个就是实现类覆盖了接口中的所有方法
	public void fly() {
		System.out.println("通过引擎起飞");
		
	}


	public void stop() {
		System.out.println("驾驶员减速停止");
		
	}
}

//****注意下面有2个接口AA，BB，另外CC继承AA，BB，现在Bullet也继承CC，则必须对CC所继承的AA，BB中的方法进行重写
class Bullet extends Object implements Flyable,Attackable,CC{


	public void fly() {
		// TODO Auto-generated method stub
		
	}


	public void stop() {
		// TODO Auto-generated method stub
		
	}



	public void attack() {
		
		
	}



	public void method1() {
		
		
	}



	public void method2() {
		
		
	}
	
	
	
	
}

//************************************************8

interface AA{
	void method1();
	
}

interface BB{
	
	void method2();
}

interface CC extends AA,BB{
	
	
}

例子5

/**
 * 
 */
package com.atguigu.java1;

/*
 * 
 * 
 */
public class UBSTest {
	public static void main(String[] args) {
		Computer com = new Computer();
		
		//1.创建了接口的非匿名实现类的非匿名对象
		Flash flash = new Flash();
		com.transferDate(flash);
		
		//2.创建了接口的非匿名实现类的匿名对象
		com.transferDate(new Printer());
		
		//3.创建了接口的匿名实现类的非匿名对象
		USB phone = new USB(){


			public void start() {
				System.out.println("手机开始工作");
				
			}

	
			public void stop() {
				System.out.println("手机结束工作");
				
			}
			
			
			
		};
		com.transferDate(phone);
		
		//4.创建了接口的匿名实现类的匿名对象
		com.transferDate(new USB(){

			public void start() {
				System.out.println("mp3开始工作");
			}

			public void stop() {
				System.out.println("mp3结束工作");
				
			}
			
			
			
		});
		
	}
}

class Computer{
	
	public void transferDate(USB usb){
		usb.start();
		
		System.out.println("具体传输数据的细节");
		
		usb.stop();
		
	}
	
}


interface USB{
	
	void start();
	
	void stop();
	
}

class Flash implements USB{
	public void start() {
		System.out.println("u盘开启工作");	
	}


	public void stop() {
		System.out.println("u盘结束工作");
	}
}

class Printer implements USB{
	public void start() {
		System.out.println("打印机开启工作");	
	}


	public void stop() {
		System.out.println("打印机结束工作");
	}
	
	
}

例子6

/**
 * 
 */
package com.atguigu.java1;

/*
 *
 *
 *
 */
public class NetWorkTest {
	public static void main(String[] args) {
		
		Server server = new Server();
		ProxyServer proxyServer = new ProxyServer(server);
		proxyServer.browse();
	}
}

interface NetWork{
	
	public void browse();
	
}

//被代理类
class Server implements NetWork{
	
	public void browse(){
		System.out.println("真是的服务器访问网络");
	}
}

//代理类
class ProxyServer implements NetWork{
	
	private NetWork work;
	
	public ProxyServer(NetWork work){
		this.work=work;
	}

	public void check(){
		System.out.println("联网之前的检查工作");
	}

	public void browse() {
		check();
		
		work.browse();
		
	}
	
	
	
}

例子7

CompareObject接口

/**
 * 
 */
package com.atguigu.exer3;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午7:17:17
 *
 */
public interface CompareObject {
	public int compareTo(Object o);
}

Circle类

/**
 * 
 */
package com.atguigu.exer3;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午7:18:45
 *
 */
public class Circle {
	private Double radius;


	public Double getRadius() {
		return radius;
	}


	public void setRadius(Double radius) {
		this.radius = radius;
	}



	public Circle(Double radius) {
		super();
		this.radius = radius;
	}


	public Circle() {
		super();
	}
	
	
	
}

ComparableCircle类

/**
 * 
 */
package com.atguigu.exer3;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午7:20:19
 *
 */
public class ComparableCircle extends Circle implements CompareObject{

	public ComparableCircle(double radius){
		super(radius);
	}

	public int compareTo(Object o) {
		if(this == o){
			return 0;
		}
		if(o instanceof ComparableCircle){
			ComparableCircle c = (ComparableCircle)o;
//			if(this.getRadius()>c.getRadius()){
//				return 1;
//			}else if(this.getRadius()<c.getRadius()){
//				return -1;
//			}else{
//				return 0;
//			}
			return this.getRadius().compareTo(c.getRadius());
		}else{
			return 0;
		}

		
	}
	
}

comparableCircleTest测试类

/**
 * 
 */
package com.atguigu.exer3;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午7:29:45
 *
 */
public class comparableCircleTest {
	public static void main(String[] args) {
		ComparableCircle c1 = new ComparableCircle(3.4);
		ComparableCircle c2 = new ComparableCircle(3.6);
		System.out.println(c1.compareTo(c2));
	}
}

例子8

接口CompareA

/**
 * 
 */
package com.atguigu.java8;

/*
 *
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	
	//默认方法
	public default void method2(){
		System.out.println("CompareA: 上海");
	}
	
	default void method3(){
		System.out.println("CompareA:上海");
	}
	
}

SubClassTest类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:12:52
 *
 */
public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();
		//接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
	}
}


class SubClass implements CompareA{
	
	
}

例子9

接口CompareA

/**
 * 
 */
package com.atguigu.java8;

/*
 *
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	
	//默认方法
	public default void method2(){
		System.out.println("CompareA: 上海");
	}
	
	default void method3(){
		System.out.println("CompareA:上海");
	}
	
}

SubClassTest类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:12:52
 *
 */
public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();
		//接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
		//通过实现类的对象，可以调用接口中默认方法
		s.method2();
		s.method3();
	}
}


class SubClass implements CompareA{
	
	
}

例子10

接口CompareA

/**
 * 
 */
package com.atguigu.java8;

/*
 *
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	
	//默认方法
	public default void method2(){
		System.out.println("CompareA: 上海");
	}
	
	default void method3(){
		System.out.println("CompareA:上海");
	}
	
}

SubClassTest类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:12:52
 *
 */
public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();
		//接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
		//通过实现类的对象，可以调用接口中默认方法
		s.method2();
		s.method3();
	}
}


//如果实现类继承的父类和实现的接口中声明了同名同参数的方法，那么子类在没有重写此方法的情况下，默认调用的是父类中同名同参数的方法
class SubClass extends SuperClass implements CompareA{
	
	public void method2(){
		System.out.println("SubClass:上海");
	}
	
}

SuperClass父类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:26:27
 *
 */
public class SuperClass {
	//将method3进行重写
	public void method3(){
		System.out.println("SuperClass:wsf");
	}
}

例子11

接口CompareA

/**
 * 
 */
package com.atguigu.java8;

/*
 *
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	
	//默认方法
	public default void method2(){
		System.out.println("CompareA: 上海");
	}
	
	default void method3(){
		System.out.println("CompareA:上海");
	}
	
}

SubClassTest类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:12:52
 *
 */
public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();
		//接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
		//通过实现类的对象，可以调用接口中默认方法
		s.method2();
		s.method3();
	}
}


//如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没有重写此方法的情况下，报错----->接口冲突
class SubClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass:上海");
	}
	
	public void method3(){
		
	}
	
}

SuperClass父类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:26:27
 *
 */
public class SuperClass {
	//将method3进行重写
	public void method3(){
		System.out.println("SuperClass:wsf");
	}
}

CompareB类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:34:38
 *
 */
public interface CompareB {
	default void method3(){
		System.out.println("CompareA:上海");
	}
}

例子12

接口CompareA

/**
 * 
 */
package com.atguigu.java8;

/*
 *
 */
public interface CompareA {
	
	//静态方法
	public static void method1(){
		System.out.println("CompareA:北京");
	}
	
	//默认方法
	public default void method2(){
		System.out.println("CompareA: 上海");
	}
	
	default void method3(){
		System.out.println("CompareA:上海");
	}
	
}

SubClassTest类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:12:52
 *
 */
public class SubClassTest {

	public static void main(String[] args) {
		SubClass s = new SubClass();
		//接口中定义的静态方法，只能通过接口来调用
		CompareA.method1();
		//通过实现类的对象，可以调用接口中默认方法
		s.method2();
		s.method3();
		
		s.myMethod();
	}
}

class SubClass extends SuperClass implements CompareA,CompareB{
	
	public void method2(){
		System.out.println("SubClass:上海");
	}
	
	public void method3(){
		System.out.println("SubClass: 深圳");
	}
	
	//知识5：如果在实现类的方法总调用父类，接口中被重写的方法
	public void myMethod(){
		method3();       //调用自己定义的重写的方法
		super.method3();    //调用的是父类中声明的
		CompareA.super.method3();//调用的是接口中的方法
		CompareB.super.method3();
	}
	
}

SuperClass父类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:26:27
 *
 */
public class SuperClass {
	//将method3进行重写
	public void method3(){
		System.out.println("SuperClass:wsf");
	}
}

CompareB类

/**
 * 
 */
package com.atguigu.java8;

/**
 * @Descripton
 * @author wsf  Email:2181821498@qq.com
 * @version
 * @date 2021年10月19日下午8:34:38
 *
 */
public interface CompareB {
	default void method3(){
		System.out.println("CompareA:上海");
	}
}
wsfhdhjs
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中的接口（interface)
qq_39586619的博客
12-09 223
接口的特点：用 interface 来定义。 接口中的所有成员变量都默认是由public static final修饰的。 接口中的所有方法都默认是由public abstract修饰的。 接口没有构造方法。构造方法用于创建对象 实现接口的类中必须提供接口中所有方法的具体实现内容。 多个无关的类可以实现同一个接口 一个类可以实现多个无关的接口 与继...
Java中的接口(interface关键字详解以及接口匿名实现类的对象)
dwjdj的博客
01-27 703
接口的使用 1、接口使用interface来定义 2、Java中，接口和类是并列的两个结构 3、如何定义接口：定义接口中的成员 3.1JDK7及以前：只能定义全局常量和抽象方法 全局常量：public static final修饰的，书写时可以省略 抽象方法：public abstract修饰的，书写时可以省略 3.2、JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法 4.接口中不能定义构造器！意味着接口不可以实例化 5.Java开发中，接口通过类去实现(implemen
java中接口（interface）详解
热门推荐
sun_shine56的博客
01-24 19万+
接口（interface） 有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。 接口(interface)是抽象方法和常量值的定义的集合。 从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。 接口定义举例 public interface Runner int id =...
接口、interface（Java）
qq_57780419的博客
03-21 132
接口，interface
接口（interface）
上帝的孩纸的博客
04-18 107
子类必须通过implements来实现接口中的规范 接口不能创建实例，但是可用于声明引用变量类型 一个类实现了接口，必须实现接口中所有方法，并且这些方法只能是public 接口支持多继承 package theChildOfGod.bjxy.oop.testInterface; public interface Flyable { int MAX_SPEED = 110...
详解java接口interface
06-17
Java 接口的定义与普通类的定义类似，区别在于使用关键字 `interface` 而不是 `class`。接口的定义格式如下： ```java public interface 接口名 { // 抽象方法和默认方法的定义 } ``` 二、Java 接口的抽象方法 ...
Java中interface接口与abstractclas
10-29
在Java编程语言中，`interface`接口和`abstract class`抽象类是两种重要的面向对象设计概念，它们都用于实现多态性，但有着显著的区别。理解这些差异对于编写可扩展和可维护的代码至关重要。 首先，接口是完全抽象...
java interface 接口的使用好处分析
08-25
Java 接口的使用好处分析 Java 接口是一种抽象的类别，通过它可以定义一组规范和规则，以便于编程时更好地组织和结构化代码。 Java 接口的使用好处主要体现在以下几个方面： 1. 多态性：Java 接口可以实现多态性，...
Java接口(interface)的概念及使用-Java教
11-22
Java接口（Interface）是Java编程语言中的一个关键概念，它是一种完全抽象的类型，用于定义对象的行为标准。接口中只包含常量定义和抽象方法，不包含任何实现代码。理解并熟练使用Java接口，对于提升代码的灵活性、...
java 接口(interface) 语法的使用和详解
Json的知识梦工厂
09-03 686
package com.day29.test; public class Test { public static void main(String[] args) { System.out.println("接口"); // 有的时候要多继承父类 // 但是java只支持单继承 // 所以有了接口 就可以实现 多继承这个状态 // 但是接口 子类 不能叫继承接口 而是...
Java基础：接口(interface)的详细介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
10-21 594
什么是接口 概述 在开发中，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有i继承的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不
java接口的理解、定义、使用
ray2580的博客
03-15 871
接口的理解 官方解释：Java接口是***一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现***，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）Balabalabala……… 我的解释：接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段。 无法多继承是什么意思呢？ 举个例子 （这里应...
接口 interface
edwardwzw的博客
06-23 416
有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。 接口是抽象方法和常量值的定义的集合,是特殊的抽象类。 接口，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。 ...
flyable java_Java学习笔记 -接口
weixin_35508482的博客
02-28 586
接口1.接口是引用数据类型2.接口是完全抽象的(抽象类是半抽象)或者也可以说接口是特殊的抽象类3.接口的语法： [修饰符列表] interface 接口名{}4.接口与接口之间， 接口与类之间都支持多继承5.接口只包含常量和抽象方法，所以没有构造方法6.接口中所有的元素都是public修饰的7.接口的抽象方法定义时： public abstract 修饰符可以省略接口中的常量定义时：public...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 586
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 707
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 683
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1220
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1232
JVM-垃圾回收与内存分配
Java接口与回调机制解析
"接口和回调在Java编程中的应用，主要涉及Java接口的概念、使用以及回调机制的解释。接口是Java中定义行为规范的关键工具，它包含抽象方法的声明，不包含实现。回调则是通过传递对象及其方法引用来指定特定事件发生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值