국비 지원 개발자 과정 _Day 2

package com.ch01;

//변수의 종류
//원시형 변수-호출하면 값이 나온다.
//참조형 변수-호출하면 주소번지가 나온다(@abcd1234 같은 형태) -> 클래스 타입은 모두 참조형이다.


    
public class Variable1 { //클래스 선언
//	선언부-코딩하는 위치가 클래스 안이면 멤버변수(전역변수)이다.
//	변수 선언하기 -> 타입 변수명(직관적인 이름)
	int age = 30; //변수 선언 + 초기화
    
//	이름 뒤에 괄호가 있으면 메소드이다.
//	나는 메소드를 선언{} 할 수 있다.
//	메소드를 호출하땐 세미콜론(;)
//	메소드 안에 메소드를 선언할 수 없다.
    void methodA() {
        System.out.println(age); //30, 전역변수 출력
    }

	public static void main(String[] args) {
//		메소드 {좌중괄호 }우중괄호 안에 선언하면 지역변수(local variable-메소드 안에서만 사용, 호출 가능)
		int age = 5; //지역변수
        
//		insert here methodA를 호출해보세요
//		static이 있는 메소드 안에서 static이 없는 메소드를 호출할 수 없다.
//		그런데 꼭 하고싶다면 인스턴스화를 하면 가능하다.
//		methodA(); //메인은 static이 붙어있으므로 static이 없는 methodA 호출불가!

		Variable1 v1 = null; //클래스 선언법(참조형변수) -> 클래스를 선언만 하였다. 실제로 객체는 만들어지지 않았다.
		v1 = new Variable1(); //이 때 비로소 객체가 생성됨-heap 메모리 영역에 로딩이 된다. -> 메모리에 있으니 호출할 수 있다.(재사용할 수 있다.)

//		v1.age = 7; //위치1, 초기화된 전역변수 7이 출력됨(순서가 중요하다)
		v1.methodA(); //methodA의 소유주는 Variable1이다(Variable1 안에 methodA가 존재한다)
		v1.age = 7; //위치2, 전역변수 30이 출력된 후 7로 초기화됨(순서가 중요하다)
	}
}

// 30

 

package com.ch01;

public class HapExam1 {
// 0~3의 합을 구하기

	static void methodSum1() {
		int sum2 = 0;
		for(int i=0; i<=3; i++) {
			sum2 += i;
		}
		System.out.println("메인 밖 메소드1, static = " + sum2);
	}
	
	void methodSum2() {
		int sum2 = 0;
		for(int i=0; i<=3; i++) {
			sum2 += i;
		}
		System.out.println("메인 밖 메소드2, 인스턴스화 = " + sum2);
	}
		
	public static void main(String[] args) {		
//		1. 변수 2개 사용
		int sum = 0;
		int num = 1;
		sum += num;
		num = 2;
		sum += num;
		num = 3;
		sum += num;
		System.out.println("변수 2개 사용 = " + sum);

//		2. for문 사용
		int sum1 = 0;
		for(int i=0; i<=3; i++) {
			sum1 += i;
		}
		System.out.println("for문 사용 = " + sum1);
		
//		3. 메인 밖 메소드 호출-static
		methodSum1();
		
//		4. 메인 밖 메소드 호출-인스턴스화
		HapExam1 MethodA = new HapExam1();
		MethodA.methodSum2();
	}
}

// 변수 2개 사용 = 6
// for문 사용 = 6
// 메인 밖 메소드1, static = 6
// 메인 밖 메소드2, 인스턴스화 = 6

 

package com.ch01;

public class A {
	double pi = 3.14; //전역변수
	
	public static void main(String[] args) {
		double pi = 5.1; //지역변수
        
//		insert here-전역변수를 출력해주세요.
		A a = new A(); //인스턴스화
        
		System.out.println(pi); //5.1출력, 지역변수
		System.out.println(a.pi); //3.14출력, 전역변수
	}
}

// 5.1
// 3.14

 

package com.ch01;
//char < byte < short < int < long < float < double
//boolean
public class Variable2 {

	public static void main(String[] args) {
		int i = 2;
		int j = i; //j = 2
		System.out.println(j); //2
		System.out.println(i == j); //true
		System.out.println(i != j); //false
		double d = 2.4;
        
//		대입연산자 오른쪽에 더 큰 타입이 오는 것은 안된다.
//		괄호가 변수명 앞에 오면 형전환 연산자(casting연산자)
//		강제 형전환
		j = (int)d; //d를 int로 형전환하여 j에 대입한다.
        System.out.println(j); //2
        
//		boolean isOk = false; //올바르지 않은 형식
//		j = (int)isOk; //정수형과 불리언은 강제 형전환이 불가하다.
	}
}

