개발자 아지트

자바에서는 함수를 메서드라 한다. 

public class Method1{
	public static void main(String[] args) {
    
    	int a = 1;
        int b = 2;
        
        int sum = a + b;
    	int sum 2 = add(10, 20);
    }
    
    public static int add(int a, int b){ // 선언부
    	int sum = a + b;  // 본문 시작
        return sum;
    }
}

모든 메서드는 return을 호출해야한다. 

반환타입이 void인 경우에는 return이 생략가능하다. (자바가 알아서 return을 넣어준다.)

return문 만나면 즉시 함수를 빠져나간다. 

함수의 반환값이 있어도 반환값을 안받고 무시도 가능하다. 

(void는 받으면 안됨)

함수 이름은 동사로 시작 시킴 

단축키:  함수이름 누르고 command + b하면 해당 함수로 이동함

함수 호출시 메모리공간이 할당됨

함수 실행 끝나면 사라짐 

인수(Argument) == 인자

호출할 때 넘기는 값. 즉, 내부로 들어가는 값

매개변수(Parameter)

메서드 정의 시 선언한 변수를 말함

넘어오는 값을 중간에서 전달하는, 매개하는 변수

메서드 내부에서 사용할 수 있는 변수

메서드 호출 및 값 전달 

자바는 항상 변수의 값을 복사해서 대입한다. 

메서드 형변환

메서드를 호출할 인자와 매개변수의 타입이 맞지 않는경우에 형변환이 필요하다.

타입이 다른경우에는 자동 형변환이 가능한 경우(인자 타입이 함수의 매개변수 타입보다 작은 타입인 경우)에만 호출이 가능하다. 

public class Casting{
	public static void main(String[] args){
    	int number = 100;
        printNum(number); // 인자로 넘김 
    }
    
    public static void printNum(double n){// 매개변수로 받음, 자동형변환됨 int -> double
    	System.out.println(n);
    }
}

메서드 오버로딩

함수 이름이 같고 매개변수가 다른(매개변수의 순서와 타입이 다른경우) 메서드를 여러개 정의하는 것을 메서드 오버로딩(Overloading)이라 한다. 

(Overloading의 의미: 과하게 물건을 적재했다)

(반환 타입만 다른 경우는 취급하지 않는다. )

==메서드 시그니처(메서드를 구분할 수 있는 기준)

int plus(int a, int b)
int plus(int c, int d)

// 위와 같은 경우도 취급하지 않는다.

자기 타입에 맞는 메서드를 찾아서 실행해되, 없는 경우에는 형 변환 가능한 타입의 메서드를 찾아서 실행함 

코드를 메서드를 사용하는 식으로 리펙토링을 하면 main()은 상세 코드가 아닌, 전체 구조(목차같은 느낌)를 한눈에 볼 수 있게 되는 모습으로 된다. (모듈처럼 만들어두는 모습) 이런 리펙토링을 메서드 추출(Extract Method)라고 한다. 꼭 재사용 하지 않더라도 보기좋게 하기 위해서 리펙토링을 진행한다. 

기본형(Primitive Type) : 변수에 사용할 값을 직접 넣을 수 있는 데이터 타입

참조형(Reference Type) : 데이터에 접근하기 위한 참조(주소)를 저장하는 데이터 타입

배열과 객체, 클래스를 담는 변수 등은 참조형에 속함.

배열은 동적으로 사이즈를 변경할 수 있다. 

코드가 실행되는 시점에 배열의 크기가 정해지기 때문이다. 

예를 들면, 사용자 입력을 받아 배열의 크기를 설정할 수 있다. 

기본 형태

	public class Array1{
    	public static void main(String[] args){
        	int[] team; // 배열 변수 선언
            teams = new int[4]; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team; // 배열 변수 선언
            teams = new int[]{1, 2, 3, 4}; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team = new int[]{1, 2, 3, 4}; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[] team = {1, 2, 3, 4}; // 배열 생성
        }
    
    }

리펙토링 :

기존 코드의 기능은 유지하면서 내부 구조를 개선하는 것을 말함.

