Saturday, January 28

The contrast between theoretical class and connection point in java

As we probably are aware reflection alludes to concealing the inner execution of the component and showing the usefulness just to the clients. for example what it works (appearing), how it works (stowing away). Unique class and connection point both are utilized for deliberation, from here onward connection point and conceptual class is fundamental requirements.

Click on this

Unique Class Versus Interface

conceptual class versus interface

Kinds of Methods: A point of interaction can contain just theoretical techniques. A theoretical class can have dynamic and non-unique strategies. From Java 8, it can likewise have default and static strategies.

 know all about the Difference Between Assault And Battery

Last Variables: Variables pronounced in Java connection points are last naturally. A theoretical class can contain non-last factors.

Variable Types: Abstract class can have last, non-last, static, and non-static factors. The interface has just static and last factors.

Execution: Abstract class can give execution of connection point. Interface can’t give an execution of a theoretical class.

Legacy versus Abstraction: A Java connection point can be carried out utilizing the “executes” watchword and a theoretical class can be expanded utilizing the “broadens” catchphrase.

Numerous executions: A point of interaction can broaden at least one Java interface, a theoretical class can expand another Java class and carry out various Java interfaces.

Admittance to information individuals: The individuals from a Java connection point are public naturally. A Java dynamic class can have class individuals like private, safeguarded, and so forth.

Model 1-a:

// To delineate the idea of a Java program

// conceptual class

// bringing in required classes


// class 1

// Partner Unique Class

unique class size {

    // announce field

    String objectName = “”;

    // constructor of this class

    sizeof(string name) { this.objectName = name; ,

    // strategy

    // non-theoretical techniques

    // to be as default execution

    public void move(int x, int y)


        System.out.println(this.objectName + ” “

                           + “has been moved”

                           + “x = ” + x + ” and y = ” + y );


    // Strategy 2

    // theoretical strategies that is destined to be

    // carried out by its subclass(es)

    theoretical public twofold field();

    theoretical public void Draw();


// Class 2

// assistant class broadens class1

class expands square shape size {

    // properties of the square shape

    int length, width;

    // constructor

    Rectangle(int length, int width, string name)


        // super catchphrase alludes to the ongoing occasion as it were


        //this watchword alludes to the ongoing case as it were

        this length = length;

        this width = width;


    // Technique 1

    // to make square shape

    @Abrogate public void Draw()


        System.out.println(“Rectangle is drawn”);


    // Strategy 2

    // to compute the square shape region

    @supersede public twofold field()


        // Length Width

        return (twofold) (length * width);



// Class 3

// assistant class broadens class1

square expands circle size {

    // Properties of a circle

    twofold pi = 3.14;

    int sweep;

    // constructor

    circle(int sweep, string name)


        // super catchphrase alludes to the parent class


        //this catchphrase alludes to the ongoing occasion as it were

        this sweep = span;


    // Strategy 1

    // to draw circle

    @Supersede public void Draw()


        // print articulation

        System.out.println(“Circle is drawn”);


    // Strategy 2

    // to work out circle region

    @abrogate public twofold field()


        return (twofold) ((pi * span * range));



// Class 4

// Prime World

class gfg {

    // fundamental driver technique


        // make object of square shape class

        // also, utilizing size class reference.

        Shape Rectangle = new Rectangle(2, 3, “Square shape”);

        System.out.println(“Area of Rectangle:”

                           + rect.area());

        rect.moveTo(1, 2);


        // make objects of circle class

        Shape circle = new Circle(2, “circle”);

        System.out.println(“Area of circle:”

                           + circle.area());

        circle.move to(2, 4);




Area of square shape: 6.0

Allow the square shape to be x = 1 and y = 2. moved to

Area of circle: 12.56

Allow the circle to be x = 2 and y = 4. has been moved to

Consider the possibility that we have no normal code among square shapes and circles then, at that point, go with the interface.

Model 1-b:

// To show the idea of the Java program interface

// Bringing in I/O classes


// interface

interface size {

    // theoretical technique

    void draw();

    twofold field();


// Class 1

// assistant class

class carries out Rectangle Shape {

    int length, width;

    // constructor

    square shape (int opposite

Follow for more such useful content.

Leave a Reply

Your email address will not be published. Required fields are marked *