学面向对象以来啊,一直听别人说Interface,抽象之类的话题.并且说的怎么怎么好,不过好象我从来都没有体会的这种好在哪里?在我自己的练习当中,唯一用的Interface的地方就是,面向接口编程.然后能过spring 把接口的实现类注进去.但是前提是必须告诉spring实现在工程里的哪个地方.  想到这里有一个疑问,希望大家给我指点一下.如果想引用同一个服务器下面的另一个工程里的接口.该怎么办.在不使用EJB的条件下.还有如果是按我的理解,调用一个接口,必须找到实现类的话.那么这个实现类必须是独立的,如果不独立的话,就是引了这么实现类也没有什么用.

0、前言
没有前言，直接开搞！！！
1、准备
集成开发环境：IDEA

JDK：1.8
2、创建项目



3、 项目结构
单文件就随便怎么放了
4、代码
Demo.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.net.*;
import java.util.*;

/**
 * @author KonBAI
 * @version 1.0
 * Create by 2020/05/10 01:08
 */
public class Demo extends JFrame {

    /**
     * 窗口标题
     */
    // TODO: 根据自己需要修改窗口标题
    public static final String WINDOWS_TITLE = "名字-333";

    public Demo() {
        initComponents();
    }

    @SuppressWarnings("unchecked")
    private void initComponents() {

        JLabel inputLabel = new JLabel();
        // 接收用户输入内容
        JTextField inputTextField = new JTextField();
        // 提交按钮
        JButton submitBtn = new JButton();
        // 获取所有的网络接口信息按钮
        JButton findAllBtn = new JButton();
        JScrollPane scrollPane = new JScrollPane();
        // 输出文本
        JTextArea viewTextArea = new JTextArea();

        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setTitle(WINDOWS_TITLE);

        inputLabel.setText("请输入 IP/InterfaceName:");

        submitBtn.setText("提 交");
        submitBtn.addActionListener(evt -> jButtonActionPerformed(evt, viewTextArea, inputTextField.getText()));

        findAllBtn.setText("获取所有的网络接口信息");
        findAllBtn.addActionListener(evt -> jButtonActionPerformed(evt, viewTextArea, null));

        viewTextArea.setColumns(20);
        viewTextArea.setRows(10);
        scrollPane.setViewportView(viewTextArea);

        GroupLayout layout = new GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                .addGroup(layout.createSequentialGroup()
                        .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING, false)
                                .addGroup(layout.createSequentialGroup()
                                        .addContainerGap()
                                        .addComponent(inputLabel, GroupLayout.PREFERRED_SIZE, 150, GroupLayout.PREFERRED_SIZE)
                                        .addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED)
                                        .addComponent(inputTextField, GroupLayout.PREFERRED_SIZE, 180, GroupLayout.PREFERRED_SIZE)
                                        .addGap(18, 18, 18)
                                        .addComponent(submitBtn, GroupLayout.PREFERRED_SIZE, 80, GroupLayout.PREFERRED_SIZE))
                                .addGroup(layout.createSequentialGroup()
                                        .addGap(46, 46, 46))
                                .addGroup(layout.createSequentialGroup()
                                        .addContainerGap()
                                        .addComponent(findAllBtn, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
                                .addGroup(layout.createSequentialGroup()
                                        .addContainerGap()
                                        .addComponent(scrollPane)))
                        .addContainerGap(20, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
                .addGroup(layout.createSequentialGroup()
                        .addGap(19, 19, 19)
                        .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
                                .addComponent(inputLabel, GroupLayout.PREFERRED_SIZE, 23, GroupLayout.PREFERRED_SIZE)
                                .addComponent(inputTextField, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
                                .addComponent(submitBtn))
                        .addComponent(findAllBtn)
                        .addPreferredGap(LayoutStyle.ComponentPlacement.UNRELATED)
                        .addComponent(scrollPane, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE, GroupLayout.PREFERRED_SIZE)
                        .addContainerGap(20, Short.MAX_VALUE))
        );
        pack();
    }

    private void jButtonActionPerformed(ActionEvent evt, JTextArea viewTextArea, String input) {
        viewTextArea.setText("");
        boolean flag = false;
        try {
            //获取所有接口，并放进枚举集合中，然后使用Collections.list()将枚举集合转换为ArrayList集合
            ArrayList<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            for (Iterator<NetworkInterface> interfaceIterator = interfaces.iterator(); interfaceIterator.hasNext(); ) {
                NetworkInterface networkInterface = interfaceIterator.next();
                String intName = networkInterface.getName(); //获取接口名
                //获取每个接口中的所有ip网络接口集合，因为可能有子接口
                ArrayList<InetAddress> inets = Collections.list(networkInterface.getInetAddresses());
                for (Iterator<InetAddress> inetAddrIterator = inets.iterator(); inetAddrIterator.hasNext(); ) {
                    InetAddress inetAddress = inetAddrIterator.next();
                    //只筛选ipv4地址，否则会同时得到Ipv6地址
                    if (inetAddress instanceof Inet4Address) {
                        String ip = inetAddress.getHostAddress();
                        if (Objects.isNull(input)) {
                            flag = true;
                            viewTextArea.append("InetfaceName:" + intName + " | IPv4:" + ip + "\n");
                        } else if (intName.equals(input) || ip.equals(input)) {
                            flag = true;
                            viewTextArea.append("InetfaceName:" + intName + " | IPv4:" + ip + "\n");
                        }
                    }
                }
            }
            if (!flag) {
                viewTextArea.setText("未找到 '" + input + "' 相关IP/InterfaceName，请重新输入");
            }
        } catch (SocketException s) {
            s.printStackTrace();
        }
    }

