Beast IT

기본형은 공유하지 않는다. 참조형만 자료를 공유함.

6.29(목)

데이터 구조 정의하기.

구조를 만들게 되면 "Flat 한 상태에서 -> 계층(layor)"이 생긴다.

클래스는 파일당 하다.

클래스는 대문자로 시작

객체는 new를 통해 만들어서 공간을 만들어야 한다. 

객체를 생성하지 않고 사용하게 되면 "NullPointerError뜸!"

🟩 재귀함수 

자기가 자기를 부르는 함수

stackoverflow errer

(?) Quic Sort(재귀함수를 이용한 정렬) 숙제!!!!!

장점 : 병렬작업을 할때는 일을 나눠서 할 수 있어서 좋다.

🟩 함수의 재사용

재사용이란? 

• 소스코드 -> 컴파일 -> 배포코드
• 위에 3개 중에 재사용한다는 의미는 배포코드를 재사용한다는 의미이다.
• 자바에서는 ". class " 단위가 재사용되는 단위이다.

private(다른 클래스에서 접근하는 것을 불허함)/ public(다른 클래서에서 쓰는 것을 허가함)/

배포단위 : Exam.java/ ExamList.java -> compile -> zip압축 ->. jar(확장자 변경) ->. jar(자바 압축파일)

jar파일로 만든 후 라이브러리 추가하는법 다시 해보기 (만약 FileInputStream 같은 파일 경로를 지정하는 class파일이 있으면 경로를 사전에 잘 설정하고 생각해 보기.)

🟩 객체지향 프로그래밍(OOP-//Object Oriented Programming)

실 세계(real world)의 일들을 객체를 사용해서 모델링하고, 객체를 사용하지 않으면 불가능 혹은 무지 어려웠을 일들을 쉽게 처리하는 방법을 제공한다는 것입니다.

객체지향은 코딩이 아니고, 설계이다.

캡슐화/ 상속 추상화/ 다형성

함수는 외부데이터의 영향을 받지 않기 위해 지역변수를 사용했다.... 근데 문제가 생겼다! 지역변수가 구조화되면 문제가 생긴다. 구조화된 객체를 사용하는 함수는 객체의 구조를 변경에 아주 취약하다.

캡슐화를 하면 데이터 구조에 따른 코드의 수정법 위를 캡슐 범위로 한정할 수 있다.(캡슐 범위 내에서 오류가 나서 그 부분만 찾으면 된다.)

은닉성

객체지향의 캡슐화

데이터구조 + 함수구조

🟩 객체와 개체

개체 : 개별적으롤 나눌 수 있는 것 (비행기, 자동차, 사람)/ 종류명(Type)이 개체이다.

객체 : "B747"이라는 개체의 "왼쪽으로 날아가는 비행기" 객체

추상화된 이름, 개체, 객체 구분하기

객체의 속성이란?

모든 객체는 식별하기 위해 식별코드가 존재한다.

🟩 static 메서드와 instance 메서드

class안에 함수는 static 메서드(울타리 안에 있는 함수)

객체지향으로 만들어지면 instance메서드

Static Method는 받아오는 값(매개변수)이 있으니까 This를 사용할 수 없다.

Instance Method는 받아오는 값(매개변수)가 없으니까 This를 사용해서 받아온다.(This생략가능)

🟩 생성자 : 초기화를 위한 특별한 함수

1. 객체가 생성되자마자 무조건 제일 먼저 실행되어야 만 한다.

2. 생성될 때 단 한 번만 실행되어야 만 한다.

new Exam();
new Exam + ();//소괄호는 생성자를 호출했다는 것

//생성자를 안만들어주면 기본 생성자가 생성됨

public Exam{
	private int kor;
	private int eng;
	private int math;
}

Exam exam = new Exam();
Exam exam = new Exam(1); //parameter 
Exam exam = new Exam(1,6);

public Exam(){//객체의 초기화(이름이 없어서 여러번 호출 할 방법이 없음)
         kor =3;
         eng = 4;
         math= 5;
     }
    public Exam(int a){//객체의 초기화(이름이 없어서 여러번 호출 할 방법이 없음)
        kor =a;
        eng = 4;
        math= 5;
    }
    public Exam(int a, int b){//객체의 초기화(이름이 없어서 여러번 호출 할 방법이 없음)
        kor =a;
        eng = b;
        math= 5;
    }

🟩 생성자 오버로드

public Exam(){//객체의 초기화(이름이 없어서 여러번 호출 할 방법이 없음)
     //this.kor=3;//사용한 적이 없어야 한다.
     this(3,4,5);//이름이 없기때문에 this를 사용한다.
 }
public Exam(int kor,int eng, int math){//객체의 초기화(이름이 없어서 여러번 호출 할 방법이 없음)
    this.kor =kor;
    this.eng = eng;
    this.math= math;
}

🟩 캡슐에 역할부여와 플랫폼

캡슐화는 함수만 묶는 것이 아니라 역할을 주어지는 것.

Ex) Exam아 국어 성적 저장해~!

