jasta

Get a Beautiful Rounded Taskbar in Windows 11

Jakob — Sat, 20 Apr 2024 09:07:11 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to get a beautiful rounded taskbar in Windows 11, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and set up your rounded Taskbar on Windows 11.

How Will Your Rounded Taskbar finally look

With the upgrade from Windows 10 to Windows 11, you already get more customization features for your taskbar. But you might still not be happy with the aesthetics of it. With this tutorial, you can change your taskbar from this:

to that:

Download the Rounded Taskbar Program

To get a rounded taskbar in Windows 11, you first need to download RoundedTB. Here you can find the latest released version. After opening the release page via the link provided, you have to scroll down till you see the RoundedTB_canaryXXXXXXXX_2.7z file. Just click on it and the download will start automatically. After the download is finished, you need to unzip the file to a location of your choice. Keep in mind that you download the ‘whole’ program and not just a setup. Every file from the zip file must stay in the same location as the exe file as long as you use RoundedTB.

Set up Your Rounded Taskbar in Windows 11

After downloading and unzipping the file, you have to execute the exe file, which is located inside the extracted zip file first. You will then see a welcome window on your screen where you can just press OK to come to the final taskbar customization window.

After clicking OK, you will already see the configuration window, where you can set various settings. The first thing you need to decide is, whether you enable dynamic mode. When disabled the whole taskbar is configured as one element. If the dynamic mode is enabled you can customize the notification area separately. So if you want a clean taskbar with just your programs in the middle you can set the following settings to the taskbar:

For the notification area you should set:

Now only your actual taskbar with your programs will be visible. The notification area will appear as soon as you hover over it with your mouse. Also, don’t forget to disable Widgets for your taskbar, otherwise only one-half of the taskbar will be gone. This can be done via settings -> personalization -> taskbar -> taskbar items.

If you still find your taskbar kind of weird looking, try to open the taskbar settings and change the alignment to left and then back to right. Now everything should look normal.

The last thing you need to do is automatically start the program when booting your computer. For that, you just have to right-click on the program icon in the notification area and check ‘Run at startup’.

Important: If you update from a previous version, you need to delete or rename the old settings file of RoundedTB, since this is not compatible with this new version. It is located in %USERPROFILE%\APPDATA\Local\. The name of the file is rtb.json.

Now you have a rounded taskbar in Windows 11, which should look like the taskbar in the screenshot at the beginning of the tutorial. Should you encounter any questions or challenges, don’t hesitate to reach out. Your feedback, queries, and insights are always valued, and I’m here to assist you. Until next time!

Writing Unit Tests in Java with JUnit 5: A Comprehensive Guide

Jakob — Sun, 14 Apr 2024 14:51:39 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to write unit tests in Java with JUnit 5, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and start writing unit tests in Java with JUnit 5.

Why You Should Implement Unit Tests for Your Java Application

In modern software development, unit testing stands as an indispensable pillar of ensuring code quality and reliability. At its core, unit testing involves the systematic validation of individual units or components of a software application, typically at the function or method level. The primary goal? To verify that each unit behaves exactly as intended under various conditions, effectively contributing to the overall functionality of the system.

Writing unit tests in Java with JUnit 5 offers a structured approach to this crucial aspect of software engineering. By meticulously crafting tests to assess the behavior of isolated code units, developers gain invaluable insights into the correctness and robustness of their implementations. But why is unit testing so vital, especially in the context of Java development with JUnit 5?

First and foremost, unit testing serves as an early warning system, flagging potential bugs and errors in the codebase long before they manifest into critical issues in a production environment. By identifying and rectifying these issues early in the development lifecycle, developers can significantly reduce the time and effort spent on debugging and troubleshooting later stages.

Moreover, unit testing fosters a culture of confidence and trust in the codebase. Each passing test provides a tangible affirmation that a particular piece of functionality works as expected, instilling a sense of assurance among developers and stakeholders alike. This confidence translates into smoother integration processes, as developers can confidently integrate their changes knowing that existing functionality remains intact.

Furthermore, writing unit tests in Java with JUnit 5 facilitates seamless code maintenance and refactoring. As software projects evolve over time, developers often need to make changes to existing code to accommodate new requirements or optimize performance. Unit tests act as a safety net, ensuring that modifications do not inadvertently introduce regressions or break existing functionality.

In summary, unit testing with JUnit 5 is not merely a best practice; it’s a fundamental aspect of modern software development. By validating individual units of code in isolation, developers can uncover defects early, build confidence in their codebase, and facilitate seamless maintenance and evolution of software projects.

Most Important Annotations for JUnit 5 tests in Java

In JUnit 5, annotations play an important role in defining the behavior and structure of unit tests. Understanding and effectively utilizing these annotations is essential for writing clear, concise, and maintainable test code. Below, are some important annotations that are necessary for writing unit tests in Java with JUnit 5.

@Test

This annotation is used to mark a method as a test method. JUnit 5 will execute all methods annotated with @Test.

@BeforeEach

Methods annotated with @BeforeEach are executed before each test method in the class. They are typically used to set up common test fixtures or initialize resources.

@AfterEach

Methods annotated with @AfterEach are executed after each test method in the class. They are commonly used to clean up resources or reset the state after each test.

@BeforeAll

Methods annotated with @BeforeAll are executed once before all test methods in the class. They are used for setup operations that are performed once for the entire test class.

@AfterAll

Methods annotated with @AfterAll are executed once after all test methods in the class have been executed. They are typically used for cleanup operations that need to be performed once after all tests have finished.

@Disabled

Methods annotated with @Disabled are skipped during test execution. This annotation is useful for temporarily excluding tests that are not ready or relevant

@ExtendWith

Used to register extensions with JUnit 5 tests, @ExtendWith allows you to customize the behavior of test classes or methods by applying additional functionality provided by extensions.

Step-by-Step Guide to Writing Unit Tests in Java with JUnit 5

In this tutorial, we are writing unit tests in Java with JUnit 5 for our FileHelper from the reading and writing to files in Java tutorials. You can find the full code of the FileHelper class here on our GitHub repository.

