---
title: "Cast Operator — AP CSA Definition, Examples & Exam Tips"
description: "The cast operator (int) or (double) explicitly converts a value to another primitive type in Java. Know truncation rules and cast placement for AP CSA Unit 1."
canonical: "https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator"
type: "key-term"
subject: "AP Computer Science A"
unit: "Unit 1"
---

# Cast Operator — AP CSA Definition, Examples & Exam Tips

## Definition

In AP Computer Science A, the cast operator is the syntax (type) placed before a value or expression to explicitly convert it to a primitive type, such as (int) or (double); casting a double to an int truncates everything after the decimal point (EK 1.5.A.2).

## What It Is

The cast operator is a pair of [parentheses](/ap-comp-sci-a/unit-1/expressions-and-assignment-statements/study-guide/01dr6uUPDAn3SjtK2Psr "fv-autolink") containing a type name, written right before a value or [expression](/ap-comp-sci-a/key-terms/expression "fv-autolink"), that tells Java to convert that value to the named type. On the AP exam you only need two of them: `(int)` and `(double)` (EK 1.5.A.1). So `(double) 7` produces `7.0`, and `(int) 4.7` produces `4` (not 5).

That last example is the rule the exam loves. [Casting](/ap-comp-sci-a/unit-1/casting-and-ranges-of-variables/study-guide/kW3XXEIwJwVRXFx3ntdC "fv-autolink") a double to an int **truncates**, meaning Java chops off everything after the decimal point. It does not round. If you actually want rounding, the CED gives you a trick: `(int)(x + 0.5)` rounds a non-negative double to the nearest integer, and `(int)(x - 0.5)` works for negatives (EK 1.5.A.4). Casting also works in the other direction, but Java often does that one for you. When an int meets a double in an arithmetic expression, the int is automatically widened to a double without you writing anything (EK 1.5.A.3).

## Why It Matters

The cast operator lives in **Topic 1.5 (Casting and Ranges of Variables)** in [Unit 1](/ap-comp-sci-a/unit-1 "fv-autolink") and directly supports learning objective **[AP Comp Sci A](/ap-comp-sci-a "fv-autolink") 1.5.A**, which asks you to write code that casts primitive values in arithmetic expressions and predict the exact value produced. It is the fix for the most common Unit 1 trap, integer division. `7 / 2` evaluates to `3` in Java because both operands are ints, but `(double) 7 / 2` gives you `3.5`. Casting is also how you control truncation versus rounding, which connects to the accuracy limits described in **AP Comp Sci A 1.5.C**. This skill never goes away. Every later unit that computes an average, a percentage, or a ratio quietly tests whether you remember where to put the cast.

## Connections

### [Cast to int (Unit 1)](/ap-comp-sci-a/key-terms/cast-to-int)

Casting to int is the specific move that trips people up most. `(int) 4.7` is 4 because [truncation](/ap-comp-sci-a/key-terms/truncation "fv-autolink") just deletes the decimal part. Think of it as cutting, not rounding. The rounding recipe `(int)(x + 0.5)` exists exactly because the cast alone won't round for you.

### [Arithmetic expression (Unit 1)](/ap-comp-sci-a/key-terms/arithmetic-expression)

Where you place the cast inside an [arithmetic expression](/ap-comp-sci-a/key-terms/arithmetic-expression "fv-autolink") changes everything. `(double) a / b` casts `a` first, so the division is decimal division. `(double) (a / b)` does integer division first, then casts the already-truncated result. Same characters, different answers.

### [Round-off error (Unit 1)](/ap-comp-sci-a/key-terms/round-off-error)

Casting and [round-off error](/ap-comp-sci-a/key-terms/round-off-error "fv-autolink") are the two ways a number loses information in Topic 1.5. A cast to int throws away the decimal part on purpose; a round-off error happens when a double can't be stored precisely in memory (EK 1.5.C.1). Both mean the value you see may not be the value you expected.

### Integer overflow (Unit 1)

Casting won't save you from overflow. An int is stored in 4 bytes, so it must stay between Integer.MIN_VALUE and Integer.MAX_VALUE (EK 1.5.B.2). If an expression would land outside that range, you get an in-range but wrong int value, no matter how you cast afterward.

## On the AP Exam

Cast operators show up constantly in multiple-choice questions that hand you a short code segment and ask for the exact output. The classic stems test three things. First, cast placement: a question might define `result1 = (double) a / b;` and `result2 = (double) (a / b);` and ask what prints, and the answer hinges on whether the cast happens before or after integer division. Second, truncation: given `transform(4.7)` where the code does `int temp = (int) val;`, you need to know temp is 4, so the method returns 4.5. Third, casting combined with mod or Math.round to extract digits, where `(int)(value * 100)` and `(int) Math.round(value * 100)` can produce different digits because of round-off error. On FRQs, casting is a tool rather than a headline. You'll need `(double)` whenever you compute an average from int data, and forgetting it is a silent way to lose points to integer division.

## cast operator vs Automatic widening (implicit casting)

The cast operator is explicit; you write `(int)` or `(double)` yourself. Widening is automatic: when an int appears in an expression with a double, Java converts the int to a double on its own (EK 1.5.A.3), because no information is lost going from int to double. The reverse never happens automatically. Java will not silently turn a double into an int, because that would throw away the decimal part, so you must write `(int)` explicitly. Quick rule: widening is free, narrowing requires a cast.

## Key Takeaways

