ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 系统相关> 文章详细

模拟windows10计算器的实现

2021-07-04 23:33:05  阅读：126  来源： 互联网

标签：case map String windows10 element 计算器 put new 模拟


用户界面部分：

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.HashMap;
import java.util.Vector;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.table.*;


public class caculate extends JFrame implements ActionListener,MouseListener {
JTextField contain1,contain2;//内容显示区域
String midstring="";//用于需要计算表达式的更新
JComboBox sanjiao,hanshu;//三角学，函数下拉框
String resul[] =new String[100]; //存储用户点击的命令
int resulkey=0; //计数
String data[]=new String[100]; //存储按钮的内容
int data1[]=new int[] {16,17,18,21,22,23,26,27,28,31,32,33}; //要切换的按钮的位置	
HashMap<String,String> map = new HashMap<>();	//存储命令的键值对
	
JButton pan1Button[]=new JButton[6]; //panel1按钮组
JButton pan2Button[]=new JButton[6]; //panel2按钮组
JButton pan3Button[]=new JButton[6];
static JButton button[]=new JButton[35];
Color color;
Color color1=new Color(240,240,240);
Color color2=new Color(230,230,230);
Color color3=new Color(150,200,255);

public static void main(String[] args) {
	// TODO Auto-generated method stub
	caculate cacu=new caculate();
	cacu.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
	cacu.setSize(340,545);
	cacu.setVisible(true);
}
public caculate() {
	super("计算器");
	this.setBackground(color1);
	setLocationRelativeTo(getOwner());		
	setLayout(new GridBagLayout());
	setMenuBar(change());
			
	map.put("+","+");
    map.put("-","-");
    map.put("*","*");
    map.put("/","/");
    map.put("(","(");
    map.put(")",")");
    map.put("x^2","^");
    map.put("x^3","^");
    map.put("1/x","^");
    map.put("e^x","^");
    map.put("√x","^");
    map.put("x^y","^");
    map.put("10^x","^");
    map.put("∛x","^");
    map.put("√(y&x)","^");
    map.put("2^x","^");
    map.put("n!","#");
    map.put("|x|","a");
    map.put("exp","e");
    map.put("mod","%");
    map.put("log_y⁡x","l");
    map.put("log","l");
    map.put("ln","l");
    map.put("+/-","~");
    map.put("sin","s");
    map.put("sin^-1","S");
    map.put("sinh","h");
    map.put("cos","c");
    map.put("cos^-1","C");
    map.put("cosh","H");
    map.put("tan","t");
    map.put("tan^-1","T");
    map.put("tanh","N");
    map.put("rand","r");
    map.put("ceil","q");
    map.put("floor","f");
    map.put("pi","p");
    map.put("e","E");
    map.put(".", ".");
	
	contain1=new JTextField(10);
	contain1.setBorder(BorderFactory.createEmptyBorder());
	contain1.setHorizontalAlignment(JTextField.RIGHT);
	contain1.setEditable(false);
	contain1.setBackground(color1);
			
	contain2=new JTextField(10); 
	contain2.setText("0");
	contain2.setBorder(BorderFactory.createEmptyBorder());
	contain2.setHorizontalAlignment(JTextField.RIGHT);
	contain2.setBackground(color1);
	contain2.setFont(new Font("楷体",Font.BOLD,32));
	
	GridBagConstraints gridBag=new GridBagConstraints();
	gridBag.fill=GridBagConstraints.BOTH;
	gridBag.weightx=100;
	gridBag.weighty=10;
	addToBag(contain1,gridBag, 0,0,1,1);
	addToBag(contain2,gridBag, 0,1,1,1);
	
	gridBag.weightx=100;
	gridBag.weighty=0;
	JPanel pan1=new JPanel();
	JPanel pan2=new JPanel();
	JPanel pan3=new JPanel();
			
	pan1.setBackground(color1);
	pan1.setLayout(new GridLayout(1,6,0,0));
	pan2.setBackground(color1);
	pan2.setLayout(new GridLayout(1,6,0,0));
	pan3.setBackground(color1);
	pan3.setLayout(new GridLayout(1,6,0,0));
	
			
	addToBag(pan1,gridBag,0,2,1,1);
	addToBag(pan2,gridBag,0,3,1,1);
	addToBag(pan3,gridBag,0,4,1,1);
	
	String[] san= {"三角学","sin","cos","tan","sin^-1","cos^-1","tan^-1","sinh","cosh","tanh"};
	sanjiao=detCbB(san);
	pan3.add(sanjiao);	
	String[] han= {"函数","ceil","floor","rand"};
	hanshu=detCbB(han);
	pan3.add(hanshu);
	
	JPanel pan=new JPanel();
	pan.setBackground(color1);
	pan.setLayout(new GridLayout(7,5,0,0));
	gridBag.weightx=100;
	gridBag.weighty=100;
	addToBag(pan,gridBag,0,5,1,1);
	
	
	
	getkey(data); //从文件中读取按钮数据
	Initpan(data,pan);//初始化pan面板
	Initpan1(data,pan1);//初始化pan1面板
	Initpan2(data,pan2);//初始化pan2面板
	
}

void Initpan(String[] data,JPanel pan) {
	int j=0;
	for(int i=0;i<35;i++)
	{ 
		button[i]=new JButton(data[j++]);
		button[i].setBackground(color1);
		button[i].setBorder(BorderFactory.createMatteBorder(1, 1, 1, 1, color2));
		pan.add(button[i]);
		button[i].addActionListener(this);
		button[i].addMouseListener(this);
	}
			
	for(int x:data1) {			
		button[x].setBackground(Color.white);
	}
	button[34].setBackground(color3);
	
	
}	
void Initpan1(String[] data ,JPanel pan1) {
	int j=41;
	for(int i=0;i<5;i++) {
		if(i<2) {
		pan1Button[i]=new JButton(data[j++]);
		
		pan1Button[i].addActionListener(this);
		pan1Button[i].addMouseListener(this);
		}
		else
		{
			pan1Button[i]=new JButton(" ");
		}
		pan1Button[i].setBackground(color1);
		pan1Button[i].setBorderPainted(false);
		pan1.add(pan1Button[i]);
		
	}
	
}

void Initpan2(String[] data,JPanel pan2) {
	int j=43;
	for(int i=0;i<6;i++) {
		pan2Button[i]=new JButton(data[j++]);
		pan2Button[i].setBackground(color1);
		pan2Button[i].setBorderPainted(false);
		pan2.add(pan2Button[i]);
		if(i<2||i==5) {
			pan2Button[i].setEnabled(false);
		}
		else
		{
		pan2Button[i].addActionListener(this);
		pan2Button[i].addMouseListener(this);
		}
	}	
}

void addToBag(Component c,GridBagConstraints gbc, int x,int y,int w,int h) {
	gbc.gridx=x;
	gbc.gridy=y;
	gbc.gridheight=h;
	gbc.gridwidth=w;
	add(c,gbc);
	
	
}

//从文件中读取数据
public void getkey(String[] param) {


	try {
		File file=new File("text.txt");
		BufferedReader in=new BufferedReader(new InputStreamReader(new FileInputStream(file),"UTF8"));
		boolean eof=false;
		int flag=0;
		while(!eof) {
			String x=in.readLine();
			if(x==null) {
				eof=true;
			}
			else {
				param[flag++]=x;
			}
		}
		
	}
	catch(IOException e) {}

}

//创建下拉组合框
public JComboBox detCbB(String[] Ordata) {
	
	
	JComboBox example=new JComboBox(Ordata);
	example.setBackground(color1);
	example.setBorder(null);
	//example.setForeground(color);
	example.addItemListener(new ItemListener() {

		@Override
		public void itemStateChanged(ItemEvent e) {
			// TODO Auto-generated method stub
			if(e.getStateChange()==ItemEvent.SELECTED) {
				if(midstring.equals("=")) {
					contain1.setText("");
					midstring="";
					
				}	
				if(e.getStateChange()==ItemEvent.DESELECTED) {
					
						
					}
			int k=example.getSelectedIndex();
			if(Ordata[k]=="三角学"||Ordata[k]=="函数") {
				
			}
			else {
			resul[resulkey++]=Ordata[k];
			midstring+=Ordata[k];
			contain1.setText(midstring);
			}
			}
		}
		
		
		
	});
	return example;
	
}
@Override
public void actionPerformed(ActionEvent e) {
	// TODO Auto-generated method stub
	String command=e.getActionCommand();
	sanjiao.setSelectedIndex(0);
	hanshu.setSelectedIndex(0);
	if(midstring.equals("=")) {
		contain1.setText("");
		midstring="";
		
	}
	if(command.equals("2nd")) {
		JButton butt=(JButton)e.getSource();
		if(butt.getBackground()==color3) {
			restoreButton();
			butt.setBackground(color1);
			color=color1;
		}
		else {
		changeButton();
		butt.setBackground(color3);
		color=color3;
		}
		}
	else
	{
		if(command.equals("=")) {
			String result=changeType(resul);
			System.out.println(result);
			System.out.println(resulkey);
			System.out.println(Cauculate.midtolast(result));
			Double result1=Cauculate.CaculateLastStackExpression(Cauculate.midtolast(result));
			contain2.setText(Double.toString(result1));
			midstring="=";
			resulkey=0;
		}
		else 
		{
			if(command.equals("c"))//清除单个命令
			{
				if(midstring.length()>0)
				{
				int len=resul[resulkey-1].length();//获取上一个命令的长度
				midstring=midstring.substring(0, midstring.length()-len);	//有问题	
				resulkey--;
				}
				command="";
			}
			if(command.equals("×")) //清除所有的命令
			{
				midstring="";
				command="";
				resulkey=0;
			}
			resul[resulkey++]=command;
			midstring+=command;
			if(command=="") {//纠正计数问题
				resulkey--;
			}
			contain1.setText(midstring);
			if(command.charAt(0)>'0'&&command.charAt(0)<'9') 
			{
				contain2.setText(command);
			}
			
		}
	
	}
	
	
}

private String changeType(String[] resul2) {
	// TODO Auto-generated method stub
	String ch="";
	for(int i=0;i<resulkey;i++) {
		
		if(!isNumber(resul2[i])) {
			switch (resul2[i]) {
				case "x^2": 
				ch+=map.get(resul2[i])+"2";
				break;
				case "x^3": 
					ch+=map.get(resul2[i])+"3";
					break;
				case "1/x": 
					ch+=map.get(resul2[i])+"(0-1)";
					break;
				case "e^x": 
					ch+='E'+map.get(resul2[i]);
					break;
				case "√x": 
					ch+=map.get(resul2[i])+"(1/2)";
					break;
				case "x^y": 
					ch+=resul2[i+1]+map.get(resul2[i])+resul2[i+2];
					i+=2;
					break;				
				case "10^x": 
					ch+="10"+map.get(resul2[i]);
					break;
				case "∛x": 
					ch+=map.get(resul2[i])+"(1/3)";
					break;
				case "√(y&x)": 
					ch+=resul2[i+1]+map.get(resul2[i])+(1/(Double.parseDouble(resul2[i+2])));
					i+=2;
					break;
				case "log_y⁡x": 
					ch+=resul2[i+1]+map.get(resul2[i])+resul2[i+2];
					i+=2;
					break;
				case "log": 
					ch+="10"+map.get(resul2[i]);
					break;
				case "ln": 
					ch+="E"+map.get(resul2[i]);
					break;
				default:
					ch+=map.get(resul2[i]);
					break;
			
				
				
			}			
		}
		else {
			
			ch+=resul2[i];
			
		}
		
		
	}
	
	return ch;
}

public static boolean isNumber(String str) {
	
	for(int i=0;i<str.length();i++) {
		
		if(!Character.isDigit(str.charAt(i)))
		{
			return false;
		}
		
		
	}
	return true;
	
}
private MenuBar change() {
	
	MenuBar jmenubar=new MenuBar();
	jmenubar.addNotify();
	Menu ch=new Menu("==");
	jmenubar.add(ch);
	MenuItem item1=new MenuItem("Science");
	ch.add(item1);
	MenuItem item2=new MenuItem("绘图");
	ch.add(item2);
	MenuItem item3=new MenuItem("标准");
	ch.add(item3);
	MenuItem item4=new MenuItem("程序员");
	ch.add(item4);
	Menu type=new Menu("Science");
	jmenubar.add(type);
	return jmenubar;
	
}
//按2nd改变按钮
public void changeButton() {
	int k=5;
	for(int i=35;i<41;i++) {
		button[k].setText(data[i]);
		k+=5;
	}
}
//按2nd复原按钮
public void restoreButton() {
	int k=5;
	for(int i=35;i<41;i++) {
		button[k].setText(data[k]);
		k+=5;
	}
	
}

@Override
public void mouseClicked(MouseEvent e) {
	// TODO Auto-generated method stub
	
}
@Override
public void mousePressed(MouseEvent e) {
	// TODO Auto-generated method stub
	
}
@Override
public void mouseReleased(MouseEvent e) {
	// TODO Auto-generated method stub
	
}
@Override
public void mouseEntered(MouseEvent e) {
	// TODO Auto-generated method stub
if(e.getComponent().getClass().equals(button[0].getClass())) {
	color=((JButton)e.getSource()).getBackground();
	((JButton)e.getSource()).setBackground(new Color(220,220,220));
	
}
}
@Override
public void mouseExited(MouseEvent e) {
	// TODO Auto-generated method stub
	if(e.getComponent().getClass().equals(button[0].getClass())) {
	
		((JButton)e.getSource()).setBackground(color);
		
	}

	
	
}



}

