Month: March 2021

BankAccount-InstanceStatic – instance vs static member field & method
BankAccount-InstanceStatic

import java.util.*;
public class BankAccount {
    private int balance;
    private static int interestRate; // (%)

    public BankAccount() { 
        balance = 0; 
        interestRate = 5; 
    }

    public void deposit(int amount) { 
        balance += amount;
    }
   
    public void withdrawl(int amount) { 
        balance -= amount; 
    }

    public void print() { 
        System.out.println("final balance=" + 
	        (balance + balance * interestRate * 0.01) +
		" balance=" +
		balance +
		" interest=" +
		(balance * interestRate * 0.01));
		printInterestRate(); 
    }

    public static void setInterestRate(int interestRate) { 
        BankAccount.interestRate = interestRate; 
    }

    public static void printInterestRate() { 
        System.out.println("interestRate=" +
        interestRate); 
    }

    public int getUserInputInt() {
        Scanner input = new Scanner(System.in);
        System.out.print("Please enter Integer value: ");
        int value = input.nextInt();
        return value;
    }

    public static void main(String[] args) {
        BankAccount b = new BankAccount();
        b.deposit(2000);
        b.withdrawl(1000);
        b.print();
        BankAccount.printInterestRate();

        int amount = b.getUserInputInt();
        b.deposit(amount);
        b.print();
    }
}

ValueClass-InstanceStatic

Instance member field: int value

Static member field: static int count

public class ValueClass {
    private int value = 0; // instance field
    private static int count = 0; // static field
    static Scanner input = new Scanner(System.in); // static field

    public ValueClass() { 
	this(0); 
    }

    public ValueClass(int value) { 
        this.value = value;
        count++;
    }

    public void setValue(int value) { // instance method
        this.value = value; 
    }

    public int getValue() { // instance method
        return this.value; 
    }

    public void print() { // instance method
        System.out.println("value=" + this.value + " # of value=" + count);
    }

    public static int getCount() { // static method
        return count;
    }

    public static void printString(String str) { // static method
        System.out.print(str);
    }

    public static int getUserInputInt() { // static method
        int value = input.nextInt();
        return value;
    }

    public static void main(String[] args) {
        ValueClass v = new ValueClass();
        v.print();
        v.setValue(2000);
        int value = v.getValue();
        v.print();

        ValueClass.printString("Please enter the integer value: ");		
        int val = ValueClass.getUserInputInt();
        v.setValue(val);
        v.print();

        ValueClass v2 = new ValueClass(300);
        v2.print();

        ValueClass[] vArray = new ValueClass[3];
        for (int i=0; i<3; i++) {
            ValueClass v3 = new ValueClass();
            ValueClass.printString("Please enter the integer value: ");
            v3.setValue(ValueClass.getUserInputInt());
            vArray[i] = v3;
        }
    }
}

PersonTest-InstanceStatic

PersonTest-InstanceStatic – instance member field & method vs static member field & method

public class Person {
    String name; // instance member field
    int age; // instance member field
    
    public Person() { // default constructor
        this("JAVA", 20); // call Person(String n, int a);
    }

    public Person(String name, int age) { // constructor
        this.name = name;
        this.age = age;
    }

    public void setName(String name) { // instance method
        this.name = name;
    }

    public void setAge(int age) { // instance method
        this.age = age;
    }

    public String getName() { // instance method
        return name;
    }

    public int getAge() { // instance method
        return age;
    }

    public void print() { // instance method
        System.out.println("Person Name=" + name + " Age=" + age);
    }

    @Override
    public String toString() { // instance method
        return "Person Name=" + name + " Age=" + age;
    }
}

public class Person2 {
    static String name; // static member field
    static int age; // static member field

    public Person2() { // default constructor
        this("JAVA", 20); // call Person2(String n, int a);
    }

    public Person2(String n, int a) { // constructor
        name = n;
        age = a;
    }

    public static void setName(String n) { // static method
        name = n;
    }

    public static void setAge(int a) { // static method
        age = a;
    }

    public static String getName() { // static method
        return name;
    }

