DEV Community: TahirDotDev

How to Quickly Shut Down Windows 10 with the Slide-to-Shut-Down Feature

TahirDotDev — Mon, 01 Jul 2024 03:12:57 +0000

Are you tired of clicking through multiple menus to shut down your Windows 10 PC? Look no further! In this video, we'll show you how to enable the slide-to-shut-down feature and boost your productivity. This simple trick will save you time and make you a Windows 10 pro.

Enabling the Slide-to-Shut-Down Feature:

First you have to go to Desktop and create a shortcut.

Then you have to give it the name: slidetoshutdown.exe.

After that click Next and Finish.

Now you have made the SlideToShutdown feature but every time you want to use it, you have to double click it which is annoying.
For that, let's create a shortcut key for it.
Right-click on the shortcut and go ton Properties.

In the Shortcut Key field, give your favorite shortcut and It will be used every time you want to do SlideToshutdown.

Here is the video tutorial of it:

In conclusion, enabling the slide-to-shut-down feature on Windows 10 is a simple trick that can boost your productivity and save you time. By following the tips and tricks in this video, you'll be a Windows 10 pro in no time!

Follow me for more!

Instagram: https://instagram.com/@tahirdotdev
Facebook: https://facebook.com/@tahirdotdev
YouTube: https://youtube.com/@tahirdotdev

Don't Panic! Recover Your Windows Crash with System Restore Points

TahirDotDev — Mon, 01 Jul 2024 02:44:28 +0000

Has your once-reliable Windows PC become sluggish, unstable, or even crashed entirely? Don't despair! Before you consider drastic measures like a full system reinstall, there's a handy built-in tool called System Restore Point that can be your digital guardian angel.

What is System Restore Point?

Think of a System Restore Point as a time machine for your computer. It takes a snapshot of your system's settings, files, and drivers at a specific point in time. This allows you to revert your PC back to that state if something goes wrong in the future, like a bad software installation or a buggy update.

Here is a video tutorial of my YouTube channel to assist you:

https://www.youtube.com/watch?v=CDHg_P5ZJKM

Why Use System Restore Point?

Recover from Software Issues: Installed a new program that messed things up? System Restore can take you back to a point before the installation, effectively undoing the damage.
Rollback Faulty Updates: Sometimes, Windows updates can introduce problems. System Restore lets you revert to a point before the update, giving you time to wait for a fix.
Rescue from System Instability: Experiencing random crashes, freezes, or strange behavior? Restoring to a stable point can get your PC back on track.

Here's How to Use System Restore Point:

Enable System Protection (if not already on):

Search for "System Protection" in the Windows search bar.
Click "Create a restore point" under the relevant drive (usually C:).
Enable "Turn on system protection" and allocate some disk space for restore points (e.g., 5-10%).
Click "Apply" and "OK" to activate System Protection.

*Performing a System Restore: *

Search for "Control Panel" and open it.
Search for "Recovery" and select "Open System Restore."
Click "Next" to proceed with system restore.
Choose a desired restore point (ideally one created before the issue started).
Confirm your selection and click "Finish" to initiate the restore process.

Important Notes:

System Restore won't affect your personal files like documents, photos, or music.
However, it will remove applications, drivers, and updates installed after the chosen restore point.
Make sure you have a recent backup of important data before performing a System Restore.

By having System Restore Points enabled, you gain a valuable safety net against software mishaps. So, create restore points regularly, especially before installing new programs or applying major updates. Remember, prevention is always better than cure, and System Restore Point can be your knight in shining armor when your Windows PC needs a reset!

Follow for more!

Instagram: https://instagram.com/@tahirdotdev
Facebook: https://facebook.com/@tahirdotdev
YouTube: https://youtube.com/@tahirdotdev

Linking Git with GitHub and Android Studio: A Step-by-Step Guide

TahirDotDev — Mon, 20 May 2024 04:07:35 +0000

Integrating Git with GitHub and Android Studio can significantly streamline your development workflow, providing robust version control and easy collaboration. Whether you’re a solo developer or part of a team, this guide will walk you through the process of linking Git, GitHub, and Android Studio seamlessly.

Step 1: Setting Up Git

Before you can link Git with GitHub and Android Studio, you need to have Git installed on your system.

Install Git:

Windows: Download and install Git from git-scm.com.
macOS: Use Homebrew to install Git with brew install git.
Linux: Install Git using your package manager, e.g., sudo apt-get install git for Debian-based systems.

Configure Git: Open a terminal and set your global username and email for Git:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

Step 2: Creating a GitHub Repository

Sign Up for GitHub: If you don’t have an account, sign up at GitHub.
Create a Repository:

