Nested classes
ญาณิศา ประทุมสุวรรณ์ 650710539
คลาสซ้อน(nested class) คือ คลาสที่ประกาศอยู่ภายในอีกคลาส จุดประสงค์ของคลาสซ้อนเป็นการจัดกลุ่มคลาสที่อยู่ด้วยกัน ซึ่งทำให้โค้ดของคุณสามารถอ่านง่ายและบำรุงรักษาได้มากขึ้น
Overview
ตัวอย่างเช่น class Car (OuterClass) ที่มี class Engine (InnerClass) ซ้อนอยู่ข้างใน
รถแต่ละคันจะมีเครื่องยนต์ที่แตกต่างกันไป
using System;
namespace CsharpNestedClass {
// outer class
public class Car {
public void displayCar() {
Console.WriteLine("Car: Bugatti");
}
// inner class
public class Engine {
public void displayEngine() {
Console.WriteLine("Engine: Petrol Engine");
}
}
}
class Program {
static void Main(string[] args) {
// create object of outer class
Car sportsCar = new Car();
// access method of outer class
sportsCar.displayCar();
// create object of inner class
Car.Engine petrolEngine = new Car.Engine();
// access member of inner class
petrolEngine.displayEngine();
Console.ReadLine();
}
}
}Nested Type: Non-static
ระดับการเข้าถึง Defaultจะเป็นprivate
public class Container
{
class Nested
{
Nested() { }
}
}เพื่อให้คลาสอื่นเข้าถึงได้นอกจากคลาสContainer เราจะเปลี่ยนคลาสNestedเป็น public และเพื่อให้คลาสอื่นสร้างobjectได้เราจะเปลี่ยนconstructorเป็นpublicด้วย
public class Container
{
public class Nested
{
public Nested() {Console.WriteLine("Public Nested class constructor called"); }
}
}Access Modifiers ตัวอื่นๆที่Nested Classสามารถใช้ได้: protected, internal, protected internal, private, private protected
สำหรับ protected, protected internal, private protected สามารถเข้าถึงได้เฉพาะคลาสลูกที่Inheritคลาส OuterClassเท่านั้น
public class OuterClass
{
private class NestedClass
{ // private สร้างอินสแตนซ์ในOuterClass
public void ShowMessage()
{
Console.WriteLine("Hello from private NestedClass");
}
}
public void AccessNestedClass()
{
NestedClass nested = new NestedClass();
nested.ShowMessage();
}
}
class Program
{
static void Main()
{
OuterClass outer = new OuterClass();
outer.AccessNestedClass();
}
}
Nested Type: Static
public class Container
{
public static class Nested
{
public static void DisplayMessage()
{
Console.WriteLine("Static Nested class method called");
}
}
}
public class Program
{
public static void Main()
{
Container.Nested.DisplayMessage();
}
}ไม่จำเป็นต้องสร้างอินสแตนซ์ของ Container เพื่อใช้งาน Nested
Access Outer Class Members Inside Inner Class
คลาสชั้นในสามารถเข้าถึงแอตทริบิวต์และเมธอดของคลาสภายนอกได้
using System;
public class OuterClass
{
public int x = 10;
public class InnerClass
{
public int MyInnerMethod()
{
return new OuterClass().x;
}
}
}
public class MainClass
{
public static void Main(string[] args)
{
OuterClass myOuter = new OuterClass();
OuterClass.InnerClass myInner = new OuterClass.InnerClass();
Console.WriteLine(myInner.MyInnerMethod());
}
}
Nested Classes in Java
ในภาษาJavaแบ่งกว้างๆได้เป็น 2 ประเภทเช่นเดียวกับในภาษาC# คือ Static และ Non-static
Non-static มีคลาสพิเศษ 2 ชนิด
Local Classes
java: รองรับการประกาศคลาสภายในเมธอด โดยคลาสที่อยู่ภายในเมธอดสามารถเข้าถึงตัวแปรภายในเมธอดได้ (ถ้าตัวแปรนั้นเป็น final หรือ effectively final)
public class OuterClass {
void myMethod() {
int num = 10;
class LocalClass {
void printNumber() {
System.out.println("Value of num: " + num);
}
} //คลาสLocalClassประกาศอยู่ในเมธอดmyMethod สามารถเข้าถึงตัวแปรnumได้
LocalClass local = new LocalClass();
local.printNumber();
}
public static void main(String args[]) {
OuterClass outer = new OuterClass();
outer.myMethod();
}
}
C#: ไม่มีการรองรับการประกาศคลาสภายในเมธอด แต่สามารถใช้ local function ซึ่งเป็นฟังก์ชันที่ประกาศภายในเมธอดได้ และ local function นี้สามารถเข้าถึงตัวแปรใน scope เดียวกันได้
using System;
public class OuterClass
{
public void MyMethod()
{
int num = 10;
void LocalFunction()
{
Console.WriteLine("Value of num: " + num);
}
LocalFunction();
}
public static void Main(string[] args)
{
OuterClass outer = new OuterClass();
outer.MyMethod();
}
}
Anonymous Classes
Java: anonymous inner class คือวิธีการสร้าง instance ของคลาส (มักจะเป็น interface หรือ abstract class) โดยไม่ต้องตั้งชื่อ มักจะใช้ในการจัดการเหตุการณ์ (events) หรือสร้าง object ขนาดเล็ก
public class TestClass
{
private void TestMethod()
{
MyInterface localVar = new MyInterface() //สร้างAnonymous Class
{
public void method1()
{
someCode();
}
public void method2(int i, boolean b)
{
someCode();
}
}; //override เมธอด method1 และ method2
}
}C#: ไม่มีการรองรับ anonymous inner class โดยตรง แต่สามารถทำสิ่งที่คล้ายกันได้โดยใช้ คลาส private หรือ lambda (สำหรับ functional interfaces หรือ delegates)
public class TestClass
{
private void TestMethod()
{
MyInterface localVar = new MyInterfaceAnonymousInnerClass(this);
} //TestMethodมีการสร้าง instance ของคลาส MyInterfaceAnonymousInnerClass
//โดยส่งออบเจ็กต์ของ TestClass ไปให้คอนสตรัคเตอร์ของ MyInterfaceAnonymousInnerClass
private class MyInterfaceAnonymousInnerClass : MyInterface
{ //Anonymous ของโค้ดนี้คือ MyInterfaceAnonymousInnerClass
private readonly TestClass outerInstance;
public MyInterfaceAnonymousInnerClass(TestClass outerInstance)
{
this.outerInstance = outerInstance;
}
public void method1()
{
someCode();
}
public void method2(int i, bool b)
{
someCode();
}
}
}Nested Classes in Python
nested class 2 ประเภทที่นิยมใช้ในภาษาPython
1. Multiple Inner Classes ในภาษาc#ก็สามารถเขียน Multiple inner classได้เช่นกัน
class Employe:
def __init__(self):
self.name = "Employe"
self.intern = self.intern()
self.head = self.head()
def show(self):
print('Employe List')
print('Name:', self.name)
class intern:
def __init__(self):
self.name = 'Smith'
self.Id = '657'
def display(self):
print("Name:", self.name)
print("Id:", self.Id)
class head:
def __init__(self):
self.name = 'Auba'
self.Id = '007'
def display(self):
print("Name:", self.name)
print("Degree:", self.Id)
outer = Employe()
outer.show()
d1 = outer.intern
d2 = outer.head
print()
d1.display()
print()
d2.display()2. Multilevel inner class ในภาษาc#ก็สามารถเขียน Multilevel inner classได้เช่นกัน
class multi:
def __init__(self):
self.inner = self.Inner()
self.innerinner = self.inner.InnerInner()
def show(self):
print("This is Outer class")
## inner class
class Inner:
def __init__(self):
self.innerinner = self.InnerInner()
def show_classes(self):
print("This is Inner class")
print(self.innerinner)
class InnerInner:
def inner_display(self, msg):
print("InnerInner class")
print(msg)
def inner_display(self, msg):
print("This is Inner class")
print(msg)
outer=multi()
outer.show()
inner = multi.Inner()
innerinner = inner.InnerInner()
innerinner.inner_display("completed")Video Presentation
Slide
Reference
Overview
วันชัย ขันตี, Programming Concepts, Retrieved 5 October2024, from/http://www.bus.tu.ac.th/usr/wanchai/is311/knowledge/innerclass.pdf
(ใช้ตัวอย่างโค้ด)C# Nested Class, Retrieved 5 October2024, from/https://dev.programiz.com/csharp-programming/nested-class
Nested Type
Nested Types (C# Programming Guide), Retrieved 5 October2024, from/https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/nested-types
Access Outer Class Members Inside Inner class
(2024), Java Inner Classes, Retrieved 5 October2024, from/https://www.w3schools.com/java/java_inner_classes.asp
Nested Class in Java
(2023), Nested Classes in Java,Retrieved 5 October2024, from/https://www.geeksforgeeks.org/nested-classes-java/
Java and C# Equivalents, Retrieved 5 October2024, from/https://www.tangiblesoftwaresolutions.com/java-and-csharp-equivalents.html
Nested Class in Python
(2021), Nested Classes in Python Explained with Examples,Retrieved 5 October2024, from/https://www.pythonpool.com/nested-classes-python/
Last updated