// 2
// true
// false
// 2

 

package com.ch01;

public class Variable3 {
	public static void main(String[] args) {
//		String은 참조형타입
//		String은 참조형 타입이지만 예외적으로 값이 출력된다.
		String name = "이순신";
		System.out.println(name);
        
//		int i = (int)name; //잘못된 형식
		int age = 30;
		String s_age = "30";
		System.out.println(age + 1); //31
		System.out.println(s_age + 1); //301
		System.out.println(10 + 1); //11
		System.out.println(10 + "1"); //101
	}
}

// 이순신
// 31
// 301
// 11
// 101

 

package com.ch01;

//A is a B이다(작은범위는 큰범위다)
//자동차는 소나타이다
//소나타는 자동차이다
//HapExam2는 Object를 상속받았다
public class HapExam2 extends Object{
	public static void main(String[] args) {
		int i1 = 1;
		int i2 = 2;
		int i3 = 3;
		System.out.println(i1 + " " + i2 + " " + i3);
	}
}

// 1 2 3

 

package com.ch01;

public class HapExam3 extends Object{
	public static void main(String[] args) {
		int i = 1;
//		증가연산자가 뒤에 있으면 먼저 출력하고 1을 증가하라는 의미.
		System.out.println(i++ + " " + i++ + " " + i);
		
		int j = 0;
//		+=는 덧셈을 먼저하고 대입하라는 의미. j = j + 1 과 같은 뜻.
		System.out.println((j += 1) + " " + (j += 1) + " " + (j += 1));
		
		int x = 0;
		System.out.println((x = x + 1) + " " + (x = x + 1) + " " + (x = x + 1));
	}
}

// 1 2 3
// 1 2 3
// 1 2 3

 

package com.ch01;

public class HapExam4 extends Object{
	public static void main(String[] args) {
//		1부터 3까지 세는 숫자를 담는 변수 선언
		int count = 1; //디폴트 값은 1이다.
        
//		1부터 3까지의 누적된 합을 담는 변수 선언
		int dap = 0;
        
		dap = count + dap; //1+0
		count = count + 1; //2
		dap = count + dap; //2+1
		count = count + 1; //3
		dap = count + dap;3+3
		System.out.println(dap); //6
	}
}

// 6

 

package com.ch01;

public class HapExam5 extends Object{
	public static void main(String[] args) {
//		1. 1부터 5까지 홀수합 구하기
		int num1 = 1;
		int sum1 = 0;
        
//		1~5까지의 홀수의 합을 구할때는 연산을 3번 반복해야한다.
		sum1 += num1 ;
		num1 += 2; //3
		sum1 += num1 ;
		num1 += 2; //5
		sum1 += num1 ;
		num1 += 2; //7
        
//		만약 num1이 5보다 크면 연산하지 말 것.
		if(num1 > 5) {
			System.out.println("여기로 들어오면[num1이 5보다 크면] 출력됨==> " + num1);
			return; //이 조건을 만족하면 main 메소드를 빠져나가라.(뒤의 것은 실행X)
		}
		sum1 += num1 ;
		System.out.println(sum1);
		
//		2. 1부터 5까지 홀수합 구하기-for문
		int count1 = 0;
		for(int i=1; i<=5; i++) {
			if(i%2 != 0) { //홀수일 경우
				count1 += i;
			}
		}
		System.out.println(count1); //9
		
//		3. 1부터 5까지 짝수합 구하기
		int num2 = 2;
		int sum2 = 0;
        
//		1~5까지의 짝수의 합을 구할때는 연산을 2번 반복해야한다.
		sum2 += num2;
		num2 += 2; //4
		sum2 += num2 ;

		System.out.println(sum2); //6
			
//		4. 1부터 5까지 짝수합 구하기-for문
		int count2 = 0;
		for(int i=1; i<=5; i++) {
			if(i%2 == 0) { //짝수일 경우
				count2 += i;
			}
		}
		System.out.println(count2); //6
	}
}

 

package com.ch01;

public class HapExam6 extends Object{
	public static void main(String[] args) {
//		1부터 7까지 홀수합 구하기
		int num1 = 1;
		int sum1 = 0;
        
//		1~7까지의 홀수의 합을 구할때는 연산을 4번 반복해야한다.
		sum1 += num1 ;
		num1 += 2; //3
		sum1 += num1 ;
		num1 += 2; //5
		sum1 += num1 ;
		num1 += 2; //7
        
//		만약 num1이 7보다 크면 연산하지 말 것.
		if(num1 > 7) {
			System.out.println("여기로 들어오면[num1이 7보다 크면] 출력됨==> " + num1);
			return; //이 조건을 만족하면 main 메소드를 빠져나가라.
		}
		sum1 += num1 ;
		
		System.out.println(sum1); //16
	}
}

 