Go to GitHub and click the “New” button to create a new repository.
Enter a repository name, description (optional), and choose visibility (public or private).
Initialize the repository with a README (optional) and choose a .gitignore template for Android.
Click "Create repository".

Step 3: Cloning the Repository in Android Studio

Open Android Studio and select "Check out project from Version Control" from the Welcome screen. If a project is already open, go to File > New > Project from Version Control > Git.
Enter Repository URL: In the URL field, paste the URL of the GitHub repository you created. This URL can be found on the GitHub repository page (typically looks like https://github.com/username/repository.git).
Clone: Click "Clone". Android Studio will clone the repository to your local machine and open it.

Step 4: Initializing a Local Repository (if not already done)

If your project is already in Android Studio and you want to link it to a new GitHub repository:

Enable Version Control Integration:

Go to VCS > Enable Version Control Integration.
Select "Git" and click "OK".

Create a Local Repository:

Open the Terminal in Android Studio and initialize a Git repository by running:

git init

Add all existing project files to the repository:

git add .
git commit -m "Initial commit"

Add Remote Repository:

In the terminal, add the GitHub repository as a remote:

git remote add origin https://github.com/username/repository.git

Push your local commits to GitHub:

git push -u origin master

Step 5: Using Git Features in Android Studio

With Git linked to GitHub and Android Studio, you can now leverage version control features directly within the IDE.

Commit Changes:

Make changes to your project files.
Go to VCS > Commit, or use the "Commit" button in the Version Control tool window.
Write a meaningful commit message and click "Commit" or "Commit and Push" to push changes directly to GitHub.

Pull and Fetch:

To update your local repository with changes from GitHub, go to VCS > Git > Pull.
To fetch changes without merging them, go to VCS > Git > Fetch.

Branching:

Create and manage branches via VCS > Git > Branches.
To create a new branch, select "New Branch", enter a branch name, and click "OK".
Switch between branches by selecting the desired branch from the "Branches" menu.

Merge:

To merge a branch into your current branch, go to VCS > Git > Merge Changes.

Step 6: Collaborating with Pull Requests

To collaborate with others, use GitHub's pull request feature:

Push your branch to GitHub:

git push origin your-branch-name

Create a Pull Request:

Go to your GitHub repository, click on "Pull Requests", and then "New Pull Request".
Select the branch you want to merge into the base branch (e.g., master).
Review the changes, add comments if necessary, and click "Create Pull Request".

By integrating Git with GitHub and Android Studio, you can enhance your development workflow, improve collaboration, and maintain a clear project history. Following these steps ensures that you can manage your code effectively, track changes, and collaborate seamlessly with your team. Happy coding!

Kickstart Your Journey into Android Development with Java

TahirDotDev — Sat, 18 May 2024 13:43:21 +0000

Introduction

In the dynamic world of technology, mobile app development has taken center stage. With millions of apps available on the Google Play Store, Android remains a dominant force in the mobile operating system market. For aspiring developers, mastering Android development using Java can open up a world of opportunities. Whether you're building a simple utility app or the next big social media platform, Java provides a robust foundation for creating powerful and user-friendly Android applications. In this blog post, we'll explore why Java is an excellent choice for Android development and guide you through the essential steps to get started.

Why Choose Java for Android Development?

Proven and Reliable: Java has been around for decades and is known for its stability and performance. It's the original language for Android development, which means it has extensive documentation, a large community, and plenty of libraries to support your development process.
Object-Oriented: Java’s object-oriented nature allows developers to create modular programs and reusable code, making the development process more efficient and organized.
Comprehensive Libraries: Java boasts a wide array of libraries and tools that simplify many aspects of Android development, from UI design to network communication.
Platform Independence: Java's "write once, run anywhere" philosophy means that your code can run on any device that supports the Java Virtual Machine (JVM), which is particularly useful for cross-platform development.

Getting Started with Android Development in Java

Step 1: Setting Up Your Development Environment

To start developing Android apps in Java, you'll need to set up your development environment. Here's what you'll need:

Java Development Kit (JDK): Download and install the latest version of the JDK from the Oracle website.
Android Studio: This is the official Integrated Development Environment (IDE) for Android development. You can download it from the Android developer website.

Step 2: Creating Your First Android Project

Once your environment is set up, follow these steps to create a new Android project:

Open Android Studio and click on "Start a new Android Studio project."
Configure your project: Enter your project name, package name, and save location. Choose the language (Java) and the minimum API level for your app.
Select a Template: Android Studio provides various templates to get you started. For beginners, the "Empty Activity" template is a good choice.
Set Up the Activity: Name your activity (e.g., MainActivity) and finish the setup

Step 3: Understanding the Project Structure

An Android project in Java typically consists of:

Java Folder: Contains your Java source files, including your activities and any helper classes.
Res Folder: Houses your app’s resources, such as layouts (XML files), images, and strings.
Manifest File: The AndroidManifest.xml file contains essential information about your app, including its components and permissions.

Step 4: Designing the User Interface

Android Studio’s layout editor allows you to design your app’s UI using a drag-and-drop interface or by editing XML directly. Here’s a simple example of an XML layout file for a basic activity:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/welcomeText"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Welcome to Android Development!"
        android:textSize="20sp"
        android:layout_centerInParent="true"/>
</RelativeLayout>

Step 5: Writing Your First Java Code

With your UI set up, it’s time to write some Java code. Open your MainActivity.java file and add the following code to display a welcome message:

package com.example.myfirstapp;

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // Find the TextView by its ID and set a welcome message
        TextView welcomeText = findViewById(R.id.welcomeText);
        welcomeText.setText("Hello, Android Developers!");
    }
}