To start, we must create a class that will later contain all the tests. This can be automatically done. For that, you need to open the class which should be tested and press CTRL+SHIFT+T on your keyboard. Now a small menu will appear where you can click on create new test. Then a configuration window is going to show on your screen. With that configurator, you can choose the JUnit version, the class name, a superclass, and the destination package and you can even auto-generate the setup and teardown methods and create test methods for the methods inside the class.

For this tutorial, we are just choosing the correct version and the class name. The rest will be left empty.

For our FileHelper we want to test both read and write methods. All of the methods have a Path as a method parameter so we first need to create a file within a directory that can be used for testing. To not have to worry about deleting the directory after all the tests, we are using the @TempDir annotation. This will generate a temporary directory when starting the tests. After all the tests run through, the directory will be deleted automatically. Without this annotation it would be necessary, to create the directory in the @BeforeAll method and delete it in the @AfterAll method.

In addition to the directory that will contain the file, we are also declaring a file name, the file for the tests itself and the file content in the test class.

  @TempDir
  private File tempDir;
  private final String fileName = "tempFile.txt";
  private File tempFile = new File(tempDir, fileName);;
  private final List testContent = List.of("Hello World!", "This is a test.");

After declaring every necessary variable in the class we are creating the @BeforeEach and @AfterEach method. In these methods, we are going to create/delete the file that will be used for the tests.

  @BeforeEach
  void setUp() throws IOException {
    tempFile.createNewFile();
  }

  @AfterEach
  void tearDown() {
    tempFile.delete();
  }

Now we are going to test our methods of the FileWriter class. Since the FileWriter class has read and write methods implemented with java.nio and java.io, we are going to test these in two different tests.

To create a unit test you need to write a method that does something to begin with. In this case, this would be FileHelper.writeToFile and FileHelper.readFromFile. To make this method a test you need to add a @Test annotation above the method declaration. Now the method is already a valid test which calls a method but doesn’t check if the method is actually working. Therefore we are adding an assertEquals call which will check if the file content written and then read by our FileHelper has the same amount of lines. Furthermore, we are iterating through the read results and checking if it is equal to the content we wanted to write with the FileHelper.

If all these assertions are correct, we know that the writing and reading of files is working correctly. The same checks are also done in the test method for the java.io FileWriter methods.

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    List fileContent = FileHelper.readFromFile(tempFile.getAbsolutePath());

    assertEquals(testContent.size(), fileContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), fileContent.get(i));
    }
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    List fileContent = FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath());

    assertEquals(testContent.size(), fileContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), fileContent.get(i));
    }
  }

To prevent code duplications, the checks can also be done in a separate method which is called by a test method. The code would then look like this:

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFile(tempFile.getAbsolutePath()));
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath()));
  }

  private void checkReadResult(List actualContent) {
    assertEquals(testContent.size(), actualContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), actualContent.get(i));
    }
  }

It’s also possible to assert Exceptions to test invalid parameters given to the FileHelper. Instead of assertEquals you can use assertThrows with the expected exception class, an executable code and you can also add an error message to all of your assertions. It is also possible to check the exception message because assertThrows returns the occurred exception.

  @Test
  void readFromFileError() {
    RuntimeException e = assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFile(tempDir.getAbsolutePath()),
        "Exception was not thrown!");

    assertEquals(e.getCause().getMessage(), "The file cannot be accessed!");
  }

  @Test
  void readFromFileBufferedReaderError() {
    assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFileBufferedReader(tempDir.getAbsolutePath()),
        "Exception was not thrown!");
  }

Your full test class should now be the same as the code below. You can also find the complete code here.

import static org.junit.jupiter.api.Assertions.*;

import java.io.File;
import java.io.IOException;
import java.util.List;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;

class FileHelperTest {

  @TempDir
  private File tempDir;
  private final String fileName = "tempFile.txt";
  private File tempFile = new File(tempDir, fileName);;
  private final List testContent = List.of("Hello World!", "This is a test.");

  @BeforeEach
  void setUp() throws IOException {
    tempFile.createNewFile();
  }

  @AfterEach
  void tearDown() {
    tempFile.delete();
  }

  @Test
  void testFileWriter() {
    FileHelper.writeToFile(tempFile.getAbsolutePath(), String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFile(tempFile.getAbsolutePath()));
  }

  @Test
  void testBufferedFileWriter() {
    FileHelper.writeToFileBufferedWriter(tempFile.getAbsolutePath(),
        String.join("\n", testContent));
    checkReadResult(FileHelper.readFromFileBufferedReader(tempFile.getAbsolutePath()));
  }

  private void checkReadResult(List actualContent) {
    assertEquals(testContent.size(), actualContent.size());

    for (int i = 0; i < testContent.size(); i++) {
      assertEquals(testContent.get(i), actualContent.get(i));
    }
  }

  @Test
  void readFromFileError() {
    RuntimeException e = assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFile(tempDir.getAbsolutePath()),
        "Exception was not thrown!");

    assertEquals(e.getCause().getMessage(), "The file cannot be accessed!");
  }

  @Test
  void readFromFileBufferedReaderError() {
    assertThrows(RuntimeException.class,
        () -> FileHelper.readFromFileBufferedReader(tempDir.getAbsolutePath()),
        "Exception was not thrown!");
  }
}

Now that your test class is ready, you can execute the whole test class with all the tests with the green arrow next to the class name inside the code or just run a single test method with the green arrow next to the method declaration.

When the tests are finished you will see the result of them in the run window at the bottom of your IDE as shown in the screenshot below.

If you don’t see each test method result but only the test class, you have to switch from running unit tests with Gradle to running them with IntelliJ IDEA. To do this you first have to open the settings of IntelliJ. This can be done with CTRL+ALT+S or via the top menu under ‘File’. After opening the settings window, you need to find ‘Build, Execution, Deployment’ on the left side, expand it, find Build Tools and click on Gradle. In the window after clicking on Gradle you can now set ‘Run tests using:. Choose IntelliJ IDEA from the drop-down menu and click OK.

If you now run your unit tests you will see every single test listed on the run window.

If a unit test fails you will also be able to see the difference in the result window, so you don’t have to debug into the test to see what values are getting compared or checked.

