使用对象与方法

An algorithm 算法 is a finite, step-by-step procedure that solves a problem. A program 程序 expresses an algorithm in a language a computer can run. Java is compiled 编译: the compiler 编译器 translates your source code into bytecode, which the Java Virtual Machine (JVM) runs. A syntax error 语法错误 (breaking the grammar) is caught by the compiler; a logic error 逻辑错误 (wrong result) is not – the program runs but misbehaves.

A variable 变量 is a named box that stores a value of a fixed type 类型. Java's main primitive types 基本类型 are int (whole numbers), double (decimals), and boolean (true/false). Declare with the type first:

int score = 90;
double price = 4.99;
boolean passed = true;

An expression 表达式 combines values and operators to compute a result: + - * / and % (modulus 取模, the remainder). Integer division truncates: 7 / 2 is 3, while 7 % 2 is 1. Operator precedence follows math (*,/,% before +,-). Print with:

System.out.print("no newline");
System.out.println("with newline");

Dividing an integer by the integer 0 (like 7 / 0) is not allowed and crashes at run time with an ArithmeticException. Inside a string, a backslash marks an escape sequence 转义序列: \" prints a double quote, \\ a single backslash, and \n starts a new line – so System.out.println("She said \"hi\""); prints She said "hi".

An assignment 赋值 x = expr; evaluates the right side and stores it in the left variable. Read input with a Scanner:

Scanner in = new Scanner(System.in);
int age = in.nextInt();
String name = in.next();

Each type has a fixed range; an int overflows past about 2.1 billion. Casting 类型转换 converts between types. Widening (int to double) is automatic; narrowing needs an explicit cast, which truncates (does not round):

double avg = (double) total / count;   // force real division
int whole = (int) 3.9;                 // 3, truncated

Exam skill: watch for integer division producing a truncated result when a decimal was expected – cast one operand to double first.

Worked example. Trace each expression:

• 7 / 2 → 3 (both int, so division truncates);
• 7.0 / 2 → 3.5 (one double forces real division);
• 7 % 2 → 1 (the remainder);
• (double) 7 / 2 → 3.5 (the cast binds tighter than /, so it is 7.0 / 2);
• (double) (7 / 2) → 3.0 (the parentheses compute 7 / 2 = 3 in int first, then widen).

The last two look alike but differ – the position of the cast decides whether the truncation happens.

Shorthands combine an operation with assignment: x += 5 means x = x + 5; likewise -=, *=, /=, %=. The increment and decrement operators x++ and x-- add or subtract one.

Common mistakes.

• x =+ 3; is not x += 3;: it reads as x = +3, so x becomes 3.
• The integer-division rule still applies: with int x = 25;, x /= 4; gives 6, not 6.25.
• x++; changes x itself; x + 1 on its own changes nothing and does not compile as a statement.

An API (Application Programming Interface) 应用程序接口 is the published list of classes and methods you may use. A library 库 is a collection of ready-made classes (like Math, String, Scanner). You read the API documentation to learn what a method needs (its parameters) and returns, without seeing its inner code – an example of abstraction 抽象.

Comments 注释 are ignored by the compiler but explain code to humans: // for a single line, /* ... */ for a block, and /** ... */ for a Javadoc comment that documents a method's purpose, parameters, and return value. Precise preconditions and postconditions are written here.

