XQA
Back to Java
2026-01-287 min read

JS Media Queries (Java)

Learn JS Media Queries (Java) step by step with clear examples and exercises.

Why This Matters

Media queries are essential in modern web development as they enable the creation of responsive websites that adapt to various screen sizes and devices. While primarily used with CSS, implementing media queries in Java can provide more dynamic control over layout adjustments for creating responsive web applications using Java-based frameworks such as GWT (Google Web Toolkit) or Vaadin. In this lesson, we will explore how to use media queries in Java to create responsive web applications.

Why This Matters

Media queries are a crucial aspect of responsive web design, allowing developers to create websites that adapt to various screen sizes and devices. By using media queries in Java, we can achieve more dynamic control over layout adjustments and provide an optimal user experience across different platforms.

Prerequisites

Before diving into media queries using Java, you should have a solid understanding of the following:

  1. HTML and CSS basics
  2. Java programming fundamentals
  3. JavaScript for handling DOM manipulation and event listeners (if using GWT or Vaadin)
  4. Basic concepts of responsive web design
  5. Familiarity with a Java-based web framework such as GWT or Vaadin

Core Concept

To use media queries in Java, we'll use the power of CSS within our chosen Java-based web framework. Both GWT and Vaadin provide support for CSS, allowing us to write media queries that respond to different screen sizes and devices.

Setting Up the Project

First, create a new project using your preferred Java-based web framework (e.g., GWT or Vaadin). Ensure you have set up the necessary dependencies and configurations required by the framework.

Using GWT:

  1. Create a new GWT project using the GWT Eclipse Plugin or GWT Gradle Plugin.
  2. Add the necessary CSS files to your project's war directory (e.g., styles.css).
  3. Include the CSS file in your HTML template using a `` tag:
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>JS Media Queries (Java)</title>
<!-- Include your CSS file -->
<link rel="stylesheet" type="text/css" href="styles.css">
</head>
<body>
<!-- Your HTML content goes here -->
</body>
</html>

Using Vaadin:

  1. Create a new Vaadin project using the Vaadin Web Components Starter.
  2. Add your CSS file to the src/main/webapp/styles directory (e.g., styles.css).
  3. Include the CSS file in your HTML template using a `` tag:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>JS Media Queries (Java)</title>
<!-- Include your CSS file -->
<link rel="stylesheet" type="text/css" href="/styles/styles.css">
</head>
<body>
<!-- Your HTML content goes here -->
</body>
</html>

Creating Responsive Layouts with Media Queries

Now, let's create a simple example of a responsive layout using media queries in Java:

  1. Define two CSS classes for small and large screens:
/* Small Screen Styles */
@media (max-width: 600px) {
.small-screen {
display: block;
}

.large-screen {
display: none;
}
}

/* Large Screen Styles */
@media (min-width: 600px) {
.small-screen {
display: none;
}

.large-screen {
display: block;
}
}
  1. Create two HTML div elements that will be used to display content on different screen sizes:
<div class="small-screen">Small Screen Content</div>
<div class="large-screen" style="display: none;">Large Screen Content</div>
  1. Write the following JavaScript code (GWT) or Java code (Vaadin) to handle media queries and display the appropriate content based on the screen size:

JavaScript (GWT):

// Check if the viewport is wide enough for large content
if (window.matchMedia('(min-width: 600px)').matches) {
$wnd.document.getElementById("smallScreenContent").style.display = "none";
$wnd.document.getElementById("largeScreenContent").style.display = "block";
}

Java (Vaadin):

// Check if the viewport is wide enough for large content
if (window.matchMedia('(min-width: 600px)').matches) {
smallScreenContent.setVisible(false);
largeScreenContent.setVisible(true);
}

In this example, we first check if the viewport is wide enough for large content (600px) and display the appropriate div accordingly. We then attach a media query listener to handle changes in screen size by hiding or showing the respective divs as needed.

Worked Example

Let's create a more complex example that involves changing the layout of a navigation bar based on different screen sizes:

  1. Create an HTML structure for the navigation bar and content:
<div class="navbar">
<!-- Navigation items go here -->
</div>

<div id="content"></div>
  1. Define CSS classes for small and large screens:
/* Small Screen Styles */
@media (max-width: 600px) {
.navbar {
display: flex;
justify-content: space-between;
}

.navbar-item {
width: 100%;
}
}

/* Large Screen Styles */
@media (min-width: 600px) {
.navbar {
display: flex;
justify-content: center;
}

.navbar-item {
width: auto;
}
}
  1. Write the following JavaScript code (GWT) or Java code (Vaadin) to handle media queries and adjust the navigation bar layout based on screen size:

JavaScript (GWT):

// Check if the viewport is wide enough for large navigation
if (window.matchMedia('(min-width: 600px)').matches) {
navbar.style.justifyContent = "center";
} else {
navbar.style.justifyContent = "space-between";
}

Java (Vaadin):

// Check if the viewport is wide enough for large navigation
if (window.matchMedia('(min-width: 600px)').matches) {
navbar.setJustifyContent("center");
} else {
navbar.setJustifyContent("space-between");
}

In this example, we first check if the viewport is wide enough for large navigation (600px) and adjust the layout of the navigation bar accordingly. We then attach a media query listener to handle changes in screen size by adjusting the layout as needed.

Common Mistakes

  1. Not properly including the CSS file in your HTML template or using incorrect paths.
  2. Forgetting to initialize the JavaScript code after the library is loaded (GWT).
  3. Using incorrect media query syntax, such as missing parentheses or using invalid units (e.g., px instead of em).
  4. Not considering the possibility that a user may resize the browser window during page load, causing the layout to switch unexpectedly.
  5. Failing to test the application across multiple devices and screen sizes to ensure proper responsiveness.

Practice Questions

  1. Modify the example above to use a media query with a minimum width of 900px instead of 600px.
  2. Add a media query that hides the navigation bar on screens smaller than 480px and displays it as a dropdown menu using GWT's HorizontalPanel or Vaadin's VerticalLayout.
  3. Create a responsive layout for an image gallery, where images are displayed in a grid on larger screens and stacked vertically on smaller screens using GWT's FlexTable or Vaadin's GridLayout.

FAQ

  1. Why is it important to use media queries in Java for responsive web design?

Media queries allow us to create web applications that adapt to various screen sizes and devices, providing an optimal user experience across different platforms.

  1. Can I use media queries with other JavaScript libraries besides GWT or Vaadin?

Yes, many other JavaScript libraries offer support for media queries, such as React's CSS-in-JS solutions (e.g., styled-components) and Angular's built-in support for responsive design. However, when using a Java-based web framework like GWT or Vaadin, you can use their CSS support to achieve similar results more efficiently.

  1. What are some best practices for writing media queries in Java?

Some best practices include using meaningful names for media query breakpoints, keeping the number of breakpoints to a minimum, and testing the application across multiple devices and screen sizes.

  1. How can I handle media queries when using server-side technologies like Node.js or PHP instead of Java?

Server-side technologies can generate different HTML or CSS based on the user's device and screen size, allowing you to create responsive layouts without relying on client-side JavaScript. Frameworks like Bootstrap provide tools for creating responsive designs using server-side technologies.

  1. What are some common pitfalls to avoid when working with media queries in Java?

Common pitfalls include forgetting to account for the possibility that a user may resize the browser window during page load, using incorrect syntax or units in media queries, and not testing the application across multiple devices and screen sizes. Additionally, be mindful of the performance impact of generating excessive amounts of HTML or CSS based on media queries, as it can lead to slower load times for some users.

JS Media Queries (Java) | Java | XQA Learn