🟩 상속

객체의 분리와 결합(Has A 관계)

UI와 데이터 서비스는 분리하는 것이 바람직 하다.

Getter/Setter

용도 : 

객체지향 프로그램의 구조

Dependency 의존성 = 도구라고 부른다

c를 b가 만들엇다

객체의 탈부착 관계(Associaton Has a 상속)

-------------------------------------------
1. Association: 파트타이머
부품(Exam) 클래스의 속성만 준비한 상태에서
필요에 의해 객체를 주입해야 하는데,

이때 setter(혹은 다른 이름의 만들어주는 메소드도 가능)
또는 생성자의 매개변수로 부품(Exam) 클래스의 객체를 생성하는 녀석


2. Aggregation: 파트타이머
Association이 일대다(배열)의 관계가 되면 이녀석


3. Composition: 정규직
제품 클래스(ExamConsole)의 객체가 만들어지면서
생성자에 의해 부품 클래스(Exam)의 객체가 동시에 만들어지는 녀석
(일대다, 일대일 구분 없음)
-------------------------------------------

Composition has a(일체형) : 객체를 A가 만들때 B객체가 같이 있는 것.(한번에 다 준비되어 있는 상태)

public class ExamConsole {
	// has a 상속관계/ A(ExamConsole)가 B(Exam)를 가지고 있다.
    // 누군가가 ExamConsole을 만들면 Exam이 자동으로 만들어 진다.
    //Composition has a 관계
    
    private Exam exam = new Exam();
    
}

Aggregation has a () : 그때 그때 필요할 때 만들어 두는 관계.(준비만 해두는 상태)

public class ExamConsole {
    private Exam[] exams;
    private int index;

    public ExamConsole() {
        int max = 3;
        exams = new Exam[max];
        index = 0;
    }
}

Association has a(분리형) : 

객체들은 관계가 있는데 다 이용관계이다.

Dependency Injection

어소시에이션>>어그리게이션   외부생성 장착

컴포지션       자체 내부에서 부품 생성

IS A 상속

틀을 이용해서(가지고) 만들었다.(프레임워크를 사용하는 관계)

메소드 재정의 Override 하기

🟩 제네릭(Generic)이란?

콜렉션을 사용하면서 반환하는 값이 무엇 인지 모르면 치명적이게 된다.

그래서 우리는 자료형식을 비우게 된다.

자바에서는 생성된 자료형식으로 Object를 만들고, 담고 빼줄때 사용자가 원하는 형식으로 형변환을 해준다.

Object가 들어오고, 나갈때 사용자가 원하는 어떠한 형식으로 바꿔주는 것을 Generic이라고 한다.

GList<String,Integer> list = new GList<String,Integer>();

반드시 Object로 변환이 가능한 Wrapper형식으로 적어줘야한다. [int (x) / Integer (o)]

public class GList<타입, 두번째타입>
public class GList<T>//상징적으로 <T>를 많이 씀

예시 코드

package com.newlecture.app.util;

public class Program {
    public static void main(String[] args) {
        GList<Integer> list = new GList<>();
        list.add(3);
        list.add(5);
        int size = list.size();
        System.out.printf("size : %d\n",size);

        list.clear();
        size = list.size();
        System.out.printf("size : %d\n",size);

        list.add(7);
        int num = (Integer) list.get(0); //Object -> Integer
        System.out.printf("num : %d\n",num);
        //num= (Integer)list.get(1);
    }
}

package com.newlecture.app.util;

public class GList<T> {

    private Object[] nums;
    private int current;

    public GList(){
        nums = new Object[3];
        current =0;
    }

    public void add(T num) {
        nums[current]=num;
        current++;
    }