As we wrap up our journey through the process of writing unit tests in Java with JUnit 5, I hope you’ve found this guide insightful and helpful in enhancing your knowledge. Should you encounter any questions or challenges while implementing, don’t hesitate to reach out. Your feedback, queries, and insights are always valued, and I’m here to assist you on your coding adventures. Until next time, happy coding!

Implement Powerful Logging in Java with Log4j2

Jakob — Thu, 04 Apr 2024 15:57:50 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to implement logging in Java with Log4j2, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and start implementing logging in Java with Log4j2.

Why Proper Logging is Necessary for Every Application

Proper logging is indispensable for every application as it serves as a crucial lifeline for developers and operators alike. Logging provides a detailed record of system behavior, errors, and events, aiding in troubleshooting and debugging processes. It offers insights into the application’s health, performance, and usage patterns, enabling developers to identify and rectify issues promptly.

Moreover, comprehensive logs enhance security by facilitating the detection of suspicious activities or breaches. In essence, robust logging practices not only enhance the reliability and maintainability of an application but also contribute significantly to its overall security and performance.

Adding Log4j2 Dependencies to Your Project

Before implementing logging in Java with Log4j2 you first need to add certain dependencies to your Java project so that you can use Log4j2. If you are using Kotlin as your DSL you can copy the required dependencies from below. If you use any other language you can find the correct dependency implementation on the Maven repository. To follow this tutorial you need the slf4j-api dependency and the log4j-slf4j2-impl. The dependencies need to be added to your build.gradle if you use Gradle or to your pom.xml if you use Maven.

    implementation("org.slf4j:slf4j-api:2.0.12")
    implementation("org.apache.logging.log4j:log4j-slf4j2-impl:2.23.1")

Implement Logging in Java with Log4j2

The first thing you need to do to implement logging in Java with Log4j2 is, to create a configuration file. In that file, you need to define different settings like log levels, different log appenders and settings for these like a Rollover strategy. The file must be placed in your application’s resources folder and named ‘log4j2’. The file type is XML. After the creation, it should look like the red highlighted file below.

Inside the file, you can now define different configurations. For example, you can create a File logger or configure it, to log everything in the application console. But you can also configure multiple loggers. All the different configurations can be found on the website of Apache about log4j2.

In this tutorial, we are going to create a file logger. The file logger will be configured with a SizeBasedTriggeringPolicy which means that if the current log file of the app is bigger than the configured value, a new log file will be created and the ‘full’ one will be saved. We are also adding a DefaultRolloverStrategy. With that, it can be prevented that hundreds of ‘full’ log files are being created. You can have different conditions to delete old log files like a maximum amount, an age limitation and many more.

You can copy the full code of the file logger configuration from the jasta GitHub repository or from below. Carefully read the comments in the XML file to fully understand the meaning of each line inside the file, configure it to your requirements, and implement your custom logging in Java with Log4j2.




  
    
    /logs
  

  
    
    
      
        
        %d{yyyy-MM-dd HH:mm:ss.SSS} [%C{1}.%M] [%level] %logger{36} - %msg%n

After you have copied the code above or configured it to your requirements, you can start logging in Java with Log4j2. Therefore you have to call LoggerFactory.getLogger() with either a class or a String as a constructor parameter. The given Parameter will be the name of the logger. The returned Object will be a Logger Object from org.slf4j.Logger. You can now call different log methods like debug, error, info, warn, trace and many more. Depending on what log level is set in the configuration file some messages will not get logged. All available methods can be seen here.

An example declaration would look like this:

private static final Logger LOGGER = LoggerFactory.getLogger(TestDriver.class);

Later the Logger object can be used like this:

LOGGER.info("Application is starting...");

If you are logging much, your log output directory will look similar to the screenshot below. As you can see, a new log file is created after 10KB (in this case 11KB since it is such a small unit. With MB it would not be 11MB). Also, the old log files are created with the date and time as configured in the log4j2.xml file. Furthermore, the limit of 10 old log files is also considered. If a new log file were to be created, the oldest log file, in this case ‘App_2024-04-06_05-13-05.log’, would be deleted.

This was the process of implementing logging in Java with Log4j2. If you have any questions or trouble implementing your logging system feel free to leave a comment below.

Writing to Files in Java: Master File Operations with Ease

Jakob — Fri, 29 Mar 2024 17:29:15 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into writing to files in Java, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and start writing to files in Java.

The Importance of Writing to Files in Java

In the world of software development, the ability to write data to files in Java plays a vital role in managing and preserving valuable information. This aspect is often considered the counterpart to reading files, as it enables developers to not only access existing data but also store new or modified data for future use.

When we talk about writing files in Java, we’re essentially talking about the process of saving data to different types of files, be it plain text files, structured data files like CSV or XML, or even binary files. This capability is crucial for a wide range of applications. For instance, in a logging scenario, writing critical events to a log file ensures that important information is recorded for debugging or auditing purposes.

Moreover, writing to files in Java facilitates data persistence, ensuring that essential data isn’t lost between application sessions. This is particularly crucial for applications that require user preferences or settings to be saved, allowing users to seamlessly resume their activities without losing their custom configurations.

Beyond basic data storage, Java’s file writing capabilities extend to creating structured outputs in formats suitable for sharing and collaboration. For example, generating reports in PDF or Excel formats allows users to analyze and share data insights efficiently. This ability to produce structured outputs enhances the usability and versatility of Java-powered applications across various domains.

Mastering the art of writing to files in Java empowers developers to design robust and efficient software solutions that not only capture and retain crucial data but also unleash the full potential of their applications to deliver impactful insights and drive innovation.

Implement Different Ways to Write to Files

For reading files in Java there are two different approaches. One uses Java.io which is available since version 1.1 and the other uses a method of Java.nio which was introduced with version 1.7.

Java NIO Files

