Computer Science - Java Programming Basics

Scope: Defines exactly where a variable exists and is accessible within a program.
Class: Described as a blueprint or template used for the creation of objects.
Object: A specific instance generated from a class blueprint.
Primitive Type: Refers to the most basic data types provided by the language, specifically including examples such as $int$ and $boolean$ .
Static Method: A method that is called at the class level rather than being invoked on a specific instance/object.
Instance Variable: A variable for which every individual object created from a class receives its own unique copy.
Constructor: A specialized method whose primary purpose is to create and initialize objects.
Instance Method: A method that defines the specific actions or capabilities of an object.
Visibility: Mechanisms that control access to classes, methods, and variables (e.g., $public$ versus $private$ ).
Package: A structured grouping of related classes.

Object-Oriented Programming (OOP): A programming paradigm that focuses on the conceptualization of objects and the data and actions associated with them.
Local Variable: A variable that is constrained in existence to the interior of a method; it cannot be accessed outside that method.
State: The data associated with an object at any given time.
Behavior: The specific actions or functions an object can perform.
Client: A designation for a program that utilizes an external class, such as the $String$ class, to perform tasks.
Static Variable: A variable that is shared across all instances of a class; only one copy exists regardless of how many objects are instantiated.
The 'this' Keyword: An explicit reference to the current object in which the code is executing.
The 'super' Keyword: An explicit reference to the parent or superclass of the current class.
Method Overriding: The process by which a subclass provides a specific implementation for a method that is already defined in its parent class, effectively replacing the parent's version.
Abstract Class: A specific type of class that is designed to be a base for other classes and cannot be instantiated on its own.

Object vs. Instance: In the context of computer science and Java, the terms "object" and "instance" are synonymous and represent the same concept.
Static Variables vs. Instance Copies: It is false to claim that static variables give each object its own copy; rather, static variables are shared, while instance variables provide unique copies to each object.
Constructor Characteristics: Constructors do not possess a return type (not even $void$ ).
Variable Accessibility: Private variables are strictly encapsulated and cannot be accessed from code outside their defining class.
Method Overloading Requirements: To overload a method, the method name must remain the same while the parameter lists must differ in type, number, or order.
Shadowing: This occurs when two variables within overlapping scopes share the same name (e.g., a local parameter variable having the same name as an instance variable).
Interface Implementation: In basic Java contexts, interfaces are generally understood to contain abstract definitions rather than fully implemented methods.
Polymorphism: A principle wherein a single method or interface can behave differently depending on the specific object it is acting upon.

Source Code Fragment: - $public\,class\,Dog\,\{$ - $private\,String\,name;$ - $public\,Dog(String\,name)\,\{$ - $this.name\,=\,name;$ - $\}$ - $public\,void\,bark()\,\{$ - System.out.println(name\,+\,\"\,says\,woof!\"); - $\}$ - $\}$
Class Name Identification: The name of the class is $Dog$ .
Variable Classification: The variable $name$ is a private instance variable of the type $String$ .
Constructor Identification: The constructor is the block $public\,Dog(String\,name)\,\{\,this.name\,=\,name;\,\}$ .
Method Classification: The $bark()$ method represents an object's behavior, as it is an action the object performs.
Keyword Context: The expression $this.name$ refers specifically to the instance variable belonging to the current object, distinguishing it from the parameter $name$ passed into the constructor.

Source Code Fragment: - $public\,class\,Counter\,\{$ - $public\,static\,int\,count\,=\,0;$ - $public\,Counter()\,\{$ - $count++;$ - $\}$ - $\}$
Static vs. Instance: The variable $count$ is explicitly declared as a static variable.
Data Sharing: Because it is static, $count$ is shared across every object created from the $Counter$ class.
Operational Logic: Whenever a new object of the $Counter$ class is instantiated (calling the constructor), the shared $count$ variable is incremented by $1$ ( $count++$ ). If multiple objects are created, $count$ will reflect the total number of objects instantiated.

Difference Between a Class and an Object: A class serves as the abstract blueprint or template defining the structure and capabilities, while an object is a concrete, tangible realization of that template existing in memory.
Getter vs. Setter: - A Getter is a method used to retrieve or read the value of a private instance variable. - A Setter is a method used to update or modify the value of a private instance variable, often providing a layer of validation.
Importance of Visibility: Visibility modifiers (like $public$ and $private$ ) are critical for implementing encapsulation. They protect the internal state of an object from unauthorized or accidental modification by external classes, ensuring that the object's data remains consistent and secure.
Method Overloading Definition and Application: Method overloading is the ability to define multiple methods within the same class that share the same name but have different signatures (parameter lists). - Example: Consider a class with two $add$ methods: - $public\,int\,add(int\,a,\,int\,b)$ for integers. - $public\,double\,add(double\,a,\,double\,b)$ for floating-point numbers.