    public static void main(String[] args) {
    	// TODO: 添加窗口样式
    	
        EventQueue.invokeLater(() -> new Demo().setVisible(true));
    }

}


5、运行截图



5、自定义修改

1、修改窗口标题



2、添加窗口样式(可有可无)



添加代码如下 ：

// TODO: 添加窗口样式
  try {
      /**
       * Metal风格: javax.swing.plaf.metal.MetalLookAndFeel
       * Nimbus风格: javax.swing.plaf.nimbus.NimbusLookAndFeel
       * Motif风格: com.sun.java.swing.plaf.motif.MotifLookAndFeel
       * Windows风格: com.sun.java.swing.plaf.windows.WindowsLookAndFeel
       * WindowsClassic风格: com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel
       */
      UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
  } catch (Exception e) {
      e.printStackTrace();
  }

直接调用 
比如 
interface A { 
void interfaceMethod(); 
} 


class B { 
public void classMethod(A a) { 
a.interfaceMethod();
}
}
直接这样调用没有任何问题的 因为他A是接口不能实例化 他传给你的a对象一定是实现了A接口的 调用的也就是实现的那个方法 } }

写代码都会要求高密度，低耦合，尽量避免循环引用的出现。曾经面试时，有一道面试题是这样的，如果A引用B，B引用C，C又引用A，怎么解决这种循环引用？如图：



这也是今天写这个的原因，个人思路为把环状拆分为一条直线，也就是让A持有B，B持有C，而把C要调用的A中的内容抽离出来，这里把这部分叫做D，通过B,把D传递给C。也就是C持有的，实际上不再是A，而是A里的一部分C需要的内容（D）。如图：



当然这里所给的，只是一种思路，因为根据实际问题，如果ABC三者处于同级，那再让A持有B，B持有C就不合适了，也需要只暴露某一部分公共的内容。比如玩家攻击敌人，玩家和敌人属于同级，可能只需要执行一个敌人掉血的函数，而却把整个敌人类暴露给玩家类，就很不合适了。这里不做赘述，具体要根据不同环境进一步规划该怎么写，这里只提供思路。

公共部分D，以什么形式传递，就是下面要写的内容，有两种方式，委托和接口。下面重点说接口的方式。这里提供一个别人写的博客：讲到了解决循环引用的第三种方式，反射。

https://blog.csdn.net/ZslLoveMiwa/article/details/80813568

本文只写接口方式，委托比较简单，同样可以用写一个更复杂点的事件系统去做处理。代码如下：

ClassA

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public interface MethodA
{
    void MethodA();
    
}

public class ClassA : MonoBehaviour, MethodA
{
   
    private ClassB m_claasB;

    void Start () {
        m_claasB = new ClassB(this);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.A))
        {
            CCallA();
        }

        if (Input.GetKeyDown(KeyCode.B))
        {
            ACallB();
        }

        if (Input.GetKeyDown(KeyCode.C))
        {
            BCallC();
        }
    }

    public void MethodA()
    {
       Debug.Log("Class A__MethodA"); 
    }

    public void CCallA()
    {
        m_claasB.CCallA();
    }

    public void BCallC()
    {
        m_claasB.BCallC();
    }

    public void ACallB()
    {
        m_claasB.MethodB();
    }


}

ClassB:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;



public class ClassB 
{

    private ClassC m_classC;

    public ClassB(MethodA actionA)
    {
        m_classC=new ClassC(actionA);
    }

    public void MethodB()
    {
       Debug.Log("ClassB_MethodB");
    }

    public void BCallC()
    {
        m_classC.MethodC();
    }

    public void CCallA()
    {
        m_classC.CallA();
    }

}


ClassC:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;



public class ClassC : MonoBehaviour
{

    private MethodA _methodA;
	// Use this for initialization
	public ClassC(MethodA ActionA )
	{
	    _methodA = ActionA;

	}
	
    public void MethodC()
    {
       Debug.Log("ClassC _MethodC");
    }

    public void CallA()
    {
        _methodA.MethodA();
    }
}


其实不管是委托，还是接口，其目的都是只暴露给其他类需要调用的部分，尽可能少的暴露不必要的内容给其他类。