Category Archives: Software Development

Java learned as so far:

Posted on September 17, 2020 | Leave a comment

Java variables,
Array, 2d array
Method
Different method invoking and return type
Class
– Class is actually a blueprint/specification/design
– A class can create as many as objects it needs to create
Object
– Earth is a software application where human and other thing is software objects.For creating object we need to create a human class
– Objects do particular behavior in a class
– Object exist only in application runtime actually when application is running
– Objects have identity,state and behavior
–
this keyword – it represent current object
Instance
Constructor – The costructor is a special method with the same name as the class and it’s used to instantiate objects from that class
– Every class has a by default constructor if we don’t put it manually
– The constructor is special method containing instructions for object creation. it can be said it is so called birth method. It has instructions for how the object will be born when the application starts up
Static keyword
Stack and heap memory
Garbage collection
Object oriented Programming = better organizing of code, it is a way to organize our code from multiple files by creating objects
Local variable
Reference variable
Instance variable
Inheritance
– Inheritance is the approach to get/transfer behaviour of one class to another
– We use extends keyword for inheriting, in inheritance we inherit from parent class which known as base class and the class which needs inheritation is known as child class or sub class/derived class
– super keyword it extract constructor and it’s variable from parent class but reverse is not possible
Overrides
– Same method name with different purpose
– Same method name in parent class but in child class the method name is same but with different purpose
– Overrides means replace
– Override is not a good idea sometimes so we go for interface
Interfaces
– Interface is a contract with a class. The class needs to implements that method of the interface according to contract
– Interface has a method which does not need body, so it is just only to define, it is called as abstract method
– one parent class
– We use implements keyword while putting interface in a class
Abstract class
– When you don’t need all methods to invoke you can use abstract method, you can not make object from abstract class. Abstract method needs to be in abstract class. We use abstract keyword for both method and object to define abstract class and methods
– you can only extend abstract class but can not instantiate abstract class
– We can define abstract class as a type while creating object
Polymorphism

Loops
Exception Handling

Collection Framework
Wrapper class
Threading
Concurrency
Database

Jshell
Functional Interfaces
Lambda expressions

-Lambda helps us to use separate from associated object
– it can run without class
– We need to use lot of interfaces for this

Streams

Ei bold kora jayga diye project banaye banaye clear korte hobe
Italic kora jaygagula motamuti clear asey In Sha Allah, Alhamdulillah
The source is : Imtiaz Ahmed’s complete Java course

Master Object Oriented Design in Java course note

Association: It defines relationship between classes, it defines how the software will behave
Dependency Association: For example from code:

public class Driver {
    public void drive(Vehicle raceCar){
        raceCar.accelerate();
    }
}

public class Driver {

public void drive(Vehicle raceCar){

raceCar.accelerate();

}

A driver receives a vehicle reference only as driver then only he can drive or accelerate

Composition: A particular object . It imply ownership
for example in this code:

package Lesson_1;

public class Vehicle1 {
    Engine myEngine; //c
    public vehicle(Engine anEngine){
        myEngine=anEngine;
    }

    public void operateVehicle(){
        myEngine.start();
    }
}

package Lesson_1;

public class Vehicle1 {

Engine myEngine; //c

public vehicle(Engine anEngine){

myEngine=anEngine;

}

public void operateVehicle(){

myEngine.start();

}

Aggregation Association: It does not imply ownership

public class SchoolLanguageDepartment{

   SpanishCourse spanish;
   FrenchCourse french;
   HindiCourse hindi;
   BanglaCourse bangla;

}

public class SchoolLanguageDepartment{

SpanishCourse spanish;

FrenchCourse french;

HindiCourse hindi;

BanglaCourse bangla;

}

Here Department to SpanishCourse relation is composite

But Course to Student relationship is not composite because it does not imply ownership a student can take many courses or not

public class HistoryCourse{

  Student[] registeredStudent;

}

public class HistoryCourse{

Student[] registeredStudent;

}

We find this relationship from above diagram, the block diamond and white diamond is the part of UML diagram

Forming Association between objects:

public class NewsPaperCompany{

    Customer customer;

    public void setCustomer(Customer aCustomer){
        customer=aCustomer;
    }


}

public class NewsPaperCompany{

Customer customer;

public void setCustomer(Customer aCustomer){

customer=aCustomer;

}

has a relationship in customer .

Now when to stop delivery

public class Customer{

    NewsPaperCompany paperCompany;

    public void setNewsPaperCompany(NewsPaperCompany aPaperCompany)
    {
        paperCompany=aPaperCompany;
    }

    public void cancelSubscription{
        paperCompany.stopDelivery();
    }
}

public class Customer{

NewsPaperCompany paperCompany;

public void setNewsPaperCompany(NewsPaperCompany aPaperCompany)

{

paperCompany=aPaperCompany;

}

public void cancelSubscription{

paperCompany.stopDelivery();

}

Overview of software design:
For example: Hospital Employee Management System
Task of the software:
Hire and Terminate Employees
Print Reports(XML,CSV Formats)

Problem Statement:
Current status of the software

Tips for design:
– You must draw design in paper or whiteboard don’t go to code directly
– Don’t overdesign or overdraw
– We have to develop iteratively but early steps should be kept simple
– Class names should be nouns based on their intention

Single Responsibility Priniciple(SRP): Not all the things in the same class

Don’t repeat yourself(DRY):

Arrow sign always describe that it is depends on that dependency class:

DAO=Data Access Object

Single Responsibility Principle Special Notes:
A class should have only one single reason to change

Open closed principle sayings about class design:

Classes should be open for extension but closed for modification.

Open Closed Principle and Strategy pattern:
Software modules should be open for extension and closed for modification
In development lifecycle software requirements needs to be constantly pour in. If developed need to change the already made codes the design is fragile. Fragile means broken.

So open closed principle save engineers from fragile design

instanceof operator we used here in the code:
HotelManagementSystem class:

package OpenClosedPrinciple;

public class HospitalManagement {
    public void callUpon(Employee employee){
        if (employee instanceof Nurse){
            checkVitalSigns();
            drawBlood();
            cleanPatientArea();
        }else if (employee instanceof Doctor){
            prescribeMedicine();
            diagnosePatients();
        }
    }


    //Nurses
    private void checkVitalSigns(){
        System.out.println("Checking Vitals");
    }

    private void drawBlood(){
        System.out.println("drawing blood");
    }

    private void cleanPatientArea(){
        System.out.println("cleaning patient Area");
    }
    //Doctors
    public void prescribeMedicine(){
        System.out.println("Prescribed Medicine");
    }

