Day3

C 언어 프로그래밍

유닉스 바쉬셀 코드가 아주 예쁘다..

 

객체에 동작을 표현하기 

함수는 특정한 동작. 값을 넣으면 값이 튀어나오는 것. function: 기능. 동작

메서드는 클래스 안에서 어떠한 동작을 표현할 수 있는 것

자바나 씨샵 클래스 안에서 클래스의 동작을 설명하기 때문에.

 

메서드는 동작을 구현하기 위한 것

메서드가 로드되면 전용 스택이 하나 생김. 메서드는 한번 종료되면 다시 액세스할 수 없다. 

 

지역 변수

전역 변수

 

알고리즘은 일단 플로우 차트를 그려보고 정리가 되면 코드를 짜라..

 

자바는 주소값을 절대로 넘길 수 없다. 자바는 무조건 값을 복사해서 전달!! 중요함.

(C, C#은 주소값을 넘길 수 있다. 같은 jvm을 쓰는 코틀린은 되지만 자바는 안됨.)

 

객체 지향을 쓰는 근본적인 이유: 재사용성 때문

재사용이 가능하게 하려면 추상화, 설계를 잘해야 함.

다형성이 중요함. 같은 타입의 객체가 다른 방식으로 작동하게 만드는 것. 

 

자바 상수 final

c에서는 const

 

파라미터를 던지고 값에 따라 값이 변할 때

 

클래스 안에 있어서 동작하기 때문에 메서드라고 부르는거지 사실 메서드와 함수는 동일하다..?

 

같은 타입의 뭔가가 다른 동작을 하는 것이 다형성

---

1. 메서드

public class page38 {
    
    enum TimeofDay {Morning, Afternoon, Evening}

    static void greet(){
        System.out.println("Hello");
    }
    static void greet(String name){
        System.out.println("Hello "+name);
    }
    static void greet(String name, TimeofDay timeofDay){
        String message ="";
        switch(timeofDay){
            case Morning:
                message = "Good morning, ";
                break;
            case Afternoon:
                message = "Good Afternoon, ";
                break;
            case Evening:
                message = "Good Evening, ";
                break;
        }
        System.out.println(message + name);
    }
    public static void main(String[] args){
        greet();
        greet("Dave");
        greet("Taylor", TimeofDay.Evening);
    }
    
}

 

int returnAInt(){
    return 1;
}
int i = returnAInt(); //

String hello(String name){
    return "Hello, "+name;
}
System.out.print(i);
String s = hello("Dave");
System.out.print(s);

2. C#에서 주소 전달을 통해 값을 스왑하기

class sample {
    static void process(ref int i){
        System.Console.WriteLine(i);
        i += 5;
        System.Console.WriteLine(i);
    }

    public static void swap(ref int i, ref int j){
        int temp = i;
        i = j;
        j=temp;
    }

    public static void Main(){
        // int i =5;
        // process(ref i);
        // System.Console.WriteLine(i);
        int i =5;
        int j =10;
        swap(ref i,ref j);
        Console.WriteLine("{0}, {1}",i,j);
    }
}

 

3. 자바에서 배열 이용하여 값 스왑하기

public class swapJava {
    public static void swap(int[] arr){
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }
    public static void main(String[] args){
        int a = 10;
        int b = 1;
        int[] arr ={a,b};

        swap(arr);

        System.out.println(arr[0]+" "+arr[1]);
    }
}

 

4. 자바에서 연산 우선 순위 이용하여 값 스왑하기

public class trickSwap {
    private static Integer Swap(Integer original, Integer willBeChanged) {
        return original;
    }
    public static void main(String args[]) {
        Integer a = new Integer(10);
        Integer b = new Integer(20);

        // 호출 시 전달인자에서 a = b, 바뀌기 전의 a를 반환하므로 b = a
        b = Swap(a, a = b);

        System.out.println(a + " " + b);
    }
}

 

5. WhilteTest.java 숫자 0이 들어오기 전까지 계속 입력을 받는다

import java.util.Scanner;

public class WhileTest{
    public static void main(String [] args){
        Scanner scanner = new Scanner(System.in);
        int[] array = new int[10];
        int index =0;
        while(true){
            try{
                System.out.println("Please enter a digit ( 0: EXIT)");
                String line = scanner.nextLine();
                int inputInt = Integer.parseInt(line);
                if (inputInt == 0){
                    break;
                }
                printIntArray(array);
                
                array[index] = inputInt;
                index++;
                if(array[index] > array.length){//배열 크기보다 더  인덱스 값이 더  커지면 종료해야됨 이부분 나중에 다시 봐..
                    break;
                }
         }catch(ArithmeticException e){
            System.out.println("Please enter digit!");
         }
         catch(NumberFormatException e){
            System.out.println("Please enter digit!");
         }
         
        }
    }
    // 재사용성이 높은 코드니 메서드로 만들자
    private static void printIntArray(int[] array){ 
        for(int i:array){
            System.out.print(i+"");
        }
        System.out.println();

    }


}

---

1. Adder

class Adder {
    public int apply(int right, int left) {
        return right + left;
    }
}

 

2. Multiplier

public class Multiplier {
    public int apply(int left, int right) {
        return left * right;
    }
}

3. Algorithm

import java.util.Scanner;


public class Algorithm {
    // To-do add sigma method here
    public static int sigma(int begin, int end, int step){
        // int result=0;  //처음 코드
        // for(int i = begin; i <= end ; i+=step){
        //     result = result + i;
        // }
        // return result;
        return accumulate(new Adder(), 0, begin, end, step); //최종 코드
    }
    // To-do add pi method here
    public static int pi(int begin, int end, int step){
        // int result=1; //처음 코드
        // for(int i = begin; i <= end ; i+=step){
        //     result = result * i;
        // }
        // return result;
        return accumulate(new Multiplier(), 1, begin, end, step);
    }
    // To-do add accumulate method here
    public static int accumulate(Adder adder, int init, int begin, int end, int step){
        int result= init;
        for(int next = begin; next <= end ; next += step){
            result = adder.apply(result, next);
        }
        return result;
    }
    // To-do add overloaded accumulate method here
    public static int accumulate(Multiplier binder, int init, int begin, int end, int step){
        int result= init;
        for(int next = begin; next <= end ; next += step){
            result = binder.apply(result, next);
        }
        return result;
    }

    public static void main(String[] args) {
       
        // for(int i=0;i<10;i++){
        //     sum += i;
        // }

        // System.out.println(sum);
        // System.out.println(accumulate(new Adder(), 0, 1, 10, 1));
        // System.out.println(accumulate(new Multiplier(), 1, 1, 10, 2));
        System.out.println(sigma(1, 10, 2));
        System.out.println(pi(1, 20, 3));
      
        
        
    }
}