The more modern and easy solution for writing to files in Java is Java.nio.Files. With that, you can call the static method write from Files with a Path parameter, the content as a byte array and OpenOptions. Via the OpenOptions you can decide what should happen if the file already exists/not exists. There are many different options like Create, Create_New and Append. You can find all the options with a description here.

  public static void writeToFile(String path, String content) {
    try {
      Files.write(Path.of(path), content.getBytes(), StandardOpenOption.CREATE);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

BufferedWriter with FileWriter

The more traditional and sometimes necessary way with a Java version below 1.7 is with a BufferedWriter and a FileWriter. After initializing the BufferedWriter with the FileWriter the write method of the BufferedWriter has to be called with the content as a String. After the method call the BufferedWriter has to be closed via its close method.

  public static void writeToFileBufferedWriter(String path, String content) {
    File fileToWrite = new File(path);
    try {
      boolean fileExists = fileToWrite.exists();
      if (!fileExists) {
        fileExists = fileToWrite.createNewFile();
      }

      if (fileExists && fileToWrite.isFile() && fileToWrite.canWrite()) {
        BufferedWriter writer = new BufferedWriter(new FileWriter(fileToWrite));
        writer.write(content);
        writer.close();
      } else {
        throw new RuntimeException(new IOException("The file cannot be accessed!"));
      }
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

You can also find the whole code on the jasta GitHub repository. To also learn how to read files in Java you can click here. If you have any questions or feedback feel free to comment below.

Reading Files in Java: Unleash Data Insights Effortless

Jakob — Fri, 29 Mar 2024 17:29:08 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into reading files in Java, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and start reading files in Java.

The Importance of Reading Files in Java

In the realm of software development, the ability to efficiently read and process data from files is a fundamental skill, and Java equips developers with powerful tools to accomplish this task seamlessly.

Reading files in Java is not merely a technical necessity; it is a gateway to unlocking valuable insights and harnessing the potential of diverse data sources. Whether it’s parsing configuration files, analyzing log data, or extracting information from structured documents, Java’s file reading capabilities play a pivotal role in enabling developers to interact with data stored in various formats.

From plain text files to complex binary formats, Java offers versatile mechanisms for accessing and manipulating file contents. Moreover, Java’s support for popular data interchange formats such as JSON and XML further enhances its utility in modern software development.

JSON and XML, being widely adopted for their simplicity and flexibility in representing structured data, find extensive use in web services, configuration files, and data exchange between different systems. By adeptly reading and processing files in Java, developers can seamlessly integrate these data formats into their applications, thereby facilitating interoperability and enhancing the overall functionality and usability of their software solutions.

In essence, mastering the art of reading files in Java is not merely about manipulating bytes and characters; it’s about harnessing the potential of data to drive innovation, gain insights, and deliver impactful software solutions.

Implement Different Ways to Read Files

For reading files in Java there are two different approaches. One uses Java.io which is available since version 1.1 and the other uses a method of Java.nio which was introduced with version 1.7.

Java NIO Files

The more modern and easy solution for reading files in Java is Java.nio.Files. With that, you can call the static method readAllLines from Files with a Path parameter. A Path can be created via toPath on a File object or with Path.of(). Optionally you can add a Charset after the path as well. It returns a list of strings where one entry represents one line in the file.

  public static List readFromFile(String path) {
    File fileToRead = new File(path);

    if (fileToRead.exists() && fileToRead.isFile() && fileToRead.canRead()) {
      try {
        return Files.readAllLines(fileToRead.toPath());
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      throw new RuntimeException(new IOException("The file cannot be accessed!"));
    }
  }

BufferedReader with FileReader

The more traditional and sometimes necessary way with a Java version below 1.7 is with a BufferedReader and a FileReader. After initializing the BufferedReader with the FilleReader the readLine method of the BufferedReader has to be called to get the next line. When the file ends, the method will return null. After the end of the file is reached the BufferedReader has to be closed.

  public static List readFromFileBufferedReader(String path) {
    File fileToRead = new File(path);

    if (fileToRead.exists() && fileToRead.isFile() && fileToRead.canRead()) {
      try {
        BufferedReader reader = new BufferedReader(new FileReader(fileToRead));
        String temp;
        List content = new ArrayList<>();

        while ((temp = reader.readLine()) != null) {
          content.add(temp);
        }

        reader.close();

        return content;
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    } else {
      throw new RuntimeException(new IOException("The file cannot be accessed!"));
    }
  }

You can also find the whole code on the jasta GitHub repository. You can also click here to learn how to write to files in Java. If you have any questions or feedback feel free to comment below.

Mastering Java Objects: Comprehensive Guide to Constructors, Getters, and Setters

Jakob — Sun, 24 Mar 2024 17:16:15 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to create and use Java Objects, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and start coding with Java Objects.

What are Java Objects and Why Do They Exist?

As you might already know, there are some predefined objects in Java. Examples would be a String which stores some text or an Integer which can store a number. These are already pretty useful but what would you do, if you want to store multiple pieces of information for one thing? An example would be a car. All necessary information cannot be stored inside a String or an Integer. So the best approach is to create a new Object which cannot just store one particular information but many different things.

Regarding the car example some things that should be stored would be:

Brand
Model
Plate
Color
Seats
Steering wheel

Of course, there are many more things, but this is enough for the beginning. Some of the info can be easily stored in a string like the brand or the model whereas others require more details like the seats and steering wheel. This is because seats can come in various configurations for example with heating or without. That is also the case for the steering wheel. Therefore we would also need to create custom Java objects for the seats and the steering wheel.

Understanding the Purpose of Constructors in Java

Before actually creating your first Java Objects you have to know about constructors. A constructor is called at the very beginning of creating an object. It is called once and then never again. The purpose of it is to set some variables in the object or execute functions that are necessary at the beginning. Variables that are given with the constructor to the Java Object are often:

Values that must be set before any method call
Values that are already known upon the creation of the object
Values that are used for a method call inside the constructor

To get back to the car example a constructor would look like this:

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }

With that constructor, we are already setting the brand and the model inside the car object since this information is already known on creation. Other information is probably not known when starting with the creation of the car.

Good to know is, if there is no constructor defined in a class it is the same as an empty constructor. But there can also be multiple constructor definitions.

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }  
  
  public Car(String brand, String model, String color) {
    this.brand = brand;
    this.model = model;
    this.color = color;
  }

In the example above you have two constructors so you can create an object with these options depending on if you already know the color. In the code a new car object can now be created via ‘new Car(“Audi”, “A4”);’ or ‘new Car(“Audi”, “A4”, “Green”);’.

The difference between a constructor and a setter method is, that a constructor is once called when creating an object. A setter method can be but must not be called after initializing the object and can also be called multiple times with different values.

How to Create and Use Java Objects

Now let’s implement the car example with Java Objects. The complete code can be found and cloned from the jasta GitHub repository. To begin with we have to create our objects by creating new classes. If you don’t know how to create classes in IntelliJ IDEA click here. We need to create the following classes: Car, Seat, Steeringwheel and a Main class to test the Java Objects. After creating all classes your project structure looks like the screenshot below.

First of all, we are adding code to the seat class. We are adding three variables to the class: material, weight and heating. Since we will probably know all of these when creating the seat we are setting all of them inside the constructor. Also, these attributes will not change, therefore they have the final keyword in front of the declaration so they can not be modified later on. To get the values of the variables we are also adding get methods.

public class Seat {

  private final String material;
  private final int weight;
  private final boolean heating;

  public Seat(String material, int weight, boolean heating) {
    this.material = material;
    this.weight = weight;
    this.heating = heating;
  }

  public String getMaterial() {
    return material;
  }

  public int getWeight() {
    return weight;
  }

  public boolean isHeating() {
    return heating;
  }
}

The second class which will be implemented is the Steeringwheel class. For simplicity, we are just adding two variables: material and diameter. These will be known on creation and should not be changed later. Therefore the final keyword is added again and the values are assigned inside the constructor. In addition, of course, getter methods are added.

public class Steeringwheel {

  private final String material;
  private final int diameter;

  public Steeringwheel(String material, int diameter) {
    this.material = material;
    this.diameter = diameter;
  }

  public String getMaterial() {
    return material;
  }

  public int getDiameter() {
    return diameter;
  }
}

Now that all Java Objects used for the car object are created, we can implement the car class. As previously described a car will have multiple seats therefore a list of seats, a String brand, a String model, a Steeringwheel object, a String plate and a String with the car’s color. The list type, the brand and the model shouldn’t be modified after initialization therefore they are declared final. Since the list type is already declared at the variable declaration only the brand and the model need to be set in the constructor. Every other attribute can be set via the corresponding set method. Of course getter methods are added as well.

import java.util.ArrayList;
import java.util.List;

public class Car {

  private final List seats = new ArrayList<>();
  private final String brand;
  private final String model;
  private Steeringwheel steeringwheel;
  private String plate;
  private String color;

  public Car(String brand, String model) {
    this.brand = brand;
    this.model = model;
  }

  public List getSeats() {
    return seats;
  }

  public void addSeat(Seat seat) {
    seats.add(seat);
  }

  public String getBrand() {
    return brand;
  }

  public String getModel() {
    return model;
  }

  public Steeringwheel getSteeringwheel() {
    return steeringwheel;
  }

  public void setSteeringwheel(Steeringwheel steeringwheel) {
    this.steeringwheel = steeringwheel;
  }

  public String getPlate() {
    return plate;
  }

  public void setPlate(String plate) {
    this.plate = plate;
  }

  public String getColor() {
    return color;
  }

  public void setColor(String color) {
    this.color = color;
  }
}

To test and understand how all this works, you can copy the code from below into your main class and execute it.

public class Main {

  public static void main(String[] args) {
    Car audiA4 = new Car("Audi", "A4");

    audiA4.setColor("green");

    Steeringwheel steeringwheel = new Steeringwheel("Leather", 38);
    audiA4.setSteeringwheel(steeringwheel);

    audiA4.addSeat(new Seat("Leather", 10, true));
    audiA4.addSeat(new Seat("Leather", 10, true));
    audiA4.addSeat(new Seat("Fabric", 8, false));
    audiA4.addSeat(new Seat("Fabric", 8, false));
    audiA4.addSeat(new Seat("Fabric", 8, false));

    audiA4.setPlate("ABCD1");

    System.out.println(
        "Car: " + audiA4.getBrand() + " " + audiA4.getModel() + " in " + audiA4.getColor());
    System.out.println(
        "Steeringwheel: " + audiA4.getSteeringwheel().getMaterial() + " steeringwheel which is "
            + audiA4.getSteeringwheel().getDiameter() + "cm big");

    int count = 1;
    String tempSeatOutput;
    for (Seat seat : audiA4.getSeats()) {
      tempSeatOutput =
          "Seat " + count + ": " + seat.getMaterial() + " seat which weights " + seat.getWeight()
              + "kg";

      if (seat.isHeating()) {
        tempSeatOutput += " and can heat up";
      } else {
        tempSeatOutput += " and cannot heat up";
      }

      System.out.println(tempSeatOutput);
      count++;
    }

    System.out.println("Plate: " + audiA4.getPlate());
  }
}

The code above creates a new object with Car audiA4 = new Car(“Audi”, “A4”);. ‘Audi’ and ‘A4’ are the constructor arguments (brand and model). After creation, we are now using the setter methods of the car objects to set other variables.

The color is just set with a simple String argument. To set a Steeringwheel object we first have to create one. This is done like the Car object but now with Steeringwheel: Steeringwheel steeringwheel = new Steeringwheel(“Leather”, 38);. When creating the Steeringwheel Object the constructor arguments (material and diameter) are added. Now there are two separate objects. One is the Car and the other one is the Steeringwheel Object. To link the Steeringwheel object to the Car object we need to call the setSteeringwheel method of the car. The same process is now done with the seats but with anonymous objects.

Anonymous objects are used if you don’t need to access the object later on in the code. So you can type new Seat(, , ) and add it immediately to the car with addSeat. This has two benefits. All this is done within one line and you don’t have to think about an object name. This can also be done with the Steeringwheel object since it will not be used directly later in the code.

After setting the plate every information about the car is printed out in the console. To do this the respective getter method is called to get the wanted String, Steeringwheel or Seat objects.

That’s the process of creating and using Java Objects. If you have any questions feel free to leave a comment.

Effortlessly Managing Your Projects with GitHub Desktop

Jakob — Sun, 17 Mar 2024 16:33:28 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to easily enhance your project management with GitHub Desktop, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and set up GitHub Desktop.

Downloading and Setting Up GitHub Desktop

To start managing your projects with GitHub Desktop you first need to download the setup file. This can be done via the official GitHub Desktop Website. You can click here to open it. After the Website has loaded click the Download button highlighted on the screenshot below.

After downloading the setup executable file you can open and run it. When the setup is started up it looks like in the picture below. Now you have two options. The first is to log in with an already existing account which we will do in this tutorial. The second option is to create a new free account on GitHub. You can also create an account on the github.com website first and then follow the steps described below.

After clicking on Sign in to GitHub.com you are redirected to the GitHub website where you have to authorize GitHub Desktop rights to your account. To do this press ‘Authorize desktop’ on the right. If you don’t see the screen from below you have to log in to your account first.

After authorization, your web browser will ask you for permission to open GitHub Desktop again. This message can vary from browser to browser. In Microsoft Edge, you need to click on Open. If you want to always open GitHub Desktop automatically in the future you can also check the checkbox above the buttons.

After opening GitHub Desktop again your Git configuration will be displayed on your screen. There may be an auto-generated email address in the email field. You can change that back to your default GitHub email address by clicking the arrow next to it. When everything is configured you can hit Finish.

Managing Your Projects with GitHub Desktop

To start managing your projects with GitHub Desktop you need to clone a repository. You can see your existing repositories on the left side of the screen. There you can select one and click on Clone . If you don’t have a repository yet you can also try the options on the right side of the screen. With ‘Create a New Repository on your hard drive…’ a completely new folder will be created and used as a repository. With the button below you can transform an existing folder to a repository.

After pressing Clone, you will see another dialog popping up. There you can find the GitHub address of the repository and the location where you want to place it on your hard drive. Adjust it to your needs and confirm your choice with a final click on Clone.

You can start committing to the repo after the cloning process. To commit something to a GitHub you first need some changes. The best practice is to create or update the ReadMe.md file. After saving the file, GitHub Desktop automatically detects changes and will display them to you. You can see all the changes made in the currently selected file on the right. On the left side, you can see all modified files. There you can also deselect files that you don’t want to commit. On the bottom of the left side, you will see the field for the commit message, the description and the Commit button.

You can commit your changes to different branches which can be selected at the top of the screen. Since this is just the ReadMe file it will be committed to the main branch. After you have made sure that you have just selected the files you want to commit, selected the correct branch, entered a commit message and optionally added a description you can click Commit.

After pressing commit you have to push the changes to the repository. This can be done either with a click on the Push button in the blue box, with CTRL+P or a press Push at the top of the view. If you don’t see the Push origin at the top you can click on the arrow to switch modes. Now your changes are pushed to the repository.

When there are multiple team members or you have made changes on the GitHub web app you want to have those changes locally as well. This is also done with a click on Pull in the blue box, CTRL+SHIFT+P or with the top menu.

To see the repository history in GitHub Desktop you can press History on the left side. You can see every change with the included files and the exact changes depending on the selected files.

With the top menu, you can switch between repositories and branches to see exactly where what changed. With these features, monitoring and managing your projects with GitHub Desktop can be done by everyone.

Now you should be able to manage your Java, Android and many more projects easily. If you have any problems or questions feel free to leave a comment.

Crafting Your First Android App with Java: A Beginner’s Guide to Success

Jakob — Sat, 16 Mar 2024 14:51:36 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to create your first Android app with Java, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and create an Android app with Java.

Creating an Android App with Java in Android Studio

To start, you first need to click on the new project button to start configuring your Android app.

On the first page, you need to select what activity you want to use for creating your app. Since we don’t want any pre-created buttons or menus in this app we are just using the Empty Views Activity.

FYI: An activity is one screen of an app. If you are for example creating an app with a login mechanism you would have the following activities:

Login Activity
Registration Activity
Home Activity

The app would probably start with the login activity. On this activity, you could now have two fields for email and password and two buttons. One for new users which would open the registration activity and one login button which would redirect the user to the home activity.

After pressing next you will see the actual configuration screen of your project. There you can change various settings for your app. You can enter whatever you like regarding the name and the package name. This applies also to the save location. However, if you change the directory, no new folder will be created with the project name so the project gets generated exactly in the folder you choose. So don’t choose a parent folder without creating a subfolder.

For the language you should also choose whatever you know the best. For this tutorial, I am choosing Java. The next point is the minimum SDK. This means any device with an Android version below this version won’t be able to download and use this app. A good minimum SDK is API 24 which is already preselected. Below the drop-down menu, you can also see how many smartphones can use this app. The last configuration option is the build configuration language. You can choose between Kotlin and Groovy and since Kotlin is superior we are choosing it.

After every configuration option is set it should look similar to the screenshot below. If this is the case you can start the generating process of your Android app with Java by clicking Finish.

After your project is generated you should locate two important files in the project explorer on the left of the screen. The MainActivity class contains all the programming logic for our activity. The activity_main.xml file contains the information on how your MainActivity will look like.

When opening the activity_main.xml you will probably see a white screen with a Hello World! text since this is the default option. But there is also an option to see the code of the actual file side by side with the live preview of it which is mandatory for developing an app. To switch to this view click on the symbol in the top right corner highlighted in the screenshot below. You can also see another highlighted button. With that, you can switch from seeing a blueprint beneath the actual preview of the activity to just previewing the activity. For that, you have to switch to Design only.

Extending the Source Code of Your App

Now that you know the basics we are extending the source code of your Android app with Java a bit so there will be a Button that can be pressed which increases a counter that is displayed in a TextView. For this, we are giving the already existing TextView in the activity_main.xml an ID. An ID is needed so we can access the TextView via the logic inside the MainActivity Java class. To add an ID you need to add the line below inside the TextView tag.

android:id="@+id/counterLabel"

After adding this line we are also adding a Button to the activity with this code:

Now our activity_main.xml is done and should look like this:

The user interface is now done. There is a Button and a TextView. Now we need to access these two components inside the MainActivity.java and work with them.
First of all, we are adding 3 variables to the class.

private TextView counterLabel; This will be set to our TextView
private Button counterButton; This will be set to our Button
private int currentCount = 0; This will work as our counter variable

Then we initialize the TextView and Button variables. This can be done in the onCreate method since this method is only once called at the very start of the activity. To get different components of your XML files you call findViewById(R.id.). So the assignments will look like this.

counterLabel = findViewById(R.id.counterLabel);
counterButton = findViewById(R.id.countUpButton);

The next step is to set the text of the counter label to 0. For setting an initial value there are always two options. The first one is to set it directly inside the activity_main.xml file with the android:text attribute or you can do it via code like this:

counterLabel.setText(String.valueOf(currentCount));

Last, we need to add an onClickListener with which we can override the onClick method to increase our counter and set the new value to our TextView. To do this you can either use a lambda expression or not. That depends entirely on what you prefer to use. You can see the difference below:

counterButton.setOnClickListener(v -> {
    currentCount++;
    counterLabel.setText(String.valueOf(currentCount));
});

counterButton.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        currentCount++;
        counterLabel.setText(String.valueOf(currentCount));
    }
});

Finally, your finished MainActivity class will look like this:

package com.example.myfirstandroidapp;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private TextView counterLabel;
    private Button counterButton;
    private int currentCount = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        counterLabel = findViewById(R.id.counterLabel);
        counterButton = findViewById(R.id.countUpButton);

        counterLabel.setText(String.valueOf(currentCount));

        counterButton.setOnClickListener((v) -> {
            currentCount++;
            counterLabel.setText(String.valueOf(currentCount));
        });
    }
}

