#abstract classes

Me, moments after looking at my old code: Oh God

New Post has been published on https://is.gd/5fxfc5

Abstract Classes Object reflection Strict Mode JavaScript

(adsbygoogle = window.adsbygoogle || []).push();

How to implement Abstract Classes & Object reflection & Strict Mode In JavaScript?

In this article we will understand How do I create an Abstract Classes & Object reflection & Strict Mode in JavaScript By Sagar Jaybhay.

Abstract Classes

Object-oriented programming languages like C# and java support abstract classes. These classes are incomplete and when you trying to create an object of that abstract classes it will throw a compile-time error.

The abstract classes are mainly for base classes.

var Shape=function(nameofshape) this.shapeName=nameofshape; throw new Error("You can't create object of this abstract class.") ; Shape.prototype.draw=function() return "Drawing the Shape "+this.shapeName; var Circle=function(name) this.shapeName=name; Circle.prototype=Object.create(Shape.prototype); var circle=new Circle("Circle"); document.writeln("<br/>"); document.writeln("is circle instance of Circle "+(circle instanceof Circle)); document.writeln("<br/>"); document.writeln("is circle instance of Shape "+(circle instanceof Shape)) document.writeln("<br/>"); document.writeln(circle.draw());

Object.create(Shape);

This method is used to create an object of class without using a constructor.

(adsbygoogle = window.adsbygoogle || []).push();

Abstract Class in JavaScript

Object reflection In JavaScript

C#, java like object-oriented programming languages support a reflection.

Reflection allows us to inspect meta-data of assemblies, modules, and types. Since javascript is an object-oriented programming language it also supports reflection.

var Student=function(firstname,lastname,id) this.FirstName=firstname; this.LastName=lastname; this.Id=id; Student.prototype.getFullname=function() return this.FirstName+" "+this.LastName; Student.prototype.getID=function() return this.Id; var stud=new Student("Sagar","Jaybhay",101); document.writeln("Below are the properties"); for(property in stud) document.writeln("<br/>"); document.writeln(property); document.writeln("<HR>"); document.writeln("Below are the properties with values"); for(property in stud) document.writeln("<br/>"); document.writeln(property+ " : "+stud[property])

Object reflection In JavaScript

Strict Mode In Javascript

ECMAScript version 5 introduced strict mode to javascript. With this use of strict mode it easy to detect javascript silent error as they would throw an error. By using strick mode your debugging is easier and mistakes are reduced. Most modern browsers support strict mode.

In C# or Java, these are object-oriented languages like that Javascript also object-oriented language. But javascript is not very god at reporting errors or throwing an error.

Suppose in c# without declaring the type of variable you cant assign value to it. C# compiler will throw the compile-time error.

Fullname=”sagar”

But in javascript without declaring variable you can assign value to that variable. But this behavior you want to suppress.

"use strict"; mystring="sagar"; document.writeln(mystring);

Then you need to use strict mode.

Strict Mode In JavaScript

To overcome this I declare variable an error goes off.

"use strict"; var mystring="sagar"; document.writeln(mystring);

Strict Mode In JavaScript 1

You can write a strict mode in function also means you want to monitor a function and rather than typing the use strict in the whole script file you can type inside the function like below.

var display=function() "use strict"; var mystring="sagar"; document.writeln(mystring); display();

The rules are applied inside the function and if you write any variable outside the function that will work regular one.

Summary

By using above code example you will able to understand How do I create an abstract base class & Object reflection & Strict Mode in JavaScript By Sagar Jaybhay.

GitHub Project Link :- https://github.com/Sagar-Jaybhay/JavaScript-All-Labs

(adsbygoogle = window.adsbygoogle || []).push();

Before defining what an abstract class is, I need to tell you what an abstract method is.

An abstract method is a method with a signature but no implementation. A function signature refers to the return types and argument types. For example, the following is an abstract method:

public abstract String speak(String request)

Any class that has an abstract method is an abstract class.

Abstract classes cannot be instantiated like normal classes through the new keyword*.

This makes sense because they have abstract methods. For example, let’s say you had the following abstract class:

public abstract class Animal {

    public abstract String speak(String request)

}

If you were to do the following:

Animal animal = new Animal();

animal.speak(”Gimme food”);