    public void diagnosePatients(){
        System.out.println("Diagnose Patient");
    }

}

package OpenClosedPrinciple;

public class HospitalManagement {

public void callUpon(Employee employee){

if (employee instanceof Nurse){

checkVitalSigns();

drawBlood();

cleanPatientArea();

}else if (employee instanceof Doctor){

prescribeMedicine();

diagnosePatients();

}

//Nurses

private void checkVitalSigns(){

System.out.println("Checking Vitals");

}

private void drawBlood(){

System.out.println("drawing blood");

}

private void cleanPatientArea(){

System.out.println("cleaning patient Area");

}

//Doctors

public void prescribeMedicine(){

System.out.println("Prescribed Medicine");

}

public void diagnosePatients(){

System.out.println("Diagnose Patient");

}

Here it is like a junk drawer

So we will make it changes because it is violating OCP principle. This chamging process is known as Strategy pattern. So let’s do it.

We could also do it with interface class except abstract class

Example after applying Strategy pattern:
Nurse.java

package OpenClosedPrinciple;

public class Nurse extends Employee {


    public Nurse(int id, String name, String department, boolean working) {
        super(id, name, department, working);
        System.out.println("Nurse in action: ");
    }


    private void checkVitalSigns(){
        System.out.println("Checking Vitals");
    }

    private void drawBlood(){
        System.out.println("drawing blood");
    }

    private void cleanPatientArea(){
        System.out.println("cleaning patient Area");
    }


    public void performDuties(){
        checkVitalSigns();
        drawBlood();
        cleanPatientArea();
    }
}

package OpenClosedPrinciple;

public class Nurse extends Employee {

public Nurse(int id, String name, String department, boolean working) {

super(id, name, department, working);

System.out.println("Nurse in action: ");

}

private void checkVitalSigns(){

System.out.println("Checking Vitals");

}

private void drawBlood(){

System.out.println("drawing blood");

}

private void cleanPatientArea(){

System.out.println("cleaning patient Area");

}

public void performDuties(){

checkVitalSigns();

drawBlood();

cleanPatientArea();

}

Doctor,java

package OpenClosedPrinciple;

public class Doctor extends Employee {
    public Doctor(int id, String name, String department, boolean working) {
        super(id, name, department, working);
        System.out.println("Doctor in action..");
    }


    public void prescribeMedicine(){
        System.out.println("Prescribed Medicine");
    }

    public void diagnosePatients(){
        System.out.println("Diagnose Patient");
    }

    public void performDuties(){
        prescribeMedicine();
        diagnosePatients();
    }

}

package OpenClosedPrinciple;

public class Doctor extends Employee {

public Doctor(int id, String name, String department, boolean working) {

super(id, name, department, working);

System.out.println("Doctor in action..");

}

public void prescribeMedicine(){

System.out.println("Prescribed Medicine");

}

public void diagnosePatients(){

System.out.println("Diagnose Patient");

}

public void performDuties(){

prescribeMedicine();

diagnosePatients();

}

HospitalManagement.java

package OpenClosedPrinciple;

public class HospitalManagement {
    public void callUpon(Employee employee){
//        if (employee instanceof Nurse){
//            checkVitalSigns();
//            drawBlood();
//            cleanPatientArea();
//        }else if (employee instanceof Doctor){
//            prescribeMedicine();
//            diagnosePatients();
//        }
        employee.performDuties();
    }





}

package OpenClosedPrinciple;

public class HospitalManagement {

public void callUpon(Employee employee){

// if (employee instanceof Nurse){

// checkVitalSigns();

// drawBlood();

// cleanPatientArea();

// }else if (employee instanceof Doctor){

// prescribeMedicine();

// diagnosePatients();

// }

employee.performDuties();

}

Employee.java

package OpenClosedPrinciple;

abstract public class Employee {
    private int id;
    private String name;
    private String department;
    private boolean working;


    public Employee(int id, String name, String department, boolean working) {
        this.id = id;
        this.name = name;
        this.department = department;
        this.working = working;
    }

    public abstract void performDuties();

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", department='" + department + '\'' +
                ", working=" + working +
                '}';
    }
}

package OpenClosedPrinciple;

abstract public class Employee {

private int id;

private String name;

private String department;

private boolean working;

public Employee(int id, String name, String department, boolean working) {

this.id = id;

this.name = name;

this.department = department;

this.working = working;

}

public abstract void performDuties();

@Override

public String toString() {

return "Employee{" +

"id=" + id +

", name='" + name + '\'' +

", department='" + department + '\'' +

", working=" + working +

'}';

}

EmergencyRoomProcess.java

package OpenClosedPrinciple;

public class EmergencyRoomProcess {
    public static void main(String[] args) {
        HospitalManagement ERDirector=new HospitalManagement();
        Employee peggy=new Nurse(1, "Peggy","Emergency Department",true);
        ERDirector.callUpon(peggy);

        Employee suzan = new Doctor(2,"Suzan","Emergency",true);
        ERDirector.callUpon(suzan);

    }
}

package OpenClosedPrinciple;

public class EmergencyRoomProcess {

public static void main(String[] args) {

HospitalManagement ERDirector=new HospitalManagement();

Employee peggy=new Nurse(1, "Peggy","Emergency Department",true);

ERDirector.callUpon(peggy);

Employee suzan = new Doctor(2,"Suzan","Emergency",true);

ERDirector.callUpon(suzan);

}

To String Tutorial:

DemoToString.java

package SomeBasicThingsPractice;

public class DemoToString {
    public static void main(String[] args) {

        Student s1=new Student(11,"Robin");
//        System.out.println(s1.sname);
//        System.out.println(s1.rollno);
        System.out.println(s1.toString());
    }


}

class Student{
    int rollno;
    String sname;

    public Student(int rollno, String sname) {
        this.rollno = rollno;
        this.sname = sname;
    }


    public String toString(){
        return "Student name is: "+sname+" and roll no:"+rollno;
    }
}

package SomeBasicThingsPractice;

public class DemoToString {

public static void main(String[] args) {

Student s1=new Student(11,"Robin");

// System.out.println(s1.sname);

// System.out.println(s1.rollno);

System.out.println(s1.toString());

}

class Student{

int rollno;

String sname;

public Student(int rollno, String sname) {

this.rollno = rollno;

this.sname = sname;

}

public String toString(){

return "Student name is: "+sname+" and roll no:"+rollno;

}

Dependency Inversion Principle:
Device Manufacturing Company has:

The manufacturing process:
1. Assembly
2. Testing
3. Packaging
4. Storage

GeneralMAnufacturingProcess
UML diagram:

We depend on something in driving like car is stopping by traffic light
Imagine a life every car has different mechanism
Violation of Dependency Inversion Principle
When higher level modules depend on lower level ones succeptible to change
Dangers of coupling:
Tight coupling :

Well design software has single responsibility
This method says high level modules should not depend on lowlevel modules. It should depend on abstractions
Abstract classes and Interfaces don’t change as often as concrete classes/ derivatives
Cohesion means related things together.

This code I tried to run in class inside class but did not worked. Then I downloaded course code and run worked then again I tried to do with my directory structure then it worked.

Quizes from OOP course:
Q1:
Q2: The Dependency Inversion Principle states
Interfaces and abstract classes change far less often the concrete derivatives. Concrete classes should depend on Interfaces and abstract classes because they change less often and are higher level modules

Q3: In general the dependency inversion principle states that code should only depend on things that don’t change often
True
Liskov Substitution Principle:
Subtypes must be substitutable for their basetypes

There are some patterns which is not good known as Anti-pattern:
Here the link can be found

This is a ISA relationship, Nurse and Doctor depends on Employee class. Employee class is Abstract class

When it is adding a substitute teacher who does not work as like a teacher it violates the LISKOV pronciple as per this line of definition: Subtypes must be substitutable for their basetypes

So we changed to a new UML which does not violate LISKOV principle and did the code.

New UML:

Question 1:
The Liskov Substitution principle states, that child classes should not be substitutable in place of their parents.

Interface Segregation Principle:

Fat class is a class which has too many responsibilities.

CustomerTransaction

import java.util.Date;
import java.util.List;

public class CustomerTransaction implements Accounting, Reporting {

    private List<Product> products;
    private Customer customer;

    public CustomerTransaction(Customer customer,List<Product> products){
            this.products=products;
            this.customer=customer;
    }

    //methods for reporting
    @Override
    public String getName(){
        return "name";
    }

    @Override
    public Date getDate(){
        return new Date();
    }

    @Override
    public String getProductBreakDown(){
        String reportlist = null;
        for(Product product: products){
            reportlist+=product.getProductName();
        }
        return  reportlist;
    }

    @Override
    public void prepareInvoice(){
        System.out.println("invoice prepared....");
    }

    @Override
    public void chargeCustomer(){
    System.out.println("charged the customer");
    }


}

import java.util.Date;

import java.util.List;

public class CustomerTransaction implements Accounting, Reporting {

private List<Product> products;

private Customer customer;

public CustomerTransaction(Customer customer,List<Product> products){

this.products=products;

this.customer=customer;

}

//methods for reporting

@Override

public String getName(){

return "name";

}

@Override

public Date getDate(){

return new Date();

}

@Override

public String getProductBreakDown(){

String reportlist = null;

for(Product product: products){

reportlist+=product.getProductName();

}

return reportlist;

}

@Override

public void prepareInvoice(){

System.out.println("invoice prepared....");

}

@Override

public void chargeCustomer(){

System.out.println("charged the customer");

}

public class AccountsReceivable {

    private CustomerTransaction transactionObject;


    public AccountsReceivable(CustomerTransaction aTransaction){
        transactionObject=aTransaction;
    }

    public void postPayment(){
        transactionObject.chargeCustomer();
    }

    public void sendInvoice(){
        transactionObject.prepareInvoice();
    }




}

public class AccountsReceivable {

private CustomerTransaction transactionObject;

public AccountsReceivable(CustomerTransaction aTransaction){

transactionObject=aTransaction;

}

public void postPayment(){

transactionObject.chargeCustomer();

}

public void sendInvoice(){

transactionObject.prepareInvoice();

}

public class Product {

private int productID;

    public int getProductID() {
        return productID;
    }

    public void setProductID(int productID) {
        this.productID = productID;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    private String productName;

}

public class Product {

private int productID;

public int getProductID() {

return productID;

}

public void setProductID(int productID) {

this.productID = productID;

}

public String getProductName() {

return productName;

}

public void setProductName(String productName) {

this.productName = productName;

}

private String productName;

}

public class Customer {
    private String name;


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Customer {

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public class ReportGenerator {


    private Reporting transactionObject;

    public void generateReport(){
        System.out.println(transactionObject.getName()+" "+transactionObject.getProductBreakDown()+" "+transactionObject.getDate());
    }

}

public class ReportGenerator {

private Reporting transactionObject;

public void generateReport(){

System.out.println(transactionObject.getName()+" "+transactionObject.getProductBreakDown()+" "+transactionObject.getDate());

}

import java.util.Date;

public interface Reporting {
    //methods for reporting
    String getName();

    Date getDate();

    String getProductBreakDown();
}

import java.util.Date;

public interface Reporting {

//methods for reporting

String getName();

Date getDate();

String getProductBreakDown();

}

public interface Accounting {
    void prepareInvoice();

    void chargeCustomer();
}

public interface Accounting {

void prepareInvoice();

void chargeCustomer();

}

From Quiz: Main Kotha about Interface Segregation Principle:

This principle does not have to do with the number of dependencies that may exist in an application. The principle simply states that modules should not have dependencies on code they do not use.

If a module does not use functionality from another module, there is no reason to have a direct dependency between them. There should be an abstraction in between to segregate the 2 modules

Dependency Injection:
When the application is not running there is no object because onbject only available in runtime, you will find only some classes

Tight Coupling:
Cohesion:
A very popular dependency injection implementation is spring framework bundled with spring container.

Dependency injection is

Dependency Injection Using Spring:
Observer Pattern:
The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.
One basic UML diagram from wikipedia:

Created one for the course:

Builder Pattern:
When there is so many constructors and tough to handle it. Example codes with some bugs. Will do the solution later.

code example:
user.java

import java.lang.module.ModuleDescriptor;

public class User {
    private String userName; //Required
    private String emailAddress; //Required
    private String firstName; //Optional
    private String lastName; //Optional
    private int phoneNumber; //Optional
    private String address; //Optional

    public User(Builder builder) {
        this.userName=builder.userName;
        this.emailAddress=builder.emailAddress;
        this.firstName=builder.firstName;
        this.phoneNumber=builder.phoneNumber;
        this.address=builder.address;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", emailAddress='" + emailAddress + '\'' +
                ", firstName='" + firstName + '\'' +
                ", lastName='" + lastName + '\'' +
                ", phoneNumber=" + phoneNumber +
                ", address='" + address + '\'' +
                '}';
    }



    public static class Builder{
        private String userName; //Required
        private String emailAddress; //Required
        private String firstName; //Optional
        private String lastName; //Optional
        private int phoneNumber; //Optional
        private String address; //Optional

        public Builder(String userName,String email){
            this.userName=userName;
            this.emailAddress=email;
        }

        public Builder firstName(String value){
            this.firstName=value;
            return this;
        }

        public Builder lastName(String value){
            this.lastName=value;
            return this;
        }

        public User build(){
            return new User(this);
        }

    }

}

import java.lang.module.ModuleDescriptor;

public class User {

private String userName; //Required

private String emailAddress; //Required

private String firstName; //Optional

private String lastName; //Optional

private int phoneNumber; //Optional

private String address; //Optional

public User(Builder builder) {

this.userName=builder.userName;

this.emailAddress=builder.emailAddress;

this.firstName=builder.firstName;

this.phoneNumber=builder.phoneNumber;

this.address=builder.address;

}

@Override

public String toString() {

return "User{" +

"userName='" + userName + '\'' +

", emailAddress='" + emailAddress + '\'' +

", firstName='" + firstName + '\'' +

", lastName='" + lastName + '\'' +

", phoneNumber=" + phoneNumber +

", address='" + address + '\'' +

'}';

}

public static class Builder{

private String userName; //Required

private String emailAddress; //Required

private String firstName; //Optional

private String lastName; //Optional

private int phoneNumber; //Optional

private String address; //Optional

public Builder(String userName,String email){

this.userName=userName;

this.emailAddress=email;

}

public Builder firstName(String value){

this.firstName=value;

return this;

}

public Builder lastName(String value){

this.lastName=value;

return this;

}

public User build(){

return new User(this);

}

app.java

public class App {
    public static void main(String[] args) {
        User websiteUser = new User.Builder("bobMax", "bob@bob.com").firstName("bob").lastName("max").build();


        System.out.println(websiteUser);
    }
}

public class App {

public static void main(String[] args) {

User websiteUser = new User.Builder("bobMax", "[email protected]").firstName("bob").lastName("max").build();

System.out.println(websiteUser);

}

Factory Pattern:

UML Diagram:

codes:
Vehicle.java

public interface Vehicle {
   public void startEngine();
}

public interface Vehicle {

public void startEngine();

}

VehicleFactory.java

public class VehicleFactory {
    public Vehicle getVehicle(VehicleType vehicleType)
    {
        return vehicleType.getVehicle();
    }

}

public class VehicleFactory {

public Vehicle getVehicle(VehicleType vehicleType)

{

return vehicleType.getVehicle();

}

App.java

public class App {
    public static void main(String[] args) {
        VehicleFactory vehicleFactory=new VehicleFactory();
        Vehicle vehicle=vehicleFactory.getVehicle(VehicleType.ELECTRIC);
        vehicle.startEngine();
    }
}

public class App {

public static void main(String[] args) {

VehicleFactory vehicleFactory=new VehicleFactory();

Vehicle vehicle=vehicleFactory.getVehicle(VehicleType.ELECTRIC);

vehicle.startEngine();

}

VehicleType.java

public enum VehicleType {
    TRUCK {
        public Vehicle getVehicle() {
            return new Truck();
        }
    }, CAR {
        public Vehicle getVehicle() {
            return new Car();
        }
    }, ELECTRIC {
        public Vehicle getVehicle() {
            return new ElectricCar();
        }


    };


    abstract Vehicle getVehicle();

    }

public enum VehicleType {

TRUCK {

public Vehicle getVehicle() {

return new Truck();

}

}, CAR {

public Vehicle getVehicle() {

return new Car();

}

}, ELECTRIC {

public Vehicle getVehicle() {

return new ElectricCar();

}

};

abstract Vehicle getVehicle();

}

ElectricCar.java

public class ElectricCar implements Vehicle{

    @Override
    public void startEngine() {
        System.out.println("push button started electric car´s engine");
    }
}

public class ElectricCar implements Vehicle{

@Override

public void startEngine() {

System.out.println("push button started electric car´s engine");

}

Car.java

public class Car implements Vehicle{
    public void startEngine(){
        System.out.println("started simple engine");
    }
}

public class Car implements Vehicle{

public void startEngine(){

System.out.println("started simple engine");

}

Truck.java

public class Truck implements Vehicle {

    @Override
    public void startEngine() {
        System.out.println("started a large engine");
    }
}

public class Truck implements Vehicle {

@Override

public void startEngine() {

System.out.println("started a large engine");

}

Singleton Design Pattern: It only uses once in an application.

PerformanceStage

public class PerformanceStage {
    //private constructor for singleton
    private static int counter;
    private static PerformanceStage INSTANCE=null;

    private PerformanceStage(){
        counter++;
    }
    public synchronized static PerformanceStage getInstance(){
        if(INSTANCE==null){
            INSTANCE = new PerformanceStage();
        }
        return INSTANCE;
    }

    public void turnOnLights(){
        System.out.println("turned on lights...");
    }

    public int getCounter(){
        return counter;
    }

}

public class PerformanceStage {

//private constructor for singleton

private static int counter;

private static PerformanceStage INSTANCE=null;

private PerformanceStage(){

counter++;

}

public synchronized static PerformanceStage getInstance(){

if(INSTANCE==null){

INSTANCE = new PerformanceStage();

}

return INSTANCE;

}

public void turnOnLights(){

System.out.println("turned on lights...");

}

public int getCounter(){

return counter;

}

Application.java

public class Application {
    public static void main(String[] args) {
        PerformanceStage stage=PerformanceStage.getInstance();
        stage.turnOnLights();
        System.out.println(stage.getCounter());


        PerformanceStage stage2=new PerformanceStage();
        PerformanceStage stage3=new PerformanceStage();
        PerformanceStage stage4=new PerformanceStage();
        PerformanceStage stage5=new PerformanceStage();

        System.out.println(stage3.getCounter());
    }
}

public class Application {

public static void main(String[] args) {

PerformanceStage stage=PerformanceStage.getInstance();

stage.turnOnLights();

System.out.println(stage.getCounter());

PerformanceStage stage2=new PerformanceStage();

PerformanceStage stage3=new PerformanceStage();

PerformanceStage stage4=new PerformanceStage();

PerformanceStage stage5=new PerformanceStage();

System.out.println(stage3.getCounter());

}

Course Source Imtiaz Ahmed Master OOP Design udemy course
Best Book Rereference/Website reference for learning Java: https://beginnersbook.com/2013/12/java-string-equals-and-equalsignorecase-methods-example/

Leave a comment

Posted in Design Patterns Implementations, Java, Java, Object Notation, OO Analysis and Design, OOP, Pattern Oriented Software Architecture(POS), Software Engineering

Tagged Design Patterns, Java, Object Oriented Analysis and Design, OOAD, OOP

Why we need design patterns, the most important design patterns

Posted on September 16, 2020 | Leave a comment

Singleton
Facade pattern[fassad]
Adapter/Bridge pattern
Strategy pattern
Observer pattern

Leave a comment

Posted in Design Patterns Implementations

Design Pattern and Object oriented Data Analaysis

Posted on June 13, 2020 | Leave a comment

Writing here to clearing engineering concept of a software for future reference.

Example for Class, Constructors and Methods:

Main.java

public static void main(String[] args)
{
User user=new User("Zaki",30);
//user.name="Zaki";

//System.out.println(user.name);
user.sayHello();
}

public static void main(String[] args)

{

User user=new User("Zaki",30);

//user.name="Zaki";

//System.out.println(user.name);

user.sayHello();

}

User.java

public class User{
	//defining the attribute
	public String name;
		
	//constructor creation
	public User(String name, int age){
		this.name=name;
	}
	
	//method creation
	public void sayHello{
		System.out.println("This is "+name);
	}
	
	//a interface is a contract a capability that a class should provide
//interface we can build loose coupled calculator

}

public class User{

//defining the attribute

public String name;

//constructor creation

public User(String name, int age){

this.name=name;

}

//method creation

public void sayHello{

System.out.println("This is "+name);

}

//a interface is a contract a capability that a class should provide

//interface we can build loose coupled calculator

}

Interface Example

Leave a comment

Posted in Design Patterns Implementations, OO Analysis and Design, OOP

Design Pattern:Cohesion in Java

Posted on December 15, 2019 | Leave a comment

I did not understand well from this link:
https://www.geeksforgeeks.org/cohesion-in-java/

Leave a comment

Posted in Design Patterns Implementations

Github in Ubuntu

Posted on November 10, 2019 | Leave a comment

git push -u origin master

1	git push -u origin master

Leave a comment

Posted in git, Github, Version Control/SVN

Cyclometic Complexity

Posted on November 1, 2019 | Leave a comment

Leave a comment

Posted in Software Development, Software Development Life Cycle(SDLC)

LICT .NET Training | Kamal Protap Sir | Part 6

Posted on January 10, 2018 | Leave a comment

19.11.17 Videos:
Relationships:
Inheritance, Association, Aggregation and Composition
These are except that inheritance
From the slide:
Association:
Relation between students and teacher. Both are independent.
Manager has a swipe card to enter the company premises Association
Inheritance:
A manager is a type of Employee. Employee is a parent of manager
Aggregation:
These kind of relationship is called Aggregations. It represents a Has-A relationship.
public class Manager{
//aggregation relation
public List<Worker> workers=new List<Worker>();
//here worker is the child object and manager is the parent object

}

public class Worker{

public string WorkerName=” “;

Worker object=new Objects;

}
Composition(Death Relationships)

StringBuilder:

It is very useful while string can make complexity in heap but StringBuilder helps to reduce it by modifed string.

System.Text.StringBuilder class can be used and it comes from System.Text namespace

StringBuilder is mutable
StringBuilder performs faster than string when appending multiple string values

StringBuilder sb=new StringBuilder();

Use append method to add or append strings with StringBuilder
Use ToString() method to get the string from StringBuilder

Relationships Code and Videos:

Manager( is a )type of employee(Employee is a parent of Manager) – Inheritance
Manager ( has a ) swipe card to enter company premises – Association
He has many workers under him. – Aggregation relationship
His salary depend on project success. – Composition
Project success depends on a manager. –

I have completed the program may be I need to do it / practice it letter with heart. 🙂

Leave a comment

Posted in LICT

C# IEnumerable vs IEnumerator

Posted on January 9, 2018 | Leave a comment

When we work with Collections in C# we need to iterate the items of collections. One way fo doing is this foreach loop.

The class should implenet IEnumerable interface. The IEnumerable interface also inehirts from IEnumerator interface/

codes:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IEnumerableandIEnumerator
{
    class Player
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public Player(string name, int age)
        {
            Name = name;
            Age = age;
        }
    }

    class Team:IEnumerable
    {
       private Player[] playerArray=new Player[4]; //aggregated class

        public Team()
        {
            playerArray[0] = new Player("Virat", 28);
            playerArray[1] = new Player("Dhoni", 35);
            playerArray[2] = new Player("Rohit", 29);
            playerArray[3]= new Player("Yuvraj",34);
        }

        public IEnumerator GetEnumerator()
        {
            return playerArray.GetEnumerator();
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            
            //string[] PlayerArray = {"Virat", "Rohit", "Dhoni"};
            //foreach (var items in PlayerArray)
            //{
            //    Console.WriteLine("Player is {0}",items);
            //}
            Team obj=new Team();

            foreach (Player iteemPlayer in obj)
            {
                Console.WriteLine("Name is {0} and Age is {1}",iteemPlayer.Name,iteemPlayer.Age);
            }
            Console.ReadLine();
        }
    }
}

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace IEnumerableandIEnumerator

{

class Player

{

public string Name { get; set; }

public int Age { get; set; }

public Player(string name, int age)

{

Name = name;

Age = age;

}

class Team:IEnumerable

{

private Player[] playerArray=new Player[4]; //aggregated class

public Team()

{

playerArray[0] = new Player("Virat", 28);

playerArray[1] = new Player("Dhoni", 35);

playerArray[2] = new Player("Rohit", 29);

playerArray[3]= new Player("Yuvraj",34);

}

public IEnumerator GetEnumerator()

{

return playerArray.GetEnumerator();

}

class Program

{

static void Main(string[] args)

{

//string[] PlayerArray = {"Virat", "Rohit", "Dhoni"};

//foreach (var items in PlayerArray)

//{

// Console.WriteLine("Player is {0}",items);

//}

Team obj=new Team();

foreach (Player iteemPlayer in obj)

{

Console.WriteLine("Name is {0} and Age is {1}",iteemPlayer.Name,iteemPlayer.Age);

}

Console.ReadLine();

}

Leave a comment

Posted in .NET

LICT .NET Training | Kamal Protap Sir | Part 5

Posted on January 7, 2018 | Leave a comment

16/11/2017 vids

ExtensionMethod
Object Initializer
CollectionInitializer
QueryExpression
– It contains three clauses
from, where, orderby
Linq
IEnumerable

Diffrenet Datasource:
Array, Database, XML,LIST/Collection also datasource, File Concept also data source
Data we can able to store in known as data source
Data source: Where the data is available

using System;
using System.Collections.Generic;
using System.Linq;

namespace linqSample
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] num=new int[5]{45, 78,45,34,2};
            IEnumerable<int> res=from N in num
                                 where N>40
                                 orderby N
                                 select N;

            foreach (var item in res)
            {
                Console.WriteLine(res);
            }

            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

namespace linqSample

{

class Program

{

static void Main(string[] args)

{

int[] num=new int[5]{45, 78,45,34,2};

IEnumerable<int> res=from N in num

where N>40

orderby N

select N;

foreach (var item in res)

{

Console.WriteLine(res);

}

Console.ReadKey();

}

Linq-Language Integrated Query
What is strongly typed ?

Strongly typed means:
Which show error immediately at a time of declaration that is called strongly typed. It is also called compile time error.

Weakly typed means:
Which show error in runtime is called weakly typed like delegate.It is also known as loosely type.

Intellisense and Strongly typed is supproted in LINQ concept.

LINQ enabled data sources is very very important for interview:
LINQ to Objects : It means with array, arralist, etc.
LINQ to Datasets: It’s connected with ADO.NET
LINQ to SQL: It’s connected to SQL
LINQ to Entities: It’s connected to other data base like oracle or mysql
LINQ to XML: It’s connected to XML files

IQueryable
Where IQueryable is inherited from IEnumerable
IEnumerable

There are two expression in LINQ QueryExpression and methodExpression

Differed Execution:

using System;
using System.Collections.Generic;
using System.Linq;

namespace linqSample
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] num=new int[5]{45,78,45,34,2};
            IEnumerable<int> res=from N in num
                                 where N>40
                                 orderby N descending 
                                 select N;

            foreach (var item in res)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

namespace linqSample

{

class Program

{

static void Main(string[] args)

{

int[] num=new int[5]{45,78,45,34,2};

IEnumerable<int> res=from N in num

where N>40

orderby N descending

select N;

foreach (var item in res)

{

Console.WriteLine(item);

}

Console.ReadKey();

}

Forced Execution:

using System;
using System.Collections.Generic;
using System.Linq;

namespace linqSample
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] num=new int[5]{45,78,45,34,2};
            IEnumerable<int> res=(from N in num
                                 where N>40
                                 orderby N descending 
                                 select N).ToArray();

            foreach (var item in res)
            {
                Console.WriteLine(item);
            }

            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

namespace linqSample

{

class Program

{

static void Main(string[] args)

{

int[] num=new int[5]{45,78,45,34,2};

IEnumerable<int> res=(from N in num

where N>40

orderby N descending

select N).ToArray();

foreach (var item in res)

{

Console.WriteLine(item);

}

Console.ReadKey();

}

Immediate:

Leave a comment

Posted in LICT

LICT .NET Training | Kamal Protap Sir | Part 4

Posted on January 2, 2018 | Leave a comment

MVC Part:

Controller getting input.

ApplicationManagement video was so important

In Controller Folder HomeController.Cs is a controller which is controlling all the things

here is the code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MVC.Controllers
{
    public class HomeController : Controller
    {
        public string Index() //we can override the abstract class ActionResult is an Abstract class
        {
            return "hi welcome";
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";

            return View();
        }
}
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

namespace MVC.Controllers

{

public class HomeController : Controller

{

public string Index() //we can override the abstract class ActionResult is an Abstract class

{

return "hi welcome";

}

public ActionResult About()

{

ViewBag.Message = "Your application description page.";

return View();

}

App_Start Folder:

RouteConfig.cs file we will find that

using System.Web;

namespace MVC
{

public class RouteConfig{

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathinfo}");

routes.MapRoute(
name:"Default",
url: "{controller}/{action}/{id}",
defaults:new{controller="Home",action="Index",id=UrlParameter.Optional
);
}
}
}

using System.Web;

namespace MVC

{

public class RouteConfig{

public static void RegisterRoutes(RouteCollection routes)

{

routes.IgnoreRoute("{resource}.axd/{*pathinfo}");

routes.MapRoute(

name:"Default",

url: "{controller}/{action}/{id}",

defaults:new{controller="Home",action="Index",id=UrlParameter.Optional

);

}

Views/Home/About
Views/Home/Contact

How to communicate with Controller and View:
ViewData and ViewBag passing the data from a controller to view

Interview questions:
ViewData: ViewData is dictionary of objects that is dervied from ViewData dictionary class and is accessible using string as keys.

ViewBag: viewBag is dynamic property. That take advantages of dynamic features.

both does not provide any compile time error.

In model we need to write the business logic.

In View we can show the actual things what we want to show:

View->Details.cshtml

@model MVC.Models.Employee
@{
    ViewBag.Title = "Details";
}

<h2>Employee Details</h2>
<table style="font-family: Arial">
    <tr>
        <td>
            <b>Employee Id:</b>
        </td>
        <td>
            @Model.EmployeeId
        </td>
    </tr>
    <tr>
        <td>
            <b>Employee Name:</b>
        </td>
        <td>
            @Model.Name
        </td>
    </tr>
    <tr>
        <td>
            
        </td>
    </tr>
     
</table>

@model MVC.Models.Employee

ViewBag.Title = "Details";

}

<h2>Employee Details</h2>

<tr>

<td>

<b>Employee Id:</b>

</td>

<td>

@Model.EmployeeId

</td>

</tr>

<tr>

<td>

<b>Employee Name:</b>

</td>

<td>

@Model.Name

</td>

</tr>

<tr>

<td>

</td>

</tr>

</table>

Employee.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MVC.Models
{
    public class Employee
    {
        public int EmployeeId { get; set; }
        public string Name { get; set; }
        public string Gender { get; set; }
        public string City { get; set; }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

namespace MVC.Models

{

public class Employee

{

public int EmployeeId { get; set; }

public string Name { get; set; }

public string Gender { get; set; }

public string City { get; set; }

}

EmployeeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using MVC.Models;

namespace MVC.Controllers
{
    public class EmployeeController:Controller
    {
        public ActionResult Details()
        {
            Employee emp=new Employee()
            {
                EmployeeId=1,
                Name="Kamal"
                Gender="Male",
                City="Chennai"
            };
            return View(emp);
        }


    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

using System.Web.Mvc;

using MVC.Models;

namespace MVC.Controllers

{

public class EmployeeController:Controller

{

public ActionResult Details()

{

Employee emp=new Employee()

{

EmployeeId=1,

Name="Kamal"

Gender="Male",

City="Chennai"

};

return View(emp);

}

Leave a comment

Posted in LICT

LICT .NET Training | Kamal Protap Sir | Part 3

Posted on December 27, 2017 | Leave a comment

09/11/2017 vids

Property:

using System;

namespace LinqOperators
{
    class Student
    {
        private int Sid;
        private string sname;


        public int StudentID
        {
            get { return Sid; }
            set { Sid = value; }
        }

        //public void Display()
        //{
        //    Console.WriteLine(Sid);
        //}

        public string StudentName
        {
            get { return sname;  }
            set { sname = value;  }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student obj=new Student();
            obj.StudentID = 10;
            obj.StudentName = "Zaki";
            Console.WriteLine(obj.StudentName);
            Console.WriteLine(obj.StudentID);
            //obj.Display();
            Console.ReadKey();
        }
    }
}

using System;

namespace LinqOperators

{

class Student

{

private int Sid;

private string sname;

public int StudentID

{

get { return Sid; }

set { Sid = value; }

}

//public void Display()

//{

// Console.WriteLine(Sid);

//}

public string StudentName

{

get { return sname; }

set { sname = value; }

}

class Program

{

static void Main(string[] args)

{

Student obj=new Student();

obj.StudentID = 10;

obj.StudentName = "Zaki";

Console.WriteLine(obj.StudentName);

Console.WriteLine(obj.StudentID);

//obj.Display();

Console.ReadKey();

}

Automatic Property:

//auto implemented property

using System;

namespace LinqOperators
{
    class Student
    {
        public int Sid { private get; set; }
        public string Sname { get; set; }


       
    }

    class Program
    {
        static void Main(string[] args)
        {
            
            Student obj=new Student();
            obj.Sid = 10;
            obj.Sname = "Zaki";
            Console.WriteLine(obj.Sid+" "+obj.Sname);
            Console.ReadKey();
        }
    }
}

//auto implemented property

using System;

namespace LinqOperators

{

class Student

{

public int Sid { private get; set; }

public string Sname { get; set; }

}

class Program

{

static void Main(string[] args)

{

Student obj=new Student();

obj.Sid = 10;

obj.Sname = "Zaki";

Console.WriteLine(obj.Sid+" "+obj.Sname);

Console.ReadKey();

}

Delegates:

using System;

namespace Delegates
{
    delegate int Caluclation(int Fnum, int Snum);

    class Delegates
    {
        public static int Add(int Firstnum, int Secondnum)
        {
            return Firstnum + Secondnum;
        }

        public static int Sub(int Firstnum, int Secondnum)
        {
            return Firstnum - Secondnum;
        }

        public static string Display(string Sname)
        {
            return Sname;
        }

        public static void Main(string[] args)
        {
            Caluclation calc = Add;
            Console.WriteLine(calc.Invoke(3, 4));
            calc = Sub;
            Console.WriteLine(calc.Invoke(10, 5));

            Console.ReadKey();
        }
    }
}

using System;

namespace Delegates

{

delegate int Caluclation(int Fnum, int Snum);

class Delegates

{

public static int Add(int Firstnum, int Secondnum)

{

return Firstnum + Secondnum;

}

public static int Sub(int Firstnum, int Secondnum)

{

return Firstnum - Secondnum;

}

public static string Display(string Sname)

{

return Sname;

}

public static void Main(string[] args)

{

Caluclation calc = Add;

Console.WriteLine(calc.Invoke(3, 4));

calc = Sub;

Console.WriteLine(calc.Invoke(10, 5));

Console.ReadKey();

}

Lambda Expression with FUNC:

using System;


namespace LamdawithDelegates
{
    delegate int MyDelegatesss(int firstNum, int secondNum);

    class Program
    {
        public static int Add(int firstNum, int secondNum)
        {
            return firstNum + secondNum;
        }
        static void Main(string[] args)
        {
            MyDelegatesss calc = Add;
            Console.WriteLine(calc.Invoke(5,4));
            Console.ReadKey();

        }
    }
}

using System;

namespace LamdawithDelegates

{

delegate int MyDelegatesss(int firstNum, int secondNum);

class Program

{

public static int Add(int firstNum, int secondNum)

{

return firstNum + secondNum;

}

static void Main(string[] args)

{

MyDelegatesss calc = Add;

Console.WriteLine(calc.Invoke(5,4));

Console.ReadKey();

}

Some logics:

//delegate example

delegate int MyDelegate(int firstNumber, int secondNumber);
MyDelegate myDelegate=(firstNumber,secondNumber)=>firstNumber+secondNumber
int result=myDelegate(3,4);
Console.WriteLine(result);

//delegate example

delegate int MyDelegate(int firstNumber, int secondNumber);

MyDelegate myDelegate=(firstNumber,secondNumber)=>firstNumber+secondNumber

int result=myDelegate(3,4);

Console.WriteLine(result);

Lambda using Function:

//lambda using FUNC
Func<int, int , int> funcdel=(a,b)=>{return a*b};
int Result=funcdel(30,20);
Console.WriteLine(Result);

//lambda using FUNC

Func<int, int , int> funcdel=(a,b)=>{return a*b};

int Result=funcdel(30,20);

Console.WriteLine(Result);

Multicast Delegates:

A delegate instance holding the multiple method at a time is multicast delegate.
But the rule is that all the method must be altered because all method in a single instance they remain present. Multiple reference method at a time.

using System;

namespace MulticastDelegates
{
    public delegate void MultiDelegate(int a, int b);

    public class SampleClass
    {
        public static void Add(int x, int y)
        {
            Console.WriteLine("Addition value:"+(x+y));

        }

        public static void Sub(int x, int y)
        {
            Console.WriteLine("Subtraction Value:"+(x-y)); 
        }

        public static void Mul(int x, int y)
        {
            Console.WriteLine("Mutiplication Value:"+(x*y));
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            MultiDelegate del = SampleClass.Add;
            del += SampleClass.Sub;
            del += SampleClass.Mul;
            del(10, 5);
            Console.WriteLine();
            del -= SampleClass.Mul;
            del -= SampleClass.Sub;
            del(10, 5);
            Console.ReadKey();
        }
    }
}

using System;

namespace MulticastDelegates

{

public delegate void MultiDelegate(int a, int b);

public class SampleClass

{

public static void Add(int x, int y)

{

Console.WriteLine("Addition value:"+(x+y));

}

public static void Sub(int x, int y)

{

Console.WriteLine("Subtraction Value:"+(x-y));

}

public static void Mul(int x, int y)

{

Console.WriteLine("Mutiplication Value:"+(x*y));

}

class Program

{

static void Main(string[] args)

{

MultiDelegate del = SampleClass.Add;

del += SampleClass.Sub;

del += SampleClass.Mul;

del(10, 5);

Console.WriteLine();

del -= SampleClass.Mul;

del -= SampleClass.Sub;

del(10, 5);

Console.ReadKey();

}

Anonymous Method:
Unnamed function. In the bracket we are writing the logic. Unnamed method we are writing the logic. Unanmed method.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AnonynemousMethod
{
    public delegate double Areapointer(int r);
    class Program
    {
        static void Main(string[] args)
        {
            Areapointer point=new Areapointer(
                delegate(int r)
                {
                    return 3.14 * r * r;
                }
                );

            double area = point(20);

            Console.WriteLine(area);

            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AnonynemousMethod

{

public delegate double Areapointer(int r);

class Program

{

static void Main(string[] args)

{

Areapointer point=new Areapointer(

delegate(int r)

{

return 3.14 * r * r;

}

);

double area = point(20);

Console.WriteLine(area);

Console.ReadKey();

}

The same AnonymousMethod work can be done in a single line with this lambda operation:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AnonynemousMethod
{
    public delegate double Areapointer(int r);
    class Program
    {
        static void Main(string[] args)
        {
            Areapointer point = r => 3.14 * r * r;

            double area = point(20);

            Console.WriteLine(area);

            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace AnonynemousMethod

{

public delegate double Areapointer(int r);

class Program

{

static void Main(string[] args)

{

Areapointer point = r => 3.14 * r * r;

double area = point(20);

Console.WriteLine(area);

Console.ReadKey();

}

=> This is known as goes to operator and it is similar to AnonymousMethod()

Linq also using lambda not only Delegate

Func:

Func is a readymade function where the first data type is for input and the second one is for output. It does not need any delegate to declare.

using System;

namespace FuncwithLambda
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<double, double> area = r => 3.14 * r * r;
            double result = area(20);
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
}

using System;

namespace FuncwithLambda

{

class Program

{

static void Main(string[] args)

{

Func<double, double> area = r => 3.14 * r * r;

double result = area(20);

Console.WriteLine(result);

Console.ReadKey();

}

Action:
Action does not support any return type:

using System;


namespace Action
{
    class Program
    {
        static void Main(string[] args)
        {
            Action<String> area = sttr => Console.WriteLine(sttr);
            area("zaki");

        }
    }
}

using System;

namespace Action

{

class Program

{

static void Main(string[] args)

{

Action<String> area = sttr => Console.WriteLine(sttr);

area("zaki");

}

Leave a comment

Posted in .NET, LICT

DataReader and DataAdapter and DataSet

Posted on December 23, 2017 | Leave a comment

Difference Between DataReader and DataAdapter and DataSet:

Datareader: Datareader will be the best choice where we need to show the data to the user which requires no manipulation.

DataAdapter: DataAdapter read data from the database and is used to bind the data to the DataSet because DataAdapter working as a bridge between DataSet and the DataBase.

DataSet: DataSet is best suited where there is possibility of manipulation on the data.

Working in a Connected And Disconnected Environment: Part 1

In this article you will learn about the Connected And Disconnected Environment in ADO.NET.

www.c-sharpcorner.com

Leave a comment

Posted in ASP.NET

LICT .NET Training | Kamal Protap Sir | Part 2

Posted on December 19, 2017 | Leave a comment

07.11.17 Vids
DataAdapater vs DataReader:

SqlDataReader row by row executes from the table

ExecuteReader() always executes the query to the data reader object.

Using data reader:

using System;
using System.Data.SqlClient;
using System.Windows.Forms;
using System.Data;


namespace WindowsFormsApp1
{
    public partial class DataAdaptervsDatareader : Form
    {
        public DataAdaptervsDatareader()
        {
            InitializeComponent();
        }

        private void DataAdaptervsDatareader_Load(object sender, EventArgs e)
        {
            string ConString = "Server=ZAKIHP-PC\\ZAKISQL;Database=PracticeByMe;Trusted_Connection=Yes";
            SqlConnection conn = new SqlConnection(ConString);
            string querystring = "select * from tbl_ProductInfo";
            conn.Open();
            SqlCommand cmd=new SqlCommand(querystring,conn);
            SqlDataReader reader = cmd.ExecuteReader();
            while (reader.Read())
            {
                MessageBox.Show("Name: " + reader["name"] + "Price: "+ reader["price"]+"Dates: " + reader["dates"]);
                //MessageBox.Show(reader[0] + reader[1] + reader[2]);
            }
            conn.Close();

        }
    }
}

using System;

using System.Data.SqlClient;

using System.Windows.Forms;

using System.Data;

namespace WindowsFormsApp1

{

public partial class DataAdaptervsDatareader : Form

{

public DataAdaptervsDatareader()

{

InitializeComponent();

}

private void DataAdaptervsDatareader_Load(object sender, EventArgs e)

{

string ConString = "Server=ZAKIHP-PC\\ZAKISQL;Database=PracticeByMe;Trusted_Connection=Yes";

SqlConnection conn = new SqlConnection(ConString);

string querystring = "select * from tbl_ProductInfo";

conn.Open();

SqlCommand cmd=new SqlCommand(querystring,conn);

SqlDataReader reader = cmd.ExecuteReader();

while (reader.Read())

{

MessageBox.Show("Name: " + reader["name"] + "Price: "+ reader["price"]+"Dates: " + reader["dates"]);

//MessageBox.Show(reader[0] + reader[1] + reader[2]);

}

conn.Close();

}

Using data adapter:

Difference between DataReader and DataAdapter:

c# – SqlDataAdapter vs SqlDataReader – Stack Overflow

stackoverflow.com

Using data adapter:
First we call data adapter then data set

  SqlDataAdapter Da = new SqlDataAdapter(cmd);
  DataSet ds=new DataSet();

1 2	SqlDataAdapter Da = new SqlDataAdapter(cmd); DataSet ds=new DataSet();

DataSet is a disconnected architecture
DataReader is a connected architecture

DataRow()

With DataAdapter:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Windows.Forms;
using System.Data.SqlClient;

namespace ADONETPRGS
{
    public partial class Dataadaptervsdatareader : Form
    {
        public Dataadaptervsdatareader()
        {
            InitializeComponent();
        }

        private void Dataadaptervsdatareader_Load(object sender, EventArgs e)
        {
            string ConString = "Data Source=DESKTOP-0MSCGUP;Initial Catalog=Lict_Dotnet;User ID=sa;Password=sa123";
            SqlConnection con = new SqlConnection(ConString);
            string querystring = "Select * from tbl_Product";
            con.Open();
            SqlCommand cmd = new SqlCommand(querystring, con);

            SqlDataAdapter Da = new SqlDataAdapter(cmd);
            
            DataSet Ds = new DataSet();
            Da.Fill(Ds);
            //SqlDataReader reader = cmd.ExecuteReader();
            // con.Close();
            foreach (DataRow Objrow in Ds.Tables[0].Rows)
            {
                MessageBox.Show("Name:" + Objrow["Name"] + " " + "Price:" + Objrow["Price"]);
            }


            //while (reader.Read())
            //{
            //    MessageBox.Show(reader["Name"] + " : " + reader["Price"]);
            //}
            // con.Close();

        }
    }
}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Windows.Forms;

using System.Data.SqlClient;

namespace ADONETPRGS

{

public partial class Dataadaptervsdatareader : Form

{

public Dataadaptervsdatareader()

{

InitializeComponent();

}

private void Dataadaptervsdatareader_Load(object sender, EventArgs e)

{

string ConString = "Data Source=DESKTOP-0MSCGUP;Initial Catalog=Lict_Dotnet;User ID=sa;Password=sa123";

SqlConnection con = new SqlConnection(ConString);

string querystring = "Select * from tbl_Product";

con.Open();

SqlCommand cmd = new SqlCommand(querystring, con);

SqlDataAdapter Da = new SqlDataAdapter(cmd);

DataSet Ds = new DataSet();

Da.Fill(Ds);

//SqlDataReader reader = cmd.ExecuteReader();

// con.Close();

foreach (DataRow Objrow in Ds.Tables[0].Rows)

{

MessageBox.Show("Name:" + Objrow["Name"] + " " + "Price:" + Objrow["Price"]);

}

//while (reader.Read())

//{

// MessageBox.Show(reader["Name"] + " : " + reader["Price"]);

//}

// con.Close();

}

Whole datagridview has been binded with the data.

Stored procedure in Our Application:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class Storedprocedure : Form
    {
        public Storedprocedure()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            SqlConnection connection;
            SqlDataAdapter adapter;

            DataSet ds=new DataSet();
            int i = 0;
            string connectionString = "Server=ZAKIHP-PC\\ZAKISQL;Database=PracticeByMe;Trusted_Connection=Yes";
            connection = new SqlConnection(connectionString);
            SqlCommand cmd=new SqlCommand("SelectProduct", connection);
            cmd.CommandType = CommandType.StoredProcedure;
 
            adapter =new SqlDataAdapter(cmd);
            adapter.Fill(ds);

           for (i=0;i<=ds.Tables[0].Rows.Count-1;i++)
           {
               MessageBox.Show(ds.Tables[0].Rows[i][0].ToString() + " " + ds.Tables[0].Rows[i][1].ToString());
           }
        }
    }
}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Data.SqlClient;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

public partial class Storedprocedure : Form

{

public Storedprocedure()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

SqlConnection connection;

SqlDataAdapter adapter;

DataSet ds=new DataSet();

int i = 0;

string connectionString = "Server=ZAKIHP-PC\\ZAKISQL;Database=PracticeByMe;Trusted_Connection=Yes";

connection = new SqlConnection(connectionString);

SqlCommand cmd=new SqlCommand("SelectProduct", connection);

cmd.CommandType = CommandType.StoredProcedure;

adapter =new SqlDataAdapter(cmd);

adapter.Fill(ds);

for (i=0;i<=ds.Tables[0].Rows.Count-1;i++)

{

MessageBox.Show(ds.Tables[0].Rows[i][0].ToString() + " " + ds.Tables[0].Rows[i][1].ToString());

}

Leave a comment

Posted in LICT

Tagged Leveraging ICT

SqlConnection in ADO.NET

Posted on December 17, 2017 | Leave a comment

Leave a comment

Posted in ADO.NET

LICT Training Vids Summary

Posted on December 14, 2017 | Leave a comment

10.12.17: (This is one of the important videos)
AuthenticateLogic is very very important for project works: also the store procedure here is important

</authentication>

<authorization>
<deny users=”?”> //if it is * it means that it is open for all but ? sign means it is only for requested users
</authorization>

What is difference between connection string and appSettings ?

</connectionStrings>

LinqToSql Class

12.12.17: (This is one of the important videos)

For project works

Leave a comment

Posted in ASP.NET, LICT

Category Archives: Software Development

Java learned as so far:

Master Object Oriented Design in Java course note

Why we need design patterns, the most important design patterns

Design Pattern and Object oriented Data Analaysis

Design Pattern:Cohesion in Java

Github in Ubuntu

Cyclometic Complexity

LICT .NET Training | Kamal Protap Sir | Part 6

C# IEnumerable vs IEnumerator

LICT .NET Training | Kamal Protap Sir | Part 5

LICT .NET Training | Kamal Protap Sir | Part 4

LICT .NET Training | Kamal Protap Sir | Part 3

DataReader and DataAdapter and DataSet

LICT .NET Training | Kamal Protap Sir | Part 2

SqlConnection in ADO.NET

LICT Training Vids Summary

Categories

Random Quote

Random Quotes

My Facebook

Recent Posts

Archives

About Me & MyBlog

Caution and Tips:

Recent Comments

Category Archives: Software Development

Master Object Oriented Design in Java course note

Categories

Random Quote

Random Quotes

Tags

My Facebook

Recent Posts

Archives

About Me & MyBlog

Caution and Tips:

Recent Comments