    public void clear() {
//        for(int i=0;i<current;i++)
//            nums[i]=0;

        //nums = new int[3];
        current = 0;
    }

    public int size() {
        return current;
    }

    public T get(int index) {
        if(current<=index)
            throw new IndexOutOfBoundsException();

        return (T)nums[index];
    }
}

🟩 가변크기 컬렉션으로 변경하기

package com.newlecture.app.util;

public class Program {
    public static void main(String[] args) {
        GList<Integer> list = new GList<>();
        list.add(3);
        list.add(5);
        int size = list.size();
        System.out.printf("size : %d\n",size);

        list.clear();
        size = list.size();
        System.out.printf("size : %d\n",size);

        list.add(7);
        int num = (Integer) list.get(0); //Object -> Integer
        System.out.printf("num : %d\n",num);
        //num= (Integer)list.get(1);
    }
}

package com.newlecture.app.util;

public class GList<T> {

    private Object[] nums;
    private int current;
    private int capacity;//용량
    private int amount;//추가 증가량

    public GList() {
        current = 0;
        capacity = 3;
        amount = 5;
        nums = new Object[capacity];
    }

    public void add(T num) {
        //만약에 공간이 모자라면
        if (capacity <= current) {
            Object[] temp = new Object[capacity + current];

            for(int i =0;i<current;i++)
                temp[i]=nums[i];

            nums = temp;
            capacity+=amount;
        }

        nums[current] = num;
        current++;
    }

    public void clear() {
//        for(int i=0;i<current;i++)
//            nums[i]=0;

        //nums = new int[3];
        current = 0;
    }

    public int size() {
        return current;
    }

    public T get(int index) {
        if (current <= index)
            throw new IndexOutOfBoundsException();

        return (T) nums[index];
    }
}

🟩 자바 컬렉션의 3대 계보 (Set/List/Map)

        List<Integer> list = new ArrayList<>();
        list.add(3);//Index 0
        list.add(5);//Index 1
        list.add(7);//Index 2
        list.add(8);//Index 3

        list.get(2);// 7이라는 값이 나온다.
        System.out.println(list.get(2));
        System.out.println(list.size());

//        ----------------------------------------------
        //중복제거할때 유용하게 사용한다.
        Set<Integer> set = new HashSet<>();
        set.add(3);
        set.add(5);
        set.add(6);
        set.add(7);
        set.add(7);
        set.add(7);
        System.out.println(set.add(7));
        System.out.println(set.add(8));
        System.out.println(set.size());

//        ---------------------------------------------
        Map<String, Object> map = new HashMap<>();
        map.put("id", 3);
        map.put("title", "Hello");
        map.put("hit", 12);
        
        System.out.println(map.get("title"));

🟩 Java에서 Primitive 데이터 타입은

• 정수타입(byte, short, int, long)
• 실수타입(float, double)
• 논리타입(boolean)
• 문자타입(char)

총 4가지 타입으로 구성되있습니다. 

이와 비슷하게 Wrapper 타입이라고 각 Primitive 별 참조타입이 따로 존재합니다.

🟩 Wrapper 타입

• 정수타입(Byte, Short, Integer, Long)
• 실수타입(Float, Double)
• 논리타입(Boolean)
• 문자타입(Character)

🟩 Boxing 과 Unboxing 의미와 사용 이유

위의 Primitive 타입과 Wrapper 타입을 서로 왔다갔다(Casting) 할때 사용한다.

• Boxing : Primitive -> Wrapper
• Unboxing : Wrapper -> Primitive

자바에서는 기본형 타입(Primitive)는 값을 저장하기 때문에 Collection에 담을 수 없다.

이를 해결하기 위해  기본형 타입(Primitive Type)을 Boxing해서 참조 타입(Reference Type)으로 변환해서 Collection에 담을 수 있게 된다.

🟩 Boxing 과 Unboxing 방법

int x = 3;
Integer 정수갑옷 = Integer.valueOf(x);// new Integer(x); Boxing
int x1 = 정수갑옷.intValue();// Unboxing
		

String y = "hello";// 태생이 갑옷을 입고있는 문자열!

double d1 = 3.9;
Double 더블갑옷 = Double.valueOf(d1);// new Double(d1);
double d2 = 더블갑옷.doubleValue();// Unboxing

// ---정수를 문자열로 변환 & 문자열을 더블로 변환.
int n1 = 10;
String s1 = String.valueOf(n1);

