Revision approach
- Object design and Java rule tracing
- Java17 bank baseline
- Modern interface differences
- Java25 constructor differences
- Blueprint: six items
👁 Full explanation
Design with objects, then trace the Java rules that make the design run. Java 17 is the baseline for these examples; modern interface rules and Java 25 constructor differences are explained where relevant. The official allocation is six items. - Separate references from objects
- Constructor state tracing
- Field state tracing
👁 Full explanation
Draw separate boxes for reference variables and objects, then trace constructor and field state changes. - Call-resolution sequence
- Visibility and declared type
- Compile-time overload selection
- Runtime overriding
👁 Full explanation
For a call, check visibility and declared type first, overload selection second, runtime overriding third. - Interface hierarchy practice
- Valid implementations
- Checked exception
- Safe downcast
- Compiler repairs before output prediction
👁 Full explanation
Practice one small interface hierarchy with valid implementations, a checked exception and a safe downcast; repair compiler errors before predicting output.
OOP01
Objects, classes and responsibilities
[Exam Focus]- Object versus class
- Identity, state, behavior
- Fields store state
- Methods provide behavior
- Rectangle: width, height
- getArea(), getPerimeter()
- Equal fields, distinct identities
- Class: common structure and behavior
- Object: particular instance
👁 Full explanation
An object has identity, state and behavior. State is stored in fields; behavior is provided by methods. A Rectangle object may hold width and height and answer getArea() or getPerimeter(). Two objects can have equal fields and still be distinct objects. A class defines their common structure and behavior; an object is a particular instance. - Responsibility-driven classes
- Account controls balance
- Transaction records payment
- Service coordinates objects
- Messages: method calls, obj.add()
- Delegation to other objects
- Objects manage own state
- Procedural and OO reuse
- Procedural global shared data optional
👁 Full explanation
Choose classes around responsibilities: an account controls its own balance, a transaction records a payment, and a service coordinates them. Objects send messages through method calls such as obj.add(). They can delegate work to other objects; saying that objects cannot manage their own state is misleading. Procedural and object oriented designs both support reuse; global shared data is not compulsory in procedural programming.
6 related practice questions
Blueprint: OOP1, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Object versus class
OOP02
Encapsulation, hiding and abstraction
[Exam Focus]- Encapsulation, hiding and abstraction
- Encapsulation: state/operations grouped, access controlled
- Information hiding: implementation behind stable interface
- Abstraction: essential operations, irrelevant details omitted
- private balance plus deposit(amount)
- Overlapping principles, question emphasis matters
👁 Full explanation
Encapsulation groups related state and operations and controls access. Information hiding keeps implementation decisions behind a stable interface. Abstraction presents the essential operations while omitting details irrelevant to the caller. These ideas overlap: a private balance plus deposit(amount) can demonstrate all three, depending on what the question emphasizes. - Inheritance and polymorphism
- Inheritance: subtype relationship, possible implementation reuse
- Common type, concrete-specific behavior
- Fields/methods wrapping: encapsulation
- What versus how: abstraction
- Precise mechanism over vague slogan
👁 Full explanation
Inheritance forms a subtype relationship and may reuse implementation. Polymorphism lets code using a common type invoke behavior appropriate to different concrete objects. Prefer a precise mechanism over a vague slogan: wrapping fields and methods points to encapsulation; showing what an operation does while hiding how points to abstraction.
11 related practice questions
Blueprint: OOP1, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Encapsulation, hiding and abstraction
OOP03
References, instances and value passing
[Exam Focus]- Reference declaration versus object creation
- Student s;: reference only
- new Student(): allocate and initialize
- s.name, s.study(): visibility-dependent access
- t=s: reference copy
- Shared object aliasing
- Mutation through t visible through s
👁 Full explanation
Student s; declares a reference variable; it creates no Student object. Student s=new Student(); allocates and initializes an instance. Member access uses s.name or s.study(), subject to visibility. Assignment t=s copies a reference, so both can refer to the same object; changing that object through t is observable through s. - Java value passing and reachability
- All arguments passed by value
- Copied reference permits shared-object mutation
- Parameter reassignment leaves caller reference unchanged
- Unreachable objects reclaimable
- Collection timing unspecified
- Reachable cycles may retain objects
- Unreachable cycles collectible
👁 Full explanation
Java passes all arguments by value. Passing a reference copies it: a method may modify the shared object, but assigning its parameter to a new object does not reassign the caller’s reference. The runtime may reclaim unreachable objects; collection timing is unspecified. Reachable object cycles can matter for retention, but an unreachable cycle can be collected.
4 related practice questions
Blueprint: OOP1 · Note references: OOP-M, OOP-N, OOP-G
- Reference declaration versus object creation
OOP04
UML class and instance notation
[Exam Focus]- UML class box
- Name, attributes, operations
- + public, - private, # protected
- name:String
- getName():String
- Student(String,String,String,int)
- Three strings plus integer
- Age "25": wrong argument type
👁 Full explanation
A UML class box normally contains name, attributes and operations. Visibility uses + public, - private and # protected. A field can be written name:String and an operation getName():String. A constructor Student(String,String,String,int) requires three strings and an integer, so an age argument "25" has the wrong type. - UML instance notation
- Underlined instanceName:ClassName
- sara:Student
- Class notation: type
- Instance notation: particular object
- Optional slot values
- Static-feature underlining: different meaning
- Whole notation determines interpretation
👁 Full explanation
An instance is conventionally labeled with an underlined instanceName:ClassName, such as sara:Student. Class notation describes a type; instance notation describes one particular object and may show its slot values. Underlining static class features has a different purpose; read the whole notation rather than assuming every underline means the same thing.
2 related practice questions
Blueprint: OOP1 · Note references: OOP-M, OOP-N, OOP-G
- UML class box
OOP05
Variables, defaults and initialization
- Local, instance and static variables
- Locals: methods, constructors, blocks
- Definite assignment before use
- Locals: no public/private/protected
- Fields: class, outside method bodies
- Instance fields: per object
- Static fields: per class
- Location alone doesn't distinguish field kinds
👁 Full explanation
The introductory three-way grouping is local, instance and class/static variables. Locals occur in methods, constructors or blocks; they must be definitely assigned before use and cannot have public/private/protected modifiers. Fields occur in a class outside method bodies; non-static fields belong to each instance, while static fields belong to the class. Declaration location alone does not distinguish instance and static fields. - Java defaults and initialization
- Fields and array elements defaulted
- Numeric zero, char '\u0000'
- boolean false, references null
- Unassigned local int t: compilation error
- int a=10,b=10: initial values
- final local permitted
- final isn't access modifier
👁 Full explanation
Java fields and array elements receive defaults: numeric zero, char '\u0000', boolean false and references null. A local int t; followed by printing t is a compilation error. Initializers such as int a=10,b=10; assign initial values. A final local is permitted; final is not an access modifier.
10 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Local, instance and static variables
OOP06
Primitive types and conversions
- Java primitive and reference types
- byte, short, int, long
- Signed widths: 8,16,32,64 bits
- byte: -128..127
- short: -32768..32767
- float, double, char, boolean
- char: unsigned 16-bit UTF-16 unit
- Digit, letter, symbol, not whole String
- enum and String: reference types
👁 Full explanation
Java has byte, short, int, long, float, double, char and boolean. Signed integer widths are 8,16,32,64 bits respectively. byte ranges from -128 to 127; short from -32768 to 32767. char is an unsigned 16-bit UTF-16 code unit and can hold a digit, letter or symbol, not a whole String. enum and String are reference types. - Conversions and arithmetic promotion
- Compatible widening often implicit
- Narrowing usually explicit, possibly lossy
- int→float widening may lose precision
- Widening-losslessness claim false
- char/byte/short often promoted to int
- boolean ↔ numeric conversion forbidden
- if(0), numeric-zero loop condition: invalid
👁 Full explanation
A compatible widening conversion often needs no cast; narrowing usually needs an explicit cast and may lose information. Widening an int to float can lose precision, so “widening never loses information” is false. Arithmetic promotes char, byte and short to int in many expressions. boolean does not convert to or from numeric truth values; if(0) and for(...;0;...) are invalid.
11 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Java primitive and reference types
OOP07
Static members and final
- Static class members
- One field per loaded class
- Shared across instances
- Three constructor increments: count=3
- Prefer ClassName.count, ClassName.utility()
- Static method: no current instance
- Explicit object permits instance-member access
👁 Full explanation
static gives one field per loaded class, shared by its instances. If count starts at zero and every constructor increments it, three creations leave count=3. Prefer ClassName.count and ClassName.utility(). A static method has no current instance, but can still use instance members through an explicit object reference. - Static initialization and final
- Class initialization before relevant active use
- Not merely file loading
- final variable: no reassignment
- final method: no overriding
- final class: no extension
- final reference may target mutable object
- PI: static final candidate
- Student name: normally instance state
- Parameter-only calculation: possible static method
👁 Full explanation
A static initializer runs during class initialization, before the class’s first relevant active use, not simply whenever a file is loaded. final prevents reassignment of a variable, overriding of a method or extension of a class. A final reference may still refer to a mutable object. A shared mathematical PI is a good static final candidate; a student name normally belongs to an instance. A calculation using only parameters may be static.
13 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Static class members
OOP08
Access control and packages
- Java access boundaries
- private: declaring class/nest
- No modifier: package access
- protected: package plus qualified subclass access
- public: widest ordinary access
- Declaring type must be accessible
- Top-level class/interface: public or package-private
- Top-level private/protected forbidden
- Member types: additional visibility possibilities
👁 Full explanation
For ordinary members: private restricts access to the declaring class/nest; no modifier grants package access; protected grants same-package access plus qualified subclass access; public is widest, provided the declaring type itself is accessible. Top-level classes/interfaces may be public or package-private, not protected/private. Member types have additional visibility possibilities. - Protected access across packages
- Own inherited context allowed
- Appropriate subclass-typed receiver allowed
- Arbitrary superclass receiver disallowed
- Same-package unrelated classes also allowed
- protected ≠ subclasses only
- Own main accesses own instance's private fields
👁 Full explanation
Across packages, a subclass accessing a protected instance member must do so through its own inherited context or an appropriate subclass-typed receiver, not any arbitrary superclass object. protected therefore does not mean “subclasses only”: unrelated classes in the same package also have access. A class’s own main method can access private fields of an instance of that class.
16 related practice questions
Note references: OOP-M, OOP-G, OOP-A
- Java access boundaries
OOP09
Constructors and generated defaults
[Exam Focus]- Constructor identity and purpose
- Exact class name
- No return type, including void
- Initialize new object
- Overloaded/private constructors permitted
- Private: factory or controlled singleton
- Internal object creation still possible
👁 Full explanation
A constructor has the class’s exact name and no return type, not even void. It initializes the new object and can be overloaded or private. A private constructor can support a factory or controlled singleton creation; it does not mean the class can never create an object internally. - Default-constructor conditions
- No declared constructor → compiler default
- Circle(double r) suppresses generated no-arg
- new Circle(): explicit no-arg then required
- Constructors neither inherited nor overridden
- return; allowed, return expression forbidden
- Field defaults precede ordinary constructor initialization
- Defaults independent of generated constructor
👁 Full explanation
If a class declares no constructor, Java supplies a default constructor. If Circle(double r) is declared, new Circle() fails unless a no-argument constructor is also declared. Constructors are not inherited or overridden. They may contain return; but cannot return an expression. Fields get their default values before ordinary constructor initialization, rather than receiving defaults only because a default constructor was generated.
9 related practice questions
Blueprint: OOP1, OOP2 · Note references: OOP-M, OOP-N, OOP-G
- Constructor identity and purpose
OOP10
Constructor chains and initialization order
[Exam Focus]- Java17 constructor delegation
- this(args)/super(args): first statement
- this: same-class constructor
- super: immediate parent constructor
- Cannot explicitly invoke both
- Absent explicit delegation: implicit super()
- Accessible matching no-arg parent required
👁 Full explanation
Under Java 17 rules, an explicit this(args) or super(args) invocation must be the first constructor statement. this invokes another constructor in the same class; super invokes the immediate superclass constructor. A constructor cannot explicitly invoke both. If there is no explicit delegation, an implicit super() is inserted; a matching accessible no-argument parent constructor must exist. - Construction order and version conditions
- Parent construction first
- Subclass field initializers/instance blocks in order
- Relevant subclass constructor body last
- FinalExam parent: num1=4
- Subclass initializer: num=3
- this(5): num=25
- No-arg body: num1=num=25
- Java25: restricted pre-invocation statements
- First-statement rule requires version qualification
👁 Full explanation
Trace parent construction first, then subclass field initializers and instance blocks in order, then the relevant subclass constructor body. With consistent class and constructor names and this(5) chaining in the FinalExam example, the parent sets num1=4, the subclass initializes num=3, this(5) sets num=25, and the no-arg body sets num1=num, leaving 25. Java 25 permits restricted statements before explicit constructor invocation; the older first-statement rule must be version qualified.
5 related practice questions
Blueprint: OOP2 · Note references: OOP-M, OOP-N, OOP-V
- Java17 constructor delegation
OOP11
Methods, accessors and mutators
[Exam Focus]- Method structure and invocation
- Modifiers, return type, name
- Parameter list and body
- public int getAge(){return age;}
- void: no returned value
- Parameters: declared inputs
- Arguments: call-supplied values
- object.method(): instance call
- Implicit this in suitable instance context
👁 Full explanation
A method has modifiers, return type, name, parameter list and body: public int getAge(){return age;}. A void method returns no value. Parameters name the inputs in the declaration; arguments supply values at a call. An instance method can be invoked as object.method(), or with an implicit this inside suitable instance context. - Accessors, mutators and validation
- Getter: return information
- Setter: change state
- Useful operations over blanket setters
- Validate state changes
- deposit: reject negative amounts
- Separate subclass: private parent field inaccessible
- this.field doesn't bypass access
- Use permitted parent operation
👁 Full explanation
An accessor/getter returns information; a mutator/setter changes state. Encapsulation does not require blindly generating setters for every field: validate changes and expose only useful operations. For a bank account, deposit must reject negative amounts. A private field cannot normally be accessed directly by a separately declared subclass, even with this.field; use a permitted parent operation.
6 related practice questions
Blueprint: OOP1, OOP2, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Method structure and invocation
OOP12
Overloads and compile-time selection
[Exam Focus]- Method overload distinctions
- Same name, different types/count/type order
- Return type alone insufficient
- Java and C++ rule
- Inherited methods can form overloads
- Same-class-only claim simplified
- f(int), f(double), f(int,int)
- Parameter-name change: no overload
👁 Full explanation
Overloaded methods share a name but have different parameter types, counts or type order. Return type alone is insufficient in Java and C++. Overloads can also arise through inherited methods; “same class only” is a teaching simplification. f(int), f(double) and f(int,int) are distinct, but changing a parameter name does not create an overload. - Compile-time overload selection
- Declared argument types and conversions
- Exact int preferred over double widening
- Return type outside ordinary Java signature
- Different signature versus inherited-signature override
👁 Full explanation
The compiler selects the applicable signature from the declared argument types and conversions. int arguments usually choose an exact int overload rather than a wider double overload. A return type is not part of an ordinary Java method signature. Distinguish a different signature from overriding an inherited signature.
5 related practice questions
Blueprint: OOP2 · Note references: OOP-M, OOP-N, OOP-G
- Method overload distinctions
OOP13
Inheritance and composition
[Exam Focus]- Class inheritance forms
- Dog extends Animal
- Subclass/derived/child, superclass/base/parent
- One direct superclass
- Multiple implemented interfaces
- Single: one parent
- Multilevel: inheritance chain
- Hierarchical: siblings share parent
- extends Animal,Mammal: invalid Java
👁 Full explanation
class Dog extends Animal declares a subclass/derived/child of a superclass/base/parent. A class extends one direct class and can implement multiple interfaces. Single, multilevel and hierarchical inheritance mean one parent, a chain, and several children of one parent. Java does not permit class Dog extends Animal,Mammal. - Contract-based inheritance versus composition
- Subtype satisfies parent contract
- Dog is an Animal
- Pet: common name and speak contract
- Dog: specialized fetch
- Dog/Cat: appropriate speak implementations
- Composition: has-a
- Car contains Engine
- Reuse alone doesn't justify is-a
👁 Full explanation
Use inheritance when a subtype can satisfy the parent’s contract: Dog is an Animal. For shared Pet.name and speak(), put common state/contract in Pet, specialized fetch() in Dog, and appropriate speak() implementations in Dog and Cat. Composition represents has-a, such as Car containing Engine. Reuse alone does not justify an invalid is-a relationship.
17 related practice questions
Blueprint: OOP1, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Class inheritance forms
OOP14
Overriding rules
[Exam Focus]- Override eligibility and restrictions
- Inherited instance method, same signature
- Compatible return type
- Covariant reference return subtype
- Visibility cannot narrow
- Checked exceptions cannot broaden incompatibly
- @Override: compiler-checking annotation
- No Java override keyword
- Constructors/final/static/private methods: no overriding
👁 Full explanation
A subclass overrides an eligible inherited instance method with the same signature and a compatible return type; a covariant reference return may be a subtype. Visibility cannot become more restrictive, and checked exceptions cannot be broadened incompatibly. @Override requests compiler checking; Java has no override keyword. Constructors, final methods, static methods and private parent methods are not overridden. - Independent declaration versus override
- Private-parent same signature: independent child declaration
- No runtime overriding
- No ordinary static-method hiding
- Concrete subclass implements inherited abstract method
- Unrelated same-name methods: no overriding
👁 Full explanation
A same-signature child method matching a private parent method is an independent declaration, not runtime overriding and not ordinary static-method hiding. An abstract inherited method is implemented by an overriding method in a concrete subclass. Merely reusing a name in two unrelated classes does not establish overriding.
8 related practice questions
Blueprint: OOP1, OOP2 · Note references: OOP-M, OOP-N, OOP-G
- Override eligibility and restrictions
OOP15
Declared types and dynamic dispatch
[Exam Focus]- Declared type versus runtime class
- Animal a=new Dog()
- Animal: declared, Dog: actual
- Declared type controls compilable operations
- Dog-only fetch: a.fetch() fails
- Eligible sound override: Dog.sound() runtime
👁 Full explanation
For Animal a=new Dog(), Animal is the declared type and Dog the actual type. The declared type determines which member operations compile. If fetch() exists only in Dog, a.fetch() fails compilation. For an eligible overridden sound(), a.sound() invokes Dog.sound() at runtime. - Dispatch-solving sequence
- Declaration and visibility first
- Compile-time signature second
- Runtime class and most-specific override third
- Animal[]{Dog,Cat}: common speak loop
- New subclasses supply behavior
- Generic loop unchanged: extensibility
👁 Full explanation
To solve dispatch questions: check the declaration and visibility, determine the compile-time signature, then identify the object’s runtime class and its most specific override. An array Animal[]{new Dog(),new Cat()} can call speak() on each using one loop. New subclasses can supply behavior without rewriting this generic loop, which is the practical meaning of extensibility.
14 related practice questions
Blueprint: OOP1, OOP2, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Declared type versus runtime class
OOP16
this, super and hiding
- this, super and field selection
- this: current object
- this.name=name: field versus parameter
- super.name: hidden parent field
- super.sound(): parent implementation
- No second parent object
- Unqualified instance call may dispatch dynamically
- Explicit super call differs
👁 Full explanation
Java this denotes the current object; this.name=name distinguishes a field from a parameter. super.name selects a hidden superclass field; super.sound() directly requests the parent implementation. It does not create a second parent object. An unqualified instance call may dispatch dynamically; an explicit super call is different. - Field and static-method hiding
- Fields aren't dynamically overridden
- Same-signature static methods hide
- Animal a=new Dog(): static resolves Animal
- Prefer Animal.staticMethod()
- Static context: no current this/super
👁 Full explanation
Fields are hidden rather than dynamically overridden, and same-signature static methods hide rather than override. With Animal a=new Dog(), a.staticMethod() resolves using Animal’s compile-time type. Prefer Animal.staticMethod() for clarity. Java this and super are unavailable as current-instance references in static context.
9 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- this, super and field selection
OOP17
C++ this and object rules
- C++17 this pointer
- Ordinary non-static member function
- Pointer to called object
- this->field: member selection
- Implicit object argument explanation
- Member variables don't receive argument
- Static member function: no this
👁 Full explanation
In ordinary C++17 non-static member functions, this is a pointer to the object on which the function is called; this->field selects a member. It is often explained as an implicit object argument to a member function call. It is not an argument passed to member variables, and a static member function has no this pointer. - C++ versus Java object rules
- Base-pointer/reference dispatch requires virtual
- C++: multiple class inheritance
- Java: multiple interface types
- C++ object-value assignment may copy object
- Java class-variable assignment copies reference
- Check dispatch and memory-management assumptions
👁 Full explanation
C++ runtime polymorphism requires a virtual function when calling through a base pointer/reference. C++ may inherit multiple classes; Java permits multiple interface types instead. C++ object-value assignment can copy an object, whereas assigning Java class variables copies references. Never transfer Java dispatch or memory-management assumptions to a C++ question without checking the code.
2 related practice questions
Note references: OOP-T, OOP-M
- C++17 this pointer
OOP18
Abstract classes and implementations
[Exam Focus]- Abstract class capabilities
- No direct instantiation
- Fields, constructors, concrete methods allowed
- Abstract methods allowed, not required
- Abstract method: no body
- abstract plus final: conflicting requirements
- Required versus forbidden overriding
👁 Full explanation
An abstract class cannot be directly instantiated but can define fields, constructors, abstract methods and concrete methods. It need not contain an abstract method. An abstract method has no body; abstract and final conflict because an operation cannot require overriding while forbidding it. - Concrete implementation obligations
- Provide/inherit all required abstract implementations
- Otherwise subclass must remain abstract
- Required: String welcome()
- int welcome(): incompatible return
- welcome(int): overload only
- Valid implementation plus unrelated overload allowed
👁 Full explanation
A concrete subclass must provide or inherit implementations of all required abstract methods; otherwise it must itself be abstract. If parent declares abstract String welcome(), a String welcome() implementation is required; int welcome() is incompatible, and welcome(int) merely adds an overload. A valid class can contain both the required implementation and an unrelated overload.
10 related practice questions
Blueprint: OOP1, OOP2, OOP3 · Note references: OOP-M, OOP-N, OOP-G
- Abstract class capabilities
OOP19
Interfaces and modern Java
[Exam Focus]- Interface contract and implementation
- Payable: double getPaymentAmount()
- Implicit public abstract operation
- Invoice implements Payable
- Required public double getPaymentAmount()
- getQuantity()*getPricePerItem()
- Class: superclass plus zero/multiple interfaces
- Interface extends multiple interfaces
- No instance fields or constructors
- Fields: public static final
👁 Full explanation
interface Payable{double getPaymentAmount();} declares an abstract public operation. class Invoice implements Payable must provide public double getPaymentAmount(), perhaps returning getQuantity()*getPricePerItem(). A class can extend a superclass and implement zero or more interfaces. An interface can extend several interfaces. No interface instance fields or constructors exist; fields are implicitly public static final. - Modern interface method rules
- No private/default/static: public abstract
- default/static methods may have bodies
- Java9+: private helpers
- All-interface-methods-bodyless claim outdated
- All inherited abstract contracts satisfied
- Suitable public implementation may be inherited
- No direct interface instantiation
- References hold implementing objects
- Anonymous implementations
- Suitable functional-interface lambdas
👁 Full explanation
A method declaration without private, default or static is implicitly public abstract. Modern interfaces may also have default/static method bodies, and Java 9+ private helper methods. Not every interface method must lack a body in modern Java. Implementations must satisfy all inherited abstract contracts; they may inherit suitable public implementations. Interfaces cannot be instantiated directly, but references may hold implementing objects, anonymous implementations or suitable functional-interface lambdas.
17 related practice questions
Blueprint: OOP1, OOP2, OOP3 · Note references: OOP-M, OOP-N, OOP-G, OOP-I
- Interface contract and implementation
OOP20
Defaults, conflicts and class choice
- Abstract class versus interface choice
- Abstract class: shared state/construction/implementation
- Interface: unrelated-class capability
- Multiple type inheritance
- Concrete class method beats interface default
- Inherited abstract class declaration may prevail
- Concrete subclass may need explicit implementation
👁 Full explanation
Use an abstract class for shared state, construction and common implementation; use an interface for a capability across unrelated classes and multiple type inheritance. A concrete inherited class method takes precedence over an interface default. An inherited abstract class declaration can require a concrete subclass to implement the operation rather than silently adopting a default. - Interface conflicts and diamond ambiguity
- Unrelated conflicting defaults: explicit resolution
- Interfaces don't eliminate all diamond ambiguity
- Same compatible abstract signature: one public implementation
- Conflicting return types/contracts may be impossible
- Abstract versus implemented status matters
- Signature compatibility determines answer
👁 Full explanation
Unrelated interfaces providing conflicting defaults require an explicit resolution; interfaces do not remove every diamond ambiguity. If two compatible interfaces merely declare the same abstract signature, one public implementation can satisfy both. If return types or other contracts conflict, additional declarations may still be impossible. The answer to “same method in abstract class and interface” depends on whether each is abstract or implemented and whether their signatures are compatible.
3 related practice questions
Note references: OOP-M, OOP-I
- Abstract class versus interface choice
OOP21
Casts and instanceof
- Upcasting versus downcasting
- Implicit upcast leaves object unchanged
- Downcast: compile-time acceptance, runtime risk
- Car a=new Car()
- (Ferrari)a: ClassCastException
- Later drive()/brake() calls unexecuted
- Cast doesn't transform object
👁 Full explanation
Upcasting a subclass reference to a superclass is implicit and does not change the object. A downcast may pass compile-time type checks yet fail at runtime. Car a=new Car(); Ferrari f=(Ferrari)a; throws ClassCastException before subsequent drive() or brake() calls. It does not turn a plain Car into a Ferrari. - Safe narrowing and null
- instanceof before uncertain downcast
- null instanceof Ferrari: false
- Casting null yields null
- Dereferencing null fails
- Object obj="Hello": (String)obj succeeds
- (Integer)obj: ClassCastException
- 'Hello': invalid Java literal
- Clarify single-quoted bank version first
👁 Full explanation
Use if(a instanceof Ferrari) before narrowing when the dynamic type is uncertain. null instanceof Ferrari is false; casting null yields null, although dereferencing it fails. For Object obj="Hello", (String)obj succeeds and (Integer)obj throws ClassCastException. A literal 'Hello' is invalid Java syntax; use double quotes for a string literal before tracing the program.
4 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Upcasting versus downcasting
OOP22
Identity, equality and immutable strings
- Identity, equality and representation
- Reference ==: identity
- equals: class equality policy
- Object.equals: identity unless overridden
- String.equals: character content
- Equal objects require equal hashCode
- toString: textual representation, not equality
👁 Full explanation
For object references, == tests identity; equals invokes the class’s equality policy. Object.equals uses identity unless overridden; String.equals compares character content. Equal objects must have equal hashCode values when that contract is implemented. toString gives a textual representation, not an equality test. - Immutable String and text APIs
- text += " World": new concatenated result
- Hello World without original String mutation
- final String class: no subclassing
- final alone doesn't ensure arbitrary immutability
- charAt(index): char
- length(): UTF-16 units
- substring(begin,end): exclusive end
- Character.toUpperCase(ch): character conversion
- matches(String regex): regular-expression parameter
👁 Full explanation
Java String objects are immutable. text += " World" assigns a reference to a new concatenated result and can print Hello World without mutating the original String object. final class String prevents subclassing; final alone does not make arbitrary objects immutable. charAt(index) returns a char; length() counts UTF-16 units; substring(begin,end) excludes end. Character.toUpperCase(ch) converts a character, and matches(String regex) takes a regular-expression parameter named regex.
12 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Identity, equality and representation
OOP23
Numeric, bitwise and Boolean expressions
- Java expression tracing
- Left-to-right operand evaluation with precedence
- n=6,m=15,p=3: n-=m,n*=p → -27
- 6-2+10%4+7=13
- 8-2*5*(3+9/3)+6/3=-50
- Integer 6/4=1
- Double 6.0/4=1.5
- Java % accepts floating operands
- C++ % differs
👁 Full explanation
Java evaluates operands left to right while respecting precedence. With n=6,m=15,p=3, n-=m then n*=p leaves -27. 6-2+10%4+7 is 13. In 8-2*5*(3+9/3)+6/3, the result is -50. Integer 6/4 is 1; double 6.0/4 is 1.5. Unlike C++, Java % also accepts floating-point operands. - Bitwise and Boolean operations
- Binary-column method
- 11&9=9
- 9^3=10
- 10|12=14
- &&, ||: Boolean short circuit
- Boolean &, |: no short circuit
- Printed true: lowercase
- Neither 1 nor TRUE
👁 Full explanation
For bitwise values, write binary columns: 11&9=9; 9^3=10; 10|12=14. && and || short circuit Boolean operands; & and | can also operate on Boolean values without short circuiting. Printing Boolean true gives lowercase true, not 1 or uppercase TRUE.
15 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Java expression tracing
OOP24
Increment order and concatenation traps
- Increment and character-space trap
- x=5: x++ then ++x → 5,7
- y=++x*x--: 6*6=36
- Final x=5
- x + ' ' + y: arithmetic
- Space char value=32
- println result: 73
- x + " " + y: separation
👁 Full explanation
Starting x=5, printing x++ then ++x gives 5 then 7. For int y=++x*x--, Java uses 6*6=36 and leaves x=5. System.out.println(x + ' ' + y) then adds char space’s numeric value 32, so it prints 73. To print separated values, use x + " " + y instead. - String concatenation grouping
- Left-to-right + groups
- String operand starts concatenation
- 1+2+"x" → "3x"
- "x"+1+2 → "x12"
- Single-quoted space doesn't separate values
- String concatenation and evaluation order
👁 Full explanation
Once a String operand is encountered, + concatenates in left-to-right groups: 1+2+"x" gives "3x", while "x"+1+2 gives "x12". When x and y are numeric, x + ' ' + y performs numeric addition; x + " " + y concatenates a separating space. Use the expression’s operand types to determine the result.
2 related practice questions
Note references: OOP-G, OOP-X
- Increment and character-space trap
OOP25
Control-flow traces and exact output
- Control flow and exact printing
- while/for: pre-test, possibly zero
- do-while: post-test, at least once
- break: exit loop
- continue: remaining body skipped
- for continue then update
- Colon switch: fall-through without break
- Choice 1: Hello then you
- break then outside Goodbye
- default skipped
👁 Full explanation
while and for pre-test and may execute zero times; do-while post-tests and executes once. break exits the loop; continue skips its remaining body and then runs a for update. Traditional colon-style switch labels fall through without break. Choice 1 printing Hello then case 2 printing you and breaking is followed by Goodbye outside the switch; default is skipped. - Execution counts versus printing
- i=0..4: conditional even-i print
- Unconditional print(i+1)
- Exact output: "0 122 344 5"
- Sum j=1..10: 55
- if(a) then else if(a&&b)
- Second condition unreachable as true
- Reached else implies a=false
👁 Full explanation
Count executions independently from printing. For i=0..4, if(i%2==0) print(i+" "); followed unconditionally by print(i+1); produces "0 122 344 5". A loop summing j=1..10 yields 55. In if(a)... else if(a&&b)..., the second condition can never be true on a path reaching it because a is already false.
12 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Control flow and exact printing
OOP26
Array creation, bounds and ragged rows
- Array declarations and component types
- int[] a=new int[5]: valid
- int a[]={1,2,3}: valid
- int[] a={}: zero-length
- Declaration initializer needn't use new
- int a[],b: only a array
- int[] c,d: both arrays
- Object length fixed after creation
- Reference may be reassigned
- Common declared component type
- Superclass/interface component type permitted
👁 Full explanation
int[] a=new int[5]; and int a[]={1,2,3}; are valid. int[] a={}; creates a zero-length array; explicit new is unnecessary in a declaration initializer. int a[],b; makes only a an array; int[] c,d; makes both arrays. Array objects have fixed length after creation, although the reference may be reassigned. Elements have a declared common component type, which may be a superclass/interface. - Bounds and ragged arrays
- Valid indices: 0..a.length-1
- Invalid access: ArrayIndexOutOfBoundsException
- Two-dimensional: arrays of arrays
- Ragged {{12,-9,8},{7,14},{-32,-1,0}}
- Row lengths: 3,2,3
- No portable physical-contiguity guarantee
- No raw-address assumptions
👁 Full explanation
Valid indices are 0..a.length-1; an invalid access throws ArrayIndexOutOfBoundsException. Java two-dimensional arrays are arrays of arrays and may be ragged: {{12,-9,8},{7,14},{-32,-1,0}} has row lengths 3,2,3. Java does not expose a portable physical contiguity guarantee, so a language-level answer should not rely on raw addresses.
15 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Array declarations and component types
OOP27
Array algorithms, sorting and copying
- Array sum and average
- Four elements: a[i]=i*3
- Sum: 0+3+6+9=18
- Average: sum every element
- Floating division by length
- Zero length handled separately
- Representation/printing versus rounded result
- Bank mean: 98.8/6≈16.46666667
- Not exact printed-string assertion
👁 Full explanation
For int[] a=new int[4], setting a[i]=i*3 and accumulating yields 0+3+6+9=18. To average an array, sum every element and divide by its length using floating arithmetic; handle zero length separately. Floating representations and printing can differ from a rounded mathematical result. For the six-value example, the mathematical average is 98.8/6, approximately 16.46666667; the exact printed string also depends on floating representation and formatting. - Array sorting, copying and aliasing
- java.util.Arrays.sort(a): in-place
- System.arraycopy(src,srcPos,dst,dstPos,length)
- Existing destination array
- arraycopy: lowercase c
- Arrays.copyOf(a,n): new copy
- a=b: same-array alias
- Random access: reliable advantage
- Size bounded by resources/implementation
👁 Full explanation
java.util.Arrays.sort(a) sorts in place. System.arraycopy(src,srcPos,dst,dstPos,length) copies into an existing array; its exact spelling uses lowercase c. Arrays.copyOf(a,n) creates a copy. a=b merely aliases the same array. Random access is the reliable array advantage; size is bounded by implementation/resources, not unlimited.
4 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Array sum and average
OOP28
Packages, imports and Java tools
[Exam Focus]- Packages and import order
- package p; before imports
- Imports before top-level declarations
- import p.*: accessible p types
- No automatic p.sub imports
- Name organization and access control
- Subpackages gain no special access
- java.lang: implicit import
- java.util: utilities
- java.io: I/O
- java.awt: Button, Checkbox
👁 Full explanation
package p; precedes imports; imports precede top-level type declarations. import p.*; imports accessible types from p as needed, not types in p.sub automatically. Packages organize names and control access; hierarchical spelling does not grant special access between a package and its subpackages. java.lang is implicitly imported; java.util supplies utilities; java.io supplies I/O; java.awt includes Button and Checkbox. - Compilation, launch and identifiers
- javac Test.java → bytecode
- java Test → class launch
- Modern java Test.java: source-file launch
- Unrestricted run question: multiple answers possible
- Public top-level type: matching filename
- Class/method capitalization: conventions
- Identifiers case sensitive
- $ allowed, @ forbidden
👁 Full explanation
Ordinary compilation uses javac Test.java, producing bytecode, then java Test launches the class. Modern Java can also launch a source file using java Test.java; distinguish source-file launch from running a compiled class. For ordinary public top-level types, filename and type name match. Capitalized class names and lowercase method names are conventions, not universal syntax requirements. Java identifiers are case sensitive; $ is allowed but @ is not an identifier character.
18 related practice questions
Blueprint: OOP2 · Note references: OOP-M, OOP-N, OOP-G
- Packages and import order
OOP29
Exception hierarchy and checked obligations
[Exam Focus]- Throwable hierarchy and source errors
- Throwable → Exception, Error
- RuntimeException/Error subclasses: unchecked
- Other throwable classes: checked
- IOException, FileNotFoundException, SQLException: checked
- ArithmeticException, NullPointerException: unchecked
- ClassCastException, array bounds exceptions: unchecked
- Missing semicolon/undeclared variable: source errors
- Source errors aren't checked exceptions
👁 Full explanation
Throwable is the root of throwable values, with Exception and Error branches. RuntimeException and Error subclasses are unchecked; other throwable classes are checked. IOException, FileNotFoundException and SQLException are standard checked examples. ArithmeticException, NullPointerException, ClassCastException and array bounds exceptions are unchecked. A missing semicolon or undeclared variable is a compile-time source error, not a checked exception. - Checked obligations versus runtime throwing
- Compiler checks catch-or-declare obligation
- Actual exception thrown at runtime
- Custom extends Exception or RuntimeException
- Error: normally serious conditions
- Routine recovery usually inappropriate
- Catching Error technically possible
👁 Full explanation
Checked does not mean the exception occurs at compile time: the compiler checks an obligation to catch or declare it, while an actual throw occurs at runtime. A custom exception can extend Exception or RuntimeException. Error normally signals serious conditions for which routine recovery is inappropriate; it is not technically impossible to catch an Error.
8 related practice questions
Blueprint: OOP2 · Note references: OOP-M, OOP-G, OOP-E
- Throwable hierarchy and source errors
OOP30
throw, throws and catch selection
[Exam Focus]- throw versus throws
- throw new IOException("message"): active throw
- throws IOException: signature declaration
- Caller catches or propagates checked obligations
- try: guarded operations
- catch: matching thrown type/subtype
- Throw skips remaining try statements
👁 Full explanation
throw new IOException("message") actively throws a value; throws IOException in a signature declares a possible checked exception. A caller must handle or propagate checked obligations. try encloses guarded operations; a matching catch handles the thrown type or a subtype. Execution skips the remainder of the try when a throw occurs. - Catch selection and propagation
- Source-order handler selection
- FileNotFoundException before IOException
- IOException before Exception
- General-first subtype catch: unreachable, compilation failure
- No match: outward propagation
- Uncaught exception terminates its thread
- Multiple catch blocks allowed
- catch(IOException | SQLException e)
- Multi-catch alternatives cannot subclass each other
👁 Full explanation
Catch blocks are considered in source order. Place FileNotFoundException before IOException and IOException before Exception; a general catch before a subtype catch makes that later handler unreachable and prevents compilation. If no catch matches, the exception propagates outward and an uncaught exception terminates its thread. Multiple catch blocks are allowed; catch(IOException | SQLException e) handles alternatives, which must not be related by subclassing.
11 related practice questions
Blueprint: OOP2 · Note references: OOP-M, OOP-G, OOP-E
- throw versus throws
OOP31
finally, cleanup and diagnostics
- finally and pending control transfer
- Normally after try/selected catch
- Return and propagation included
- JVM/process exit or crash: exception
- Never leaving try: exception
- Return expression evaluated before finally
- finally return overrides pending return
- Potential exception suppression
- Avoid returning from finally
👁 Full explanation
finally normally executes after try and any selected catch, including when leaving by return or propagating an exception. It is not guaranteed if the process/JVM exits or crashes, or control never leaves the try. A return expression is evaluated before finally; a finally return overrides the pending return and can suppress an exception, so avoid that pattern. - Resource cleanup and diagnostics
- try-with-resources: closes AutoCloseable
- Exceptional exit cleanup
- getMessage: message
- toString: normally type and message
- printStackTrace: exception and recorded call frames
- Test success, caught failure, propagation
- Handling doesn't replace validation
- No automatic logic correction
👁 Full explanation
try-with-resources closes AutoCloseable resources even on exceptional exit. getMessage returns the message, toString normally includes type and message, and printStackTrace shows exception information and recorded call frames for diagnosis. Tests should cover expected success, caught failures and propagation. Exception handling does not replace validation or correct an algorithm’s logic automatically.
3 related practice questions
Note references: OOP-M, OOP-G, OOP-C
- finally and pending control transfer
OOP32
Streams and GUI events
[Exam Focus]- Streams and GUI events
- InputStream/OutputStream: bytes
- Reader/Writer: text characters through encoding
- Deterministic resource closure
- read()=-1: end-of-stream
- Event source notifies registered listeners
- Button → ActionListener.actionPerformed
- Swing updates: event dispatch thread
- Short handlers preserve responsiveness
👁 Full explanation
InputStream/OutputStream read and write bytes; Reader/Writer handle text characters through an encoding. Close resources deterministically. A read returning -1 signals end-of-stream. A GUI event source notifies registered listeners; a button can call an ActionListener’s actionPerformed method. In Swing, update components on the event dispatch thread and keep handlers short so the interface remains responsive.
Blueprint: OOP2, OOP3 · Note references: OOP-M, OOP-UI
- Streams and GUI events
OOP33
JDBC queries and transactions
[Exam Focus]- JDBC query lifecycle
- Connection → prepare SQL → bind values
- Execute → process results → close
- PreparedStatement: SELECT name FROM Student WHERE id=?
- ps.setInt(1,id): first parameter
- executeQuery → ResultSet
- rs.next() before column reads
- executeUpdate → affected-row count
👁 Full explanation
A JDBC operation obtains a Connection, prepares SQL, binds values, executes and processes results, then closes resources. For PreparedStatement ps=con.prepareStatement("SELECT name FROM Student WHERE id=?"), ps.setInt(1,id) binds the first parameter. executeQuery returns a ResultSet; rs.next() moves to each row before reading columns. executeUpdate returns an affected-row count for updates. - SQL binding, transactions and responsiveness
- Bound values separate from SQL syntax
- Catch/declare SQLException
- Multiple writes: disable auto-commit
- Success: commit
- Failure: rollback
- Slow database work off GUI thread
- Display through appropriate UI mechanism
👁 Full explanation
Parameter binding keeps values separate from SQL syntax. Catch or declare SQLException. When several writes form one operation, disable auto-commit, commit on success and roll back on failure. A GUI handler should delegate a slow database operation away from its UI thread, then display the result through the appropriate UI mechanism.
Blueprint: OOP2, OOP3 · Note references: OOP-J
- JDBC query lifecycle
OOP34
Historical applet lifecycle
- Historical applet environment and lifecycle
- Java embedded in HTML
- Compatible JVM host/plugin or applet viewer
- init: initialize once
- start: after initialization, resume
- stop: host deactivation, suspend
- destroy: final cleanup before unloading
- paint: drawing, not constructor
👁 Full explanation
In the historical applet model, Java code was embedded in an HTML document and executed by a compatible JVM host/plugin or applet viewer. init initializes once; start follows initialization and resumes activity; stop suspends activity when the host deactivates it; destroy performs final cleanup before unloading. paint draws content and is not a constructor. - Applet historical interpretation limits
- Historical bank concepts
- Not modern browser deployment instructions
- destroy not exclusive to browser shutdown
- Host may destroy on unloading
- Abrupt termination: cleanup unguaranteed
- JVM alone insufficient for browser embedding
👁 Full explanation
Study applets as historical Java concepts rather than modern browser deployment tools. destroy is not defined exclusively as “browser shuts down”: the host may destroy an applet on unloading, and abrupt process termination does not guarantee cleanup. A JVM alone is also not the complete browser embedding environment.
4 related practice questions
Note references: OOP-L
- Historical applet environment and lifecycle
OOP35
Android Activity and Intent
- Android interaction and communication components
- Activity: user-interaction entry point
- Often corresponds to screen
- Intent: requested action/explicit target
- Extras carry inter-activity values
- putExtra("id",17): destination reads ID
- Content provider: structured-data sharing
- Broadcast receiver: broadcast handling
- Neither substitutes parameterized activity launch
👁 Full explanation
An Android Activity is a component providing an entry point for user interaction, often corresponding to a screen. An Intent describes a requested action or explicit target; extras carry values between activities. For example, putExtra("id",17) attaches an ID for the destination to read. A content provider shares structured data, while a broadcast receiver handles broadcast messages; neither is the ordinary mechanism for starting an activity with parameters.
2 related practice questions
Note references: OOP-D1, OOP-D2
- Android interaction and communication components
OOP36
Android declarations and packaging
- Manifest and layout containers
- AndroidManifest.xml: essential app metadata
- Components, permissions, intent filters
- Manifest isn't executable code
- Not all source/layout details
- LinearLayout, RelativeLayout derive ViewGroup
- android.view.ViewGroup contains child views
👁 Full explanation
AndroidManifest.xml declares essential app metadata such as components, permissions and intent filters. It is not executable code and does not contain all source or layout details. Traditional view-based layout containers such as LinearLayout and RelativeLayout derive from android.view.ViewGroup, which contains child views. - Android packaging distinctions
- .apk: Android package archive
- Installation and runtime contents
- Android Package Kit: common exam expansion
- Documentation: Android package
- Manifest describes package
- Layout resources describe views
- Old Android questions outside Java module
👁 Full explanation
An .apk is an Android package archive used for installation and runtime contents. “Android Package Kit” is a common exam expansion; Android’s documentation calls it an Android package. A manifest describes the package, while layout resources describe views. Use these distinctions to compare Android application structure with Java language concepts.
3 related practice questions
Note references: OOP-D3, OOP-D4, OOP-D5
- Manifest and layout containers
OOP37
Malformed syntax and trace corrections
- OCR repair before literal tracing
- extends misread as Extends
- println misread as printIn/printin
- Constructor names, braces, <=, == corrupted
- Case-sensitive Java may fail compilation
- Intended trace requires stated repair
- Even i=2,4,6,8,10; i%4==0
- Only 16 and 64 print
- Extra offered values incorrect
👁 Full explanation
Check exact Java spelling and syntax: extends differs from Extends, println differs from printIn/printin, constructor names must match class names, and braces and operators such as <= and == affect validity and behavior. Java is case sensitive: an invalid program may not compile even when a possible trace seems clear. For a valid Java loop with i=2,4,6,8,10 that prints i*i only when i%4==0, the printed values are 16 and 64. - SS118 fragments and numeric output
- Recovered public String welcome() implementation
- Additional welcome(int) overload
- Current A–D fragments unreliable
- Required signature over fabricated letter
- Rounded mean choice ≠ exact printed output
👁 Full explanation
A valid implementation can define public String welcome() and additionally overload welcome(int). Identify an implementation by its complete declarations and method bodies. Check the required signature before selecting an implementation. A rounded mathematical mean is not necessarily the exact Java printed output.
11 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- OCR repair before literal tracing
OOP38
Ambiguous bank interpretations
- Overlapping single-choice options
- Static constant and parameter-only utility suitable
- Multiple valid array declarations/initializers
- Abstract class may implement complete interface
- Encapsulation/abstraction overlap
- Specific requested emphasis needed
👁 Full explanation
Several Java statements can be valid at once: a static constant and a parameter-only utility may both be suitable static members; multiple array declarations/initializers can be legal; an abstract class may contain a complete interface implementation. Encapsulation and abstraction overlap, so choose only when the requested emphasis is specific. - Interpretation-dependent bank claims
- Interface: multiple type inheritance plus abstraction
- Broad purpose choices overlap
- All-public-abstract: restricted/legacy interpretation
- protected includes same-package access
- No overriding keyword
- Compatible declarations establish overriding
- @Override: annotation
- C++ hidden object: non-static member functions
- Not arguments passed to member variables
👁 Full explanation
An interface supports multiple type inheritance and abstraction. “All methods are public abstract” applies only under a restricted abstract-declaration or legacy interpretation. Java protected also grants access within the same package, so it cannot enforce “only subclasses.” No keyword implements overriding: it is recognized from compatible declarations, and @Override is an annotation. For C++ this, ordinary non-static member functions have an implicit object; variables do not receive a hidden argument.
54 related practice questions
Note references: OOP-M, OOP-N, OOP-G
- Overlapping single-choice options
OOP39
Language classifications and portability
- Language taxonomy and portability
- C++, Java, Python, Perl: third generation
- Taxonomy separate from object orientation
- Taxonomy separate from compilation/interpretation
- Java source → JVM bytecode
- Compatible JVM plus libraries: cross-system portability
👁 Full explanation
Under the conventional introductory generation taxonomy, general-purpose high-level languages such as C++, Java, Python and Perl are third generation. The taxonomy is separate from object orientation and from compilation versus interpretation. Java source normally compiles to JVM bytecode, and a compatible JVM plus libraries supports portability across systems. - Portability qualifications and language properties
- Compatible APIs, versions, environment assumptions
- No unconditional any-device guarantee
- Java objects/classes plus primitives
- Learning difficulty: subjective judgment
- Syntax conventions versus bytecode portability
- Runtime implementation distinguished
👁 Full explanation
Portability still depends on compatible APIs, versions and environment assumptions; it is not an unconditional guarantee for any program on any device. Java supports objects and classes but also primitive values. “Difficult to learn” is a subjective judgment rather than a technical language property. Syntax conventions, bytecode portability and runtime implementation must be distinguished.
3 related practice questions
Note references: OOP-M, OOP-U
- Language taxonomy and portability
No matching topics. Clear the search or change the filter.
Blueprint learning outcomes
- OOP1 · Understand the basic object oriented concepts
OOP01, OOP02, OOP03, OOP04, OOP09, OOP11, OOP13, OOP14, OOP15, OOP18, OOP19 - OOP2 · Successfully code, debug and run programs with object oriented principles
OOP09, OOP10, OOP11, OOP12, OOP14, OOP15, OOP18, OOP19, OOP28, OOP29, OOP30, OOP32, OOP33 - OOP3 · Apply object oriented programming concepts to solve problems
OOP01, OOP02, OOP11, OOP13, OOP15, OOP18, OOP19, OOP32, OOP33