blocks|key|1086992|text|您可以在清单文件中告诉它在启动时运行哪一个。之所以没有main()，是因为main可能是用于“常规”java应用程序的约定，但它不适用于浏览器applet之类的东西。系统创建activity对象并调用其中的方法，这些方法可能被称为main，也可能不被调用。在这种情况下，情况并非如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1086993|onCreate不同于main，也不同于构造函数，因为它可以在单个活动上调用两次，例如，如果进程被终止，用户导航回该活动。请参阅http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle|offset|length|1086994|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle^0|0|1S|2A|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

You tell it which one to run on startup in the manifest file. There isn't a main() because there doesn't have to be, main may be a convention used for "regular" java apps, but it isn't for things like browser applets. The system creates the activity object and calls methods within it, which may or may not be called main. In this case, it's not.

onCreate is different from a main, and from a constructor, in that it can be called twice on a single activity, such as if the process is killed and the user navigates back to the activity. See <a href="http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle" rel="noreferrer">http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle</a>

blocks|key|872287|text|有一种main，只是碰巧不在你的控制范围之内。毕竟，main函数在任何语言中都没有什么特别之处。它只是你的代码开始执行的入口点。Android操作系统期望应用程序具有特定的结构，并根据您遵循的约定调用您的代码。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|872288|entityMap^0|Q|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

There is a main of sorts, it just happens to be out of your hands. After all, there's nothing special about a <code>main</code> function in any language. It's just the entry point where your code starts executing. The Android operating system expects applications to have a certain structure and it calls your code based on the conventions you follow.

blocks|key|872340|text|我发现这个特别有用...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|872341|http://developer.android.com/guide/topics/fundamentals.html#appcomp|offset|length|872342|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1V|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

I found this particularly useful...

<a href="http://developer.android.com/guide/topics/fundamentals.html#appcomp" rel="nofollow">http://developer.android.com/guide/topics/fundamentals.html#appcomp</a>

blocks|key|1087139|text|Android+UI框架封装了一些Java通用细节，你可以研究一下android+UI框架的源代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1087140|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The Android UI frame encapsulate some Java common details, you can study the source code of the android UI framework

blocks|key|872454|text|Applet也没有main()方法。这只取决于你的代码是如何打包的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|872455|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Applets don't have main() methods either. It just depends on how your code is packaged.

blocks|key|872503|text|我认为Jonathon的答案是正确的。他说，操作系统需要一个特定的结构。这个结构有一个名字叫“状态机”。在这种情况下，Android称之为“活动生命周期”。Rob给出了一个指向文档的链接，其中包含该状态机的重要图表，尽管文本有点枯燥。快速搜索还找到了下面的链接，它很清楚地解释了这一点：http://www.android-app-market.com/android-activity-lifecycle.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|872504|entityMap|0|LINK|mutability|MUTABLE|url|http://www.android-app-market.com/android-activity-lifecycle.html^0|3Z|1T|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I think that Jonathon's answer is going in the right direction. He says the OS expects a certain structure. There's a name for that structure which is a "state machine". In this case Android calls it the "activity lifecycle". Rob gives a link to the documentation which contains an important diagram of that state machine though the text is a bit dry. A quick search also found me the following link that explains it fairly clearly: <a href="http://www.android-app-market.com/android-activity-lifecycle.html" rel="nofollow">http://www.android-app-market.com/android-activity-lifecycle.html</a>

blocks|key|1087306|text|在Java语言中，有一个main，即使它没有被列为main()。单击图标后得到的页面，无论其名称是什么，都是main()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1087307|entityMap^0|P|6|1I|6|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

In Java, there is a main even if it isn't listed as <code>main()</code>. The page you get after the icon click, whatever its name, is the <code>main()</code>.

blocks|key|872606|text|每个应用程序都将拥有自己的虚拟机。要在应用程序的空间(VM)内运行它，必须有一个main方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|872607|活动并不是启动应用程序时要调用的实际类。有一个名为Application的类，它将是要启动的应用程序的根类。|872608|如果没有main方法，VM如何识别如何启动应用程序？|872609|框架有称为Process和VMRuntime的类，它们负责启动应用程序。这确实涉及到了main方法。|872610|为了更好地理解，请研究Android的Zygote服务。处理应用程序管理器服务、ActivityStack活动线程等。|872611|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Each application will be having it's own Virtual Machine. To run an app, within it's space (VM), must have a main method.

Activities are not the actual classes to be invoked for start of application. There is a class called Application, which will be the root class for an application to be launched.

If there is no main method, how can a VM recognize how to start an app?

Framework has classes called Process, VMRuntime which are responsible for starting an application. Which indeed deal with main method.

For better understanding, study the Zygote service of Android. deals with Applicationmanager Service, ActivityStack Activity Threadds etc.

blocks|key|872694|text|android程序员应该对此了如指掌，它简单地解释了一切，并将在未来创建活动时提供帮助。http://developer.android.com/reference/android/app/Activity.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|872695|entityMap|0|LINK|mutability|MUTABLE|url|http://developer.android.com/reference/android/app/Activity.html^0|18|1S|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

An android programmer should learn this like the back of their hands it simply explains everything and would help in the future when creating activities.
<a href="http://developer.android.com/reference/android/app/Activity.html" rel="nofollow">http://developer.android.com/reference/android/app/Activity.html</a>

