The super keyword in Ruby is used to call a method from a parent or superclass. This is useful when you want to override a method in a subclass and still access the original method.
For example, say you have a superclass called Animal and a subclass called Cat. The Animal class has a method called speak that prints out “Meow”.
class Animal
def speak
puts “Meow”
end
end
class Cat Purr
# => Meow
The self keyword in Ruby refers to the current instance of the class. It is used to access instance variables and methods within the class.
For example:
class Person
attr_accessor :name
def initialize(name)
@name = name
end
def say_hello
puts “Hello, my name is #{self.name}”
end
end
person = Person.new(“John”)
person.say_hello
# Output:
# Hello, my name is John
attr_accessor is a Ruby language method used to create getter and setter methods for instance variables.
For example, if you have an instance variable @name, you can use attr_accessor to create getter and setter methods for it:
class Person
attr_accessor :name
end
person = Person.new
person.name = “John”
puts person.name # => “John
The ‘this’ keyword is used to refer to the current object in a method or constructor. It can be used to access the object’s properties and methods.
For example,
class Car {
constructor(make, model, color) {
this.make = make;
this.model = model;
this.color = color;
}
getCarInfo() {
return `This car is a ${this.make} ${this.model} in the color ${this.color}.`;
}
}
const myCar = new Car(‘Honda’, ‘Civic’, ‘red’);
console.log(myCar.getCarInfo());
// Output: This car is a Honda Civic in the color red.
An interface in Java is a blueprint of a class that includes static constants and abstract methods. Interfaces are used to provide a common set of methods that can be accessed and used by any class, regardless of its specific implementation.
Example:
public interface Animal {
public void eat();
public void move();
}
public class Dog implements Animal {
public void eat() {
System.out.println(“The dog is eating.”);
}
public void move() {
System.out.println(“The dog is running.”);
}
}
A class in Java is a template that defines the properties and behaviors of an object. It is the basic building block of an object-oriented language.
For example, a class called “Car” might have properties such as make, model, color, and year. It could also have behaviors such as start, accelerate, brake, and turn. The class would define how these properties and behaviors are related.
An interface is a collection of abstract methods, meaning that they are not implemented in the interface itself. Interfaces can also contain constants, default methods, static methods, and nested types. An example of an interface in Java is:
public interface Animal {
public void eat();
public void sleep();
}
An abstract class is a class that contains both abstract and non-abstract methods. Abstract classes can also contain constants, default methods, static methods, and nested types. An example of an abstract class in Java is:
public abstract class Animal {
public abstract void eat();
public void sleep(){
System.out.println(“Sleeping…”);
}
}
Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects, which contain data and methods that operate on that data. OOP is used to structure a program into classes and objects, which can be used to create a more intuitive and organized code structure. In Java, OOP is used to create classes that contain both data and methods. These classes are then used to create objects that can be used to interact with the data and methods of the class.
For example, a class called Car could contain data such as make, model, year, and color. It could also contain methods such as start, stop, and accelerate. This class could then be used to create a Car object called myCar, which could be used to access and manipulate the data and methods of the Car class.
The final keyword in Java is used to indicate that a variable, method, or class cannot be changed.
For example, if you declare a variable as final, it will be a constant and cannot be changed:
final int MAX_VALUE = 100;
If you declare a method as final, it cannot be overridden by subclasses:
public final void myMethod() {
// code here
}
Finally, if you declare a class as final, it cannot be extended by subclasses:
public final class MyClass {
// code here
}
The ‘this’ keyword in JavaScript is used to refer to the object that the current context belongs to. It can be used to refer to the object that owns the current code or method.
For example:
let person = {
name: ‘John’,
age: 30,
getInfo: function() {
console.log(`Name: ${this.name}, Age: ${this.age}`);
}
};
person.getInfo(); // Outputs: Name: John, Age: 30
Vaibhav Kothia