Object-Oriented Programming
## Learning Objectives
- Understand classes and objects
- Master encapsulation
- Work with constructors
- Create and use instance methods
## Classes and Objects
### Class: Blueprint
```java
public class Person {
// Fields (attributes)
String name;
int age;
// Methods (behaviors)
void speak() {
System.out.println("My name is " + name);
}
void sayAge() {
System.out.println("I am " + age + " years old");
}
}
```
### Object: Instance
```java
public class Main {
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
person1.name = "Alice";
person1.age = 25;
person2.name = "Bob";
person2.age = 30;
person1.speak(); // My name is Alice
person2.speak(); // My name is Bob
}
}
```
## Encapsulation
### Private Fields
```java
public class Person {
private String name; // Can't access directly
private int age;
}
```
### Public Getters and Setters
```java
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age >= 0) {
this.age = age;
}
}
}
```
### Using Encapsulation
```java
Person person = new Person();
person.setName("Alice");
person.setAge(25);
System.out.println(person.getName()); // Alice
// person.name = "Bob"; // Compile error!
```
## Constructors
### Default Constructor
```java
public class Person {
private String name;
// No-arg constructor (default)
public Person() {
name = "Unknown";
}
}
```
### Parameterized Constructor
```java
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
### Calling Constructors
```java
Person p1 = new Person(); // Default
Person p2 = new Person("Alice", 25); // Parameterized
```
### Constructor Overloading
```java
public class Person {
private String name;
private int age;
public Person() {
this.name = "Unknown";
this.age = 0;
}
public Person(String name) {
this.name = name;
this.age = 0;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
```
## this Keyword
### Reference to Current Object
```java
public class Person {
private String name;
public Person(String name) {
this.name = name; // this.name = parameter name
}
public Person() {
this("Unknown"); // Call other constructor
}
}
```
## Static vs Instance
### Instance Members
```java
public class Person {
private String name; // Instance variable (unique per object)
public void speak() { // Instance method
System.out.println("I am " + this.name);
}
}
Person p1 = new Person("Alice");
Person p2 = new Person("Bob");
p1.speak(); // I am Alice
p2.speak(); // I am Bob
```
### Static Members
```java
public class Counter {
private int count; // Instance variable
public static int totalCount; // Shared by all instances
public Counter() {
count++;
totalCount++;
}
public static void printTotal() {
System.out.println("Total: " + totalCount);
}
}
```
## Method Overloading
### Same Name, Different Parameters
```java
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
}
```
## toString Method
### String Representation
```java
public class Person {
private String name;
private int age;
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
// Usage
Person p = new Person("Alice", 25);
System.out.println(p); // Prints: Person{name='Alice', age=25}
```
## Access Modifiers
| Modifier | Same Class | Same Package | Subclass | Everywhere |
|----------|------------|--------------|----------|------------|
| private | Yes | No | No | No |
| (default) | Yes | Yes | No | No |
| protected | Yes | Yes | Yes | No |
| public | Yes | Yes | Yes | Yes |
## Getters and Setters Example
```java
public class BankAccount {
private String accountNumber;
private double balance;
public BankAccount(String accountNumber, double initialBalance) {
this.accountNumber = accountNumber;
this.balance = initialBalance;
}
public String getAccountNumber() {
return accountNumber;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public boolean withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
return true;
}
return false;
}
}
```
## Summary
- Classes define objects; objects are class instances
- Encapsulation: private fields + public getters/setters
- Constructors initialize objects; can be overloaded
- `this` references current object
- Static members belong to class; instance members belong to object
- `toString()` provides string representation of objects
- Access modifiers control visibility: private, (default), protected, public
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →