关于接口以及接口的创建与使用

接口–interface

我们为什么要用接口

​ 我们平常编程的时候会遇到一个问题，一个方法可以有多种的实现方式，比如说我们吃东西可以是吃草也可以是吃肉，或者说我们开锁可以是密码开锁，也可以是指纹开锁；甚至我们编写对战人物技能的时候一个技能可以指定的对象有好几个。。。就像这样

	//设置Van的技能
	public void ack_3(SunShangxiang ssx) {
		//Van类的技能 ：对范围内的敌人造成700/1000/1300（+90%物理加成）点物理伤害
		int num=(int)(700+0.9*ad+300*lv);//将结果强制转为整数型--小数点后全部直接省略
		//计算一次技能攻击之后的血量
		ssx.hp -=num;
		
		//输出攻击结果
		System.out.print(nameID+"使用技能攻击了"+ssx.nameID);
		System.out.println(ssx.nameID+"减少了"+num+"血量，还剩hp"+ssx.hp);
		
		
	}
	public void ack_3(Xianbei tiansuohaoer) {
		//Van类的技能 ：对范围内的敌人造成700/1000/1300（+90%物理加成）点物理伤害
		int num=(int)(700+0.9*ad+300*lv);//将结果强制转为整数型--小数点后全部直接省略
		//计算一次技能攻击之后的血量
		tiansuohaoer.hp -=num;
		
		//输出攻击结果
		System.out.print(nameID+"使用技能攻击了"+tiansuohaoer.nameID);
		System.out.println(tiansuohaoer.nameID+"减少了"+num+"血量，还剩hp"+tiansuohaoer.hp);
		
		
	}

​ 这个时候我们如果将他们的不同的实现方式一一地写出来，那就太费事费时间了，我们每次都需要重新写 方法名和繁琐重复的东西，所以我们编程里面现在引入一个新的编程思想—接口

​ 那么接口它是什么呢？？？？他又是如何实现的呢？？？

什么是接口

​	所谓接口，顾名思义就是接入类的一个“东西”；那我们接入的东西又是什么呢？？？

​	我们以鼠标监听器为例，它也属于一类接口，可以通过这个接口实现对于鼠标各种操作信息的获取从而得名为监听器

​ 我们首先来看看ta的代码文件

/*
 * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package java.awt.event;

import java.util.EventListener;

/**
 * The listener interface for receiving "interesting" mouse events
 * (press, release, click, enter, and exit) on a component.
 * (To track mouse moves and mouse drags, use the
 * <code>MouseMotionListener</code>.)
 * <P>
 * The class that is interested in processing a mouse event
 * either implements this interface (and all the methods it
 * contains) or extends the abstract <code>MouseAdapter</code> class
 * (overriding only the methods of interest).
 * <P>
 * The listener object created from that class is then registered with a
 * component using the component's <code>addMouseListener</code>
 * method. A mouse event is generated when the mouse is pressed, released
 * clicked (pressed and released). A mouse event is also generated when
 * the mouse cursor enters or leaves a component. When a mouse event
 * occurs, the relevant method in the listener object is invoked, and
 * the <code>MouseEvent</code> is passed to it.
 *
 * @author Carl Quinn
 *
 * @see MouseAdapter
 * @see MouseEvent
 * @see <a href="https://docs.oracle.com/javase/tutorial/uiswing/events/mouselistener.html">Tutorial: Writing a Mouse Listener</a>
 *
 * @since 1.1
 */
public interface MouseListener extends EventListener {

    /**
     * Invoked when the mouse button has been clicked (pressed
     * and released) on a component.
     */
    public void mouseClicked(MouseEvent e);

    /**
     * Invoked when a mouse button has been pressed on a component.
     */
    public void mousePressed(MouseEvent e);

    /**
     * Invoked when a mouse button has been released on a component.
     */
    public void mouseReleased(MouseEvent e);

    /**
     * Invoked when the mouse enters a component.
     */
    public void mouseEntered(MouseEvent e);

    /**
     * Invoked when the mouse exits a component.
     */
    public void mouseExited(MouseEvent e);
}

​ 可以看出接口的内容只有方法，而且方法它没有方法体

接口–方法抽象

​	这个时候需要引入抽象的概念

​	其实接口的原理也就是将我们所需要用的方法给抽象化，因为只有	抽象之后我们才可以将这个方法以多种形式来变化使用，就像我们	可以把动物吃草、吃肉两个方法合在一起抽象为吃这一个方法。因	此接口内的所有方法默认为抽象方法（抽象方法它是没有方法体	的）；

​ 并且他前面的关键字为-----interface

​ 这是为什么呢？？？？？？

​ 那么我们就需要引入接口的创建以及结构了

接口的创建

关键字&格式

​	-关键字：interface

​	-格式：public  interface 接口名 {

 				}

​		//接口后面还可以继承其他接口

​	-属性： 接口里面的属性都是默认static final修饰的静态常量

​	-方法： 接口里面的方法都是抽象方法没有方法体，大括号用分号代替；

 public interface 接口名{
     
     int num=100;//静态常量
     //ta默认是static final修饰的静态常量
     //static所修饰的属性与方法ta属于类而不是对象，可以由类名和接口名直接调用，也是唯一可以是以类直接调用的
     void 方法名();
     //默认由public abstract修饰的一个方法--属于抽象方法
     //抽象方法是没有方法体的，大括号要由分号替换
      
 }

