-->

• Install Java For Mac
• Java Update For Mac
• Mac Java Download

After an application has been coded and tested, it is necessary toprepare a package for distribution. The first task in preparingthis package is to build the application for release, which mainlyentails setting some application attributes.

Use the following steps to build the app for release:

• Specify the Application Icon– Each Xamarin.Android application should have an applicationicon specified. Although not technically necessary, some markets,such as Google Play, require it.

• Version the Application – This stepinvolves initializing or updating the versioning information. Thisis important for future application updates and to ensure that theusers are aware of which version of the application they haveinstalled.

• Shrink the APK – The size of the final APKcan be substantially reduced by using the Xamarin.Android linker onthe managed code and ProGuard on the Java bytecode.

• Protect the Application – Prevent usersor attackers from debugging, tampering, or reverse engineering theapplication by disabling debugging, obfuscating the managed code,adding anti-debug and anti-tamper, and using native compilation.

• Set Packaging Properties –Packaging properties control the creation of the Androidapplication package (APK). This step optimizes the APK, protectsits assets, and modularizes the packaging as needed. Additionally,you can provide your users with an Android App Bundle that's optimizedfor their devices.

• Compile – This step compiles the code andassets to verify that it builds in Release mode.

• Archive for Publishing – This step builds theapp and places it in an archive for signing and publishing.

Each of these steps is described below in more detail.

Specify the Application Icon

It is strongly recommended that each Xamarin.Android applicationspecify an application icon. Some application marketplaces will notallow an Android application to be published without one. The Iconproperty of the Application attribute is used to specify theapplication icon for a Xamarin.Android project.

Native packaging was first introduced as a part of the JavaFX 2.2 SDK enabling you to package an application as a native bundle and then installing and running the application without any external dependencies on a system JRE or JavaFX SDK. Next it became usable for Java SE projects as well. Because a.app is not a file. It only looks like a 'file' to the user, but it is really a 'Bundle'. A specially structured directory, marked so that user sees it, and drag it as if it was just a file. 'Bundles' are very 'Mac' thing, and don't travel well via e-mail, or downloads, and especially not on Windows-formatted disks.

In Visual Studio 2017 and later, specify the application icon throughthe Android Manifest section of project Properties, as shown inthe following screenshot:

In Visual Studio for Mac, it is also possible to specify theapplication icon through the Android Application section ofProject Options, as shown in the following screenshot:

In these examples, @drawable/icon refers to an icon file that islocated at Resources/drawable/icon.png (note that the .pngextension is not included in the resource name). This attributecan also be declared in the file PropertiesAssemblyInfo.cs, asshown in this sample snippet:

Normally, using Android.App is declared at the top ofAssemblyInfo.cs (the namespace of the Application attribute isAndroid.App); however, you may need to add this using statement ifit is not already present.

Version the Application

Versioning is important for Android application maintenance anddistribution. Without some sort of versioning in place, it is difficultto determine if or how an application should be updated. To assist withversioning, Android recognizes two different types of information:

• Version Number – An integer value (used internally byAndroid and the application) that represents the version of theapplication. Most applications start out with this value set to 1,and then it is incremented with each build. This value has norelationship or affinity with the version name attribute(see below). Applications and publishing services should notdisplay this value to users. This value is stored in theAndroidManifest.xml file as android:versionCode.

• Version Name – A string that is used only forcommunicating information to the user about the version of theapplication (as installed on a specific device). The version nameis intended to be displayed to users or in Google Play. This stringis not used internally by Android. The version name can be anystring value that would help a user identify the build that isinstalled on their device. This value is stored in theAndroidManifest.xml file as android:versionName.

In Visual Studio, these values can be set in the Android Manifestsection of project Properties, as shown in the followingscreenshot:

These values can be set via the Build > Android Application sectionof Project Options as shown in the following screenshot:

Shrink the APK