package com.ch01;

public class P13 {

	public static void main(String[] args) {
		System.out.println(5 + 0.5); //5.5, 상수로 하였다. 변수를 사용하지 않은 코드.
		byte b = 5;
		float f = 0.5F;
        
//		byte + float = float이다, 결과값은 큰 타입이 출력된다.
//		byte - float = float이다 -> JVM이 int - float 연산을 함
		System.out.println(b + f); //5.5, 변수를 활용하였다.
		System.out.println(275); //275, JVM이 상수도 int로 형변환해서 계산함
		System.out.println(275/3);//91, int / int -> int
		System.out.println(275/3.0);//91.66666666666667, int / double -> double
		System.out.println(275.0/3);//91.66666666666667, double / int -> double
		System.out.println(275.0/3.0);//91.66666666666667, double / double -> double
		
		int x = (int)3.0; //왼쪽의 타입 int로 강체 형변환
		System.out.println(x); //3
		System.out.println(x + 1); //4
		System.out.println(x + 1.0); //4.0
	}
}

 

package com.ch01;

public class P14 {
	public static void main(String[] args) {
		float f = 1.2F;
//		실수형 뒤에 d가 없으면 double 타입이다.(d는 생략 가능하다)
		double d = 3.5;
        
//		f = d; //큰 수를 작은 수에 대입할 수 없다!
		d = f;
		System.out.println(f); //1.2
		System.out.println(d); //1.2000000476837158
	}
}

 

package com.ch01;

public class LoginForm {
	public static String login(String id, String pw) {
		System.out.println("로그인 호출 성공");
		String mem_name = null; //변수 선언만 했다. null은 모른다(미정이다.)
		mem_name = "강감찬"; //6번에서 선언한 변수의 초기화. 디폴트값이 강감찬
//		return "이순신";
//		return id;
		return mem_name;
	}
    
//	코드 진행 순서: 14-15-4-5-6-7-10-18-19
	public static void main(String[] args) {
		String rmem_name = login("tomato", "123"); //login 메소드도 static이라 호출가능
//		insert here-강감찬
		System.out.println(rmem_name);
		System.out.println(login("tomato", "123"));
	}
}

// 로그인 호출 성공
// 강감찬
// 로그인 호출 성공
// 강감찬

 

package com.ch01;

public class LoginForm1 {
	public String login(String id, String pw) {
		System.out.println("로그인 호출 성공");
		String mem_name = null; //변수 선언만 했다. null은 모른다(미정이다.)
		mem_name = "강감찬"; //6번에서 선언한 변수의 초기화. 디폴트값이 강감찬
		return mem_name;
	}
    
	void methodA() {
		login("tomato", "123"); //static 없으면 호출가능
	}
    
//	괄호가 있으면 메소드이거나 생성자이다.
	public static void main(String[] args) {
//		static영역 안에서 non-static 메소드는 호출이 불가하다.
//		login("tomato", "123");
		LoginForm1 loginForm = new LoginForm1(); //생성자
		String rmem_name = loginForm.login("tomato", "123");
//		insert here-강감찬
		System.out.println(rmem_name);
	}
}

// 로그인 호출 성공
// 강감찬

 

package com.ch01;

public class PrintTest {
	public void print() {
		System.out.println("print() 호출");
	}
	
//	public void print() { //중복정의는 안됨
//	}
	
	public void print(int i) { //타입을 바꾸면 같은 이름도 쓸 수 있음
		System.out.println("print(int i) 호출");
	}
	
	public void print(String str) {
		System.out.println("print(String str) 호출");
		System.out.println(str);
	}
	
	public static void main(String[] args) {
		PrintTest pt = new PrintTest();
		pt.print(); //print() 호출
		pt.print(10); //print(int i) 호출, i에 10이 저장
		pt.print("10"); //print(String str) 호출, str에 "10"이 저장

	}
}

// print() 호출
// print(int i) 호출
// print(String str) 호출
// 10

 

메모리 영역-stack/heap

 

변수-명사형

메소드-동사형

 

내 안에 선언된 메소드라 하더라도 메인 메소드 안에서 호출할 때는 인스턴스화를 해야만 한다

 

인스턴스화

A a = new A();

 

원시형 변수(8가지 타입)

호출하면 값이 출력됨

 

참조형 변수

호출하면 주소 번지가 출력됨

 

메소드 선언할 때 static이 있으면 인스턴스화 없이도 호출할 수 있다

 

매개변수(파라미터, 인자값)

 

변수의 종류

전역 변수/지역변수/정적 변수