(중복 제거, 복잡성을 줄이기, 이해하기 쉬운 코드로 다시 작성)

2차원 배열

arr[행][열] 

	public class Array1{
    	public static void main(String[] args){
        	int[][] team = new int[2][3]; // 배열 생성
        }
    
    }

	public class Array1{
    	public static void main(String[] args){
        	int[][] team = new int[2][3]{
                {1, 2, 3},
                {4, 5, 6}    
            }; // 배열 생성
        }
    }

향상된 for 문

코드가 간결하고 가독성이 좋음

public class test{
	public static void main(String[] args){
    int[] numbers = {1, 2, 3, 4, 5};
    
 	for (int number : numbers){
    	System.out.println(number);
    }
    }

}

(단축키 - iter) 

import java.util.Scanner;

public class Scanner1 {
	public static void main(String[] args){
    	Scanner scanner = new Scanner(System.in);
        
        String str = scanner.nextLine(); // 사용자 입력을 받는 부분
        // 엔터를 입력할 때 까지 문자를 가져옴 
        
        
        int intValue = scanner.nextInt(); // 정수값을 사용자 입력으로 받는 부분
        
        
        double doubleValue = scanner.nextDouble(); // 입력을 double로 받는 부분
        
        
    }

}

print() 다음 라인으로 넘기지 않는다. 

println() 다음 라인으로 넘긴다. 

변수의 종류

변수의 종류는 변수 선언 위치에 따라 아래와 같이 나뉜다. 

지역변수, 멤버 변수(클래스 변수, 인스턴스 변수)

지역변수

지역 변수는 특정 지역에서만 사용할 수 있는 변수이며, 지역은 코드 블록을 말한다. 

자신이 선언된 블록 외에서 자신에게 접근하려고 하면 접근할 수 없다. 

ex) if 문 안에서 선언한 변수는 if문 안에서만 사용할 수 있다. 

왜 지역 변수인가? 자신의 지역 안에서만 생존할 수 있기 때문이다. 

스코프의 표현

스코프 범위가 길다. 

스코프가 범위가  짧다. 

스코프는 왜 필요한가?

• 비효율적인 메모리 사용을 막기 위함
• 코드 복잡성을 낮추기 위함 
  • 좋은 코드는 군더더기 없는 단순한 코드임 
• 좋은 프로그램은 무한 자유가 있는 프로그램이 아닌 적절한 제약이 있는 프로그램이다.

형변환(캐스팅)

(cast-다른 물질을 녹여 특정 형태나 모양을 만드는 과정)

작은 범위에서 큰 범위로의 값은 허용함

이때, 사용자가 타입을 맞춰주지 않는 경우에는 자바에서 자동으로 형변환을 해줌(묵시적 형변환)

큰 범위의 값을 작은 범위로의 대입은 명시적 형변환이 필요하다. \

이때, 오버플로우 및 소수점 버림을 유의하고, 명시적 형변환을 사용하도록 해야한다.  

(명시적 형변환을 한다 하더라도 형변환 하기전의 변수값과 타입은 유지된다. )

타입의 범위 

int < long < double

자바에서의 계산

같은 타입끼리의 계산은 같은 타입의 결과를 나타낸다. 

서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다. 

do-while문 구조

조건에 만족하지 않아도 한번은 코드를 처한다. 

Continue

while(조건식){
	코드1;
    continue; // 즉시 조건식으로 이동한다. 
    코드2;
}

continue를 만날경우 즉시 조건식으로 가서 조건을 확인한다. 

향상된 for문 == for each

for(타입 변수명: 배열명) {
	System.out.println(변수명); // 예시, 배열의 원소를 출력함
}

기본 형태

public class test{
	public static void main(String[] args){
    int a = 19;
    
    if (a == 1) {
    	// 필요한 코드
    } else if (a == 2) {
    	// 필요한 코드
    } else{
    	// 필요한 코드
    }   
    }

}

팁

if문의 명령이 한개만 있어도 가독성이나 유지보수성을 고려했을때 중괄호를 사용하는것이 좋다. 