blocks|key|1087551|text|实际上，这种类型的模式并不是Android独有的，而是每当你在中间有一些框架时就会发生。一些基本的例子是java+Applets和Servlets。已经提供的一些答案给出了正确的回答，但我将尝试详细说明一下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1087552|当您启动一个Java应用程序时，您将启动一个JVM，然后您需要将一些内容加载到其中:因此您需要一个静态方法(+main)，因为在JVM中还没有您可以引用的对象。|1087553|如果你在中间有某种框架，它就是启动JVM并开始用它自己的服务对象填充它的框架:写你的代码就意味着写你自己的对象(这将是给定“模板”的子类)。然后，框架可以注入(加载)您的对象。框架服务对象通过调用“模板”超类中定义的生命周期方法来管理注入对象的生命周期。|1087554|例如，当您向浏览器提供一个applet时，您并没有启动一个静态的main方法:您只提供了一个java.applet.Applet的子类，它实现了一些实例方法，这些方法作为回调来管理生命周期(init、paint、stop...)。浏览器将启动JVM，实例化启动applet所需的内容，加载applet并调用它。|1087555|类似地，使用servlet，您可以子类化javax.servlet.http.HttpServlet类并实现一些实例(非静态)方法(doGet、doPost...)。Web容器(例如Tomcat)将负责启动JVM，实例化启动servlet所需的内容，加载并调用servlet。|1087556|Android中的模式几乎相同:您要做的是创建android.app.Activity的子类。当你启动一个应用程序时，系统会在清单中查找应该启动哪个活动，然后“框架”加载它并调用它的实例方法(onCreate、onPause、onResume...)。|1087557|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Actually, this type of pattern is not peculiar of Android, but happens whenever you have some framework in the middle. Some basic examples are java Applets and Servlets. Some of the answers already provide give the correct response, but I will try to elaborate a bit.

When you launch a Java app, you start a JVM and then you need to load something into it: so you need a static method (the main) because there are no objects (yet) living in the JVM that you can refer to.

If you have some sort of framework in the middle, it is the framework that will start the JVM and will start populating it with its own service objects: writing your code then means writing your own objects (which will be subclasses of given "template"). Your objects can then be injected (loaded) by the framework. The framework service objects manage the lifecycle of the injected objects by calling the lifecycle methods defined in the "template" superclass.

So for instance when you provide an applet to a browser, you do not launch a static main method: you rather only provide a subclass of java.applet.Applet that implements some instance methods which act as callback to manage the lifecycle (init, paint, stop...). It is the browser that will launch the JVM, instantiate what's needed for the launching an applet, load your applet and call it.

Similarly, with servlets you subclass the javax.servlet.http.HttpServlet class and implement some instance (non static) methods (doGet, doPost...). The Web container (e.g. Tomcat) will be in charge to launch the JVM, instantiate what's needed for launching a servlet, load your servlet and call it.

The pattern in Android is pretty much the same: what do you do is to create a subclass of android.app.Activity. When you launch an app, the system looks in the manifest to find out which activity should be started, then the "framework" loads it and calls its instance methods (onCreate, onPause, onResume...).

blocks|key|1087645|text|在Java程序中，我们需要main()方法，因为在执行字节码时，JVM将在类中搜索main()方法并在那里开始执行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1087646|在安卓中，Dalvik虚拟机被设计为找到一个类，该类是Activity的子类，并被设置为从其onCreate()方法启动应用程序的执行，因此不需要使用main()方法。|1087647|Dalvik虚拟机调用方法的顺序是基于称为安卓生命周期的优先级顺序。有关安卓生命周期的更多信息，请查看以下链接：https://developer.android.com/guide/components/activities/activity-lifecycle.html|offset|length|1087648|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.android.com/guide/components/activities/activity-lifecycle.html^0|0|0|1K|29|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

In Java programs we need a main() method, because while executing the byte code the JVM will search for the main() method in the class and start executing there.

In Android, the Dalvik Virtual Machine is designed to find a class which is a subclass of Activity and which is set to start the execution of the application from its onCreate() method, so there is no need of a main() method.

The order in which Dalvik Virtual Machine calls methods is based on order of priorities called android life cycle for more information on android life cycle check the link below
Android Life Cycle: <a href="https://developer.android.com/guide/components/activities/activity-lifecycle.html" rel="nofollow noreferrer">https://developer.android.com/guide/components/activities/activity-lifecycle.html</a>

I've seen this in a few tutorials now... but how in the world can Android source code not have a main method and still run.

For example (from <a href="http://developer.android.com/guide/tutorials/hello-world.html">http://developer.android.com/guide/tutorials/hello-world.html</a>):

<pre><code>public class HelloAndroid extends Activity {
 /** Called when the activity is first created. */
 @Override
 public void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.main);
 }
}
</code></pre>

That runs but there is no main!!!

I've also thought that using things like onCreate (or formLoad, etc.) was bad becuase a constructor should do that work and such built-in methods can be smelly sometimes. But onCreate is an entry point? Even without a main?

What if there is more than one activity... is there a hierarchy to these built in event handlers? OnCreate trumps everything else? Otherwise, how would the app know what to run or where to enter the program?

Thanks!

How can Android source code not have a main method and still run?

虚拟机

Android

容器

Java

我已经在一些教程中看到了这一点。但是Android的源代码怎么可能没有main方法还能运行呢？例如(来自)：public class HelloAndroid extends Activity {    /** Called when the activity is first created. */    @Over...

问Android源代码怎么会没有main方法，还能运行呢？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Android源代码怎么会没有main方法，还能运行呢？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Android源代码怎么会没有main方法，还能运行呢？
EN