My repo and notes for the Java Projects book.
See the antHelloWorld
project in my source code.
- In Eclipse, the project can be imported with
Import > Projects from Folder or Archive
. - Then
Run As > Ant Build
will build the project as specified by thebuild.xml
file. java -jar build/jar/HelloWorld.jar
is not enough to execute the project :no main manifest attribute, in build/jar/HelloWorld.jar
We have to modify the default manifest to add an entry point, like Eclipse would propose if we used the
Export > Jar file
functionality.For Ant, this will do :
<target name="jar" depends="dirs,compile"> <jar destfile="${jarDir}/HelloWorld.jar" basedir="${classesDir}"> <manifest> <attribute name="Main-Class" value="HelloWorld"/> </manifest> </jar> </target>
- Let’s enhance the
build.xml
file from the book: let’s create arun
and aclean
target, and make directories only in association to a task.
mvn archetype:generate
to generate a project; good alternative to
Eclipse-assisted project creation.
With Java 11, add this code to use Maven:
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.11</source>
<target>1.11</target>
<release>11</release>
</configuration>
</plugin>
</plugins>
</build>
In Java 11, with local variable type inference, you can type (for a local variable, as the name suggests):
var n = names.length;
Initializer blocks don’t need to be static. An initializer block is executed when the instance is created. More accurately, the code is compiled into the constructor and is executed with the constructor.
Terminology:
- Nested classes are divided into two categories: static and non-static. A non-static nested class is also called an inner class. These are class declarations.
- Local classes are inside a method, a constructor or an init block. These are class declarations.
- Anonymous classes are a short form of a nested/inner/local class. These are expressions.
- To be continued…
A class implementing the Comparable
interface might violate the
SRP. This is why Collections.sort
also provides a sort
method that
takes two arguments: the list to be sorted and an object implementing
the Comparator
interface.
Here I will recreate the structure of the genericsort
multimodule
Maven project from the book (p112-115).
Let’s start with a SO answer.
This will generate the parent project:
mvn archetype:generate -B \
-DarchetypeGroupId=org.codehaus.mojo.archetypes \
-DarchetypeArtifactId=pom-root \
-DarchetypeVersion=RELEASE \
-DgroupId=net.lecigne.javaprojects \
-DartifactId=SortChapter03
We want these modules in the parent POM:
<modules>
<module>SortSupportClasses</module>
<module>SortInterface</module>
<module>bubble</module>
<module>quick</module>
<module>Main</module>
</modules>
The modules will be added using this command:
declare -a mavenModules=("SortSupportClasses" "SortInterface" "bubble" "quick" "Main")
for mavenModule in ${mavenModules}; do
mvn archetype:generate -B \
-DarchetypeGroupId=org.apache.maven.archetypes \
-DarchetypeArtifactId=maven-archetype-quickstart \
-DarchetypeVersion=RELEASE \
-DgroupId=net.lecigne.javaprojects \
-DartifactId=${mavenModule}
done
Note that Maven updates the parent POM (in my case, it also adds useless newlines).
Importing the parent project with Eclipse will also import the subprojects and create a working set.
Unit tests are not used to find bugs.
A test case is readable if you look at it and in 15 seconds you can tell what it does.
In SimpleSortChapter03
I implement the code from Chapter03 without
the confusing and useless multimodule structure.
- [ ] [ch02] Study comments about Java syntax
- [ ] [ch03] Study comments about algorithms