​

接口的使用

​	我们创建好了接口之后，那么我们如何去使用ta呢？？

​	或者说我们如何将其接入一个类，而类要如何去实现它呢？？

​	那么我们来引入接口的实现--implements

关键字&格式

​	- 关键字：implements

​	- 格式：public 类名 implements 接口名{

​		}

​	//也就是类名 implements（实现了）接口名的方法

​	- 注意：需要重写接口中所有的方法

​ 我们继续以鼠标监听器为例

package com.xsx0729.oop.UI;

import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class DrawListener implements MouseListener {
	
	int x1,x2,y1,y2;
	Graphics g2;

	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
		
		System.out.println("点击了，x="+x1+"y="+y1);
		
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		 x1=e.getX();
		 y1=e.getY();
		
		System.out.println("按下");
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		 x2=e.getX();
		 y2=e.getY();
		System.out.println("释放");
		drawTrangle(x1,y1,x2,y2);
		
		
	}
	public void drawRect(int x1,int y1,int x2,int y2) {
		g2.drawLine(x1, y1, x2, y1);
		g2.drawLine(x1, y1, x1, y2);
		g2.drawLine(x1, y2, x2, y2);
		g2.drawLine(x2, y2, x2, y1);
		
	}
	public void drawTrangle(int x1,int y1,int x2,int y2) {
		g2.drawLine(x1, y1, x2, y2);
		g2.drawLine(x1, y2, x2, y2);
		g2.drawLine(x1, y1, x1, y2);
		
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("进入");
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("离开");
	}
	
	

}

从属关系

​	-接入接口的类其实也算是接口的一个子类，这个类的对象其实也算是接口的对象而已

​	所以我们在主程序中运行接口的方法可以先创建类方法

​	然后将方法的对象设置为接口类型 和接口对象

​	由于接入接口的类属于接口的子类，类对象属于接口对象所以可以之间将接入接口的类对象作为方法的参数

    
package com.xsx0802.oop;
//创建接口
public interface Lockinterface {
	
	void open();

}
//创建类接入接口
package com.xsx0802.oop;

public class facelock implements Lockinterface{

	@Override
	public void open() {
		// TODO Auto-generated method stub
		System.out.println("面容解锁");
	}

}
package com.xsx0802.oop;

public class pwdlock implements Lockinterface {
	
	public void open(){
		
		System.out.print("密码解锁");
	}

}

package com.xsx0802.oop;

public class door {
	//给door设置方法对象为接口类型
	public void lockuse(Lockinterface lock) {
		
	lock.open();
	}


	  
	  public static void main(String[] args) {
			//创建对象
			door dr=new door();
			
			pwdlock pwdlock=new pwdlock();
			facelock facelock=new facelock();
			//直接将类的对象作为方法的参数
			dr.lockuse(pwdlock);
	
	
}

​ 继续以监听器为例

package com.xsx0729.oop.UI;

import java.awt.Graphics;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class DrawListener implements MouseListener {
	
	int x1,x2,y1,y2;
	Graphics g2;

	@Override
	public void mouseClicked(MouseEvent e) {
		// TODO Auto-generated method stub
		
		System.out.println("点击了，x="+x1+"y="+y1);
		
	}

	@Override
	public void mousePressed(MouseEvent e) {
		// TODO Auto-generated method stub
		 x1=e.getX();
		 y1=e.getY();
		
		System.out.println("按下");
	}

	@Override
	public void mouseReleased(MouseEvent e) {
		// TODO Auto-generated method stub
		 x2=e.getX();
		 y2=e.getY();
		System.out.println("释放");
		drawTrangle(x1,y1,x2,y2);
		
		
	}
	public void drawRect(int x1,int y1,int x2,int y2) {
		g2.drawLine(x1, y1, x2, y1);
		g2.drawLine(x1, y1, x1, y2);
		g2.drawLine(x1, y2, x2, y2);
		g2.drawLine(x2, y2, x2, y1);
		
	}
	public void drawTrangle(int x1,int y1,int x2,int y2) {
		g2.drawLine(x1, y1, x2, y2);
		g2.drawLine(x1, y2, x2, y2);
		g2.drawLine(x1, y1, x1, y2);
		
	}

	@Override
	public void mouseEntered(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("进入");
	}

	@Override
	public void mouseExited(MouseEvent e) {
		// TODO Auto-generated method stub
		System.out.println("离开");
	}
	
	

}

package com.xsx0803.oop;
import javax.swing.*;
import javax.swing.JFrame;
import java.awt.*;
public class DrawPadUI {
	
	//创建画板
	public void initUI() {
	//创建窗口体对象
	JFrame jf=new JFrame();
	//设置窗口属性
	jf.setTitle("几何画板");
	jf.setSize(800, 800);
	jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	jf.setVisible(true);
	
	//设置监听器对象
	MyListener ml=new MyListener();
	jf.addMouseListener(ml);//ml可以直接作为监听器接口对象
	
	}
	public static void main(String[] args) {
		
		DrawPadUI ui=new DrawPadUI();
		ui.initUI();
		
		
	
	
	
	}
	
	

}

​ -这个很类似于继承，但是继承只能是类与类之间但是实现implements只能是类与接口之间

​