A precondition 前置条件 is what must be true before the method is called (the caller's job); a postcondition 后置条件 is what the method guarantees afterwards. If a precondition is broken, the method is not required to work: mean(-3, 5) breaks the precondition that a and b are not negative, so its result is not promised.

A method signature 方法签名 is a method's name plus its parameter types, e.g. nextInt() or substring(int, int). To call a method you must supply arguments 实参 that match the parameters in number, type, and order. The method header (the full declaration) also states the return type – the type of value the method gives back (void if none) – but the return type is not part of the signature, which is why two methods cannot differ by return type alone.

Worked example. String has substring(int beginIndex, int endIndex) and indexOf(String str). For String w = "network";:

• w.substring(2, 5) matches: two int arguments, returns "two";
• w.substring("2", "5") does not compile: String arguments where int is required;
• w.indexOf("work") matches: one String argument, returns 3;
• int n = w.substring(3); does not compile: the method returns a String, which cannot be stored in an int.

Several methods with the same name but different parameter lists, such as the two substring methods, are overloaded 重载.

A class (static) method 类方法 belongs to the class itself, so you call it on the class name: ClassName.method(args). No object is needed.

A void class method is a statement on its own; a non-void one returns a value that should be used:

double r = Math.sqrt(25.0);      // 5.0, stored
int big = Math.max(3, 8);        // 8
Math.sqrt(25.0);                 // compiles, but the result is lost

A class method that is called from inside its own class can be called by its name alone: average(a, b) instead of Stats.average(a, b).

The Math class provides static math methods: Math.abs(x), Math.pow(base, exp), Math.sqrt(x), and Math.random() (a double in $[0,1)$). To get a random integer from 0 to n-1: (int)(Math.random() * n).

For a whole number from low to high inclusive: (int) (Math.random() * (high - low + 1)) + low. The bracket high - low + 1 counts the values; the cast truncates; + low shifts the start.

Math.pow and Math.sqrt always return a double, so int p = Math.pow(2, 3); does not compile; (int) Math.pow(2, 3) gives 8. Casting before multiplying is a classic error: (int) Math.random() * 6 is always 0.

A class 类 is a blueprint; an object 对象 is a concrete instance 实例 built from it. A class bundles data (fields) with behavior (methods) – the heart of object-oriented programming 面向对象编程. String, Scanner, and ArrayList are all classes you instantiate.

Classes can be organised into a hierarchy. A superclass 父类 holds attributes and behaviors shared by several subclasses 子类 that extend it – an inheritance relationship 继承关系. Every class in Java is ultimately a subclass of the built-in Object class, which is why every object already has a toString method; writing a subclass method with the same signature as a superclass one is method overriding 方法重写. (Designing your own inheritance is beyond this course, but you are expected to recognise this vocabulary.)

Instantiation 实例化 creates an object with the new keyword, which calls a constructor 构造函数:

Scanner in = new Scanner(System.in);
String s = new String("hi");   // or just "hi"

The variable holds a reference 引用 (the object's address), not the object itself. Two references can point to the same object; comparing them with == compares addresses, not contents.

A reference can also point to nothing: the special value null 空值 means "not attached to any object". Calling a method on a null reference crashes at run time with a NullPointerException. Guard against it by testing with ==/!= and checking null first, so && short-circuits before the method runs: if (s != null && s.length() > 0).

An instance method 实例方法 acts on a specific object, so you call it on the object reference: object.method(args). Example: in.nextInt(), word.length().

Worked example. A BankAccount class has deposit(double amt), withdraw(double amt) and getBalance().

BankAccount a = new BankAccount(100.0);
BankAccount b = a;                 // b refers to the SAME object
b.withdraw(30.0);
a.deposit(5.0);
System.out.println(a.getBalance() + " " + b.getBalance());

There is only one object, so both calls change it: $100 - 30 + 5 = 75$, and the output is 75.0 75.0. Each instance method acts on the object before the dot; with two separate new objects the balances would differ.

String objects are immutable 不可变 – methods return a new string rather than changing the original. Key methods (all indices start at 0):

s.length();            // number of characters
s.substring(2, 5);     // chars at index 2,3,4 (5 excluded)
s.indexOf("ab");       // first position, or -1
s.equals(other);       // content comparison (never use == for Strings)
s.compareTo(other);    // <0, 0, >0 by dictionary order

Exam skill: substring(a, b) includes index a but excludes b, and String comparison must use .equals, not == – two of the most-tested String pitfalls.

Worked example. Let String s = "COMPUTER"; (indices 0–7). Then s.length() is 8; s.substring(0, 4) is "COMP" (indices 0,1,2,3 – index 4 excluded); s.substring(4) is "UTER" (from index 4 to the end); s.indexOf("PU") is 3; and s.indexOf("X") is -1 (not found). Counting the excluded endpoint of substring is the single most common slip.

Asking for an index outside 0 to length()-1 (a bad substring or charAt argument, e.g. s.substring(0, 20) here) crashes with a StringIndexOutOfBoundsException – the String cousin of the array-index error.

• Trace code by hand line by line, tracking each variable's value in a table — the exam rewards careful tracing over guessing.
• Know Java's primitive types and that integer division truncates ($7/2$ gives $3$); use a cast or a double for real division.
• Distinguish compile-time errors (syntax, types) from run-time errors – know the named ones: ArithmeticException (int ÷ 0), NullPointerException (method on a null reference), StringIndexOutOfBoundsException / ArrayIndexOutOfBoundsException – and logic errors (wrong output).
• Follow operator precedence and initialise every variable before you use it.
• On the free-response, write complete, compilable Java — return the right type and match the method header exactly.