Revise later
SpaceTo flip
If confident
All Flashcards
How is encapsulation achieved using access modifiers?
By declaring instance variables as `private` and providing `public` getter and setter methods.
Give an example of when to use a `private` static variable.
For constants or counters that should only be accessed and modified within the class.
How do access modifiers support information hiding?
By restricting access to internal data and implementation details, preventing external classes from directly manipulating them.
In what scenario would you use the 'protected' access modifier?
When you want to allow subclasses in other packages to access a member but prevent access from non-related classes.
How can proper use of scope prevent naming conflicts?
By limiting the visibility of variables, reducing the chance of accidentally using the same name for different variables in different parts of the code.
How does the concept of scope apply to method parameters?
Method parameters have local scope within the method, allowing the method to operate on specific inputs without affecting variables outside the method.
Explain how access modifiers contribute to creating a stable and maintainable API.
By defining a clear interface with `public` members and hiding implementation details with `private` members, changes to the internal implementation do not affect external code that uses the API.
How can access modifiers and scope be used to implement a singleton pattern?
By making the constructor `private` and providing a `public` static method to access the single instance, controlling instantiation and access.
How can access modifiers be used to create immutable objects?
By declaring all instance variables as `private` and not providing any setter methods, preventing modification of the object's state after creation.
How does the use of access modifiers and scope contribute to code reusability?
By creating well-defined interfaces and encapsulating implementation details, classes can be reused in different contexts without unintended side effects or dependencies.
What is the scope of 'x' in: `public void method() { int x = 5; }`?
Local scope; only accessible within the `method()` method.
Given: `private int age;` can another class directly access `age`?
No, `age` is private and only accessible within its own class.
```java
public class Test {
private int x = 10;
public void printX() {
System.out.println(x);
}
}
public class Main {
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.x); // What happens here?
}
}
```
Compile-time error: `x` is private and cannot be accessed from `Main`.
```java
public class A {
int x = 5; // package access
}
public class B {
public static void main(String[] args) {
A a = new A();
System.out.println(a.x); // When is this valid?
}
}
```
Valid only if `A` and `B` are in the same package.
```java
public class Parent {
protected int value = 10;
}
public class Child extends Parent {
public void printValue() {
System.out.println(value);
}
}
```
Is `value` accessible in `Child`?
Yes, `value` is protected and accessible in subclasses.
```java
public class Example {
public int x;
public Example(int x) {
this.x = x;
}
public static void main(String[] args) {
Example e = new Example(5);
System.out.println(e.x); // What is the output?
}
}
```
5
```java
public class Test {
private static int count = 0;
public Test() {
count++;
}
public static int getCount() {
return count;
}
public static void main(String[] args) {
Test t1 = new Test();
Test t2 = new Test();
System.out.println(Test.getCount()); // What is the output?
}
}
```
2
```java
public class ScopeTest {
int x = 10;
public void methodA() {
int x = 20;
System.out.println(x); // What is the output?
}
public static void main(String[] args) {
ScopeTest st = new ScopeTest();
st.methodA();
}
}
```
20
```java
public class AccessTest {
private int secret = 5;
public int getSecret() {
return secret;
}
public static void main(String[] args) {
AccessTest at = new AccessTest();
System.out.println(at.secret); // Will this compile?
}
}
```
No, it will not compile. `secret` is private and cannot be accessed directly from `main`.
```java
public class Test {
public static void main(String[] args) {
int x = 5;
if (true) {
int x = 10; // Is this allowed?
System.out.println(x);
}
System.out.println(x);
}
}
```
Yes, it's allowed. The inner `x` shadows the outer `x` within the `if` block. Output: 10, 5
What is 'scope' in programming?
Scope determines where a variable can be used within your code.
Define 'local scope'.
Variables declared inside a method or constructor have local scope; accessible only within that block.
Define 'global scope'.
Variables declared outside any method or constructor have global scope; accessible throughout the class.
What are 'access modifiers'?
Access modifiers control the visibility and accessibility of variables and methods from outside the class.
Define 'private' access modifier.
Private members are only accessible within the class where they are declared.
Define 'package' (default) access.
Accessible by other classes within the same package (folder).
Define 'protected' access.
Accessible by classes in the same package and by subclasses in other packages.
Define 'public' access.
Public members are accessible from any class.
What is an 'instance variable'?
A non-static variable belonging to an object.
Define 'encapsulation'.
Bundling data (variables) and methods that operate on the data into a single unit (class), and hiding the internal details from the outside world.