자바 14이상의 새로운 case문 

public class test{
	public static void main(String[] args){
    int a = 1;
    
   	int ticket = switch (a){
    	case 1 -> 100;
        case 2 -> 200;
        case 3 -> 300;
        default -> 500;
    };
    
    System.out.println(ticket); // 100 출력
    
    }
}

삼항 연산자 == 조건 연산자 

public class test{
	public static void main(String[] args){
    int a = 19;
    
   	String result = (a>=19) ? "네" : "아니오"; // result는 "네" 가됨
}

문자열 비교

문자열을 비교할 때는 .equals() 메서드를 사용한다.

만약 ==을 사용할 경우 실패할 경우가 발생할 수 있기때문이다. 

public class Test1{
	public static void main(String[] args){
    	String str1 = "hi";
        String str2 = "hello";
        
        boolean result = "hello".equals("hello"); // 리터럴 비교, true
        boolean result1 = str1.equals("hi");		// true
        boolean result2 = str1.equals(str2);		// false
    	
    }
}

문장 완성 단축키 : ctrl+ shift+ enter

논리 연산자

• &&: 두개의 피연산자가 모두 참이면 true를 반환, 둘 중 하나라도 거짓이면 false
• ||: 두개의 피연산자중 하나라도 참이면 true를 반환, 둘 다 모두 거짓이면 false

삼항 연산자:  ? :

instanceof 연산자 

• 객체의 타입을 반환한다. 

비트 연산자

• 실무에서 사용할 일이 거의 없음. 그때그때 찾아보면 

진도(1/10)

java.util 패키지

진도(2/10)

컬렉션 프레임워크

 

 

진도(3/10)

Generic

 

 

    public class Box {
        private Object obj;
        public void setObj(Object obj){
        this.obj = obj;
        }

        public Object getObj(){
        return obj;
        }
    }

    public class BoxExam {
        public static void main(String[] args) {
            Box box = new Box();
            box.setObj(new Object());
            Object obj = box.getObj();

            box.setObj("hello");
            String str = (String)box.getObj();
            System.out.println(str);

            box.setObj(1);
            int value = (int)box.getObj();
            System.out.println(value);
        }
    }

    public class Box<E> {
        private E obj;
        public void setObj(E obj){
            this.obj = obj;
        }

        public E getObj(){
            return obj;
        }
    }

    public class BoxExam {
        public static void main(String[] args) {
            Box<Object> box = new Box<>();
            box.setObj(new Object());
            Object obj = box.getObj();

            Box<String> box2 = new Box<>();
            box2.setObj("hello");
            String str = box2.getObj();
            System.out.println(str);

            Box<Integer> box3 = new Box<>();
            box3.setObj(1);
            int value = (int)box3.getObj();
            System.out.println(value);
        }
    }

진도(4/10)

Set

 

 

    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;

    public class SetExam {
        public static void main(String[] args) {
            Set<String> set1 = new HashSet<>();

            boolean flag1 = set1.add("kim");
            boolean flag2 = set1.add("lee");
            boolean flag3 = set1.add("kim");

            System.out.println(set1.size());   //저장된 크기를 출력합니다. 3개를 저장하였지만, 이미 같은 값이 있었기 때문에 2개가 출력
            System.out.println(flag1);  //true
            System.out.println(flag2);  //true
            System.out.println(flag3);  //false

            Iterator<String> iter = set1.iterator();

            while (iter.hasNext()) {   // 꺼낼 것이 있다면 true 리턴.          
                String str = iter.next(); // next()메소드는 하나를 꺼낸다. 하나를 꺼내면 자동으로 다음것을 참조한다.
                System.out.println(str);
            }
        }
    }

진도(5/10)

실습

참고: set의 내용은 for each문 또는 Iterator를 활용해서 출력할 수 있습니다. for each문을 복습하려면 이 링크를 참고하세요.

진도(6/10)

실습 

진도(7/ 10)

List

 

 

    import java.util.ArrayList;
    import java.util.List;