- The cast operator is the syntax (type) written before a value, and the AP exam only requires (int) and (double).
- Casting a double to an int truncates the decimal portion, so (int) 4.7 is 4, not 5.
- To actually round, use (int)(x + 0.5) for non-negative doubles and (int)(x - 0.5) for negative ones.
- Cast placement matters: (double) a / b performs decimal division, but (double) (a / b) casts after integer division has already truncated.
- Java automatically widens int to double in mixed expressions, but going from double to int always requires an explicit cast.
- Casting can't fix integer overflow; int values must fit between Integer.MIN_VALUE and Integer.MAX_VALUE.

## FAQs

### What is the cast operator in AP Computer Science A?

It's the syntax (type) placed before a value or expression to explicitly convert it to another primitive type. On the AP CSA exam, the only casts you need are (int) and (double), covered in Topic 1.5.

### Does casting a double to an int round the number?

No. Casting truncates, meaning it chops off everything after the decimal point, so (int) 4.7 is 4 and (int) -4.7 is -4. If you want rounding, the CED formula is (int)(x + 0.5) for non-negative numbers.

### What's the difference between (double) a / b and (double) (a / b)?

(double) a / b casts a to a double first, so the division keeps decimals (7 and 2 gives 3.5). (double) (a / b) does integer division first, truncating to 3, then casts to 3.0. Exam questions test exactly this distinction.

### How is the cast operator different from Math.round?

A cast to int truncates toward zero, while Math.round rounds to the nearest whole number. Practice questions exploit this by comparing (int)(value * 100) with (int) Math.round(value * 100), which can produce different results when round-off error makes the stored double slightly smaller than expected.

### Do I ever need to cast an int to a double in Java?

Often you don't, because Java automatically widens int values to double in mixed expressions (EK 1.5.A.3). The big exception is division between two ints: you must cast one operand to (double) before dividing, or Java performs integer division and drops the remainder.

## Related Study Guides

- [1.5 Casting and Ranges of Variables](/ap-comp-sci-a/unit-1/casting-and-ranges-of-variables/study-guide/kW3XXEIwJwVRXFx3ntdC)

## Structured Data

```json
{"@context":"https://schema.org","@graph":[{"@type":"LearningResource","@id":"https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator#resource","name":"Cast Operator — AP CSA Definition, Examples & Exam Tips","url":"https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator","learningResourceType":"Concept explainer","educationalLevel":"AP® / High School","about":{"@id":"https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator#term"},"audience":{"@type":"EducationalAudience","educationalRole":"student"},"dateModified":"2026-06-11T05:27:19.913Z","isPartOf":{"@type":"Collection","name":"AP Computer Science A Key Terms","url":"https://fiveable.me/ap-comp-sci-a/key-terms"},"publisher":{"@type":"Organization","name":"Fiveable","url":"https://fiveable.me"}},{"@type":"DefinedTerm","@id":"https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator#term","name":"cast operator","description":"In AP Computer Science A, the cast operator is the syntax (type) placed before a value or expression to explicitly convert it to a primitive type, such as (int) or (double); casting a double to an int truncates everything after the decimal point (EK 1.5.A.2).","url":"https://fiveable.me/ap-comp-sci-a/key-terms/cast-operator","inDefinedTermSet":{"@type":"DefinedTermSet","name":"AP Computer Science A Key Terms","url":"https://fiveable.me/ap-comp-sci-a/key-terms"}},{"@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is the cast operator in AP Computer Science A?","acceptedAnswer":{"@type":"Answer","text":"It's the syntax (type) placed before a value or expression to explicitly convert it to another primitive type. On the AP CSA exam, the only casts you need are (int) and (double), covered in Topic 1.5."}},{"@type":"Question","name":"Does casting a double to an int round the number?","acceptedAnswer":{"@type":"Answer","text":"No. Casting truncates, meaning it chops off everything after the decimal point, so (int) 4.7 is 4 and (int) -4.7 is -4. If you want rounding, the CED formula is (int)(x + 0.5) for non-negative numbers."}},{"@type":"Question","name":"What's the difference between (double) a / b and (double) (a / b)?","acceptedAnswer":{"@type":"Answer","text":"(double) a / b casts a to a double first, so the division keeps decimals (7 and 2 gives 3.5). (double) (a / b) does integer division first, truncating to 3, then casts to 3.0. Exam questions test exactly this distinction."}},{"@type":"Question","name":"How is the cast operator different from Math.round?","acceptedAnswer":{"@type":"Answer","text":"A cast to int truncates toward zero, while Math.round rounds to the nearest whole number. Practice questions exploit this by comparing (int)(value * 100) with (int) Math.round(value * 100), which can produce different results when round-off error makes the stored double slightly smaller than expected."}},{"@type":"Question","name":"Do I ever need to cast an int to a double in Java?","acceptedAnswer":{"@type":"Answer","text":"Often you don't, because Java automatically widens int values to double in mixed expressions (EK 1.5.A.3). The big exception is division between two ints: you must cast one operand to (double) before dividing, or Java performs integer division and drops the remainder."}}]},{"@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"AP Computer Science A","item":"https://fiveable.me/ap-comp-sci-a"},{"@type":"ListItem","position":2,"name":"Key Terms","item":"https://fiveable.me/ap-comp-sci-a/key-terms"},{"@type":"ListItem","position":3,"name":"Unit 1","item":"https://fiveable.me/ap-comp-sci-a/unit-1"},{"@type":"ListItem","position":4,"name":"cast operator"}]}]}
```