A table

A chair

A car

A computer

The purpose of a constructor in a class is to initialize objects.

To create static variables in a class.

To delete objects from memory.

To define methods in a class.

Use the copy constructor method.

Implement the Cloneable interface and use the clone() method.

Call the Object.copy() method.

Serialize the object to a file.

replicate function

copy constructor

duplicate method

clone or copy method

Single inheritance is when a class inherits from one and only one parent class.

Single inheritance allows multiple parent classes.

Single inheritance is when a class inherits from no parent class.

Single inheritance is a feature of functional programming only.

Single inheritance from one parent class

Inheritance that allows classes to share methods only

Multiple inheritance is when a class can inherit from multiple parent classes.

A method of combining multiple classes into one

implements

inherits

subclass

extends

An interface is a collection of objects that can be instantiated.

An interface is a class that can contain method implementations.

An interface in Java is a reference type that defines a contract for classes to implement.

An interface is a type of variable that holds data.

Use the 'inherits' keyword to implement an interface.

Define interface methods without implementing them.

Use the 'extends' keyword in the class declaration.

Use the 'implements' keyword in the class declaration and define all interface methods.

To improve the performance of Java applications.

To restrict the use of primitive data types in Java.

To simplify the syntax of Java code.

The purpose of generic classes in Java is to enable type-safe operations on different data types while promoting code reusability.

A method that only works with integers.

A method that cannot take any parameters.

A method that is specific to one data type.

A method that can operate on different data types specified by type parameters.

Polymorphism refers to the process of compiling code into machine language.

Polymorphism is a method of optimizing memory usage in programming.

Polymorphism is the ability of different classes to be treated as instances of the same class through a common interface.

Polymorphism is the ability to create multiple instances of a class.

Method overloading is the ability to change the name of a method in a class.

Method overloading is when a method can be called with any number of parameters.

Method overloading is the ability to define multiple methods with the same name but different parameters in a class.

Method overloading refers to the process of overriding a method in a subclass.

Method overriding is a feature in object-oriented programming where a subclass redefines a method from its superclass.

Method overriding is a way to hide methods in a subclass without changing their implementation.

Method overriding is a technique to create multiple methods with the same name in a class.

Method overriding is when a superclass redefines a method from its subclass.

Java achieves runtime polymorphism through method overloading.

Java achieves runtime polymorphism through method overriding.

Java achieves runtime polymorphism by using interfaces only.

Java achieves runtime polymorphism via static binding.

An abstract class cannot have any methods, while an interface can have implemented methods.

An abstract class can only be instantiated, while an interface cannot be instantiated.

An abstract class can implement multiple interfaces, while an interface cannot extend an abstract class.

An abstract class can have implemented methods and state, while an interface cannot.

The 'instanceof' operator is used to compare two strings.

The 'instanceof' operator creates a new instance of an object.

The 'instanceof' operator checks if a variable is undefined.

The 'instanceof' operator checks the prototype chain of an object to determine if it is an instance of a specified constructor.

Generic classes cannot have constructors.

You create a generic class by extending another class.

You create a generic class in Java by using type parameters, e.g., 'class MyClass { }'.

You can only create a generic class with interfaces.

Reflection is used for compiling Java code.

Reflection in Java is used for inspecting and manipulating classes, methods, and fields at runtime.

Reflection allows for static type checking at compile time.

Reflection is a method for optimizing Java performance.

Encapsulation is used to hide the internal state of an object and require all interaction to be performed through an object's methods.

Encapsulation allows multiple classes to share the same methods.

Encapsulation is a way to create static methods in a class.

Encapsulation is the process of combining multiple classes into one.

A class is a collection of objects, while an object is a single instance of a class.

A class can only contain methods, while an object can only contain data.

A class is a type of variable, while an object is a function.

A class is a blueprint for creating objects, while an object is an instance of a class.

The 'super' keyword is used to implement interfaces.

The 'super' keyword is used to define static methods in a class.

The 'super' keyword is used to create a new instance of a class.

The 'super' keyword is used to refer to the superclass of the current object.

'this' is used to refer to the superclass of the current object.

'this' refers to the current object in a method or constructor.

'this' is used to create a new instance of a class.

'this' is a keyword for defining static methods.

A constructor is called when an object is created, while a method is called to perform an action on an object.

A constructor is always public, while a method can be private.

A constructor is a type of variable, while a method is a type of class.

A constructor can return a value, while a method cannot.

The 'final' keyword is used to implement interfaces.

The 'final' keyword is used to define methods that can be overridden.

The 'final' keyword is used to create abstract classes.

The 'final' keyword is used to declare constants that cannot be changed.

Inheritance is used to create multiple instances of a class.

Inheritance allows a class to inherit properties and methods from another class.

Inheritance is the process of combining multiple classes into one.

Inheritance is a way to define static variables in a class.

The 'abstract' keyword indicates that a class cannot be instantiated and may contain abstract methods.

The 'abstract' keyword allows a class to implement multiple interfaces.

The 'abstract' keyword is used to define constants in a class.

The 'abstract' keyword is used to create static methods.

The 'static' keyword is used to define methods that can be called without creating an instance of a class.

The 'static' keyword is used to define abstract classes.

The 'static' keyword allows a method to be overridden.

The 'static' keyword is used to create instance variables.

The 'volatile' keyword is used to define methods that cannot be overridden.

The 'volatile' keyword is used to declare constants that can be changed.

The 'volatile' keyword indicates that a variable's value will be modified by different threads.

The 'volatile' keyword is used to create static variables.