Always call findViewById after super.onCreate(savedInstanceState); and setContentView(R.layout.activity_main);. Otherwise, it will not work.

Testing Your First Android App with Java

To test your newly created Android app with Java you have two options.
The first one is to use your real mobile phone. You can either connect it via cable or connect via Wi-Fi. To do this you first need to enable the respective debugging mode on your smartphone in the developer settings. This can vary from brand to brand so the best thing is to Google how to do it on your device. After enabling the mode you can connect your device via cable and the smartphone will automatically show up on the devices list, or you use ‘Pair Devices Using Wi-Fi’ from the options in the screenshot below and follow the steps displayed.

The second option to test your Android app with Java is, to use a virtual device. The advantage of a virtual device is, that you can have multiple. So you can test your app on devices with different sizes and Android versions. Furthermore, you can test device categories that you may not even own, like a smartwatch. To learn how to add a virtual device you can click here.

After you have added/selected the correct device you can now click on the play button next to the drop-down list, which is also highlighted in the screenshot below to start your app.

After clicking the button the app will be built. When the build process is finished the virtual device will start and launch your app. If you use your personal device the app will also launch itself. After the application is started on your device it should look like the preview from the activity_main.xml file. To test the logic we implemented you can click on the counter button. You will then see the counter getting increased with each click.

