| Lecture 1 |
- Programming Methodologies
- Procedural Programming
- Object-Oriented Programming (OOP) Introduction
- Classes and Objects
- Object Interaction
|
- Procedural vs. OOP
- Features, Advantages, Limitations of Procedural Programming
- Advantages of OOP (Real-world modeling, Reusability, Modularity, Flexibility, Info Hiding)
- OOP Applications (CUI, GUI, CAD/CAM)
- Class as a blueprint, Object as an instance
- State (Attributes) and Behavior (Methods)
- Identity
- Creating Objects (
new keyword)
- Message Passing (Method calls)
- Arguments and Return Values
- Variables vs. Objects
|
|
| Lecture 2 |
- Features of OOP (Detailed)
- Relationships between Classes
- Types of Inheritance
|
- Encapsulation: Data Hiding, Getters/Setters, Implementation Hiding, Read-only/Write-only fields. (Example:
EncapTest)
- Abstraction: Essential characteristics, Hiding irrelevant details, Interface vs. Implementation. (Example: Mobile phone)
- Inheritance: Extending functionality, Code reuse, Superclass/Subclass (Parent/Child), IS-A relationship. (Examples: Animal hierarchy, Ticket hierarchy, Vehicle hierarchy)
- Polymorphism: "Many forms", Method Overriding. (Example:
Shape, Rectangle, Triangle classes with area() method)
- Class Relationships: Kind-of (Class level), Is-A (Instance level), Part-of (Composition/Aggregation), Has-A (Composition/Aggregation).
- Inheritance Types: Single, Multiple (conceptual, Java uses interfaces), Multilevel, Hierarchical, Hybrid, Multipath. (Diagrams discussed)
- Generalization & Specialization
|
|
| Lecture 3 |
- Introduction to Java
- History and Evolution
- Java Environment & Architecture
- Basic Java Program Structure
|
- Relation to C/C++
- Why Java? (Portability, Security, Web)
- Key Features (Simple, OOP, Distributed, Robust, Secure, Portable, Multithreaded, Platform Independent, Interpreted/Compiled)
- Java Editions (J2SE, J2ME, J2EE)
- Java vs C++ Differences (Pointers, Operator Overloading, Global Variables, Pass-by-value)
- Java Architecture: Bytecode, JVM (Java Virtual Machine), JRE (Java Runtime Environment), JDK (Java Development Kit), API, Class Loader, Verifier, Execution Engine (Interpreter, JIT Compiler).
- WORA (Write Once, Run Anywhere)
- Applications vs. Applets
- Basic Syntax: Reserved words, Identifiers, Comments (
//, /* */, /** */ - Javadoc), Curly Braces, White Space.
main method structure (public static void main(String[] args))- Compile/Run Cycle (
javac, java)
- Simple Java Application Example (
TestGreeting, Greeting classes)
System.out.println()- Creating documentation (
javadoc)
|
|
| Lecture 4 |
- Java Data Types
- Operators
- String Handling
- Selection Statements (Conditionals)
- Repetition Statements (Loops)
- Arrays
|
- Data Types: Primitive (
byte, short, int, long, float, double, boolean, char - Unicode) vs. Non-primitive (String, Arrays, Classes). Type Conversion (Implicit), Casting (Explicit).
- Operators: Arithmetic (
+, -, *, /, %), Increment/Decrement (++, --), Relational (==, !=, >, <, >=, <=), Logical (&&, ||, ! - short-circuit), Bitwise (&, |, ^, ~, >>, >>>, <<), Assignment (=, +=, etc.), Conditional (Ternary ? :), instanceof. Operator Precedence.
- Strings: Concatenation (
+), Immutability, String Pool, Creating Strings (literal vs new), Comparing Strings (== vs .equals(), .equalsIgnoreCase()), Accessing characters.
- Selection:
if, if-else, Nested if, Cascading if-else if, switch (int, byte, short, char, String; case, break, default). Flow of control.
- Loops:
for (initialization, condition, increment/decrement), while (condition), do-while (executes at least once), Nested Loops. break (exit loop), continue (skip iteration). (Examples: Number squaring, Star patterns).
- Arrays: Declaring, Creating (
new), Initializing (literal {}), Accessing elements (index []), .length property, Default values, Storing multiple values, Array of objects. (Examples: cars array, createArray method).
|
|
| Lecture 5 |
- Class Definition & Declaration
- Using Multiple Classes
- Accessors (Getters) & Mutators (Setters)
- Access Modifiers
- Non-access Modifiers
|
- Class structure: Header, Body, Members (Methods, Fields). Syntax.
- Fields: Instance variables vs. Class variables (
static).
- Creating Objects (
new), multiple objects from one class.
- Accessing members using the dot operator (
.).
- Calling instance methods vs. static methods.
- Organizing code with multiple classes in separate files. Compilation order.
- Scope: Class scope for fields.
- Encapsulation: Importance of data hiding (
private).
- Accessor (Getter) methods: Return private data.
- Mutator (Setter) methods: Modify private data (potentially with validation).
- Access Modifiers: Control visibility.
- For Classes:
public, default (package-private).
- For Members (attributes, methods, constructors):
public, private, protected, default. (Summary table).
- Non-access Modifiers: Define other characteristics.
- For Classes:
final (cannot be subclassed), abstract (cannot be instantiated).
- For Members:
final (cannot be overridden/modified), static (belongs to class, not object), abstract (method without body, requires abstract class).
- Examples: Demonstrating instance vs. static variables/methods,
final variables, private access errors, using getters, abstract classes/methods.
- Difference between Access and Non-Access modifiers.
|
Final revesion
|