表达式计算部分：

基本原理

将获得的表达式由中缀转化为后缀，利用java的栈进行相应的运算。

package tttt;

import java.util.*;

public class Cauculate {

//创建用于匹配运算符的字符数组
private static char[] trans1= {'+','-','*','/','#','^','a','e','%','l','~','s','S','h','H','c','C','t','T','N','r','q','f'};//总数组
private static char[] trans2= {'+','-','*','/','^','e','%','l'};//单目运算符
private static char[] trans3= {'a','#','~','s','S','h','H','c','C','t','T','N','q','f'};//双目运算符

public static int transExp(char exp) {//运算符优先级
	int re = 0;
	switch (exp) {
	case '*':
	case '/':
		re = 2;
		break;
	case '+':
	case '-':
		re = 1;
		break;
	case '^':
		re = 4;
		break;
	case '#':
	case 'l':
	case '~':
	case 'e':
	case 's':
	case 'S':
	case 'h':
	case 'c':
	case 'C':
	case 'H':
	case 't':
	case 'T':
	case 'N':
	case 'a':
	case 'q':
	case 'f':
	case 'r':
	case '%':
		re=3;
		break;
	}
	return re;
}



public static String midtolast(String mid){//中缀表达式转后缀表达式
	Stack<Character>OperateorStack=new Stack<Character>();
	Stack<String>LastStack=new Stack<String>();//后缀表达式栈；
	int length=mid.length();
	int index=0;//指向String扫描的当前位置;
	char element;//
	String num="";//
	while(index<length){//扫描整个mid
		element=mid.charAt(index);
		if(element>='0'&&element<='9'){//得到一整个数据，例如'123'				
			num=num+element;
			if(index==length-1) {
				LastStack.push(num);
			}
			else {
			char ch=mid.charAt(index+1);
			if(ch=='.') {
				num+=ch;
				index++;
			}
			else
			{
			if(ch<'0'||ch>'9') {
				LastStack.push(num);
				num="";
			}
			}
			}
						
		}
		else if(element=='E') {
			LastStack.push(Double.toString(Math.E));
			
		}
		else if(element=='p') {
			LastStack.push(Double.toString(Math.PI));
			
		}
		else if(element=='('){
			OperateorStack.push(element);
		}
		else if(element==')'){
			while(OperateorStack.peek()!='('){
				LastStack.push(OperateorStack.pop().toString());//将左括号到右括号之间的操作符弹出
			}
			OperateorStack.pop();//让左括号出栈
		}
		else if(castele(element,trans1)){
			if(OperateorStack.isEmpty()||OperateorStack.peek()=='('){//栈为空或栈顶元素为'('则直接入栈
				OperateorStack.push(element);
			}
			else if(transExp(element)>transExp(OperateorStack.peek())){
				OperateorStack.push(element);
			}//如果element的优先级高于栈顶元素则直接入栈
			else if(transExp(element)<=transExp(OperateorStack.peek())){
				
				while(!OperateorStack.isEmpty()&&OperateorStack.peek()!='('){
					LastStack.push(OperateorStack.peek().toString());
					OperateorStack.pop();
					if(!OperateorStack.isEmpty()&&transExp(element)<=transExp(OperateorStack.peek())) {
						continue;
					}
					else {
						break;
					}
				}
				OperateorStack.push(element);
			}//如果element的优先级低于或等于栈顶元素等于栈顶元素则将栈顶元素加入后缀表达栈中				
		}
		index++;
	}
	while(!OperateorStack.isEmpty()){
		LastStack.push(OperateorStack.pop().toString());
	}
	String LastStackExpression=LastStack.pop();
	while(!LastStack.isEmpty()){
		LastStackExpression=LastStack.pop()+" "+LastStackExpression;
	}
	return LastStackExpression;
}
public static double CaculateLastStackExpression(String LastStackExpression){
	Stack<Double>operandStack=new Stack<Double>();//初始化一个操作数栈
	String[] elements=LastStackExpression.split(" ");//将LastStackExpression以空格分隔开；
	String element=null;//后缀表达式扫描到的单元；
	char elementHead;
	double operand=0,operand1=0,operand2=0;
	for (int i = 0; i < elements.length; i++) {//依次扫描后缀表达式的单元
		element=elements[i];
		elementHead=element.charAt(0);
		if (elementHead>='0'&&elementHead<='9') {//如果扫描到的是操作数串，将其转换为double数据，并压入操作数栈
			operand=Double.parseDouble(element);
			operandStack.push(operand);
		}else if(castele(elementHead,trans2)){//如果扫描到的是运算符
			operand1=operandStack.pop();//取操作数栈的栈顶
			operand2=operandStack.pop();//取操作数栈的栈顶
			operand=caculateResult(operand1,operand2,elementHead);//进行运算，得出返回结果
			operandStack.push(operand);//将结果压入操作数栈
		}
		else if(castele(elementHead,trans3)) {
			operand1=operandStack.pop();
			operand=caculateResult(operand1,0.0,elementHead);
			operandStack.push(operand);
			
		}
		else if (elementHead=='r') {
			operand=caculateResult(0.0,0.0,elementHead);
			operandStack.push(operand);
			
			
		}
	}
	return operandStack.pop() ;
}
public static double caculateResult(double operand1,double operand2,char operator){//返回的运算结果
	double result=0;
	switch (operator) {
	case '+':
		result=operand1+operand2;
		break;
	case '-':
		result=operand2-operand1;
		break;
	case '*':
		result=operand1*operand2;
		break;
	case '/':
		result=operand2/operand1;
		break;
	case '^':
		result=ScientificCalculator.Pow2(operand2,operand1);
		break;
	case '#':
		result=ScientificCalculator.Factorial((int)operand1);
		break;
	case 'l':
		result=ScientificCalculator.Log(operand2,operand1);
		break;
	case '~':
		result=ScientificCalculator.Reverse(operand1);
		break;
	case 'e':
		result=ScientificCalculator.Exp(operand2,(int)operand1);
		break;
	case 's':
		result=ScientificCalculator.Sin(operand1,1);
		break;
	case 'S':
		result=ScientificCalculator.Sin(operand1,2);
		break;
	case 'h':
		result=ScientificCalculator.Sin(operand1,3);
		break;
	case 'c':
		result=ScientificCalculator.Cos(operand1,1);
		break;
	case 'C':
		result=ScientificCalculator.Cos(operand1,2);
		break;
	case 'H':
		result=ScientificCalculator.Cos(operand1,3);
		break;
	case 't':
		result=ScientificCalculator.Tan(operand1,1);
		break;
	case 'T':
		result=ScientificCalculator.Tan(operand1,2);
		break;
	case 'N':
		result=ScientificCalculator.Tan(operand1,3);
		break;
	case 'a':
		result=ScientificCalculator.abs(operand1);
		break;
	case 'q':
		result=ScientificCalculator.ceil(operand1);
		break;
	case 'f':
		result=ScientificCalculator.floor(operand1);
		break;
	case 'r':
		result=ScientificCalculator.rand();
		break;
	case '%':
		result=ScientificCalculator.Mod(operand2,operand1);
		break;
		

	default:
		break;
	}
	return result;
}

//判断符号
public static boolean castele(char element,char[] Su) {
	for(char x:Su) {
		if(element==x)
			return true;
	}
	
	return false;
}

}

