Month: March 2026

Person Struct (in C) PersonStructC

Person Class (in C++) PersonClassCPlusPlus

Person Class (in C#) PersonClassCSharp

Person Class (in Java) PersonClassJava

Object − objects have states and behaviors.
Class – defines the grouping of data and code, the “type” of an object
Instance – a specific allocation of a class
Message – sent to objects to make them act
Method – a “function” that an object knows how to perform
Local Variables − variables defined inside methods, constructors or blocks
Instance Variables – variables within a class but outside any method (a specific piece of data belonging to an object)
Class Variables − variables declared within a class, outside any method, with the static keyword
Encapsulation – keep implementation private and seperate from interface
Polymorphism – different objects, same interface
Inheritance – hierarchical organization, share code, customize or extend behaviors

pass value type by value (값형식을 값에 의한 전달)

// 변수 int a, int b는 값을 전달  
void swap(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}

// 변수 int* a, int *b는 주소값을 전달
void swap(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

// Java uses pass-by-value
static void swap(int p, int q) {
    int t = p;
    p = q;
    q = t;
}

// Java uses pass-by-value
static void swap2(int[] p, int[] q) {
    int t = p[0];
    p[0] = q[0];
    q[0] = t;
}

// Java uses pass-by-value
static void swap(int[] p, int[] q) {
    int[] t = p;
    p = q;
    q = t;
}

// Java uses pass-by-value
static void swap2(int[][] p, int[][] q)  {
    int[] t = p[0];
    p[0] = q[0];
    q[0] = t;
}

// Java uses pass-by-value
static void swap(Point p, Point q) {
    Point t = p;
    p = q;
    q = t;
}

// Java uses pass-by-value
static void swap2(Point p, Point q) {
    double[] t = p.get(); // T t = p
    p.set(q.get());  // p = q
    q.set(t);  // q = t
}

////////////////////////////////////////

public static void main(String[] args) {
    Point p1 = new Point(10.5, 10.7);
    Point p2 = new Point(1.5, 1.7);

    swap(p1, p2);
    System.out.println(“After swap p1=” + p1 + ” p2 ” + p2); // p1=(10.5, 10.7) p2=(1.5, 1.7)
    swap2(p1, p2);
    System.out.println(“After swap2 p1=” + p1 + ” p2 ” + p2); // p1=(1.5, 1.7) p2=(10.5, 10.7)

    int[] arr1 = { 1, 2, 3 };
    int[] arr2 = { 4, 5, 6, 7, 8 };
    swap(arr1, arr2);
    System.out.print(“arr1: “);
    System.out.println(Arrays.toString(arr1)); // arr1: [1, 2, 3]
    System.out.print(“arr2: “);
    System.out.println(Arrays.toString(arr2)); // arr2: [4, 5, 6, 7, 8]

    int[][] array1 = { new int[] { 1, 2, 3 } };
    int[][] array2 = { new int[] { 4, 5, 6, 7, 8 } };
    swap2(array1, array2);
    System.out.print(“array1: “);
    System.out.println(Arrays.toString(array1[0])); // array1: [4, 5, 6, 7, 8]
    System.out.print(“array2: “);
    System.out.println(Arrays.toString(array2[0])); // array2: [1, 2, 3]

    int a = 10;
    int b = 20;
    swap(a, b);
    System.out.println(“a=” + a); // a=10
    System.out.println(“b=” + b); // b=20

    int[] a2 = { 10 };
    int[] b2 = { 20 };
    swap2(a2, b2);
    System.out.println(“a2=” + a2[0]); // a2 = 20
    System.out.println(“b2=” + b2[0]); // b2 = 10
}

//pass value type by value (값형식을 값에 의한 전달) – copy of value 전달

static void square1(int x) {
    x *= x;
    System.out.printf("The value inside square1: %d\n", x);
}

public static void main(String[] args) {
    int i = 5; 
    System.out.println("Before i=" + i);
    square1(i);
    System.out.println("After i=" + i + "\n\n");
}

//Before i=5
//The value inside square1: 25
//After i=5

//pass reference type by value (참조형식을 값에 의한 전달) – copy of reference 전달

static void square2(IntValue value) {
    value.x *= value.x;
    System.out.printf("The value inside square2: %d\n", value.x);
}

public static void main(String[] args) {
    int i = 5;
    IntValue value = new IntValue(i);
    System.out.println("Before value.x=" + value.x);
    square2(value);
    System.out.println("After value.x=" + value.x + "\n\n");
}

//Before value.x=5
//The value inside square2: 25
//After value.x=25

static void changeArray1(int[] arr) {
    arr[0]=888; // arr -> myArray이므로 원본 배열의 첫번째 값은 888로 변경
    System.out.println("changeArray1 arr=" + Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(",")));
    arr = new int[] {-3, -1, -2, -3, -4}; // local 변수로 새롭게 할당하여 지정 그러나 원본 배열 변경 안됨
    System.out.println("changeArray1 arr=" + Arrays.stream(arr).mapToObj(String::valueOf).collect(Collectors.joining(",")));
}

public static void main(String[] args) {
    int[] myArray = {1, 4, 5};
    System.out.println("Before myArray=" + Arrays.stream(myArray).mapToObj(String::valueOf).collect(Collectors.joining(",")));
    changeArray1(myArray);
    System.out.println("After changeArray1 myArray=" + Arrays.stream(myArray).mapToObj(String::valueOf).collect(Collectors.joining(",")));
}

//Before myArray=1, 4, 5
//changeArray1 arr=888, 4, 5
//changeArray1 arr=-3, -1, -2, -3, -4
//After myArray=888, 4, 5

static void changeArray2(IntValue[] arr) {
    arr[0].x=888; // 원본 배열의 첫번째 값은 888로 변경
    System.out.println("changeArray2 arr=" + Arrays.stream(arr).map(Object::toString).collect(Collectors.joining(",")));
    arr = new IntValue[] { new IntValue(-3), new IntValue(-1), new IntValue(-2), new IntValue(-3), new IntValue(-4)};  // local 변수로 새롭게 할당하여 지정 그러나 원본 배열 변경 안됨
    System.out.println("changeArray2 arr=" + Arrays.stream(arr).map(Object::toString).collect(Collectors.joining(",")));
}

public static void main(String[] args) {
    IntValue[] myArray2 = { new IntValue(1), new IntValue(4), new IntValue(5)};
    System.out.println("Before myArray2=" + Arrays.stream(myArray2).map(Object::toString).collect(Collectors.joining(",")));
    changeArray2(myArray2);
    System.out.println("After myArray2=" + Arrays.stream(myArray2).map(Object::toString).collect(Collectors.joining(",")));
}

// Before myArray2=1, 4, 5
// changeArray2 arr=888, 4, 5
// changeArray2 arr=-3, -1, -2, -3, -4
// After myArray2=888,4,5

ArithmeticCalculator (has-a Value & ArithmeticOperator)

ArithmeticOperator – PLUS, MINUS, TIMES, DIVIDE, MODULATE
Value – int x, int y
ArithmeticCalculator
UserInput
ArithmeticCalculatorTest

// returning an array from a method vs passing an array as parameter to a method

// passing an array as parameter to a method
public static int sumArray(int[] arr) {
	int sum = 0;
	for (int i = 0; i < arr.length; i++) {
		sum += arr[i];		
	}
	return sum;
}

// returning an array from a method
public static int[] assignArray(int length) {
	int[] arr = new int[length];
	for (int i = 0; i < arr.length; i++) {
		arr[i] = i;
	}
	return arr;
}

////////////////////////////////////// in main
// returning an array from a method
int[] arr1 = assignArray(3);
int[] arr2 = assignArray(5);
for (int e : arr1)	System.out.println(e); // 0 1 2
for (int e : arr2)	System.out.println(e); // 0 1 2 3 4

// passing an array as parameter to a method
int[] array1 = {100, 200, 300};
int[] array2 = {50, 60, 70, 80, 90};
int sum1 = sumArray(array1);
int sum2 = sumArray(array2);
System.out.println("array1 sum=" + sum1); // 100 + 200 + 300 = 600
System.out.println("array2 sum=" + sum2); // 50 + 60 + 70 + 80 + 90 = 350