精华内容
下载资源
问答
  • 2014-10-02 15:44:12

    今天从书上和CSDN上找了几个关于android调用webservice的例子,这些例子从代码来看,没任何错误,但是就是运行不成功。分析了android调用web接口的写法,发现这些例子在调用的时候没单独开一个线程来运行的问题。下面把CSDN上下载的例子“ Android查询电话号码”的主要改动代码贴出来,希望对学习android的初学者有帮助。

    FutureTask<String> futureTask = new FutureTask<String>(
    				new Callable<String>()
    				{
    					@Override
    					public String call() throws Exception
    					{
    						try
    						{
    							// 调用WebService
    							transport.call(soapAction, envelope);
    							if (envelope.getResponse() != null)
    							{
    								// 获取返回的数据
    								SoapObject object = (SoapObject) envelope.bodyIn;
    								// 获取返回的结果
    								String result = object.getProperty(0)
    										.toString();
    								return result;
    							}
    						} catch (Exception e)
    						{
    							e.printStackTrace();
    						}
    						return null;
    					}
    				});	 
    		new Thread(futureTask).start();
    
    		// 将WebService返回的结果显示在TextView中
    		try
    		{
    			String result=futureTask.get();
    			resultView.setText(result);
    		} catch (InterruptedException e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (ExecutionException e)
    		{
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}

    更多相关内容
  • 初学STM32CubeIDE

    千次阅读 2020-12-22 21:02:14
    初学STM32CubeIDE一、关于安装安装已经有好多人说过了,我就不重复。二、认识界面初初打开软件,自动打开“InformationCenter”就是信息中心。我们点击“ReadSTM32CubeIDEDocumentation”,再点击“STM32...

    初学

    STM32CubeIDE

    一、关于安装

    安装已经有好多人说过了,我就不重复。

    二、认识界面

    初初打开软件,

    自动打开

    Information Center

    就是信息中心。

    我们点击

    Read STM32CubeIDE

    Documentation

    ”,再点击“

    STM32CubeIDE Qiuck Start Guide

    ”就是快速启动手册。

    简单介绍一下。

    Note:

    workspace

    and

    project

    names

    must

    contain

    only

    ascii

    characters.

    This

    is

    also

    valid

    for

    the

    path

    to

    the

    workspace.

    注意:项目要用

    ascii

    字节。工作空间名也要用

    ascii

    字节。

    工作空间就是一个文件夹,用于作为

    STM32CubeIDE

    的存放暂时文件和记录文件的地方。

    三、建工程

    工程不用建在工作空间中。

    我喜欢各软件的工程集中放一起,

    再区分一个个软件专用的工程

    文件夹。

    菜单“

    File

    -

    New

    -

    STM32 Project

    ”或者“

    Start new STM32 project

    ”链接,则启动新建

    工程。

    工程的第一步:选择芯片,可以通过左则输入型号,快速选出;或者通过下拉框的过滤,最

    后选定型号。

    工程的第二步:项目的名字,还的选项。名字不要用中文,要用

    ascii

    。选项默认就可以,用

    C

    语言,输入单片机程序。

    工程的第三步:这里我也看不明白,点“

    Finish

    (

    完成

    )

    就好了。

    建工程前和后比较卡,这是在下载。

    四、设定时基

    看看电路图,我发现晶振两块,一块是

    8MHz

    ,另一块是

    32.768KHz

    。那么对应高速时钟是

    来自晶振

    8MHz

    。低速时钟是来自晶振

    32.768KHz

    那么我点开“

    System Core

    ”,选中“

    RCC

    ”。对应

    HSE

    下拉选“

    Crystal/Ceramic Resonator

    这是晶振的意思。

    BYPASS Clock Source

    ”意思是指线输入路时钟源。

    我再点击上栏“

    Clock Configuration

    ”时钟配置。

    LSE

    的连接

    Input frequency

    可以填入

    32.768

    HSE

    的连接

    Input frequency

    可以填入

    8

    HCLK

    填入

    72

    ,跳出

    Clock Wizard

    ,这是时钟向导,是否自动调整其它时钟源。点“

    OK

    ”。

    五、设定

    GPIO

    点击上栏“

    Pinout&Configuration

    ”。

    看看电路图,

    我要找

    LED

    灯,

    我发现都上拉的。

    那么

    GPIO

    设成推挽,

    初值为高电平就好了。

    展开全文
  • 作为 Pebble IDE 的 Sublime Text 2 构建系统与 Sublime 文本编辑器一起使用,以直接从 Sublime Text 构建和运行 Pebble 应用程序 ... Sublime Text 2 中打开卵石项目 点击“工具”->“构建系统”,选择“Pebble
  • 3.新建项目向导,展开 “Java” 类别,然后选择 “Java Application”(Java 应用程序),如下图所示。然后,单击 “Next”(下一步)。New Java Application 对话框将要求用户确定项目名称(Project Name)及其...

    NetBeans ide操作流程及注意事项
    要创建 IDE 项目,请执行以下操作:
    1.启动 NetBeans IDE。
    2.在 IDE 中,选择 “File”(文件)> “New Project”(新建项目)
    在这里插入图片描述

    3.在新建项目向导中,展开 “Java” 类别,然后选择 “Java Application”(Java 应用程序),如下图所示。然后,单击 “Next”(下一步)。New Java Application 对话框将要求用户确定项目名称(Project Name)及其项目文件存放位置(Project Location)
    在这里插入图片描述
    在这里插入图片描述

    4.。创建项目之后,下一步是通过右击 HelloJava→New→JFrame Form 菜单命令来创建 GUI 应用程序(Form 窗口应用程序)
    在这里插入图片描述

    5.需要确定 Form 窗口的类名。在本例中,创建的类名为
    HelloJavaForm。然后,还需要确定创建 JFrame Form 类的包的名称。Package 下拉菜单中选择 “com.mycompany。xxx(项目名)若之前的步骤项目名不是“xxx”,则下拉菜单里面的内容和本文不一样,没关系,直接选择就是了。
    设置好一切后,选择“Finish”按钮结束步骤
    在这里插入图片描述

    6.在xxxForm 的设计部分中,正方形框表示已创建的 Form 窗口。
    创建 Form 窗口之后,需要考虑两个部分,用户需要知道,它们是 Design(设计)和 Source(源代码)部分。两个部分位于创建的 Form 窗口的上方,如上图所示。Design 部分用于设计 Form 窗口的外观,而 Source 部分用于查看已创建的类(在本例中是 HelloJavaForm 类)中的代码。通过单击这两个部分中的一个,用户就可以从一个部分切换到另一个部分。
    要向 Form 窗口添加属性或控件,Java 提供了一个包含窗体控件的选项板(工具箱)。此外,还有属性部分,用于设置控件的属性。

    在这里插入图片描述

    7.属性窗口(Properties Window)是包含在面板中的窗体或控件的一部分,用于设置窗体或控件的属性。要显示“属性窗口”可以右击特定的窗体或控件,然后选择“Properties”。另外,要显示属性窗口也可以通过选择菜单 Windows→IDE Tools→Properties 来实现
    在这里插入图片描述
    Properties窗口中的“title”部分是为窗口填写标题的位置。
    在这里插入图片描述
    设置按钮的 Event 事件,该事件将在按钮被按
    下或单击时触发按钮执行某些操作。可以通过双击添加的按钮来创建 Event,这样源代码部分就会显示 IDE 生成的代码。也可以在按钮上右击→Events→Action→actionPerformed

    在这里插入图片描述

    集成开发环境 IDE 会自动从 Design 设计模式跳转到 Source 源代码模式

    在这里插入图片描述

    若要使所有标签在应用程序首次运行时不可见,则必须为所有标签指定空字符串值
    在这里插入图片描述
    变量名.setText("")
    要在标签上显示数字,必须先将数字转换为字符串。代码 Integer. toString()将整数转换为字符串。Integer类中的 toString()函数将整数作为参数传递

    在这里插入图片描述

    8.组件面板
    在这里插入图片描述
    组件的用途
    label标签
    button按钮
    Text Field 文本字段
    在这里插入图片描述
    说明:控件的 text 对应的文字描述是给用户看的,以便用户明白该控件是什么或者做什么的;控件的变量名是给程序代码用的,以便用户在写代码的时候从变量名就可以知道它对应的是哪个控件,并且知道它是做什么的。当程序里面只有几个控件时,用户可以很轻易地知道每个控件的功能,但是当一个程序达到几十上百个控件的时候,用户就会明白给控件起一个容易理解的变量名是多么的重要。 *注意变量名(Change Variable Name 修改变量名)

    展开全文
  • 前言:本文教你怎么用javac和java命令,讲解了classpath的原理,以及如何...具体代码我的GitHub可以找到 https://github.com/h2pl/MyTech 喜欢的点一下星哈谢谢。 文章首发于我的个人博客: https://h...

    本系列文章将整理到我在GitHub上的《Java面试指南》仓库,更多精彩内容请到我的仓库里查看

    https://github.com/h2pl/Java-Tutorial

    喜欢的话麻烦点下Star、Fork、Watch三连哈,感谢你的支持。

    文章首发于我的个人博客:

    www.how2playlife.com

    本文是微信公众号【Java技术江湖】的《夯实Java基础系列博文》其中一篇,本文部分内容来源于网络,为了把本文主题讲得清晰透彻,也整合了很多我认为不错的技术博客内容,引用其中了一些比较好的博客文章,如有侵权,请联系作者。

    该系列博文会告诉你如何从入门到进阶,一步步地学习Java基础知识,并上手进行实战,接着了解每个Java知识点背后的实现原理,更完整地了解整个Java技术体系,形成自己的知识框架。为了更好地总结和检验你的学习成果,本系列文章也会提供每个知识点对应的面试题以及参考答案。

    聊聊IDE的实现原理

    IDE是把双刃剑,它可以什么都帮你做了,你只要敲几行代码,点几下鼠标,程序就跑起来了,用起来相当方便。

    你不用去关心它后面做了些什么,执行了哪些命令,基于什么原理。然而也是这种过分的依赖往往让人散失了最基本的技能,当到了一个没有IDE的地方,你便觉得无从下手,给你个代码都不知道怎么去跑。好比给你瓶水,你不知道怎么打开去喝,然后活活给渴死。

    之前用惯了idea,Java文件编译运行的命令基本忘得一干二净。

    那好,不如咱们先来了解一下IDE的实现原理,这样一来,即使离开IDE,我们还是知道如何运行Java程序了。

    像Eclipse等java IDE是怎么编译和查找java源代码的呢?

    源代码保存

    这个无需多说,在编译器写入代码,并保存到文件。这个利用流来实现。

    编译为class文件

    java提供了JavaCompiler,我们可以通过它来编译java源文件为class文件。

    查找class

    可以通过Class.forName(fullClassPath)或自定义类加载器来实现。

    生成对象,并调用对象方法

    通过上面一个查找class,得到Class对象后,可以通过newInstance()或构造器的newInstance()得到对象。然后得到Method,最后调用方法,传入相关参数即可。

    示例代码:

    public class MyIDE {
    
        public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
            // 定义java代码,并保存到文件(Test.java)
            StringBuilder sb = new StringBuilder();
            sb.append("package com.tommy.core.test.reflect;\n");
            sb.append("public class Test {\n");
            sb.append("    private String name;\n");
            sb.append("    public Test(String name){\n");
            sb.append("        this.name = name;\n");
            sb.append("        System.out.println(\"hello,my name is \" + name);\n");
            sb.append("    }\n");
            sb.append("    public String sayHello(String name) {\n");
            sb.append("        return \"hello,\" + name;\n");
            sb.append("    }\n");
            sb.append("}\n");
    
            System.out.println(sb.toString());
    
            String baseOutputDir = "F:\\output\\classes\\";
            String baseDir = baseOutputDir + "com\\tommy\\core\\test\\reflect\\";
            String targetJavaOutputPath = baseDir + "Test.java";
            // 保存为java文件
            FileWriter fileWriter = new FileWriter(targetJavaOutputPath);
            fileWriter.write(sb.toString());
            fileWriter.flush();
            fileWriter.close();
    
            // 编译为class文件
            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
            StandardJavaFileManager manager = compiler.getStandardFileManager(null,null,null);
            List<File> files = new ArrayList<>();
            files.add(new File(targetJavaOutputPath));
            Iterable compilationUnits = manager.getJavaFileObjectsFromFiles(files);
    
            // 编译
            // 设置编译选项,配置class文件输出路径
            Iterable<String> options = Arrays.asList("-d",baseOutputDir);
            JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, options, null, compilationUnits);
            // 执行编译任务
            task.call();
    


    ​ // 通过反射得到对象
    ​ // Class clazz = Class.forName(“com.tommy.core.test.reflect.Test”);
    ​ // 使用自定义的类加载器加载class
    ​ Class clazz = new MyClassLoader(baseOutputDir).loadClass(“com.tommy.core.test.reflect.Test”);
    ​ // 得到构造器
    ​ Constructor constructor = clazz.getConstructor(String.class);
    ​ // 通过构造器new一个对象
    ​ Object test = constructor.newInstance(“jack.tsing”);
    ​ // 得到sayHello方法
    ​ Method method = clazz.getMethod(“sayHello”, String.class);
    ​ // 调用sayHello方法
    ​ String result = (String) method.invoke(test, “jack.ma”);
    ​ System.out.println(result);
    ​ }
    ​ }

    自定义类加载器代码:


    ​ public class MyClassLoader extends ClassLoader {
    ​ private String baseDir;
    ​ public MyClassLoader(String baseDir) {
    ​ this.baseDir = baseDir;
    ​ }
    ​ @Override
    ​ protected Class<?> findClass(String name) throws ClassNotFoundException {
    ​ String fullClassFilePath = this.baseDir + name.replace("\.","/") + “.class”;
    ​ File classFilePath = new File(fullClassFilePath);
    ​ if (classFilePath.exists()) {
    ​ FileInputStream fileInputStream = null;
    ​ ByteArrayOutputStream byteArrayOutputStream = null;
    ​ try {
    ​ fileInputStream = new FileInputStream(classFilePath);
    ​ byte[] data = new byte[1024];
    ​ int len = -1;
    ​ byteArrayOutputStream = new ByteArrayOutputStream();
    ​ while ((len = fileInputStream.read(data)) != -1) {
    ​ byteArrayOutputStream.write(data,0,len);
    ​ }

    ​ return defineClass(name,byteArrayOutputStream.toByteArray(),0,byteArrayOutputStream.size());
    ​ } catch (FileNotFoundException e) {
    ​ e.printStackTrace();
    ​ } catch (IOException e) {
    ​ e.printStackTrace();
    ​ } finally {
    ​ if (null != fileInputStream) {
    ​ try {
    ​ fileInputStream.close();
    ​ } catch (IOException e) {
    ​ e.printStackTrace();
    ​ }
    ​ }

                    if (null != byteArrayOutputStream) {
                        try {
                            byteArrayOutputStream.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            return super.findClass(name);
        }
    }    
    

    javac命令初窥

    注:以下红色标记的参数在下文中有所讲解。

    本部分参考https://www.cnblogs.com/xiazdong/p/3216220.html

    用法: javac

    其中, 可能的选项包括:

    -g 生成所有调试信息

    -g:none 不生成任何调试信息

    -g:{lines,vars,source} 只生成某些调试信息

    -nowarn 不生成任何警告

    -verbose 输出有关编译器正在执行的操作的消息

    -deprecation 输出使用已过时的 API 的源位置

    -classpath <路径> 指定查找用户类文件和注释处理程序的位置

    -cp <路径> 指定查找用户类文件和注释处理程序的位置

    -sourcepath <路径> 指定查找输入源文件的位置

    -bootclasspath <路径> 覆盖引导类文件的位置

    -extdirs <目录> 覆盖所安装扩展的位置

    -endorseddirs <目录> 覆盖签名的标准路径的位置

    -proc:{none,only} 控制是否执行注释处理和/或编译。

    -processor [,,…] 要运行的注释处理程序的名称; 绕过默认的搜索进程

    -processorpath <路径> 指定查找注释处理程序的位置

    -d <目录> 指定放置生成的类文件的位置

    -s <目录> 指定放置生成的源文件的位置

    -implicit:{none,class} 指定是否为隐式引用文件生成类文件

    -encoding <编码> 指定源文件使用的字符编码

    -source <发行版> 提供与指定发行版的源兼容性

    -target <发行版> 生成特定 VM 版本的类文件

    -version 版本信息

    -help 输出标准选项的提要

    -A关键字[=值] 传递给注释处理程序的选项

    -X 输出非标准选项的提要

    -J<标记> 直接将 <标记> 传递给运行时系统

    -Werror 出现警告时终止编译

    @<文件名> 从文件读取选项和文件名

    在详细介绍javac命令之前,先看看这个classpath是什么

    classpath是什么

    在dos下编译java程序,就要用到classpath这个概念,尤其是在没有设置环境变量的时候。classpath就是存放.class等编译后文件的路径。

    javac:如果当前你要编译的java文件中引用了其它的类(比如说:继承),但该引用类的.class文件不在当前目录下,这种情况下就需要在javac命令后面加上-classpath参数,通过使用以下三种类型的方法 来指导编译器在编译的时候去指定的路径下查找引用类。

    (1).绝对路径:javac -classpath c:/junit3.8.1/junit.jar Xxx.java

    (2).相对路径:javac -classpath …/junit3.8.1/Junit.javr Xxx.java

    (3).系统变量:javac -classpath %CLASSPATH% Xxx.java (注意:%CLASSPATH%表示使用系统变量CLASSPATH的值进行查找,这里假设Junit.jar的路径就包含在CLASSPATH系统变量中)

    IDE中的classpath

    对于一个普通的Javaweb项目,一般有这样的配置:

    1 WEB-INF/classes,lib才是classpath,WEB-INF/ 是资源目录, 客户端不能直接访问。

    2、WEB-INF/classes目录存放src目录java文件编译之后的class文件,xml、properties等资源配置文件,这是一个定位资源的入口。

    3、引用classpath路径下的文件,只需在文件名前加classpath:

    classpath:applicationContext-*.xml

    classpath:context/conf/controller.xml

    4、lib和classes同属classpath,两者的访问优先级为: lib>classes。

    5、classpath 和 classpath* 区别:

    classpath:只会到你的class路径中查找找文件;
    classpath*:不仅包含class路径,还包括jar文件中(class路径)进行查找。

    总结:

    (1).何时需要使用-classpath:当你要编译或执行的类引用了其它的类,但被引用类的.class文件不在当前目录下时,就需要通过-classpath来引入类

    (2).何时需要指定路径:当你要编译的类所在的目录和你执行javac命令的目录不是同一个目录时,就需要指定源文件的路径(CLASSPATH是用来指定.class路径的,不是用来指定.java文件的路径的)

    Java项目和Java web项目的本质区别

    (看清IDE及classpath本质)

    现在只是说说Java Project和Web Project,那么二者有区别么?回答:没有!都是Java语言的应用,只是应用场合不同罢了,那么他们的本质到底是什么?

    回答:编译后路径!虚拟机执行的是class文件而不是java文件,那么我们不管是何种项目都是写的java文件,怎么就不一样了呢?分成java和web两种了呢?

    从.classpath文件入手来看,这个文件在每个项目目录下都是存在的,很少有人打开看吧,那么我们就来一起看吧。这是一个XML文件,使用文本编辑器打开即可。

    这里展示一个web项目的.classpath

    Xml代码

    <?xml version="1.0" encoding="UTF-8"?>
    <classpath>
    <classpathentry kind="src" path="src"/>
    <classpathentry kind="src" path="resources"/>
    <classpathentry kind="src" path="test"/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    <classpathentry kind="lib" path="lib/servlet-api.jar"/>
    <classpathentry kind="lib" path="webapp/WEB-INF/lib/struts2-core-2.1.8.1.jar"/>
         ……
    <classpathentry kind="output" path="webapp/WEB-INF/classes"/>
    </classpath>
    

    XML文档包含一个根元素,就是classpath,类路径,那么这里面包含了什么信息呢?子元素是classpathentry,kind属性区别了种 类信息,src源码,con你看看后面的path就知道是JRE容器的信息。lib是项目依赖的第三方类库,output是src编译后的位置。

    既然是web项目,那么就是WEB-INF/classes目录,可能用MyEclipse的同学会说他们那里是WebRoot或者是WebContext而不是webapp,有区别么?回答:完全没有!

    既然看到了编译路径的本来面目后,还区分什么java项目和web项目么?回答:不区分!普通的java 项目你这样写就行了:,看看Eclipse是不是这样生成的?这个问题解决了吧。

    再说说webapp目录命名的问题,这个无所谓啊,web项目是要发布到服务器上的对吧,那么服务器读取的是类文件和页面文件吧,它不管源文件,它也无法去理解源文件。那么webapp目录的命名有何关系呢?只要让服务器找到不就行了。

    javac命令后缀

    -g、-g:none、-g:{lines,vars,source}

    •-g:在生成的class文件中包含所有调试信息(行号、变量、源文件)
    •-g:none :在生成的class文件中不包含任何调试信息。

    这个参数在javac编译中是看不到什么作用的,因为调试信息都在class文件中,而我们看不懂这个class文件。

    为了看出这个参数的作用,我们在eclipse中进行实验。在eclipse中,我们经常做的事就是“debug”,而在debug的时候,我们会
    •加入“断点”,这个是靠-g:lines起作用,如果不记录行号,则不能加断点。
    •在“variables”窗口中查看当前的变量,如下图所示,这是靠-g:vars起作用,否则不能查看变量信息。
    •在多个文件之间来回调用,比如 A.java的main()方法中调用了B.java的fun()函数,而我想看看程序进入fun()后的状态,这是靠-g:source,如果没有这个参数,则不能查看B.java的源代码。

    -bootclasspath、-extdirs

    -bootclasspath和-extdirs 几乎不需要用的,因为他是用来改变 “引导类”和“扩展类”。
    •引导类(组成Java平台的类):Java\jdk1.7.0_25\jre\lib\rt.jar等,用-bootclasspath设置。
    •扩展类:Java\jdk1.7.0_25\jre\lib\ext目录中的文件,用-extdirs设置。
    •用户自定义类:用-classpath设置。

    我们用-verbose编译后出现的“类文件的搜索路径”,就是由上面三个路径组成,如下:

    [类文件的搜索路径: C:\Java\jdk1.7.0_25\jre\lib\resources.jar,C:\Java\jdk1.7.0_25
    
    \jre\lib\rt.jar,C:\Java\jdk1.7.0_25\jre\lib\sunrsasign.jar,C:\Java\jdk1.7.0_25\j
    
    re\lib\jsse.jar,C:\Java\jdk1.7.0_25\jre\lib\jce.jar,C:\Java\jdk1.7.0_25\jre\lib\
    
    charsets.jar,C:\Java\jdk1.7.0_25\jre\lib\jfr.jar,C:\Java\jdk1.7.0_25\jre\classes
    
    ,C:\Java\jdk1.7.0_25\jre\lib\ext\access-bridge-32.jar,C:\Java\jdk1.7.0_25\jre\li
    
    b\ext\dnsns.jar,C:\Java\jdk1.7.0_25\jre\lib\ext\jaccess.jar,C:\Java\jdk1.7.0_25\
    
    jre\lib\ext\localedata.jar,C:\Java\jdk1.7.0_25\jre\lib\ext\sunec.jar,C:\Java\jdk
    
    1.7.0_25\jre\lib\ext\sunjce_provider.jar,C:\Java\jdk1.7.0_25\jre\lib\ext\sunmsca
    
    pi.jar,C:\Java\jdk1.7.0_25\jre\lib\ext\sunpkcs11.jar,C:\Java\jdk1.7.0_25\jre\lib
    \ext\zipfs.jar,..\bin]             
    

    如果利用 -bootclasspath 重新定义: javac -bootclasspath src Xxx.java,则会出现下面错误:

    致命错误: 在类路径或引导类路径中找不到程序包 java.lang

    -sourcepath和-classpath(-cp)

    •-classpath(-cp)指定你依赖的类的class文件的查找位置。在Linux中,用“:”分隔classpath,而在windows中,用“;”分隔。
    •-sourcepath指定你依赖的类的java文件的查找位置。

    举个例子,

    public class A
    {
        public static void main(String[] args) {
            B b = new B();
            b.print();
        }
    }
    



    ​ public class B
    ​ {
    ​ public void print()
    ​ {
    ​ System.out.println(“old”);
    ​ }
    ​ }

    目录结构如下:

    sourcepath //此处为当前目录

    |-src
        |-com
          |- B.java
        |- A.java
      |-bin
        |- B.class               //是 B.java
    

    编译后的类文件

    如果要编译 A.java,则必须要让编译器找到类B的位置,你可以指定B.class的位置,也可以是B.java的位置,也可以同时都存在。

    javac -classpath bin src/A.java                            //查找到B.class
    
    javac -sourcepath src/com src/A.java                   //查找到B.java
    
    javac -sourcepath src/com -classpath bin src/A.java    //同时查找到B.class和B.java
    

    如果同时找到了B.class和B.java,则:
    •如果B.class和B.java内容一致,则遵循B.class。
    •如果B.class和B.java内容不一致,则遵循B.java,并编译B.java。

    以上规则可以通过 -verbose选项看出。

    -d

    •d就是 destination,用于指定.class文件的生成目录,在eclipse中,源文件都在src中,编译的class文件都是在bin目录中。

    这里我用来实现一下这个功能,假设项目名称为project,此目录为当前目录,且在src/com目录中有一个Main.java文件。‘


    ​ package com;
    ​ public class Main
    ​ {
    ​ public static void main(String[] args) {
    ​ System.out.println(“Hello”);
    ​ }
    ​ }



    ​ javac -d bin src/com/Main.java

    上面的语句将Main.class生成在bin/com目录下。

    -implicit:{none,class}

    •如果有文件为A.java(其中有类A),且在类A中使用了类B,类B在B.java中,则编译A.java时,默认会自动编译B.java,且生成B.class。
    •implicit:none:不自动生成隐式引用的类文件。
    •implicit:class(默认):自动生成隐式引用的类文件。

    public class A
    {
        public static void main(String[] args) {
            B b = new B();
        }
    }
    
    public class B
    {
    }
    
    如果使用:
    


    ​ javac -implicit:none A.java

    则不会生成 B.class。

    -source和-target

    •-source:使用指定版本的JDK编译,比如:-source 1.4表示用JDK1.4的标准编译,如果在源文件中使用了泛型,则用JDK1.4是不能编译通过的。
    •-target:指定生成的class文件要运行在哪个JVM版本,以后实际运行的JVM版本必须要高于这个指定的版本。

    javac -source 1.4 Xxx.java

    javac -target 1.4 Xxx.java

    -encoding

    默认会使用系统环境的编码,比如我们一般用的中文windows就是GBK编码,所以直接javac时会用GBK编码,而Java文件一般要使用utf-8,如果用GBK就会出现乱码。

    •指定源文件的编码格式,如果源文件是UTF-8编码的,而-encoding GBK,则源文件就变成了乱码(特别是有中文时)。

    javac -encoding UTF-8 Xxx.java

    -verbose

    输出详细的编译信息,包括:classpath、加载的类文件信息。

    比如,我写了一个最简单的HelloWorld程序,在命令行中输入:

    D:\Java>javac -verbose -encoding UTF-8 HelloWorld01.java

    输出:

    [语法分析开始时间 RegularFileObject[HelloWorld01.java]]
    [语法分析已完成, 用时 21 毫秒]
    [源文件的搜索路径: .,D:\大三下\编译原理\cup\java-cup-11a.jar,E:\java\jflex\lib\J           //-sourcepath
    Flex.jar]
    [类文件的搜索路径: C:\Java\jdk1.7.0_25\jre\lib\resources.jar,C:\Java\jdk1.7.0_25      //-classpath、-bootclasspath、-extdirs
    省略............................................
    [正在加载ZipFileIndexFileObject[C:\Java\jdk1.7.0_25\lib\ct.sym(META-INF/sym/rt.j
    ar/java/lang/Object.class)]]
    [正在加载ZipFileIndexFileObject[C:\Java\jdk1.7.0_25\lib\ct.sym(META-INF/sym/rt.j
    ar/java/lang/String.class)]]
    [正在检查Demo]
    省略............................................
    [已写入RegularFileObject[Demo.class]]
    [共 447 毫秒]
    

    编写一个程序时,比如写了一句:System.out.println(“hello”),实际上还需要加载:Object、PrintStream、String等类文件,而上面就显示了加载的全部类文件。

    其他命令

    -J <标记>
    •传递一些信息给 Java Launcher.

    javac -J-Xms48m   Xxx.java          //set the startup memory to 48M.
    

    -@<文件名>

    如果同时需要编译数量较多的源文件(比如1000个),一个一个编译是不现实的(当然你可以直接 javac *.java ),比较好的方法是:将你想要编译的源文件名都写在一个文件中(比如sourcefiles.txt),其中每行写一个文件名,如下所示:

    HelloWorld01.java
    HelloWorld02.java
    HelloWorld03.java

    则使用下面的命令:

    javac @sourcefiles.txt

    编译这三个源文件。

    使用javac构建项目

    这部分参考:
    https://blog.csdn.net/mingover/article/details/57083176

    一个简单的javac编译

    新建两个文件夹,src和 build
    src/com/yp/test/HelloWorld.java
    build/

    ├─build
    └─src
        └─com
            └─yp
                └─test
                        HelloWorld.java
    

    java文件非常简单

    package com.yp.test;
    public class HelloWorld {
    
        public static void main(String[] args) {
            System.out.println("helloWorld");
        }
    }
    

    编译:
    javac src/com/yp/test/HelloWorld.java -d build

    -d 表示编译到 build文件夹下

    查看build文件夹
    ├─build
    │  └─com
    │      └─yp
    │          └─test
    │                  HelloWorld.class
    │
    └─src
        └─com
            └─yp
                └─test
                        HelloWorld.java
    

    运行文件

    E:\codeplace\n_learn\java\javacmd> java com/yp/test/HelloWorld.class
    错误: 找不到或无法加载主类 build.com.yp.test.HelloWorld.class

    运行时要指定main
    E:\codeplace\n_learn\java\javacmd\build> java com.yp.test.HelloWorld
    helloWorld

    如果引用到多个其他的类,应该怎么做呢 ?

    编译

    E:\codeplace\n_learn\java\javacmd>javac src/com/yp/test/HelloWorld.java -sourcepath src -d build -g
    1
    -sourcepath 表示 从指定的源文件目录中找到需要的.java文件并进行编译。
    也可以用-cp指定编译好的class的路径
    运行,注意:运行在build目录下

    E:\codeplace\n_learn\java\javacmd\build>java com.yp.test.HelloWorld

    怎么打成jar包?

    生成:
    E:\codeplace\n_learn\java\javacmd\build>jar cvf h.jar *
    运行:
    E:\codeplace\n_learn\java\javacmd\build>java h.jar
    错误: 找不到或无法加载主类 h.jar

    这个错误是没有指定main类,所以类似这样来指定:
    E:\codeplace\n_learn\java\javacmd\build>java -cp h.jar com.yp.test.HelloWorld

    生成可以运行的jar包

    需要指定jar包的应用程序入口点,用-e选项:

    E:\codeplace\n_learn\java\javacmd\build> jar cvfe h.jar com.yp.test.HelloWorld *
    已添加清单
    正在添加: com/(输入 = 0) (输出 = 0)(存储了 0%)
    正在添加: com/yp/(输入 = 0) (输出 = 0)(存储了 0%)
    正在添加: com/yp/test/(输入 = 0) (输出 = 0)(存储了 0%)
    正在添加: com/yp/test/entity/(输入 = 0) (输出 = 0)(存储了 0%)
    正在添加: com/yp/test/entity/Cat.class(输入 = 545) (输出 = 319)(压缩了 41%)
    正在添加: com/yp/test/HelloWorld.class(输入 = 844) (输出 = 487)(压缩了 42%)
    

    直接运行

    java -jar h.jar
    
    额外发现 
    指定了Main类后,jar包里面的 META-INF/MANIFEST.MF 是这样的, 比原来多了一行Main-Class….
    Manifest-Version: 1.0
    Created-By: 1.8.0 (Oracle Corporation)
    Main-Class: com.yp.test.HelloWorld
    

    如果类里有引用jar包呢?

    先下一个jar包 这里直接下 log4j

    * main函数改成
    
    import com.yp.test.entity.Cat;
    import org.apache.log4j.Logger;
    
    public class HelloWorld {
    
        static Logger log = Logger.getLogger(HelloWorld.class);
    
        public static void main(String[] args) {
            Cat c = new Cat("keyboard");
            log.info("这是log4j");
            System.out.println("hello," + c.getName());
        }
    
    }
    

    现的文件是这样的

    ├─build
    ├─lib
    │      log4j-1.2.17.jar
    │
    └─src
        └─com
            └─yp
                └─test
                    │  HelloWorld.java
                    │
                    └─entity
                            Cat.java
    
    
    这个时候 javac命令要接上 -cp ./lib/*.jar
    E:\codeplace\n_learn\java\javacmd>javac -encoding "utf8" src/com/yp/test/HelloWorld.java -sourcepath src -d build -g -cp ./lib/*.jar
    
    
    运行要加上-cp, -cp 选项貌似会把工作目录给换了, 所以要加上 ;../build
    E:\codeplace\n_learn\java\javacmd\build>java -cp ../lib/log4j-1.2.17.jar;../build com.yp.test.HelloWorld
    
    

    结果:

    log4j:WARN No appenders could be found for logger(com.yp.test.HelloWorld).
    log4j:WARN Please initialize the log4j system properly.
    log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
    hello,keyboard
    
    

    由于没有 log4j的配置文件,所以提示上面的问题,往 build 里面加上 log4j.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
    <log4j:configuration xmlns:log4j='http://jakarta.apache.org/log4j/'>
        <appender name="stdout" class="org.apache.log4j.ConsoleAppender">
            <layout class="org.apache.log4j.PatternLayout">
                <param name="ConversionPattern" value="%d{ABSOLUTE} %-5p [%c{1}] %m%n" />
            </layout>
        </appender>
    
        <root>
            <level value="info" />
            <appender-ref ref="stdout" />
        </root>
    </log4j:configuration>
    
    

    再运行

    E:\codeplace\n_learn\java\javacmd>java -cp lib/log4j-1.2.17.jar;build com.yp.tes t.HelloWorld
    15:19:57,359 INFO  [HelloWorld] 这是log4j
    hello,keyboard
    
    

    说明:
    这个log4j配置文件,习惯的做法是放在src目录下, 在编译过程中 copy到build中的,但根据ant的做法,不是用javac的,而是用来处理,我猜测javac是不能copy的,如果想在命令行直接 使用,应该是用cp命令主动去执行 copy操作

    ok 一个简单的java 工程就运行完了
    但是 貌似有些繁琐, 需要手动键入 java文件 以及相应的jar包 很是麻烦,
    so 可以用 shell 来脚本来简化相关操作
    shell 文件整理如下:

    #!/bin/bash  
    echo "build start"  
      
    JAR_PATH=libs  
    BIN_PATH=bin  
    SRC_PATH=src  
      
    # java文件列表目录  
    SRC_FILE_LIST_PATH=src/sources.list  
      
    #生所有的java文件列表 放入列表文件中 
    rm -f $SRC_PATH/sources  
    find $SRC_PATH/ -name *.java > $SRC_FILE_LIST_PATH  
      
    #删除旧的编译文件 生成bin目录  
    rm -rf $BIN_PATH/  
    mkdir $BIN_PATH/  
      
    #生成依赖jar包 列表  
    for file in  ${JAR_PATH}/*.jar;  
    do  
    jarfile=${jarfile}:${file}  
    done  
    echo "jarfile = "$jarfile  
      
    #编译 通过-cp指定所有的引用jar包,将src下的所有java文件进行编译
    javac -d $BIN_PATH/ -cp $jarfile @$SRC_FILE_LIST_PATH  
      
    #运行 通过-cp指定所有的引用jar包,指定入口函数运行
    java -cp $BIN_PATH$jarfile com.zuiapps.danmaku.server.Main  
    
    

    有一点需要注意的是, javac -d $BIN_PATH/ -cp j a r f i l e @ jarfile @ jarfile@SRC_FILE_LIST_PATH
    在要编译的文件很多时候,一个个敲命令会显得很长,也不方便修改,

    可以把要编译的源文件列在文件中,在文件名前加@,这样就可以对多个文件进行编译,

    以上就是吧java文件放到 $SRC_FILE_LIST_PATH 中去了

    编译 :
         1. 需要编译所有的java文件
         2. 依赖的java 包都需要加入到 classpath 中去
         3. 最后设置 编译后的 class 文件存放目录  即 -d bin/
         4. java文件过多是可以使用  @$SRC_FILE_LIST_PATH 把他们放到一个文件中去
    运行:
       1.需要吧 编译时设置的bin目录和 所有jar包加入到 classpath 中去
    
    

    javap 的使用

    javap是jdk自带的一个工具,可以对代码反编译,也可以查看java编译器生成的字节码。

    情况下,很少有人使用javap对class文件进行反编译,因为有很多成熟的反编译工具可以使用,比如jad。但是,javap还可以查看java编译器为我们生成的字节码。通过它,可以对照源代码和字节码,从而了解很多编译器内部的工作。

    javap命令分解一个class文件,它根据options来决定到底输出什么。如果没有使用options,那么javap将会输出包,类里的protected和public域以及类里的所有方法。javap将会把它们输出在标准输出上。来看这个例子,先编译(javac)下面这个类。

    import java.awt.*;
    import java.applet.*;
     
    public class DocFooter extends Applet {
            String date;
            String email;
     
            public void init() {
                    resize(500,100);
                    date = getParameter("LAST_UPDATED");
                    email = getParameter("EMAIL");
            }
    }
    
    

    在命令行上键入javap DocFooter后,输出结果如下

    Compiled from “DocFooter.java”

    public class DocFooter extends java.applet.Applet {
      java.lang.String date;
      java.lang.String email;
      public DocFooter();
      public void init();
    }
    
    

    如果加入了-c,即javap -c DocFooter,那么输出结果如下

    Compiled from “DocFooter.java”

    public class DocFooter extends java.applet.Applet {
      java.lang.String date;
     
      java.lang.String email;
     
      public DocFooter();
        Code:
           0: aload_0       
           1: invokespecial #1                  // Method java/applet/Applet."<init>":()V
           4: return       
     
      public void init();
        Code:
           0: aload_0       
           1: sipush        500
           4: bipush        100
           6: invokevirtual #2                  // Method resize:(II)V
           9: aload_0       
          10: aload_0       
          11: ldc           #3                  // String LAST_UPDATED
          13: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
          16: putfield      #5                  // Field date:Ljava/lang/String;
          19: aload_0       
          20: aload_0       
          21: ldc           #6                  // String EMAIL
          23: invokevirtual #4                  // Method getParameter:(Ljava/lang/String;)Ljava/lang/String;
          26: putfield      #7                  // Field email:Ljava/lang/String;
          29: return       
    
    }
    
    

    上面输出的内容就是字节码。

    用法摘要

    -help 帮助
    -l 输出行和变量的表
    -public 只输出public方法和域
    -protected 只输出public和protected类和成员
    -package 只输出包,public和protected类和成员,这是默认的
    -p -private 输出所有类和成员
    -s 输出内部类型签名
    -c 输出分解后的代码,例如,类中每一个方法内,包含java字节码的指令,
    -verbose 输出栈大小,方法参数的个数
    -constants 输出静态final常量
    总结

    javap可以用于反编译和查看编译器编译后的字节码。平时一般用javap -c比较多,该命令用于列出每个方法所执行的JVM指令,并显示每个方法的字节码的实际作用。可以通过字节码和源代码的对比,深入分析java的编译原理,了解和解决各种Java原理级别的问题。

    参考文章

    https://blog.csdn.net/Anbernet/article/details/81449390
    https://www.cnblogs.com/luobiao320/p/7975442.html
    https://www.jianshu.com/p/f7330dbdc051
    https://www.jianshu.com/p/6a8997560b05
    https://blog.csdn.net/w372426096/article/details/81664431
    https://blog.csdn.net/qincidong/article/details/82492140

    微信公众号

    微信公众号

    个人公众号:程序员黄小斜

    微信公众号【程序员黄小斜】新生代青年聚集地,程序员成长充电站。作者黄小斜,职业是阿里程序员,身份是斜杠青年,希望和更多的程序员交朋友,一起进步和成长!专注于分享技术、面试、职场等成长干货,这一次,我们一起出发。

    关注公众号后回复“2019”领取我这两年整理的学习资料,涵盖自学编程、求职面试、算法刷题、Java技术学习、计算机基础和考研等8000G资料合集。

    技术公众号:Java技术江湖

    微信公众号【Java技术江湖】一位阿里 Java 工程师的技术小站,专注于 Java 相关技术:SSM、SpringBoot、MySQL、分布式、中间件、集群、Linux、网络、多线程,偶尔讲点Docker、ELK,同时也分享技术干货和学习经验,致力于Java全栈开发!

    关注公众号后回复“PDF”即可领取200+页的《Java工程师面试指南》强烈推荐,几乎涵盖所有Java工程师必知必会的知识点。

    展开全文
  • 硬核,这 3 款 IDE 插件让你的代码牢不可破

    千次阅读 多人点赞 2021-01-25 12:33:45
    03、SonarLint SonarLint 可让我们编写代码的时候就对错误和漏洞进行修复,像拼写检查器一样,可以即时突出地显示出编码的一些问题,并提供清晰的补救指导,方便我们提交代码之前就解决它们。 SonarLint 支持...
  • VScode 编译器配置IDE环境(C/C++/Go)

    千次阅读 2021-09-11 09:35:16
    VScode 编译器配置IDE环境(C/C++/Go)摘要VS Code 下载安装下载安装简单使用WindowsLinuxIDE 环境配置C/C++C/C++ 编译器安装及配置简单使用 VS Code 终端进行编译和运行方式使用code runner插件:Go总结 摘要 对于 ...
  • Eclipse插件Spring IDE在Eclipse的使用

    千次阅读 2016-01-27 15:32:28
    本文介绍如何利用Eclipse插件Spring IDE在Eclipse的使用。  Eclipse是目前非常流行的开发平台,开放扩展的架构让很多程序员找到了自己个性化的工作环境。  问题提出:  采用Spring框架进行系统开发时,...
  • 如何VS Code运行C或C++程序

    万次阅读 2021-08-26 17:05:26
    由于最近的项目有个功能需要C++语言完成,本来想用Visual Studio IDE来做,但考虑到软件太重,所以就用VS Code来做,可是VS Code默认是不能编译C/C++代码的,现将VS Code运行C或C++程序的方法做如下记录...
  • 如何阅读他人的项目代码程序

    千次阅读 多人点赞 2018-09-30 21:26:01
    相信很多人和我一样,面对着别人密密麻麻的代码,宁愿自己从零开始编写自己的代码,也不...然而,阅读他人的项目源码是每一个写程序的人(我只是个项目需要的时候偶尔写程序的,不敢自称程序员)必须经历的事情。...
  • STM32CubeIDE使用

    万次阅读 2019-09-20 10:09:26
    参考 STM32CubeIDE属于一站式...STM32CubeIDE使用笔记(03):使用ST-LINK调试程序 安装 STM32终于出了这样一款工具,之前也出过开源的eclipse开发工具,但这次帮你打包了一站式的,更方便了,点击此处下载, ...
  • pycharm打开命令行或Terminal的方法

    千次阅读 2020-12-10 04:57:07
    pycharm打开命令行或Terminal的方法见图---pycharm左下角点击,就会发现以上这篇pycharm打开命令行或Terminal的方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。时间: 2019-01...
  • Selenium-IDE脚本录制,selenium-side-runner自动化测试教程

    万次阅读 多人点赞 2018-10-31 16:24:27
    文章以下内容都是 Mac 机器上按照 Selenium-IDE官方文档编写,适用于当前最新版本。其实官方文档写的很好,图文并茂,可以试着研读官方的。 这篇文章讲的是 Selenium-IDE,不是 Selenium。 为什么这么说?...
  • STM32 CubeIDE ADC及AD8232模块心电采集实验

    千次阅读 热门讨论 2021-12-17 11:13:35
    图 2 光敏电阻传感器原理图 光敏二极管依照光强改变阻值Rgm,VAD = Rgm/(Rgm+10k)*3.3V,单片机这个AD口就是把接收到的VAD电压转换为程序中读取的值。 心电模块(AD8232) 表 1 Pins of AD8232 GND 接地 3.3V 给...
  • 有时候人又不电脑旁,所以希望找到一个能手机上运行Python程序的软件,随时随地抓取数据。度娘和谷哥了很久,找到三种类型的转件。一、手机上写手机专用的Python程序:Qpython二、用电脑写可以手机上运行的...
  •  由此可见,没有真正对应的集成环境,编译过程存在的警告和错误,还是需要开发者自己定位,以及部分源文件如果存在错误提示但编译成功的bug,是不可避免的!  但,这种做法的确大大提高开发效率,一键...
  • ROS集成开发环境IDE----RoboWare开源

    千次阅读 2018-06-20 10:24:42
    http://cn.roboware.me/#/homegithub: https://github.com/TonyRobotics/RoboWare-Studio目前主要有三款软件产品:Designer+Studio+Viewer,如下...----RoboWare Studio - Open SourceRoboWare Studio is an IDE ...
  • liteIDE搭建Go Golang 开发环境图文详解

    千次阅读 2018-06-12 17:15:13
    LiteIDE是一款专为Go语言开发而设计的跨平台轻量级集成开发环境(IDE),基于Qt开发,支持Windows、Linux和Mac OS X平台。LiteIDE是最早的面向Go语言的IDE之一,这里就为大家介绍一下结合LiteIDE搭建Go开发环境,需要...
  • STM32F103C8T6Arduino IDE里编程

    万次阅读 多人点赞 2018-11-23 17:46:08
    时代进步,极客们手上的单片机也从古老的51、PIC变成了AVR、STM32,也出现了各种便捷的开发工具,例如盛极一时的Arduino;不过Atmega328所属的AVR单片机,终究还是老点了,算起来差不多是20年前的主流了,现在流行...
  • 牛逼!Java 从入门到精通,超全汇总版

    万次阅读 多人点赞 2021-05-06 19:40:33
    讲解过程,不仅搭配了丰富的图片,而且理论结合实例,用 Java 语言编写代码实现了设计模式的程序,让程序真正地运行起来,并提供了运用模式解决具体问题的练习题和答案。除此以外,本书必要时还对 Java 语言的...
  • IDE中开发的项目打包后生成 zip 格式的包,解析器通过读取 zip 包实时解析运行,有点类似中间语言的概念,但我这里生成的 zip 包中主要以 xml 文件为主,通过 xml 文件对项目的 UI,业务,数据结构 进行描述。
  • OpenMV IDE安装使用教程

    万次阅读 2019-05-11 18:57:27
    以STM32F427CPU为核心,集成了OV7725摄像头芯片,小巧的硬件模块上,用C语言高效地实现了核心机器视觉算法,提供Python编程接口。使用者们(包括发明家、爱好者以及智能设备开发商)可以用Python语言使用OpenMV...
  • 我做的东西原本是利用ARDUINO MEGA2560及各种模块搭建起来的,程序自然也是用ARDUINO IDE写的。但这种东拼西凑的产品自然不够好,更主要的是,之前ARDUINO板的电源烧掉了,我看了下原理图,当电脑USB电源和12V电源都...
  • Jetbrains IDE 使用教程

    万次阅读 多人点赞 2018-10-26 12:02:21
    Jetbrains系列IDE算是我认为做的最好的集成开发工具了,用惯了以后感觉其他IDE都有各种各样的问题。但是Jetbrains系列IDE由于是全英文的,导致很多人很难上手。因此这篇文章就来介绍一下Jetbrains系列的常用设置和...
  • JavaFX程序中嵌入Swing内容

    千次阅读 2018-10-18 13:01:04
    转载自 JavaFX程序中嵌入Swing内容 本教程描述如何JavaFX应用程序中嵌入Swing组件。本文将讨论线程限制并提供一个可运行的应用程序来说明JavaFX应用程序中嵌入带HTML内容的Swing按钮,以及Swing与JavaFX按钮...
  • 自己动手打造属于自己的C语言IDE **建议:**建议先观看功能演示,然后根据功能演示想想思路,然后看博文的思路,最后再看博文代码,最后再看完整代码,这样效果会更好。 **功能介绍:**一款基于QT的简易c语言编辑...
  • ② 对生成的流程图可以分块与源程序对应显示,支持序号操作和鼠标双击;③ 可以限定最高分析层数,有利于更好的把握程序的总体框架。④ 代码格式化(NEW);⑤ 动态提示当前框内内容(NEW) 发展前瞻① 支持各种语言,...
  • 前端UI界面自动化测试-selenium-IDE

    千次阅读 2020-10-18 11:52:54
    文章以下内容都是 Mac 机器上按照Selenium-IDE官方文档编写,适用于当前最新版本。其实官方文档写的很好,图文并茂,可以试着研读官方的。 这篇文章讲的是 Selenium-IDE,不是 Selenium。 为什么这么说?请看下...
  • 使用过官网arduinoIDE开发程序的朋友应该都知道arduinoIDE界面简洁,功能比较单一,并不像其他IDE那样提供代码补全和跨文件跳转到定义变量/函数的功能。现在可以使用VScode来开发arduino程序,支持Tab键代码补全,也...
  • 13 万字 C 语言从入门到精通保姆级教程2021 年版

    万次阅读 多人点赞 2021-06-07 12:25:01
    "拍照"等等 手机中的每一个功能就相当于C语言程序中的一个程序段(函数) 众多功能中总有一个会被先执行,不可能多个功能一起执行 想使用手机必须先执行手机的开机功能 所以C语言程序也一样,由众多功能、众多程序段组成...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,387
精华内容 13,754
关键字:

在ide中打开对应源程序