Object-oriented programming - Revision history

Dat one dev: Fixed a error in example code by changing `Animal = { name:"" }` to `Animal = { "name":"" }`

2025-06-22T04:21:08Z

Fixed a error in example code by changing `Animal = { name:"" }` to `Animal = { "name":"" }`

Redspark: Changed create to Create

2025-06-08T21:37:46Z

Changed create to Create

FR-b0n5a1 at 21:06, 8 June 2025

2025-06-08T21:06:20Z

Redspark at 20:53, 8 June 2025

2025-06-08T20:53:34Z

Redspark at 20:42, 5 June 2025

2025-06-05T20:42:22Z

Redspark: First draft not done yet.

2025-06-05T20:09:06Z

First draft not done yet.

Redspark at 02:29, 30 January 2025

2025-01-30T02:29:23Z

JoeStrout at 23:29, 19 February 2020

2020-02-19T23:29:04Z

JoeStrout: Created page with "Object-oriented programming (OOP) is an approach to organizing code by dividing it into classes and objects. MiniScript supports prototype-based OOP through new, <..."

2020-02-19T23:26:26Z

Created page with "Object-oriented programming (OOP) is an approach to organizing code by dividing it into classes and objects. MiniScript supports prototype-based OOP through <c>new</c>, <..."

New page

Object-oriented programming (OOP) is an approach to organizing code by dividing it into classes and objects.

MiniScript supports prototype-based OOP through <c>[[new]]</c>, <c>[[super]]</c>, and <c>[[isa|__isa]]</c>.

{{stub}}

@@ Line 33: / Line 33: @@
 In MiniScript, the same class would be defined as:
 <ms>
-  Animal = { name:"" }
+  Animal = { "name":"" }
   Animal.Create = function(name, age)

@@ Line 35: / Line 35: @@
   Animal = { name:"" }
-  Animal.create = function(name, age)
+  Animal.Create = function(name, age)
     a = new Animal
     a.name = name
@@ Line 99: / Line 99: @@
   Cat = new Animal
   Cat.likesToClimb = true
-  Cat.create = function(name, age, likesToClimb)
+  Cat.Create = function(name, age, likesToClimb)
     c = new Cat
     c.name = name
@@ Line 118: / Line 118: @@
   Dog = new Animal
   Dog.favouriteToy = "None"
-  Dog.create = function(name, age, favouriteToy)
+  Dog.Create = function(name, age, favouriteToy)
     d = new Dog
     d.name = name

@@ Line 127: / Line 127: @@
   Dog.speak = function
-    print self.name + " says: Meow!"
+    print self.name + " says: Woof!"
   end function

← Older revision		Revision as of 20:53, 8 June 2025
Line 62:		Line 62:

	== Inheritance ==		== Inheritance ==
		+	In the same way that humans inherit certain genetic traits from their parents, classes can inherit from a single parent classes (some languages support multiple inheritance as well). When a class inherits from another, all of the declared fields and methods of the parent class are automatically given to the child class. Only the inheritance has to be defined for this to work. For instance, in our Animal class, let's create two new children called Dog and Cat.


		+	class Cat : public Animal {
		+	private:
		+	bool likesToClimb;
		+	public:
		+	Cat(const std::string& name, int age, bool likesToClimb)
		+	: Animal(name, age), likesToClimb(likesToClimb) {}
		+	void speak() const override {
		+	std::cout << name << " says: Meow!" << std::endl;
		+	}
		+	void info() const override {
		+	Animal::info();
		+	std::cout << "Likes to climb: " << (likesToClimb ? "Yes" : "No") << std::endl;
		+	}
		+	};
		+
		+	class Dog : public Animal {
		+	private:
		+	std::string favoriteToy;
		+	public:
		+	Dog(const std::string& name, int age, const std::string& favoriteToy)
		+	: Animal(name, age), favoriteToy(favoriteToy) {}
		+	void speak() const override {
		+	std::cout << name << " says: Woof!" << std::endl;
		+	}
		+	void info() const override {
		+	Animal::info();
		+	std::cout << "Favorite toy: " << favoriteToy << std::endl;
		+	}
		+	};
		+
		+	In MiniScript, these would be defined as:
		+	<ms>
		+	Cat = new Animal
		+	Cat.likesToClimb = true
		+	Cat.create = function(name, age, likesToClimb)
		+	c = new Cat
		+	c.name = name
		+	c.age = age
		+	c.likesToClimb = likesToClimb
		+	return c
		+	end function
		+
		+	Cat.speak = function
		+	print self.name + " says: Meow!"
		+	end function
		+
		+	Cat.info = function
		+	super
		+	print "Likes to Climb: " + self.likesToClimb
		+	end function
		+
		+	Dog = new Animal
		+	Dog.favouriteToy = "None"
		+	Dog.create = function(name, age, favouriteToy)
		+	d = new Dog
		+	d.name = name
		+	d.age = age
		+	d.favouriteToy = self.favouriteToy
		+	return d
		+	end function
		+
		+	Dog.speak = function
		+	print self.name + " says: Meow!"
		+	end function
		+
		+	Dog.info = function
		+	super
		+	print "Favourite Toy: " + self.favouriteToy
		+	end function
		+	</ms>

@@ Line 20: / Line 20: @@
      std::string name;
      int age;
    public:
      Animal(const std::string& name, int age)
          : name(name), age(age) {}
      virtual ~Animal() {}
      virtual void speak() const = 0; // Pure virtual function
      virtual void info() const {
          std::cout << "Name: " << name << ", Age: " << age << std::endl;
@@ Line 60: / Line 56: @@
 When coding with encapsulation in mind, all behaviours (methods) and properties (fields) related to a class will be defined in that class.  Knowing where to draw the line to include or exclude behaviour and properties tends to make or break an OOP design.  Often it is better to define something using multiple classes rather than trying to make one monolithic class.  A good rule of thumb is to dedicate a class to a single thing.
-Looking back at our Animal class above, we can see that it has two fields (name and age) and essentially two methods (speak and info).  Looking at <c>info()</c> we can see that it only uses <c>name</c> and <c>age</c>.  As mentioned, this is because that is all that is defined in the class and so those are the only variables it has access to.
+Looking back at our Animal class above, we can see that it has two fields (name and age) and essentially two methods (speak and info).  Looking at <c>info()</c> we can see that it only uses <c>name</c> and <c>age</c>.  As mentioned, that is what is defined in the class and so those are the only variables it has access to.
->! The other two methods in C++ are the constructor and destructor.  In MiniScript, you are not required to have either of these.  However, creating a constructor may help to declutter your code and make it easier to read.
+<blockquote> &#128218; The other two methods in C++ are the constructor and destructor.  In MiniScript, you are not required to have either of these.  However, creating a constructor may help to declutter your code and make it easier to read.</blockquote>

@@ Line 1: / Line 1: @@
-Object-oriented programming (OOP) is an approach to organizing code by dividing it into classes and objects.
+Object-oriented programming (OOP) is a way of organizing code and data using objects, which are essentially self-contained units of data and methods that operate on that data. OOP is a fundamental approach to software development in many languages like Java, C++, and Python.
 MiniScript supports prototype-based OOP through <c>[[new]]</c>, <c>[[self]]</c>,  <c>[[super]]</c>, and <c>[[isa|__isa]]</c>.
 [[Category:Language]]

← Older revision		Revision as of 02:29, 30 January 2025
Line 4:		Line 4:

	{{stub}}		{{stub}}
		+
		+	[[Category:Language]]