PHP OOP: Object Oriented Programming for beginners + Project

Explore fundamental PHP object-oriented programming (oop) concepts, including classes, inheritance, methods, properties, instantiation, access modifiers, setters and getters, and constructors, to prepare for the upcoming project.

Explore how classes serve as blueprints for objects in PHP, declare and instantiate classes, and work with built-in classes, time zones, and runtime behavior.

Explore methods in PHP OOP by declaring and using class methods, understanding access modifiers, and inspecting class methods with built-in tools like get_class_methods and vardump.

Learn how class instantiation creates objects from a blueprint using the new keyword. Create multiple instances with the same blueprint and access their object methods via arrow syntax.

Define properties and constructor in a PHP class by declaring a public username and using this to assign inputs. Explain access modifiers and how the constructor requires a username parameter.

Explore class inheritance in PHP by extending a user class to an admin, reusing name and email, adding a role, and calling the parent constructor. Also implement display methods.

Explore php object oriented programming by mastering access modifiers: public, protected, and private, and learn how visibilities control data and method access within classes and subclasses.

Learn how static data in PHP belongs to the class, not instances, using static properties and methods with self and ::, and incrementing a class-wide counter on each new object.

Explore getters and setters in PHP OOP by managing user properties via a constructor and methods, including validating and updating an email with a setter and retrieving it with getter.

Explore the project overview to build a PHP OOP dashboard with login, pagination, Google API integration, Ajax uploads, jQuery interactions, and Bootstrap-driven responsive UI.

Set up a bootstrap-based gallery project structure with directories for index, includes, css, fonts, JavaScript, and an admin area to practice object oriented programming in PHP.

Learn to edit and reorganize a PHP project by adding and removing files, refactoring navigation with includes, and creating modular admin content for a cleaner CMS structure.

Clean up the admin navigation by removing unused items, set links for dashboard, users, upload, and comments pages, and add placeholders for future pages.

Build and organize admin pages (users, upload, photos, comments) in PHP, wiring them to a shared admin layout, updating titles and navigation for a cohesive project foundation.

Create a gallery_db database and a users table in phpMyAdmin with id as an auto-incrementing primary key and columns for username, password, first_name, and last_name.

Build a PHP database class using object oriented programming, with a connection, initialization, and helpful methods to manage queries. Organize code with user and photos classes.

Create config.php to define database connection constants such as host, user, password, and name (Gallery_db). Test the connection using mysqli_connect to confirm a successful link to the localhost server.

Initialize your CMS with a central init.php that includes the new_config.php and defines paths, addressing a future database conflict by renaming config.php to new_config.php for reliable includes.

Include the init.php file in your header to initialize all files, and enable output buffering with ob_start to prepare for redirects later.

Create a PHP database class to manage the connection, using a private property and an open connection method. Include config.php and instantiate the class to open the DB in init.php.

Make the private variable public to ensure a shared database connection across classes as the course expands into inheritance and broader database usage.

Learn to implement automatic database connection setup in PHP with a constructor, ensuring the connection opens automatically across pages while keeping the database property private and publicly testable.

Extend your PHP OOP project by adding a public query method that executes an SQL query using the stored connection, returns the result set, and handles failed queries.

Extend the database class by adding a private confirm_query method and a public escape_string wrapper around mysqli_real_escape_string for safer, reusable code.

Test your query methods by inserting user data and running a select from users where id = 1, then fetch the result via the class method and verify the username.

Convert the procedural mysqli connection to an object oriented approach using a mysqli object and a connection property, then test queries, real escape string, and insert ID.

Create and instantiate a user class, manage users with username and password, and build a photo library that sends photos via Ajax to a PHP server.

Create a dedicated user class to manage users, implement a find_all_users method via a database class, keep user and database queries separate, and include the class in init.php.

Testing the find_all method, the lecture demonstrates instantiating the user class, calling the method, and looping through the resulting set with mysqli_fetch_array to reveal user data.

Utilize static methods and properties to streamline code by calling them through the class name using two dots, reducing unnecessary instantiation and improving reusability.

Create a find user by id method in php oop project, using a static function, mysqli fetch array, and limit one result to reliably retrieve a username.

Enhance a user class with a universal static query method that executes any SQL and returns a result set, demonstrated via CMS testing.

Convert plain arrays to objects by defining user properties (id, username, first name, last name, password), instantiate a user, assign values to properties, and echo the id.

Use a static method to auto instantiate an object, bring in values from the database, and loop through arrays to assign values to the object's properties.

Test the static instantiation method by making it public and passing a user parameter to construct the object from the database result set.

Learn to automate instantiation and property assignment by looping over database records, mapping associative array keys to object attributes, and conditionally setting values without manual typing.