This was the process of creating your first Android app with Java in Android Studio. If you have any problems or questions feel free to comment below. To read more about creating an app in Android Studio you can visit the documentation of Google.

Add a Powerful Virtual Device in Android Studio

Jakob — Fri, 15 Mar 2024 19:15:03 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to add a powerful virtual device in Android Studio, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and add a powerful virtual device in Android Studio.

Why You Should Have One or More Virtual Devices

After developing mobile applications you will ask yourself how to test your app. There are two options: The first option is, to load your program on your smartphone. The benefits are clear. Once uploaded on your phone you can show it to friends and family members but there are also downsides. The phone must be either connected via cable or wirelessly. Additionally, debugging has to be enabled in the developer settings. Furthermore, it always has to be nearby and the uploading process often takes quite a long time.

With a virtual device, you don’t need to have your phone always with you to test your mobile applications. You can press ‘Run’ inside Android Studio and a virtual smartphone will be powered up where your app gets deployed. Also with the virtual device, you can simulate different things like a bad internet connection.

Another big advantage is, that you can have multiple virtual devices with different screen sizes and Android versions, which is extremely useful for developing apps, which have to work for older phones and should also look good on foldable phones or phones with rather small displays.

Add a Powerful Virtual Device in Android Studio

To add a powerful virtual device in Android Studio the first thing you need to do is to check if Hyper-V is enabled. To learn how to enable it, you can click here. After you have enabled it, you need to open the device manager in Android Studio. This can be done with the menu on the very right in Android Studio. There you have to click on the icon with a smartphone and the android logo. You can see the location in the screenshot below. After opening it, you have to click on the plus symbol to add a new powerful virtual device in Android Studio.