String s2 = "30.2";
double n2 = Double.parseDouble(s2);

아래 소스코드 원본을 볼 수 있다.

👇 👇

https://beastit.tistory.com/34

컬렉션에 관해 궁금하다면 아래 링크를 참조하면 된다.

https://beastit.tistory.com/87

🟩 컬렉션(Collection)이란? 

데이터를 수집하고 관리해 주는 객체

🟩 Why?

데이터 관리를 직접 할 필요가 없다.

배열을 사용할 때는 한번 설정한 공간을 더 늘리거나, 줄이지 못함!

그러나 컬렉션을 사용하면 이 문제를 해결할 수 있다.

컬렉션은 가변길이 배열을 사용하고 싶을 때 쓰는 객체

✏️ 정수형을 관리할 수 있는 컬렉션 예시

package com.newlecture.app.util;

public class Program {
    public static void main(String[] args) {
        IntList list = new IntList();
        list.add(3);
        list.add(5);
        int size = list.size();
        System.out.printf("size : %d\n",size);

        list.clear();
        size = list.size();
        System.out.printf("size : %d\n",size);

        list.add(7);
        int num = list.get(0);
        System.out.printf("num : %d\n",num);
    }
}

package com.newlecture.app.util;

public class IntList {

    private int[] nums;
    private int current;

    public IntList(){
        nums = new int[3];
        current =0;
    }

    public void add(int num) {
        nums[current]=num;
        current++;
    }

    public void clear() {
//        for(int i=0;i<current;i++)
//            nums[i]=0;

        //nums = new int[3];
        current = 0;
    }

    public int size() {
        return current;
    }

    public int get(int index) {
        if(current<=index)
            throw new IndexOutOfBoundsException();

        return nums[index];
    }
}

📌 우리가 정수형 컬렉션을 만들면 정수형만 담을 수 있다.

• Exam이라는 객체를 관리하고 싶으면 Exam 방식이 필요하다.
• 문자형을 관리하고 싶으면 문자형 방식이 필요하다.
• 실수라는 객체를 관리하고 싶으면 실수형 방식이 필요하다.

✏️ 일괄적으로 한 번에 관리하고 싶은데 이런 방법이 있을까???

💡 있음 💡

자바에서 모든 클래스는 Object라는 녀석을 상속받게 돼있다.

어떠한 클래스도 Object라는 부모를 가진다면 모든 객체는 Object라는 단일화된 형식으로 참조할 수 있다.

👇 👇 👇 👇 👇

그러나!

기본형식(Primitive)으로 사용하는 값들(int, float, double.... 등등)은 참조할 수 없다.

기본 형식은 값은 담는 것이다.

👇 👇

이 문제를 해결하기 위해 JDK5.0부터 새로운 것이 등장했다.(Auto Boxing/ UnBoxing)

🟩 Wrapper 클래스와 Auto Boxing/ UnBoxing

Object라는 자료형이 있다. 

형식 자체는 참조형이어서 객체 자체는 참조할 수 있지만, 값은 담는 것이어서 참조할 수 없다.

" 3 " 이라는 녀석 (Primitive)이 참조가 되려면 공간으로 바뀌어야 하는데, 공간이 되도록 감싸는 것이 필요하다. 

이것을 Boxing이라고 한다.

이렇게 Boxing 한 값은 객체여서 나중에 쓰려면 다시 기본형식(Primitive)으로 바꿔 주어야 한다.

이것을 UnBoxing이라고 한다.

이렇게 Boxing에 사용되는 것을 Wrapper 클래스라고 한다.

👇 👇

String은 참조형이어서 바로 참조가 가능하다.

이제 값을 이용할 수 있는 변수 형식이 2가지(값형식, 참조형식)가 생긴다.

👇 👇

동작하는 것이 같다고 "Integer"로만 사용하게 되면, 내부적으로 Boxing, UnBoxing이 연산이 자꾸 일어나

때문에 연산작업이 계속되어서 효율이 안 좋아진다!

(한 두 개 작업하면 괜찮지만, 수백만 개의 데이터를 연산하면... 어후...)

https://beastit.tistory.com/34

위 링크는 수업 초기에 선생님께서 "정수갑옷"이라는 표현을 사용해서 설명해 주신 게... 이제 와서 보니 Wrapper Class에