Create a private method to check if an object has a given attribute using get_object_vars and array_key_exists, returning true or false based on the object's properties.

Return objects from a database query by applying the instantiation method, building an object array of user properties.

Learn to use an instantiation method to fetch all user objects, iterate with foreach, and print usernames, while building universal, reusable object-oriented programming methods for future classes in PHP.

Learn to fetch a single user by ID using a PHP OOP approach, instantiate objects from query results, and return the first item or false when no match.

Discover how to implement a PHP autoload function to automatically load undeclared classes, provide a safety net for missing files, and improve error handling.

Replace the deprecated autoload with SPL autoload register to enable multiple autoloaders. The lecture shows building a custom autoloader, testing it, and refining it with file and class existence checks.

Build a session class to manage gallery system sessions in one place. Implement login, logout, admin access, user validation, and view tracking with an object oriented approach.

Learn to start and manage user sessions in PHP by building a session class, using require_once for security, and automatically starting sessions to support the login system.

Implement a private login check method in PHP OOP to verify the session user ID, assign it to the object, unset the user ID, and update the sign-in status accordingly.

Learn to set a default session value, auto-invoke login in the constructor, and implement a getter and login method that verifies users from the database and updates session IDs.

Create a logout method in the session class that unsets session data, clears the login flag, and requires users to log in again through the login form.

Control access to the admin area by checking the session and redirecting unauthenticated users to login.php using a custom redirect function in functions.php.

Create a PHP object-oriented login page that validates post data, trims inputs, checks user credentials, and logs in via sessions with redirect to index and clear error handling.

Develop a static verify user method in the user class to validate the provided username and password against the database, sanitizing input and returning a result for login.

Create verify method by building a sql query to select from users where username equals input and password equals input, limit one, returning user object or false via a ternary.

Learn why you cannot return twice inside a function in php object oriented programming and how to fix a past mistake by removing an unnecessary return.

Position the login.php file outside the includes directory inside the admin folder, at the same level as index.php.

Demonstrates creating a login form, validating credentials via a verify user method, handling submission, and redirecting to the admin index, with debugging and include adjustments.

Build and test a login and logout feature in a PHP gallery system, using session handling, redirection, and a simple log out page linked in the top navigation.

Learn to create a PHP OOP message method that stores and outputs session messages for actions like delete or update, with a check message method and constructor initialization.

Learn how to provide user-friendly login feedback in a PHP OOP context by preserving input, sanitizing output with HTML entities, and displaying clear error messages using Bootstrap styling.

Explore file basics and learn how to set file permissions on Linux and Unix systems, and discover PHP functions to get paths for a photo-centered project on Ubuntu servers.

Set up secure file permissions by separating uploaded files from main app files, and apply read, write, and execute rights using symbolic and octal notations.

Learn to handle files and directories in PHP, using magic constants like __FILE__ and __DIR__. Explore file_exists and the ternary operator to simplify checks in a gallery project.

Explore file upload in PHP, learn common upload errors, configure php.ini settings, move files between locations, and understand the upload file structure using the superglobal files.

Discover how to configure PHP for file uploads by adjusting file_uploads, post_max_size, upload_max_filesize, memory_limit, and more, locate and edit the PHP configuration file, and verify settings with phpinfo and localhost.

Learn to send files via an HTML form using multipart/form-data in a PHP post request, including input type file handling and moving uploads from temp to a permanent location.

Analyze the uploaded file structure using the PHP file superglobal, exploring keys name, type, size, tmp_name, and error, and how to move the temporary file to a permanent location.

Learn to handle PHP file upload errors by mapping error codes to descriptive messages with an associative array, using constants over numbers, and displaying user-friendly feedback after form submission.

Learn how to move an uploaded file from a temporary location to a server uploads folder using move_uploaded_file, handling temp name and file name with success or error messages.

Explore object oriented PHP, learn CRUD (create, delete, read, update), test methods, and debug to advance your web development career.

Explore the create operation of CRUD by inserting user data into the database, escaping strings, and assigning values to the user object.

Implement the create method to run the database query, return true or false, and prepare to capture the auto-incremented insert ID for the object.

Create a custom insert id method in the database class to return the last mysqli insert_id, assign it to the user object, and prepare for testing the create method.

Instantiate a user class object with static values, call its create method to insert into the database columns, and update the object with the new id; verify the result in phpMyAdmin.

Implement an update method in PHP using mysqli, escaping values, and building an update query for the users table, returning true on success via a ternary based on affected rows.

Verify the update method by retrieving a user by ID, modifying the last name to Williams, and calling the update operation to persist changes in a PHP OOP context.