    public class ListExam {

        public static void main(String[] args) {
            List<String> list = new ArrayList<>();

            // list에 3개의 문자열을 저장합니다.
            list.add("kim");
            list.add("lee");
            list.add("kim");

            System.out.println(list.size()); //list에 저장된 자료의 수를 출력 (중복을 허용하므로 3 출력) 
            for(int i = 0; i < list.size(); i++){
                String str = list.get(i);
                System.out.println(str);
            }
        }   
    }

진도(8/ 10)

실습

진도(9/10)

Map

 

 

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;   
    public class MapExam {  
        public static void main(String[] args) {
            // Key, Value가 모두 String 타입인 HashMap인스턴스를 만듭니다.
            Map<String, String> map = new HashMap<>();

            // key와 value값을 put으로 저장합니다.
            map.put("001", "kim");
            map.put("002", "lee");
            map.put("003", "choi");
            // 같은 key가 2개 있을 수 없습니다. 첫번째로 저장했던 001, kim은 001, kang으로 바뀐다.
            map.put("001", "kang");

            // map에 저장된 자료의 수를 추력합니다. 3이 출력됩니다.
            System.out.println(map.size());

            // 키가 001, 002, 003인 값을 꺼내 출력합니다.
            System.out.println(map.get("001"));
            System.out.println(map.get("002"));
            System.out.println(map.get("003"));

            // map에 저장된 모든 key들을 Set자료구조로 꺼냅니다.
            Set<String> keys = map.keySet();
            // Set자료구조에 있는 모든 key를 꺼내기 위하여 Iterator를 구합니다.
            Iterator<String> iter = keys.iterator();
            while (iter.hasNext()) {
                // key를 꺼냅니다.
                String key = iter.next();
                // key에 해당하는 value를 꺼냅니다.
                String value = map.get(key);
                // key와 value를 출력합니다.
                System.out.println(key + " : " + value);
            }
        }
    }

진도(10/10)

실습

진도(1/8)

java.lang 패키지/오토박싱

 

 

    public class WrapperExam {
        public static void main(String[] args) {
            int i = 5; 
            Integer i2 = new Integer(5);
            Integer i3 = 5;     //오토박싱
            int i4 = i2.intValue();
            int i5 = i2;       //오토언박싱
        }
    }

진도(2/8)

실습

진도(3/8)

스트링버퍼

 

 

    StringBuffer sb = new StringBuffer();
    // 해당 스트링 버퍼에 "hello", 공백, "world"를 차례대로 추가

    sb.append("hello");
    sb.append(" ");
    sb.append("world");
    // StringBuffer에 추가된 값을 toString()메소드를 이용하여 반환

    String str = sb.toString();

    StringBuffer sb2 = new StringBuffer();
    StringBuffer sb3 = sb2.append("hello");
    if(sb2 == sb3){
        System.out.println("sb2 == sb3");
    }

        String str2 = new StringBuffer().append("hello").append(" ").append("world").toString();
        System.out.println(str2);

진도(4/8)

실습

진도(5/8)

스트링 클래스의 문제점

 

 

String클래스는 문자열을 다룰때 사용하는 클래스

        String str1 = "hello world";
        String str2 = str1.substring(5);
        System.out.println(str1);
        System.out.println(str2);

    hello world
     world

    String str3 = str1 + str2;
    System.out.println(str3);

    hello world world

    String str4 = new StringBuffer().append(str1).append(str2).toString();
    System.out.println(str4);

진도(6/8)

실습

문자열을 반복문 안에서 더하는 것은 성능상 문제가 생길 수 있으니 반드시 피해야 합니다.

진도(7/8)

Math

 

    public class MathExam {
        public static void main(String[] args) {
            int value1 = Math.max(5, 20);
            int value2 = Math.min(5, -5);
            int value3 = Math.abs(-10);
            double value4 = Math.random();
            double value5 = Math.sqrt(25);  
        }
    }

진도(8/8)

진도(1/2)

Object와 오버라이딩

 

 

진도(2/2)