def addition(n):
   return n+n
number=(10, 20, 30, 40)
res= map(addition, number)
print(list(res))

20, 40, 60, 80

Following are the basic features of OOPs :

• Object: - An object is a physical entity which has a state and behaviour. It occupies space in memory. It is a sample of a class. Object helps to access the methods and variables in the program.
• Class - A Class is "collection of objects." A class is a logical entity, which does not take any space. A class includes all the data and methods which shows the behaviour of an object.
• Inheritance - Inheritance is a process by which one class can have all properties of other class. Inheritance increases the code reusability. There are two terms used
  • Child class (Subclass): Class which inherits other class, called as Child class or derived class.
  • Parent class (Superclass): A class which got inherited by another class is termed as parent class or Base class.
• Polymorphism: - Polymorphism is a method of performing "a single task in different ways." Polymorphism enables a programmer to use methods or operators in different ways. In Java, we use method overloading and overriding to obtain the polymorphism.
• Abstraction: If we show only functionality and hide the explanations or details then this process is called as Abstraction. For achieving the abstraction, we use two ways in Java
  • Abstract class
  • Interface
• Encapsulation: Encapsulation is a process of enclosing the data and code together to form a single unit. It makes the data safer within the code for any modification. For achieving the encapsulation, we can declare the data variables of class as private.

#include
#include
void main()
{
    int num1,num2,nextnum,n,i;
    cout<<"Enter the value for range:"; //Fibonacci series range value will be inputted
    cin>>n;
    num1=0;
    num2=1;
    cout<<"Fibonacci series is:"<<endl;
    if(n==1)    
        cout<<num1<<endl;  //Single value will be printed if range value is 1
    else if(n==2)
        cout<<num1<<"\t"<<num2<<endl;  //Two values will be printed if the range value is two
    else
    {
        cout<<num1<<"\t"<<num2<<"\t";
        for(i=3;i<=n;i++)    //Fibonacci series will be printed based on range limit
        {
            nextnum=num1+num2;
            cout<<nextnum<<"\t";
            num1=num2;
            num2=nextnum;
        }
    }
    getch();
}

// A functional interface with a single abstract method.
interface ExampleInterface
{
    // An abstract method
    void abstractPrint(int a);
}
class InterviewBit
{
    public static void main(String args[])
    {
        /* A lambda expression to implement the above functional interface. */
        ExampleInterface ob = (int a)->{System.out.println(a)};
 
        // This calls above lambda expression and prints 20.
        ob.abstractPrint(20);
    }
}

class EncapsulationEg{  
    private String empname;  
    private int empage;  
    private int empid;   
     
    public String getEmpName() //getter method   
    {  
        return empname;  
    }  
    public int getEmpAge()  
    {  
        return empage;  
    }  
    public int getEmpId()  
    {  
        return empid;  
    }  
    public void setEmpName(String setvalue)  //setter methods   
{   
        empname=setvalue;  
    }  
    public void setEmpAge(int setvalue){  
        empage=setvalue;  
    }  
    public void setEmpId(int setvalue){  
        empid=setvalue;  
    }  
      
    }  
    public class TestEncapsulation{  
        public static void main(String args[]){  
          
         EncapsulationEg en= new  EncapsulationEg();  
         en.setEmpName("Alvin");  
        en.setEmpAge(22);  
        en.setEmpId(12568);  
         System.out.println("Employee Name: " +en.getEmpAge());  
         System.out.println("Employee Age: " +en.getEmpAge());  
         System.out.println("Employee ID: " +en.getEmpId());  
    }  
}

Employee Name: 22
Employee Age: 22
Employee ID: 12568

Return-type method_name()  
{  
// Code to be executed  
method_name(); // same name of calling method   }  

class A{    //Superclass  
void name()  
{  
System.out.println("this is student of Superclass");  
}  
}  
 
class Student extends A  //Subclass  
{  
void name(){      // method Override with same signature(runtime polymorphism)  
System.out.println("this is student of subclass");  
}  
public static void main (String[] args) {  
A a= new A();    // refrence of A class  
A b= new Student();   // refrence of student class  
 
a.name();  
b.name();  
}  
} 

this is student of Superclass
this is student of subclass

public class ClassName implements Interface1, Interface2,..., InterfaceN
{  
    //Code   
}  

public class FreeTimeLearn implements X, Y
{
    //Code
}

class Animal{  
  void print(){
    System.out.println("Inside Animal");
  }  
}  
class Birds extends Animal{  
  void print(){
    System.out.println("Inside Birds");
  }
}
class Mammals extends Animal{  
  void print(){
System.out.println("Inside Mammals");
}
  }
class Reptiles extends Animal{  
  void print(){
    System.out.println("Inside Reptiles");
  }
}
class InterviewBit{
  public static void main(String args[]){
    Animal a = new Animal();
    Animal b = new Birds(); //upcasting  
    Animal m = new Mammals(); //upcasting  
    Animal r = new Reptiles(); //upcasting  
    a.print();
    b.print();
    m.print();  
    r.print();  
  }  
} 

Inside Animal
Inside Birds
Inside Mammals
Inside Reptiles

/* C program to demonstrate the difference between var++ and ++var */

#include  
int main()  
{  
    int x,y;  
    x=7, y=1;  
    printf("%d %d\n", x++, x);   //will generate 7, 8 as output  
    printf("%d %d", ++y, y);    //will generate 2, 2 as output  
}

#include<stdio.h>  
#include<conio.h>
void main()  
{  
    cout<<"Enter the character:"<<endl;  
    getch();  
}  

class class_name
{  
    //Statements  
    friend return_type function_name();
}

public interface List<E> extends Collection<E>

interface InterfaceA {  
default public void m1() { System.out.println("This is interface A!"); }  
 
}  
interface InterfaceB {  
default public void m1(){ System.out.println("This is interface B!"); }  //same signature as interface InterfaceA?  
 
}  
 
public class Simple implements InterfaceA, InterfaceB {  
public static void main(String args[]) {  
Simple s1= new Simple();  
s1.m1();   // It will give error..  
}}

#include<stdio.h>  
main()  
{  
printf("enter the character. \n");  
getch();  
}

enter the character.

Syntax for main():

void main(){  
///Program body;  
}

ptr=  (type_cast*)  malloc( size_t size );  
Syntax for calloc() function:

ptr= (type_cast *) calloc(n , size_t size );