What would you get back? It’s impossible to tell because we haven’t written the implementation for speak yet.

This is why abstract classes are made to be extended. 

Abstract methods simply tell the subclass what methods the subclass must implement. In this case, it is speak.

public class Dog extends Animal {

    @Override

    public String speak(String request) {

        return “Woof, woof”;

    }

}

LINK

Objective

Today, we're taking what we learned yesterday about Inheritance and extending it to Abstract Classes. Because this is a very specific Object-Oriented concept, submissions are limited to the few languages that use this construct. Check out the Tutorial tab for learning materials and an instructional video!

Task

Given a Book class and a Solution class, write a MyBook class that does the following:

Inherits from Book

Has a parameterized constructor taking these 3 parameters:

string title

string author

int price

Implements the Book class' abstract display() method so it prints these 3 lines:

Title:, a space, and then the current instance's title.

Author:, a space, and then the current instance's author.

Price:, a space, and then the current instance's price.

Note: Because these classes are being written in the same file, you must not use an access modifier (e.g.: public) when declaring MyBook or your code will not execute.

Input Format

You are not responsible for reading any input from stdin. The Solution class creates a Book object and calls the MyBook class constructor (passing it the necessary arguments). It then calls the display method on the Book object.

Output Format

The void display() method should print and label the respective title, author, and price of the MyBook object's instance (with each value on its own line) like so: Title: $title Author: $author Price: $price Note: The $ is prepended to variable names to indicate they are placeholders for variables.

Sample Input

The following input from stdin is handled by the locked stub code in your editor: The Alchemist Paulo Coelho 248

Sample Output

The following output is printed by your display() method: Title: The Alchemist Author: Paulo Coelho Price: 248

Solution

LINK

Nella programmazione ad oggetti spesso può crearsi il dubbio sulla differenza tra un'interfaccia e una classe astratta e sulle modalità per cui sia necessario utilizzare una a discapito dell'altra. Vediamo per prima cosa cosa sono entrambe per poi fare delle considerazioni sul loro utilizzo.

1. Interfacce

Un'interfaccia è un tipo di dato (paragonabile ad una classe) con le seguenti caratteristiche:

Risulta composta solo da metodi astratti;

ogni metodo dichiarato in un'interfaccia deve essere implementato nella sottoclasse;

Non ha attributi e quindi non può avere uno stato;

Permette l'ereditarietà multipla, in quanto una classe può essere figlia di più interfacce

Un'interfaccia può essere vista come punto di incontro tra componenti simili che hanno una struttura interna diversa.

2. Classi astratte

Citando wikipedia, la classe astratta da sola non può essere istanziata, viene progettata soltanto per svolgere la funzione di classe base e da cui le classi derivate possono ereditare i metodi. Le caratteristiche "incomplete" della classe astratta vengono condivise da un gruppo di sotto-classi figlie, che vi aggiungono caratteristiche diverse, in modo da colmare le "lacune" della classe base astratta. Una classe astratta possiede le seguenti caratteristiche:

Non può essere istanziata;

Contiene almeno un metodo astratto;

Può avere attributi e quindi avere uno stato;

Una classe può essere figlia di una sola classe astratta.

Questo processo di astrazione ha lo scopo di creare una struttura base che semplifica il processo di sviluppo del software o che indirizza la programmazione delle classi figlie. Utilizzando una classe astratta è possibile inoltre definire delle implementazioni di default di metodi nel caso in cui i figli non le implementino.

3. Classe astratta o interfaccia?

Quando definiamo una classe astratta stiamo definendo le caratteristiche generiche di un oggetto (cosa un oggetto è), che saranno implementate genericamente dalle classi figlie. Nel caso invece di un'interfaccia definiamo ciò che un oggetto può fare, e siamo conseguentemente obbligati a definire, nella classe figlia, le implementazioni a questa capacità. Quindi un oggetto è solo di un tipo (può essere figlio di una sola classe astratta) ma può avere tante abilità diverse (può ereditare da diverse interface). Per esempio la classe string (in c#) ha la seguente dichiarazione:

public sealed class String : IComparable, ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, IEnumerable, IEquatable<string>

Come si può notare le interface indicano tutte le cose che questo oggetto può fare, le capacità che deve implementare per poter essere definito string.