Class Creation

Abstraction means hiding details so you can focus on the main idea. Data abstraction names data (like a class's attributes) without showing how it's stored, and procedural abstraction lets you use a method knowing only what it does. Breaking a big behavior into smaller methods, and planning classes with diagrams, makes programs easier to build and reuse.

A reliable program does what it should under the stated conditions, which is why you test it with many kinds of input. Programs can help or harm society, the economy and culture, sometimes in ways nobody intended, and reusing someone else's code raises legal questions: open-source code is free to use under its license, but other code needs permission.

Every class you write starts with a header like public class Name, followed by a body with its instance variables, constructors and methods. Encapsulation means hiding a class's inner details: instance variables are private, so only the class itself can use them, while public methods and constructors give other classes controlled access. Each object gets its own copy of the instance variables.

An object's state is the current values of its instance variables (the object has-a name, has-a score, and so on). A constructor sets that starting state, usually from its parameters, and if a parameter is a mutable object, the safe move is to store a copy, not the caller's reference. If you write no constructor, Java supplies a no-parameter default one, and the instance variables start at 0, 0.0, false or null.

A void method does a job and returns nothing, while a non-void method returns one value of its declared type. Accessor methods (getters) hand back a copy of an instance variable's value, and mutator methods (setters) change it. A return statement exits the method right away, and changing a primitive parameter never changes the caller's variable.

When you pass an object to a method, the parameter gets a copy of the reference, not a copy of the object, so the method can change the original object's state. Returning an object also returns a reference. A method can use the private data of a parameter only when that parameter's type is the method's own class.

A static (class) variable is shared by every object of the class, unlike an instance variable, where each object has its own copy. Static methods can work with static variables and call other static methods, but there's no object behind them, so they can't use instance variables or instance methods unless an object is passed in. A variable marked final can't be changed once it has a value.

A local variable, including a parameter, exists only inside the block where it's declared and can't be marked public or private. When a parameter or local variable has the same name as an instance variable, that name means the local one inside the method or constructor; this is called shadowing.

Inside a constructor or instance method, this refers to the current object, the one the method was called on. You often see this.name = name to set an instance variable when a parameter has the same name, and you can pass this as an argument. Static methods have no this.