Xamarin.Android APKs can be made smaller through a combination of theXamarin.Android linker, which removes unnecessary managed code, andthe ProGuard tool from the Android SDK, which removes unused Javabytecode. The build process first uses the Xamarin.Android linker tooptimize the app at the managed code (C#) level, and then it later usesProGuard (if enabled) to optimize the APK at the Java bytecode level.

Configure the Linker

Release mode turns off the shared runtime and turns on linking so thatthe application only ships the pieces of Xamarin.Android required atruntime. The linker in Xamarin.Android uses static analysis todetermine which assemblies, types, and type members are used orreferenced by a Xamarin.Android application. The linker then discardsall the unused assemblies, types, and members that are not used (orreferenced). This can result in a significant reduction in the packagesize. For example, consider theHelloWorld sample, whichexperiences an 83% reduction in the final size of its APK:

• Configuration: None – Xamarin.Android 4.2.5 Size = 17.4 MB.

• Configuration: SDK Assemblies Only – Xamarin.Android 4.2.5 Size = 3.0 MB.

Set linker options through the Android Options section of the projectProperties:

The Linking pull-down menu provides the following options forcontrolling the linker:

• None – This turns off the linker; no linking will beperformed.

• SDK Assemblies Only – This will only link the assembliesthat are required by Xamarin.Android.Other assemblies will not be linked.

• Sdk and User Assemblies – This will link all assembliesthat are required by the application, and not just the onesrequired by Xamarin.Android.

Set linker options through the Linker tab in the Android Buildsection of Project Options, as shown in the following screenshot:

The options for controlling the linker are as follows:

• Don't link – This turns off the linker; no linking willbe performed.

• Link SDK assemblies only – This will only link theassemblies that arerequired byXamarin.Android. Otherassemblies will not be linked.

• Link all assemblies – This will link all assemblies thatare required by the application, and not just the ones required byXamarin.Android.

Linking can produce some unintended side effects, so it is importantthat an application be re-tested in Release mode on a physical device.

ProGuard

ProGuard is an Android SDK tool that links and obfuscates Java code.ProGuard is normally used to create smaller applications by reducingthe footprint of large included libraries (such as Google PlayServices) in your APK. ProGuard removes unused Java bytecode, whichmakes the resulting app smaller. For example, using ProGuard on smallXamarin.Android apps usually achieves about a 24% reduction in size– using ProGuard on larger apps with multiple librarydependencies typically achieves an even greater size reduction.

ProGuard is not an alternative to the Xamarin.Android linker. TheXamarin.Android linker links managed code, while ProGuard links Javabytecode. The build process first uses the Xamarin.Android linker tooptimize the managed (C#) code in the app, and then it later usesProGuard (if enabled) to optimize the APK at the Java bytecode level.

When Enable ProGuard is checked, Xamarin.Android runs the ProGuardtool on the resulting APK. A ProGuard configuration file is generatedand used by ProGuard at build time. Xamarin.Android also supportscustom ProguardConfiguration build actions. You can add a customProGuard configuration file to your project, right-click it, and selectit as a build action as shown in this example:

ProGuard is disabled by default. The Enable ProGuard option isavailable only when the project is set to Release mode. AllProGuard build actions are ignored unless Enable ProGuard ischecked. The Xamarin.Android ProGuard configuration does not obfuscatethe APK, and it is not possible to enable obfuscation, even with customconfiguration files. If you wish to use obfuscation, please seeApplication Protection with Dotfuscator.

For more detailed information about using the ProGuard tool, seeProGuard.

Protect the Application

Disable Debugging

During development of an Android application, debugging is performedwith the use of the Java Debug Wire Protocol (JDWP). This is atechnology that allows tools such as adb to communicate with a JVM forthe purposes of debugging. JDWP is turned on by default for Debugbuilds of a Xamarin.Android application. While JDWP is important duringdevelopment, it can pose a security issue for released applications.

Important

Simple project management software mac os x 10 13 download. Always disable the debug state in a released application as itis possible (via JDWP) to gain full access to the Java process andexecute arbitrary code in the context of the application if this debugstate is not disabled.

The Android Manifest contains the android:debuggable attribute, whichcontrols whether or not the application may be debugged. It isconsidered a good practice to set the android:debuggable attribute tofalse. The simplest way to do this is by adding a conditional compilestatement in AssemblyInfo.cs:

Note that Debug builds automatically set some permissions to make debugeasier (such as Internet andReadExternalStorage). Release builds, however, use onlythe permissions that you explicitly configure. If you find thatswitching to the Release build causes your app to lose a permissionthat was available in the Debug build, verify that you have explicitlyenabled this permission in the Required permissionslist as described inPermissions.

Application Protection with Dotfuscator

Even with debugging disabled, it is still possible forattackers to re-package an application, adding or removingconfiguration options or permissions. This allows them toreverse-engineer, debug, or tamper with the application.Dotfuscator CommunityEdition (CE) canbe used to obfuscate managed code and inject runtime security statedetection code into a Xamarin.Android app at build time to detectand respond if the app is running on a rooted device.

Dotfuscator CE is included with Visual Studio 2017.To use Dotfuscator, click Tools > PreEmptive Protection - Dotfuscator.

To configure Dotfuscator CE, please seeUsing Dotfuscator Community Edition with Xamarin.Once it is configured, Dotfuscator CE will automatically protect eachbuild that is created.

Even with debugging disabled, it is still possible forattackers to re-package an application, adding or removingconfiguration options or permissions. This allows them toreverse-engineer, debug, or tamper with the application.Although it does not support Visual Studio for Mac, you can useDotfuscator Community Edition (CE)with Visual Studio to obfuscate managed code and inject runtime security statedetection code into a Xamarin.Android app at build time to detectand respond if the app is running on a rooted device.

To configure Dotfuscator CE, please seeUsing Dotfuscator Community Edition with Xamarin.Once it is configured, Dotfuscator CE will automatically protect eachbuild that is created.

Bundle Assemblies into Native Code

When this option is enabled, assemblies are bundled into a nativeshared library. This allows assemblies to be compressed, permittingsmaller .apk files. Assembly compression also confers a minimalform of obfuscation; such obfuscation should not be relied upon.

This option requires an Enterprise license and is only available whenUse Fast Deployment is disabled. Bundle assemblies into nativecode is disabled by default.

Note that the Bundle into Native Code option does not mean thatthe assemblies are compiled into native code. It is not possible to useAOT Compilation to compile assemblies into native code.

AOT Compilation

The AOT Compilation option (on thePackaging Properties page) enablesAhead-of-Time (AOT) compilation of assemblies. When this option isenabled, Just In Time (JIT) startup overhead is minimized byprecompiling assemblies before runtime. The resulting native code isincluded in the APK along with the uncompiled assemblies. This resultsin shorter application startup time, but at the expense of slightlylarger APK sizes.

The AOT Compilation option requires an Enterprise license orhigher. AOT compilation is available only when the project isconfigured for Release mode, and it is disabled by default. For moreinformation about AOT Compilation, seeAOT.

LLVM Optimizing Compiler

The LLVM Optimizing Compiler will create smaller and faster compiledcode and convert AOT-compiled assemblies into native code, but at theexpense of slower build times. The LLVM compiler is disabled bydefault. To use the LLVM compiler, the AOT Compilation option mustfirst be enabled (on thePackaging Properties page).

Note

The LLVM Optimizing Compiler option requires an Enterprise license.

Set Packaging Properties

Packaging properties can be set in the Android Options section ofproject Properties, as shown in the following screenshot:

Packaging properties can be set in the Project Options, as shown inthe following screenshot:

Many of these properties, such as Use Shared Runtime, and UseFast Deployment are intended for Debug mode. However, when theapplication is configured for Release mode, there are other settingsthat determine how the app isoptimized for size and execution speed,how it is protected from tampering, and how it can bepackaged to support different architectures and size restrictions.

Install Java For Mac

Specify Supported Architectures

When preparing a Xamarin.Android app for release, it is necessary tospecify the CPU architectures that are supported. A single APK cancontain machine code to support multiple, different architectures. SeeCPU Architecturesfor details about supporting multiple CPU architectures.

Generate One Package (.APK) per Selected ABI

When this option is enabled, one APK will be created for each of thesupported ABI's (selected on the Advanced tab, as described inCPU Architectures)rather than a single, large APK for all supported ABI's. This option isavailable only when the project is configured for Release mode, and itis disabled by default.

Multi-Dex

When the Enable Multi-Dex option is enabled, Android SDK tools areused to bypass the 65K method limit of the .dex file format. The65K method limitation is based on the number of Java methods that anapp references (including those in any libraries that the app dependson) – it is not based on the number of methods that are writtenin the source code. If an application only defines a few methods butuses many (or large libraries), it is possible that the 65K limit willbe exceeded.

It is possible that an app is not using every method in every librarythat is referenced; therefore, it is possible that a tool such asProGuard (see above) can remove the unused methods from code. The bestpractice is to enable Enable Multi-Dex only if absolutelynecessary, i.e.the app still references more than 65K Java methods evenafter using ProGuard.

For more information about Multi-Dex, seeConfigure Apps with Over 64K Methods.

Android App Bundles

Java Update For Mac

App bundles differ from APKs as they cannot be deployed directly to a device. Rather, it's a format that is intended to be uploaded with all of your compiled code and resources. After you upload your signed app bundle, Google Play will have everything it needs to build and sign your application's APKs and serve them to your users using Dynamic Delivery.

To enable support for Android App Bundles, you'll need to opt-in to the bundle value of the Android Package Format property within your Android project options. Before you do this, ensure you change your project to a Release configuration as app bundles are intended for release packages only.

You can now generate an app bundle by following the Archive Flow. This will generate an app bundle for your application.

For more information about Android App Bundles, see Android App Bundles.

Compile

After all of the above steps are completed, the app is ready forcompilation. Select Build > Rebuild Solution to verify that itbuilds successfully in Release mode. Note that this step does not yetproduce an APK.

Signing the App Package discusses packaging and signing in more detail.

After all of the above steps are completed, compile the application(select Build > Build All) to verify that it builds successfullyin Release mode. Note that this step does not yet produce an APK.

Archive for Publishing

To begin the publishing process, right-click the project in SolutionExplorer and select the Archive.. context menu item:

Archive.. launches the Archive Manager and begins the processof archiving the App bundle as shown in this screenshot:

Another way to create an archive is to right-click the Solution in theSolution Explorer and select Archive All.., which builds thesolution and archives all Xamarin projects that can generate anarchive:

Both Archive and Archive All automatically launch the ArchiveManager. To launch the Archive Manager directly, click theTools > Archive Manager.. menu item:

The solution's archives at any time by right clicking the Solutionnode and selecting View Archives:

The Archive Manager

The Archive Manager is comprised of a Solution List pane, anArchives List, and a Details Panel:

The Solution List displays all solutions having at least onearchived project. The Solution List includes the followingsections:

• Current Solution – Displays the current solution. Note that this area may be empty if the current solution does not have an existing archive.
• All Archives – Displays all solutions that have an archive.
• Search text box (at the top) – Filters the solutions listed in the All Archives list according to the search string entered in the text box.

The Archives List displays the list of all archives for theselected solution. The Archives List includes the followingsections:

• Selected solution name – Displays the name of the solution selected in the Solution List. All information shown in the Archives List refers to this selected solution.
• Platforms Filter – This field makes it possible to filter archives by platform type (such as iOS or Android).
• Archive Items – List of archives for the selected solution. Each item in this list includes the project name, creation date, and platform. It can also show additional information such as the progress when an item is being archived or published.

The Details Panel displays additional information about eacharchive. It also allows the user to start the Distribution workflow oropen the folder where the distribution has been created. The BuildComments section makes it possible to include build comments in thearchive.

Distribution

When an archived version of the application is ready to publish, selectthe archive in the Archive Manager and click the Distribute..button:

The Distribution Channel dialog shows information about the app, anindication of distribution workflow progress, and a choice ofdistribution channels. On the first run, two choices are presented:

It is possible to choose one of the following distribution channels:

• Ad-Hoc – Saves a signed APK to disk that can be sideloaded to Android devices. Continue to Signing the App Package to learn how to create an Android signing identity, create a new signing certificate for Android applications, and publish an ad hoc version of the app to disk. This is a good way to create an APK for testing.

• Google Play – Publishes a signed APK to Google Play. Continue to Publishing to Google Play to learn how to sign and publish an APK in the Google Play store.

To begin the publishing process, select Build > Archive for Publishing:

Archive for Publishing builds the project and bundles it into anarchive file. The Archive All menu choice archives all archivableprojects in the solution. Both options automatically open the ArchiveManager when the build and bundling operations complete:

In this example, the Archive Manager lists only one archivedapplication, MyApp. Notice that the comment field allows a shortcomment to be saved with the archive. To publish an archived version ofa Xamarin.Android application, select the app in the ArchiveManager and click Sign and Distribute.. as shown above. Theresulting Sign and Distribute dialog presents two choices:

From here, it is possible to select the distribution channel:

• Ad-Hoc – Saves a signed APK to disk so it can besideloaded to Android devices. Continue toSigning the AppPackageto learn how to create an Android signing identity, create a newsigning certificate for Android applications, and publish an“ad hoc” version of the app to disk. This is a good wayto create an APK for testing.

• Google Play – Publishes a signed APK to Google Play.Continue toPublishing to Google Playto learn how to sign and publish an APK in the Google Play store.

Related Links

Before You Begin

Purpose

In this tutorial, you create and build a Java Platform, Standard Edition (Java SE) application using Maven. You install, configure, build, and create an executable Java Archive (JAR) file with Maven.

Time to Complete

Approximately 90 minutes

Background

Maven is a build management tool that is central to project build tasks such as compilation, packaging, and artifact management. Maven uses a strict XML-based rule set to promote consistency while maintaining flexibility. Because most Java-centric continuous integration systems integrate well with Maven, it's a good choice for an underlying build system.
The primary goal of Maven is to provide:

• A project model that is reusable, maintainable, and easier to comprehend

• Plug-ins or tools that interact with the declarative model
  

The Maven project structure and contents are declared in the pom.xml file. The Project Object Model (POM) is the fundamental unit of the entire Maven system.
Maven contains three types of repositories for storing JARs, plug-ins, and other project-related artifacts:

• Local Repository: The location created on your machine when you run your first instance of a Maven command in your machine

• Central Repository: The Maven community-owned repository that contains commonly used libraries

• Remote Repository: A developer-owned custom repository that contains project-related libraries and JARs

What Do You Need?

• Download and install the latest Java SE Development Kit. For this tutorial, the available version is Java SE 8.
• Download the Apache Maven. For this tutorial, the available version is 3.2.2.

Setting Up the Maven Environment

In this section, you extract the downloaded archive and install the latest Maven version to a directory of your choice. You verify the Java installation, set the Maven environment, and verify the Maven installation.

1. Verify the Java installation:
   

   java -version

   The output displays the Java version that you installed.

2. Extract the downloaded Maven x.x.x archive to a local directory.

   The archive names are:

   • Windows OS: apache-maven-3.2.2-bin.zip

   • Linux OS: apache-maven-3.2.2-bin.tar.gz

   • Mac OS: apache-maven-3.2.2-bin.tar.gz

   Note: This OBE shows you how to install and create a Java SE application using Maven in a Windows operating system.

3. Click Start, right-click Computer, and select Properties.

4. On the Control Panel home page, click Advanced system settings.

5. In the System Properties dialog box, click the Advanced tab, and then click Environment Variables.
   

   The Environment Variables dialog box is displayed.

6. Click New, add M2, M2_HOME, and MAVEN_OPTS to the environment variables, and click OK.

7. Under System variables, click New, enter the following values in the Edit System variable dialog box, and click OK:

   • Variable name: Path

   • Variable value: %M2% (Enter the value after bin in the system path)

8. Verify the Maven installation:

   mvn -version

   The output displays the installed Maven version, the Java version, the Java home, the Default locale, and the OS name.

Creating a Java SE Project from a Maven Template

1. Open the command prompt, navigate to the directory where you installed Maven, and create Maven_app, a Maven-based Java application folder:

   mvn archetype:generate -DgroupId=com.example.bank
-DartifactId=OracleBanking
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

   An archetype is an original pattern/model for creating similar projects. In Maven, an archetype is a template of a project that is combined with user input to produce a working Maven project. The following table describes what the template does:
   

   Archetype ArtifactIds	Description
   mvn archetype:generate	Creates a project
   -DgroupId=com.example.bank	Creates the com.example.bank dependency package structure
   maven-archetype-quickstart	Creates a Java project
   -DinteractiveMode=false	Sets interactive mode to false

   
   The Java project named OracleBanking is created. The following table presents the project details:
   

   Project Structure	Description
   OracleBanking	Contains src folder and pom.xml
   src/main/java	Contains Java code files under the package structure (com.example/bank)
   src/test	Contains test code files under the package structure (com.example/bank)
   pom.xml	Contains information about the project and details of various configurations used by Maven to build the project

2. Open the OracleBanking project and verify the Java source file:

App.java

3. Verify Java test file:
   AppTest.java

   By default, Maven adds the App.java source file and the AppTest.java test file to the default directory structure.

4. Open the pom.xml file and review the code.

   Each project has a single pom.xml file, and each pom.xml file has a project element and three mandatory fields: groupId, artifactId, and version. Notice that Maven has already added JUnit as the test framework. The following table describes what each node does:

   Node	Description
   project	Top-level element in all Maven pom.xml files
   modelVersion	Object model version that this POM is using
   groupId	Project groupId (for example, com.example.bank)
   artifactId	Project ID (for example, OracleBanking)
   packaging	Project files converted into a JAR file
   version	Project version used in the artifact's repository to separate each version (for example, 1.0-SNAPSHOT)
   name	Project display name
   url	Location of the project site

Creating and Modifying Java Source Files

In this section, you calculate simple interest by creating the SimpleInterest.java source file and modifying the App.java source file.

1. Navigate to the directory where you created your Maven project, and then open the specified location:

   **Maven_appOracleBankingsrcmainjavacomexamplebank

2. Create a Java source file named SimpleInterest.java.

3. Edit the SimpleInterest.java file with the following code:

   The calculateSimpleInterest method calculates the interest rate on the loan amount, the tenure of the loan, and the rate of interest per annum.

4. Press Ctrl+S and close the file.

5. Modify App.java with the following code:

6. Review the code. It should look like the following:

7. Press Ctrl+S and close the file.

Creating a Manifest with Maven

In this section, you learn how to use maven-jar-plugin to create a manifest file and package it by adding it to the JAR file.

The manifest file performs the following tasks:

• Defines the entry point of the project and creates an executable JAR file.
  
• Adds the class path of the project dependencies.
  

1. Edit the pom.xml file:
   

   You defined maven-jar-plugin in pom.xml, and configured it within the configuration tag.

2. Review the code. It should look like the following:

   In the Maven project, you specify the main class details by updating the pom.xml file. The com.example.bank.App class in the project is the main class that will be executed when you execute the JAR file.

3. Press Ctrl+S and close the file.

You successfully updated your pom.xml file.

Testing, Building, and Running the Application Using Maven

Testing the Application

In this section, you learn how to test your application with AppTest.java using the Maven command-line interface (CLI).

1. Import the package into AppTest.java:

import junit.framework.Assert;


2. Edit the AppTest method:

3. Review the code. It should look like the following:

   You modified the simple interest value, and then verified the value by using assert statements in the JUnit test case.

4. Press Ctrl+S and then run the test cases in AppTest.java inside the OracleBanking project.

   mvn test
   

5. Review the output.

   The test case failed and the assert failed message is displayed.

6. Modify AppTest.java:
   

   You modified the simple interest value, and then verified the value by using assert statements in the JUnit test case.

7. Press Ctrl+S and then run the test cases in AppTest.java:

   mvn test

   The test case executed successfully, and a build success message is displayed.

Building the Application

In this section, you learn how to clean and build your application using the Maven CLI.

1. Clean and build your Maven project, and review the output:

   mvn clean package
   

   You successfully built the OracleBanking Java SE application using Maven.

2. Navigate to the directory where you created OracleBanking and notice that a target folder was created.

3. Open the target folder, and review the folder structure.

   Folder name	Description
   classes	Contains .class files of Java source files
   test-classes	Contains .class files of Java test files
   maven-archiver	Contains the pom.properties file
   surefire-reports	Contains the report of the application when mvn command is executed.
   java	Empty Java file
   OracleBanking-1.0-SNAPSHOT.jar	Contains all the project related details in a single zip file. This is the executable JAR file used to run the application

Packaging and Running the Application

In this section, you learn how to package and run the Java SE project using the Maven CLI.

1. Navigate to the directory where you installed Maven, and open the settings.xml file.

   The <localRepository> tag specifies the local repository location on your machine. By default, the local repository is created in the %USER_HOME% directory. You can specify another location by updating it in the settings.xml file. If you need to set proxy details for the application, then update it in the settings.xml file.

2. Clean and package the files, plug-ins, and libraries before running the application:

   mvn clean package

3. Use the Maven Local repository to run your Java SE Maven application:

   mvn exec:java -Dexec.mainClass='com.example.bank.App' -s '*****location of settings.xml file.********'
   

4. Review the output.

   You successfully executed the Java SE application named OracleBanking using Maven. The simple interest is calculated and displayed in the Maven CLI.

5. Execute the JAR file with following commands:

   cd target
java -jar OracleBanking-1.0-SNAPSHOT.jar
   

6. Review the output.

   You successfully executed the OracleBanking Java SE application by using Maven. The simple interest is calculated and displayed in the Maven CLI.

Want to Learn More?

• Installing and Configuring Maven for Build Automation and Dependency Management in Oracle Fusion Middleware Developing Applications Using Continuous Integration

Credits

To navigate this Oracle by Example tutorial, note the following:

Mac Java Download

Topic List:

Click a topic to navigate to that section.

Expand All Topics:

Click the button to show or hide the details for the sections. By default, all topics are collapsed.

Hide All Images:

Click the button to show or hide the screenshots. By default, all images are displayed.

Print:

Click the button to print the content. The content that is currently displayed or hidden is printed.

To navigate to a particular section in this tutorial, select the topic from the list.