After clicking on the plus icon, a new dialog will be displayed on your screen. Now the real process to add a powerful virtual device in Android Studio begins. First of all, you have to decide which device you want to create. You can choose from different categories like phones, tablets, watches, or even TVs. In this tutorial, we are using the Google Pixel 8 since the size is rather common. After choosing the device you can confirm your selection with a click on Next.

In the next dialog window, you can choose your desired Android version for your new virtual device in Android Studio. If you have already downloaded the desired version, you can select it and click on next. Otherwise, you have to click on the small download icon next to the Android version name. In this case, I am choosing the newest version, 14.

After pressing on download another window will appear where you must accept the license agreement. Just select Accept and press Next to start downloading the SDK.

The download will take some time. After it is finished you can press the Finish button in the bottom right corner of the download dialog.

After clicking on Finish you will be back at the window where you can choose the desired Android version. You can now select the downloaded version and confirm the selection by pressing Next on the bottom.

After clicking Next you will see the last dialog to create a virtual device in Android Studio. There you will see a quick overview of your selections and you can also give the device a name. I would recommend that you include the API version (Android version) in the name, so you quickly know what version the device is running on. After you have checked your previous selections and named your device you can finish the process to add a virtual device in Android Studio with a click on the Finish button.

Now your device will show up in the device overview of the device manager. You can start the virtual smartphone directly by launching your app with the play icon on the top or you can start the device without starting your mobile application via the play button next to your device inside the device manager.