관한 설명이었다! 지금 너무 속이 후련해서 행복하다!   뉴레카! 유레카! 유렉쌤짱!

🟩 Object 컬렉션으로 변경하기

package com.newlecture.app.util;

public class Program {
    public static void main(String[] args) {
        ObjectList list = new ObjectList();
        list.add(3);
        list.add(5);
        int size = list.size();
        System.out.printf("size : %d\n",size);

        list.clear();
        size = list.size();
        System.out.printf("size : %d\n",size);

        list.add(7);
        int num = list.get(0); //Integer
        System.out.printf("num : %d\n",num);
        num= list.get(1);
    }
}

package com.newlecture.app.util;

public class ObjectList {

    private Object[] nums;
    private int current;

    public ObjectList(){
        nums = new Object[3];
        current =0;
    }

    public void add(Object num) {
        nums[current]=num;
        current++;
    }

    public void clear() {
//        for(int i=0;i<current;i++)
//            nums[i]=0;

        //nums = new int[3];
        current = 0;
    }

    public int size() {
        return current;
    }

    public Object get(int index) {
        if(current<=index)
            throw new IndexOutOfBoundsException();

        return nums[index];
    }
}

이렇게 이전 int형 컬렉션을 Object형식으로 변환해주었다.

참조를 반환해서 오류가 발생한다. 

Object -> Integer로 수정하면 위 문제가 해결된다.

👇 👇

더 자세하게 알고 싶으면 아래 뉴렉처 선생님의 강의를 들어보세요. 강추!

👇 👇

https://youtube.com/playlist?list=PLq8wAnVUcTFWKOIbvo18pJZ9zsxtXz_-k 

🟩 함수 오버로드(overload)

동일한 기능, 동일한 이름의 메소드에 여러가지 매개 변수를 추가하여

(하나의 함수 이름에 매개 변수를 과적하여) 기능을 확장시킨 함수 (옵션이 있는 함수)

(EX) print 메소드, print라는 함수의 의미는 살리면서 선택해서 사용할 수 있어졌다.

이때 과적된 내용을 가지고 있는 녀석이 기본 함수 안에 들어가는 방법으로, 중복된 내용을 반복시키지 않고 구현해 줄 수 있다.

→  과적된 애는 인자가 더 많아서 품을 수 있는 애가 많기 때문에 과적함수(오버로딩)가 기본 함수(과적된 내용이 없이 기본값을 가진 함수) 안으로 들어감

기존 함수가 있는데 동일한 함수에 일정 기능을 추가해서 사용하고 싶을 때 사용한다.

//성적 출력
examPrint(list);
System.out.println();
examPrint(list,3);//Overload(과적) 함수

기존 메서드를 이용하면 전체내용을 출력하는데, 3개만 출력하고 싶을 때 위처럼 만듦.

//성적 출력
examPrint(list);
System.out.println();
examPrint(list,3);//Overload(과적) 함수

 private static void examPrint(ExamList list, int limit) {
        Exam[] exams= list.exams;

        int size = limit;

        int num=1;//성적 등수 확인용 숫자.

        for (int i = 0; i < size; i++) {
            Exam exam = exams[i];
            int kor = exam.kor;
            int eng = exam.eng;
            int math = exam.math;

            int total = exam.total;
            float avg = exam.avg;

//                    if (avg >= 80)//성적 80이상
            System.out.printf("%d등 %3d, %3d, %3d, 총점 %3d 평균 %.2f\n", num, kor, eng, math, total, avg);
            num++;
        }

    }
    private static void examPrint(ExamList list) {
        Exam[] exams= list.exams;

        int size = list.index;

        int num=1;//성적 등수 확인용 숫자.

        for (int i = 0; i < size; i++) {
            Exam exam = exams[i];
            int kor = exam.kor;
            int eng = exam.eng;
            int math = exam.math;

            int total = exam.total;
            float avg = exam.avg;

//                    if (avg >= 80)//성적 80이상
            System.out.printf("%d등 %3d, %3d, %3d, 총점 %3d 평균 %.2f\n", num, kor, eng, math, total, avg);
            num++;
        }

    }