单个函数部分：

单个按钮功能的实现。

package tttt;

import java.lang.Math;
import java.util.HashMap;
import java.util.Map;

public class ScientificCalculator {

// 指数运算：x^2，1/x，e^x，平方根  " ^ "
static public double Pow2(double x,double n)
{
    return Math.pow(x,n);
}

// 阶乘运算：  " # "
static public int Factorial(int x)
{
    if (x <= 0)
    {
        throw new IllegalArgumentException("需要计算的参数必须为正数！");//抛出不合理参数异常
    }
    if (x == 1)
    {
        return 1;//跳出循环
    }
    else
    {
        return  x * Factorial(x - 1);//递归
    }
}

// 对数运算：log，ln  “ l ”
static public double Log(double base,double value)
{
    return Math.log(value) / Math.log(base);
}

static public double Mod(double x,double y)
{
    return x%y;
}

// 取反运算：+/-  " ~ "
static public double Reverse(double x)
{
    return -x;
}

// 科学计数法：x*e^n  "e"
static public double Exp(double x,int n)
{
    return x * Math.pow(10,n);
}

// sin、sin^-1(asin)、sinh、sinh^-1(asinh)
// 运算: degree:度数; sin:flag=1 " s "; sin^-1(asin):flag=2 " S "; sinh:flag=3 " h "
static public double Sin(double degree,int flag)
{
    double radians = Math.toRadians(degree);
    switch (flag)
    {
        case 1:
            return Math.sin(radians);
        case 2:
            return Math.asin(radians);
        case 3:
            return Math.sinh(degree);
        default:
            throw new IllegalStateException("Unexpected value: " + flag);
    }
}

// cos、cos^-1(acos)、cosh
// 运算: degree:度数; cos:flag=1 " c "; cos^-1(acos):flag=2 " C "; cosh:flag=3 " H "
static public double Cos(double degree,int flag)
{
    double radians = Math.toRadians(degree);
    switch (flag)
    {
        case 1:
            return Math.cos(radians);
        case 2:
            return Math.acos(radians);
        case 3:
            return Math.cosh(degree);
        default:
            throw new IllegalStateException("Unexpected value: " + flag);
    }
}

// tan、tan^-1(atan)、tanh
// 运算: degree:度数; tan:flag=1 " t "; tan^-1(atan):flag=2 " T "; tanh:fla g=3 " N "
static public double Tan(double degree,int flag)
{
    double radians = Math.toRadians(degree);
    switch (flag)
    {
        case 1:
            return Math.tan(radians);
        case 2:
            return Math.atan(radians);
        case 3:
            return Math.tanh(degree);
        default:
            throw new IllegalStateException("Unexpected value: " + flag);
    }
}

// 绝对值：|x| " a "
static public double abs(double x)
{
    return Math.abs(x);
}

// 向上取整：ceil " q "
static public double ceil(double x)
{
    return Math.ceil(x);
}

// 向下取整：floor " f "
static public double floor(double x)
{
    return Math.floor(x);
}

// 取随机数：rand " r "
static public double rand()
{
    return Math.random();
}

public static void main(String[] args)
{
  System.out.println(Exp(Math.PI,1));
}
}

运行结果

标签：case,map,String,windows10,element,计算器,put,new,模拟
来源： https://www.cnblogs.com/SuperBird/p/caculate.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有