Step 6: Running Your App

Connect an Android device to your computer or set up an Android Virtual Device (AVD) using the AVD Manager in Android Studio. Click the "Run" button (the green play icon) in Android Studio to build and run your app.

Conclusion
Congratulations! You've just created your first Android app using Java. As you continue your journey, explore more advanced topics like database management, networking, and integrating third-party libraries. The possibilities are endless, and with a strong foundation in Java, you're well on your way to becoming a proficient Android developer. Happy coding!

Additional Resources

By leveraging Java's power and flexibility, you can create impressive Android applications that stand out in the competitive mobile app market. Dive in, experiment, and let your creativity flourish!

Java OOPs

TahirDotDev — Sat, 18 May 2024 13:25:36 +0000

1. Class and Object
Class:
A class is a blueprint for creating objects. It defines a datatype by bundling data and methods that work on the data into one single unit.

public class Car {
    // Fields (variables)
    String color;
    String model;
    int year;

    // Methods
    void displayInfo() {
        System.out.println("Model: " + model);
        System.out.println("Color: " + color);
        System.out.println("Year: " + year);
    }
}

Object:
An object is an instance of a class. When a class is instantiated, memory is allocated, and a reference to that memory is returned.

public class Main {
    public static void main(String[] args) {
        // Creating an object of the Car class
        Car myCar = new Car();
        myCar.color = "Red";
        myCar.model = "Toyota";
        myCar.year = 2021;

        myCar.displayInfo();
    }
}

2. Encapsulation
Encapsulation is the mechanism of restricting access to some of the object's components and protecting the object's state from unauthorized access and modification. This is achieved through access modifiers (private, public, protected).

public class Person {
    // Private fields
    private String name;
    private int age;

    // Public getter and setter methods
    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;
        }
    }
}

3. Inheritance
Inheritance is a mechanism wherein a new class inherits the properties and behavior (methods) of an existing class. The existing class is called the superclass, and the new class is called the subclass.

// Superclass
public class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

// Subclass
public class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // Inherited method
        myDog.bark(); // Subclass method
    }
}

4. Polymorphism
Polymorphism means "many forms," and it allows one interface to be used for a general class of actions. The specific action is determined by the exact nature of the situation. Polymorphism can be achieved through method overriding and method overloading.

Method Overriding:
When a subclass provides a specific implementation of a method that is already defined in its superclass.

public class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        myAnimal.sound();  // Outputs: Dog barks
    }
}

Method Overloading:
When two or more methods in the same class have the same name but different parameters.

public class MathOperation {
    // Method overloading by changing the number of parameters
    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Main {
    public static void main(String[] args) {
        MathOperation math = new MathOperation();
        System.out.println(math.add(5, 3));      // Outputs: 8
        System.out.println(math.add(5, 3, 2));   // Outputs: 10
    }
}

5. Abstraction
Abstraction is the concept of hiding the complex implementation details and showing only the essential features of the object. This can be achieved using abstract classes and interfaces.

Abstract Class:
An abstract class cannot be instantiated and can contain abstract methods which are methods without implementation.

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape myShape = new Circle();
        myShape.draw();  // Outputs: Drawing a circle
    }
}

Interface:
An interface is a reference type in Java, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types.

interface Animal {
    void eat();
    void sleep();
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats");
    }

    @Override
    public void sleep() {
        System.out.println("Dog sleeps");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();   // Outputs: Dog eats
        myDog.sleep(); // Outputs: Dog sleeps
    }
}

These are the core concepts of OOP in Java. By understanding and applying these principles, you can create well-structured, reusable, and maintainable code.