Update Class Topic

Author: LeonnardoVerol

docs/programming-languages/class/abstract-class/_go.mdx

@@ -1,3 +1,16 @@
 ```Go
-// TODO
+// No Native Abstract Class Support.
+// Use interfaces to define required behavior.
+
+type Shape interface {
+	Area() float64
+}
+
+type Circle struct {
+	Radius float64
+}
+
+func (circle Circle) Area() float64 {
+	return math.Pi * circle.Radius * circle.Radius
+}
 ```

docs/programming-languages/class/abstract-class/_rust.mdx

@@ -1,3 +1,18 @@
 ```Rust
-// TODO
+// No Native Abstract Class Support.
+// Use traits to define required behavior.
+
+trait Shape {
+	fn area(&self) -> f64;
+}
+
+struct Circle {
+	radius: f64,
+}
+
+impl Shape for Circle {
+	fn area(&self) -> f64 {
+		std::f64::consts::PI * self.radius * self.radius
+	}
+}
 ```

docs/programming-languages/class/abstract-class/_typescript.mdx

@@ -1,3 +1,19 @@
 ```Typescript
-// TODO
+abstract class Shape {
+	public abstract area(): number;
+
+	public describe(): string {
+		return `Area: ${this.area()}`;
+	}
+}
+
+class Circle extends Shape {
+	public constructor(private readonly radius: number) {
+		super();
+	}
+
+	public area(): number {
+		return Math.PI * this.radius * this.radius;
+	}
+}
 ```

docs/programming-languages/class/basic-template/_cpp.mdx

@@ -114,8 +114,25 @@ void MyClass::myPublicMethod (float someVariable)
 ```
 
 ```Cpp
-// TODO
-// const & Ref example
+// Passing and returning by const reference
+// Prefer this for non-fundamental types when the function should not mutate the value.
+
+class MyClass
+{
+private:
+	std::string my_private_property;
+
+public:
+	std::string const &getMyPrivateProperty() const
+	{
+		return this->my_private_property;
+	}
+
+	void setMyPrivateProperty(std::string const &value)
+	{
+		this->my_private_property = value;
+	}
+};
 ```
 
 ```Cpp

docs/programming-languages/class/basic-template/_go.mdx

@@ -1,3 +1,24 @@
 ```Go
-// TODO
+type MyClass struct {
+	MyPublicProperty  float64
+	myPrivateProperty float64
+}
+
+func NewMyClass(value float64) MyClass {
+	return MyClass{
+		MyPublicProperty:  value,
+		myPrivateProperty: value,
+	}
+}
+
+func (value MyClass) GetMyPrivateProperty() float64 {
+	return value.myPrivateProperty
+}
+
+func (value *MyClass) SetMyPrivateProperty(newValue float64) {
+	value.myPrivateProperty = newValue
+}
+
+myClass := NewMyClass(10.0)
+myClass.SetMyPrivateProperty(20.0)
 ```

docs/programming-languages/class/basic-template/_rust.mdx

@@ -1,3 +1,26 @@
 ```Rust
-// TODO
+struct MyClass {
+	my_public_property: f32,
+	my_private_property: f32,
+}
+
+impl MyClass {
+	fn new(value: f32) -> Self {
+		Self {
+			my_public_property: value,
+			my_private_property: value,
+		}
+	}
+
+	fn get_my_private_property(&self) -> f32 {
+		self.my_private_property
+	}
+
+	fn set_my_private_property(&mut self, value: f32) {
+		self.my_private_property = value;
+	}
+}
+
+let mut my_class = MyClass::new(10.0);
+my_class.set_my_private_property(20.0);
 ```

docs/programming-languages/class/constructors-destructors/_csharp.mdx

@@ -1,3 +1,19 @@
 ```Cs
-// TODO
+class MyClass
+{
+	public MyClass()
+	{
+		// Default Constructor
+	}
+
+	public MyClass(int value)
+	{
+		// Constructor With Parameters
+	}
+
+	~MyClass()
+	{
+		// Finalizer
+	}
+}
 ```

docs/programming-languages/class/constructors-destructors/_go.mdx

@@ -1,3 +1,18 @@
 ```Go
-// TODO
+type MyStruct struct {
+	Value int
+}
+
+// Go has no constructor syntax.
+// Use factory functions by convention.
+func NewMyStruct(value int) MyStruct {
+	return MyStruct{Value: value}
+}
+
+// Destructors are Not Available.
+// Use explicit Close/Cleanup methods when needed.
+func (value MyStruct) Close() error {
+	// cleanup
+	return nil
+}
 ```

docs/programming-languages/class/constructors-destructors/_java.mdx

@@ -1,3 +1,20 @@
 ```Java
-// TODO
+class MyClass {
+	public MyClass() {
+		// Default Constructor
+	}
+
+	public MyClass(int value) {
+		// Constructor With Parameters
+	}
+}
+
+// Destructors are Not Available.
+// Use try-with-resources and AutoCloseable for deterministic cleanup.
+class MyResource implements AutoCloseable {
+	@Override
+	public void close() {
+		// cleanup
+	}
+}
 ```

docs/programming-languages/class/constructors-destructors/_javascript.mdx

@@ -1,3 +1,17 @@
 ```Javascript
-// TODO
+class MyClass {
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+const myClass = new MyClass(10);
+
+// Destructors are Not Available.
+// Use explicit cleanup methods when needed.
+class Resource {
+	close() {
+		// cleanup
+	}
+}
 ```