    public static int getAge() { // static method
        return age;
    }

    public static void print() { // static method에서는 this 사용 불가
        System.out.println("Person Name=" + name + " Age=" + age);
    }

    @Override
    public String toString() {
        return "Person Name=" + name + " Age=" + age; // instance method에서는 static member variable 접근 가능
    }
}

public class Person3 {
    static String name; // static member field
    static int age; // static member field

    private Person3() { // private default constructor
    }

    public static void setName(String n) { // static method
        name = n;
    }

    public static void setAge(int a) { // static method
        age = a;
    }

    public static String getName() { // static method
        return name;
    }

    public static int getAge() { // static method
        return age;
    }

    public static void print() { // static method에서는 this 사용 불가
        System.out.println("Person Name=" + name + " Age=" + age);
    }
}

public class PersonTest {
    static Scanner input = new Scanner(System.in);

    public static void main(String[] args) {
        Person[] pArray = new Person[3]; 

        // 만약 Person 객체를 하나만 생성한 후 for문에서 공유해 사용할 경우  
        // 마지막으로 입력된 데이터로 모든 데이터값이 치환됨 
        Person p = new Person(); 
        for (int i = 0; i < 3; i++) {
            System.out.print("\n\nEnter Person name and age : ");
            p.setName(input.next()); // 입력정보
            p.setAge(input.nextInt()); // 입력정보
            p.Print(); 
            pArray[i] = p; //배열에 들어간 모든 원소는 동일한 p
        }
        System.out.println("pArray : " + Arrays.toString(pArray)); 

        Person[] pArray1 = new Person[3]; 
        // 아래와 같이 for문 안에 Person p = new Person()와같이 
        // 새로운 객체를 생성해야 각자 다르게 입력된 정보가 들어가게 됨 
        for (int i = 0; i < 3; i++) {
            Person p1 = new Person(); 
            System.out.print("\n\nEnter Person name and age : ");
            p1.setName(input.next()); // 입력정보
            p1.setAge(input.nextInt()); // 입력정보
            p1.Print();
            pArray1[i] = p1; // p1는 새로운 Person객체이므로 배열에서 각각 다른 원소가 들어간다  
        } 
        System.out.println("pArray1 : " + Arrays.toString(pArray1)); 

        // 만약 Person2 객체의 name과 age는 static이라서,  
        // static은 공유하는 것이므로, 마지막으로 입력된 데이터로 모든 데이터값이 치환됨 
        Person2[] pArray2 = new Person2[3]; 
        for (int i = 0; i < 3; i++) {  
            Person2 p2 = new Person2(); 
            System.out.print("\n\nEnter Person name and age : ");
            p2.setName(input.next()); // Person2.setName(input.next())와 동일
            p2.setAge(input.nextInt()); // Person2.setAge(input.nextInt())와 동일
            pArray2[i] = p2; // p2 객체의 name과 age는 static이므로 모두 공유하기때문에, 배열의 모든 원소는 마지막에 들어간 정보로 셋팅
        }
        System.out.println("pArray2 : " + Arrays.toString(pArray2));
 
        Person3[] pArray3 = new Person3[3]; // Person3 타입의 배열생성 OK 
        for (int i = 0; i < 3; i++) {  
            //Person3 p3 = new Person3(); // error Person3() has private access 
            System.out.print("\n\nEnter Person name and age : ");
            Person3.setName(input.next()); // p3.setName(input.next()) 사용을 못하게 함
            Person3.setAge(input.nextInt()); // p3.setAge(input.nextInt()) 사용을 못하게 함
            //pArray3[i] = p3; // error p3 객체를 생성할 수 없으므로 사용 불가능  
        } 
        Person3.print();

default (package private – access in other classes within the same package)

public (visible everywhere)

protected (only access in its own class, its subclass and other classes within the same package)

private (only access in its own class)

http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html

Person Struct (in C) PersonStructC

Person Class (in C++) PersonClassCPlusPlus

Person Class (in C#) PersonClassCSharp

Person Class (in Java) PersonClassJava

// 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

// 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