위에처럼 짜면 코드가 길어져서 아래와 같이 작성할 수 있다.

 private static void examPrint(ExamList list) {//오버로드 함수
        int size = list.index;
        examPrint(list, size);
    }

    private static void examPrint(ExamList list, int limit) {
        Exam[] exams = list.exams;

        int size = limit;

        int num = 1;//성적 등수 확인용 숫자.

        for (int i = 0; i < size; i++) {
            Exam exam = exams[i];
            int kor = exam.kor;
            int eng = exam.eng;
            int math = exam.math;

            int total = exam.total;
            float avg = exam.avg;

//                    if (avg >= 80)//성적 80이상
            System.out.printf("%d등 %3d, %3d, %3d, 총점 %3d 평균 %.2f\n", num, kor, eng, math, total, avg);
            num++;
        }

    }

아래 코드는 혼자서 오버로드 함수를 구현해 본 것이다.

//overloading
	{
        aaprint();
        aaprint(3);
    }

    private static void aaprint() {
        int defaultNum = 10;//기본 값 10
        aaprint(defaultNum);
    }

    private static void aaprint(int limit) {
        int size = limit;
        for (int i = 0; i < limit; i++)
            System.out.println("출력");
    }

🟩 메서드란?

특정 작업을 수행하는 일련의 문장들을 하나로 묶은 것이다.

✅ 메서드를 사용하는 이유

• 높은 재사용성 : 한번 만들어 놓은 메서드는 몇 번이고 호출할 수 있다.
• 중복된 코드의 제거 : 반복되는 문장을 묶어서 메서드로 작성하면, 메서드를 호출하는 문장으로 대체할 수 있다.
• 프로그램의 구조화 : 메서드를 사용해 main에서 전체 흐름이 한눈에 들어오게 구조화 가능하다.

✅ 메서드의 선언과 구현

public static 반환값형식 함수명(인자형식)//메서드 선언부

public static int num(int a, int b){ //예시
	return 반환값;
}

num(3,4); //메서드 구현방법

반환하는것은 그 함수를 통해 무엇이 남는지? 남겨지는것을 한다.

public class Program2 {
    //로또번호 저장하기
    public static int[][] creatLottos(){
        int[][] lottos={{1,2,3,4,5,6},{7,8,9,10,11,12},{13,14,15,16,17,18}};

        return lottos;
    }
    //로또 출력
    public static void printLottos(int[][] lottos){
        for(int i=0;i<3;i++) {
            for (int j = 0; j < 6; j++)
                System.out.printf("%4d, ",lottos[i][j]);

            System.out.println();
        }
    }
    //로또 저장소 바꿔주기
    public static void swapLottos(int[][] lottos,int i,int j){
        int[] temp = lottos[i];
        lottos[i]=lottos[j];
        lottos[j]=temp;
    }

    public static void main(String[] args) {

        int[][] lottos = creatLottos();//로또번호 생성 후 lottos에 저장해주기
        
        //로또 출력
        printLottos(lottos);

        System.out.println("\n-----------첫번째와 세번째 바꾸기-----------\n");
        
        //로또 저장소 바꿔주기
        swapLottos(lottos,0,2);//값바꾸기
        
        //로또 출력
        printLottos(lottos);


    }
}

public class BasicProgram2 {
    static int sum(int n) {
        int total = (n * (n + 1)) / 2;
        return total;
    }

    static int power(int x) {
        return ((x + 3) * (x + 3) + x / 3 * (x - 2) + 5);
    }

    public static void main(String[] args) {
        //int result = 1+2+3+4+5+6+7+8+9+10~n;
        int result = sum(11);
        System.out.printf("result : %d\n", result);

        //(x+3)*(x+3)+ x/3*(x-2)+5
        int result2 = power(7) + 3 + power(7) - power(3);
        System.out.printf("result : %d\n", result2);

        int a1 = f1();
        int a2 = f2(20, 30);
        f3(33);
        f4(9);

//        int[] lotto = new int[3];
//        print(3,5.3f,lotto);


        char[][] names = new char[3][10];

        double cnt = print(true, 4.0, names);
    }

    static double print(boolean a, double b, char[][] c) {
        return 2.2;
    }

    //print(2,3.0f,'a') 함수로 만들어보자!
//    static void print(int i, float f,int[] a){
//        System.out.printf("출력 값 : %d %.2f %c\n",i,f,a[0]);
//    }
    private static void f4(int i) {
        System.out.printf("출력 값 : %d\n", i);
    }

    private static void f3(int i) {

    }

    private static int f2(int i, int i1) {
        return 0;
    }

    private static int f1() {
        return 0;
    }
}