Problem: Black Circle on the Screen in Addition to the Camera

Sometimes there might be a problem after you’ve added a powerful virtual device to Android Studio – a black circle is displayed on the screen in addition to the camera punch hole. This is because a display cutout is activated in the developer options of the device. To deactivate it you first have to activate the developer options. You can do this by opening the settings on the smartphone, then clicking on ‘About phone’ and scrolling down to ‘Build number’. You have to click on Build number 7 times to enable the developer options. After clicking on it that many times you will see a message on the screen that the developer options are now enabled.

After the activation, you have to go back to the start of the settings. Now scroll down to ‘System’ and open the ‘Developer options’. You now have to search for ‘Display cutout’. The setting is located approximately two-thirds of the way up the menu. After you have found it you can click on it and select ‘Device default’ so only the normal camera punch hole is visible.

Now everything should be working without any problems. If you have any troubles or questions feel free to leave a comment or visit the official documentation of Google.

Improve Your Code and Make It More Readable with Google Code Style in 5 Simple Steps

Jakob — Mon, 11 Mar 2024 18:35:18 +0000

Hello tech enthusiasts! Welcome back to jasta, your go-to destination for all things tech. Today, we’re diving into how to make your code cleaner and more readable with Google Code Style in 5 simple steps, providing a step-by-step guide to help you accomplish this on your computer. Whether you’re a seasoned tech guru or just starting your digital journey, our straightforward instructions will make the process a breeze. Let’s jump in and enable Google Code Style in IntelliJ IDEA.

Why You Should Format Your Code

Formatting your code is like organizing your room – it makes everything easier to find and understand. Clean, well-formatted code is crucial for readability and maintainability, especially as projects grow. It helps you and others comprehend the logic and structure effortlessly. Consistent indentation, clear naming conventions, and proper spacing enhance code clarity, reducing errors and debugging time. Formatted code is also more professional, fostering collaboration and making it easier for others to contribute or review your work.

Ultimately, investing time in formatting your code pays off in improved efficiency, better collaboration, and smoother project maintenance, creating a solid foundation for your programming journey.

Download the Official Google Code Style

To now add Google Code Style to your programming environment (IntelliJ IDEA) and be able to format your code quickly, you first have to download the necessary file. The file you need is a simple XML file that can be downloaded from a GitHub repository. You can find the correct repository here.

The link provided above will directly open the needed file. To download it the file, you have to click on the download symbol in the top right corner. You can also see it highlighted in the screenshot below.

If you don’t want to download the file from GitHub, you can also copy the XML content from below and save it inside a new file. Make sure that you save it as a XML file, otherwise you won’t be able to use it inside IntelliJ IDEA.

Add Google Code Style to IntelliJ IDEA

After downloading the file or creating one with the provided content above, you can now start IntelliJ IDEA. After starting you first have to select File on the top menu and click on Settings. Alternatively you can press CTRL+ALT+S to open the settings of IntelliJ.

After the settings windows is opened, you have to open the Editor entry on the left-hand side of the window and then find Code Style and click on it. At the top of the window, you should now see a Scheme label with a drop-down menu and a settings wheel next to it. To now import your XML file you have to click on the settings wheel, select the last menu entry, Import Scheme, and last but not least click on IntelliJ IDEA code style XML.

Now a popup will be displayed to you, where you have to select your Google Code Style XML file. So find it on the presented explorer and click on it once. To confirm your choice you have to press OK on the bottom of the dialog.

After confirming your choice, you have now the option to give your code style a name. Just give it a name you like and you remember that this is the Google Code Style. In this example, I named it GoogleStyle.

Lastly, you may need to select the just-created style as your default IntelliJ IDEA code style. To do so you have to select the new entry from the drop-down menu next to the settings wheel where you have just imported the settings. After doing so you can click on Apply or OK to apply the newly made settings.

To now format your code you have to select the area where you want to apply the Google Code Style or select the whole class with CTRL+A and then format it with CTRL+ALT+L. Now your code is formatted according to the code style inside the imported XML file.

jasta

Get a Beautiful Rounded Taskbar in Windows 11

Table of Contents

How Will Your Rounded Taskbar finally look

Download the Rounded Taskbar Program

Set up Your Rounded Taskbar in Windows 11

Writing Unit Tests in Java with JUnit 5: A Comprehensive Guide

Table of Contents

Why You Should Implement Unit Tests for Your Java Application

Most Important Annotations for JUnit 5 tests in Java

Step-by-Step Guide to Writing Unit Tests in Java with JUnit 5

Implement Powerful Logging in Java with Log4j2

Table of Contents

Why Proper Logging is Necessary for Every Application

Adding Log4j2 Dependencies to Your Project

Implement Logging in Java with Log4j2

Writing to Files in Java: Master File Operations with Ease

Table of Contents

The Importance of Writing to Files in Java

Implement Different Ways to Write to Files

Java NIO Files

BufferedWriter with FileWriter

Reading Files in Java: Unleash Data Insights Effortless

Table of Contents

The Importance of Reading Files in Java

Implement Different Ways to Read Files

Java NIO Files

BufferedReader with FileReader

Mastering Java Objects: Comprehensive Guide to Constructors, Getters, and Setters

Table of Contents

What are Java Objects and Why Do They Exist?

Understanding the Purpose of Constructors in Java

How to Create and Use Java Objects

Effortlessly Managing Your Projects with GitHub Desktop

Table of Contents

Downloading and Setting Up GitHub Desktop

Managing Your Projects with GitHub Desktop

Crafting Your First Android App with Java: A Beginner’s Guide to Success

Table of Contents

Creating an Android App with Java in Android Studio

Extending the Source Code of Your App

Testing Your First Android App with Java

Add a Powerful Virtual Device in Android Studio

Table of Contents

Why You Should Have One or More Virtual Devices

Add a Powerful Virtual Device in Android Studio

Problem: Black Circle on the Screen in Addition to the Camera

Improve Your Code and Make It More Readable with Google Code Style in 5 Simple Steps

Table of Contents

Why You Should Format Your Code

Download the Official Google Code Style

Add Google Code Style to IntelliJ IDEA