[java] 자바 기초 공부

package java1;
import java.util.Scanner;

public class java01_기초 {

	// 1. 메인함수 : 우선실행
	public static void main(String[] args) {
		//2. 하단 콘솔에 로그 출력
		System.out.println("Hello World");
		
		//================
		//3. 자료형과 변수
		//================
		//변수 : 값을 저장할 수 있는 메모리 공간.(데이터를 담는 그릇)
		//상수 : 값이 변하면 안될 때 변수 선언시 앞에 final을 붙여서 선언.
		//final int J; J = 10; (J에는 값을 담을 수 있는 기회가 단 한 번만 허락됨)
		
		//a. 문자형
		char var1 = '롸'; //작은따옴표, 한글자의 한글 or 영문 가능
		String var2 = "롸롸롸"; //큰따옴표, 여러글자 문자열 가능
	
		//b. 정수형
		byte var3 = -128; //-128~+127까지 숫자가 가능하다.
		short var4 = -32768; //-32768~+32767까지 숫자가 가능하다.
		int var5 = 9999; //-21억~+21억까지 숫자가 가능하다.
		long var6 = 9999L; //여러 숫자 입력가능.
		
		//c. 실수형
		float var7 = 0.5f; //소수점 선언 후 f 꼭 붙여주기
		double var8 = 0.5; //소수점 선언
		
		//d. 논리형
		boolean isStart = false; //true 또는 false 로 조건식에서 사용.

		//================
		//4. 형변환
		//================
		//이렇게 괄호로 표시해주는 형변환을 명시적 형변환, 그냥 덮어쓰는걸 묵시적 형변환.
		byte var9 = (byte)var5;
		System.out.println(var9); //-1

		//================================
		//5. 산술연산자 ++이 앞과 뒤에 붙었을때의 차이.
		//================================
		

		//================
		//6. if문
		//================
		//만약 고객의 아이디가 맞으면 True, 틀리면 False, 빈칸이면 다시입력.
		String ID = "";
		
		if (ID == "aaa") {	
			System.out.println("True");	
		}else if(ID=="") {
			System.out.println("아이디를 입력하세요.");
		}else {
			System.out.println("False");
		}

		//=================================================
		// 7. 조건식과 동일/삼항연산자 : 조건식 ? 피연산자1 : 피연산자2
		//=================================================
		// 조건식의 연산결과가 true 이면, 결과는 피연산자 1이고, 조건식의 연산결과가 false 이면 결과는 피연산자2
		int b1 = (5>4) ? 50 : 40;
		System.out.println(b1);
		//5가 4보다 크면 맞으면 50 틀리면 40. 그걸 b1에 담기
		
		//================
		// 8. 반복문
		//================
		//for(초기식 ; 범위 ; 조건){ 실행구문;}
		for(int i=0 ;i<3 ; i++) {
			System.out.println("실행 ");
		}
		System.out.println("실행2");
		
		
		//================
		//9. while문
		//================
		//while(조건){실행구문;}
		//스캐너는 입력받을때 쓰는 것. 선언해주어야한다.

		Scanner data = new Scanner(System.in); //System.in은 화면에서 값을 입력받겠다는 뜻.
		
		int i = data.nextInt(); //a에 입력한 숫자 입력값에 따라서 i가 변함.
		
		while(i<10) {
			System.out.println(i);
			i++;
		}
		
		data.close();//스캔 끝나는거 표시해주기.
		
		System.out.println("a");
		
		
		
		//================
		//10. 배열
		//================
		//같은 데이터 타입을 가진 연속된 메모리 공간으로 이루어진 자료구조
		//같은 데이터 타입을 가진 여러개의 변수가 필요할 때 사용한다.
		
		//좋은 단어 모음 / 부정 단어 모음
		String goodWord[] = {"멋진","좋은","사랑","굿"};
		String badWord[] = {"별로","나쁜","쓰레기"};
		
		//배열에 담은거 반복문으로 출력
		for (int i2=0 ; i2<goodWord.length ; i2++) {
			System.out.println(goodWord[i2]); //출력할때 배열의 인덱스번호로 출력.
		}
		
		//복합
//		for (int i3=0 ; i3<goodWord.length ; i3++) {
//			for(int i4=0 ; i4<badWord.length ; i4++) {
//				System.out.println("a1");
//				System.out.println("b");
//			} 
//			System.out.println("끝");
//		}
		//a1,b가 안쪽 for	문 안에서 3번 끝 한번, 그걸 총 4번 반복.
		
		
		
		//배열에 값 저장.
		//goodWord[4] = "새로운 단어"; -> 에러 : 배열은 4자리밖에 없는데 내가 5번째 자리에 계속 넣으려함.
		goodWord[3] = "새로운 단어";
		
		System.out.println(goodWord[0]);
		System.out.println(goodWord[1]);
		System.out.println(goodWord[2]);
		System.out.println(goodWord[3]); //덮어쓰기됨.
		
		
		//선언과 동시에 초기화하는 방법
	    int[] array = new int[]{1,2,3,4,5};
	    System.out.println(array[2]);
	    //int 값을 5개저장 할 수 있는 배열이며, 해당 배열에는 1,2,3,4,5가 순서대로 저장되게 된다.
		
	
	}//main

}//class

package java1;

public class java02_접근제한자 {
	
	

	//===============================================================================
	//접근제한자.
	//1. public : 타 패키지에서도 여기서 생성한 a 변수를 가져올 수 있음.
	//2. default : 같은 패키지 안에서만 생성한 a 변수에 접근 가능.
	//3. private : 같은 클래스 안에서만 생성한 a 변수에 접근 가능.
	//4. protected : default랑 비슷하지만 예외적으로 타 패키지에서 현재 클래스를 상속해서 쓸 경우, 접근 가능함.
	//===============================================================================

	protected String a = "결과"; //앞에 접근제한자 붙이기.
	
	
public static void main(String[] args) {
	
	java02_접근제한자 test = new java02_접근제한자();
	System.out.println(test.a); //3. private : 같은 클래스 안에서만
	


}

//왜 쓸까?
//1. 보안을 위해
//2. 협업에 있어서 적절한 권한을 부여해서 쓰기 위해.
	
}

 

package java1;

public class java02_접근제한자2 {

	
	public static void main(String[] args) {
		
		java02_접근제한자 test = new java02_접근제한자();
		System.out.println(test.a); //2. default : 같은 패키지 안에서만
	}
}

package test;

import java1.java02_접근제한자; //수입하고

public class java02_접근제한자_타패키지 extends java02_접근제한자{
									//상속받기 

public static void main(String[] args) {
	//4. protected : default랑 비슷하지만 예외적으로 타 패키지에서 현재 클래스를 상속해서 쓸 경우, 접근 가능함.
	
		
		//java02_접근제한자 test = new java02_접근제한자();
		//System.out.println(test.a); //이렇게는 에러남. getter/setter를 쓰면 됨.
	
	java02_접근제한자_타패키지 test = new java02_접근제한자_타패키지();
	System.out.println(test.a); //자식껄로 선언해서 자기껏처럼 부모꺼에서 선언된 변수를 가져다 쓸 수는 있음.

}
	
}

package java1;

	//-------------
	//클래스(Class)란 : 설계도.
	//-------------

	//객체를 생성하기 위한 설계도 혹은 틀
	//서로 관련 되어 있는 메서드의 집합
	//객체들의 속성을 묶어 놓은 집합체
	
	//-------------
	//객체란(Object)란 : 설계도대로 만든 도구(속성과 기능으로 이루어져있음.속성:멤버변수(자료형과 그 안의 데이터까지), 기능:메서드)
	//-------------

	//객체를 다양하게 표현하지만 나는 클래스에 정의된 내용대로 생성된 것이라 생각한다.
	//객체는 속성과 동작으로 이루어져 있다.
	//특징
	//- OOP의 관점에서 클래스의 타입으로 선언되었을 때 '객체'라고 부른다.
	//클래스로부터 만들어진 객체를 '클래스의 인스턴스(Instance)라고도 부른다.
	
	//-----------------
	//인스턴스(Instance)란 : 클래스에서 객체가 생성되면 인스턴스라 부른다.
	//-----------------

	//- OOP에서 어떤 클래스에 속하는 객체를 인스턴스라고 부른다.
	//클래스로부터 생성된 객체를 인스턴스라 생각하면 쉬울것이다.
	//특징
	//- 객체가 만들어지는 과정을 클래스의 인스턴스화라고 한다.
	//클래스와 인스턴스는 같은 의미이기에 이 둘을 문맥에 따라 구별하는 것이 맞다.
	//ex) 책상은 객체이다, 책상은 책상 클래스의 인스턴스이다.

	
	
	
	//앞서 말한것처럼 클래스는 객체를 만들기위한 설계도이다.
	//객체는 속성과 기능 이 두가지의 구성요소로 이루어져 있는데
	//속성을 멤버변수, 기능을 메서드(함수)라고 자주 부른다.
	
	public class java03_class {
		
	    //멤버변수(속성변수,전역변수)
	    String name;
	    int number;
	    int grade;
		
	    // 메서드(함수 = 기능)
	    public void getGrade() {
	        grade += 10;
	    }

	    public static void main(String[] args) {
	    	java03_class student1 = new java03_class(); // 객체를 생성할때는 new 연산자를 통해 생성한다.
	      									// java03_class()는 생성자를 호출한다는 의미이다.(생성자는 좀 이따 설명)
	        student1.name = "영희";
	        student1.number = 1;
	        student1.grade = 80;

	        System.out.println("학생의 이름은 " + student1.name);
	        System.out.println("학생의 번호는 " + student1.number);
	        System.out.println("학생의 성적은 " + student1.grade);

	        student1.getGrade();

	        System.out.println("학생의 성적은 " + student1.grade);

	    }
}


/*  <클래스 정리>
 * 접근지정자 : public / private / default / protected

 *	추상클래스/메소드 -> 덜 완성된 틀만 형성해서 자식이 제대로 안을 채워서 쓸 수 있게 함.
 * abstract class : 클래스에 바디가 없는 메소드가 1개 이상. 따라서 "객체 생성이 불가" -> 기능없이 비어있다.
 * abstract 메소드 : 리턴,메소드명,매개변수만 정의되고 실행될 구문이 없음(바디없음). -> 안에 채워서 써라.

 * final class : 이 클래스는 상속이 되지 않는다(자식이 없다).
 * final 메소드 : 오버라이딩(재정의) 불가. 클래스 상속이 되도 자식클래스에서 이 메소드는 값(실행구문)을 바꿀 수 없다.

 * static 변수 = 데이터; : 자료형 선언 없이 가져다 쓸 수 있다. (java04_Constructor2 참고)
 * static 메소드 : 객체 생성 없이 이 메소드 가져다 쓸 수 있다.
 * final 변수 : 갱신금지. 이 변수 데이터는 덮어써지지 않는다.

 * 생성자는 생성자명(매개변수){실행구문;}으로 되어있고, this.변수 로 그 생성자값 가져올 수 있다.
 
 * void 메소드 : 리턴이 없는 메소드. 행동만 하고 끝. return;은 가능하지만 return a;는 불가능.
 * return은 "자료형 메소드" 형태로 return에서 그 자료형 타입을 리턴해줘야한다. 
 */
	
	
	
	
	
	

package java1;

public class java03_method {

		//제일먼저 실행되는 메인 메소드
	public static void main(String[] args) {
	
		//------------------------------------
		//2. 이 클래스에 있는걸 사용하기 위해 선언한다.
		//------------------------------------
		java03_method methodExample = new java03_method();
		
		//methodExample. 하면 이 클래스 내부에서 사용할 수 있는 메소드가 나온다.
		//methodExample.StrCombine(c, d); //자동으로 c,d가 생긴다.
		methodExample.StrCombine("void로 문자열을 ", "합치는 기능"); //그 c,d 자리에 우리가 메소드에서 설정한 문자열 넣어주자.
	
	
	//--------------------------------------------------------------
	//3. 실행하면 메인에서 StrCombine을 실행하면 메소드 가져와서 sysout해서 출력됨.
	//--------------------------------------------------------------
		//왜 메소드를 만들까?
		//1. 유지보수성을 위해서
		//2. 가독성이 좋아지니까.
		//3. 캡슐화(여러곳에서 중복된 코드를 작성할 필요가 없어지니까. 여러번 선언할 필요없이 호출만 하면 됨.)
	
	
	//----------------
	//5. 메인에서 출력하기.
	//-----------------
		System.out.println(methodExample.StrCombine2("리턴형으로 문자열을 ", "합치는 기능"));
		
		//--------------------------------------------------------------
		//6. 실행하면 메인에서 StrCombine2로 원소들을 보내서(return) 그 결과값을 출력.
		//--------------------------------------------------------------
		//메소드에서 타입을 설정해준다(이번경우 String).
		//다른곳에서 메소드가 실행되면 그 결과값을 다시 메소드로 가져와서 메소드에 담아준다.(이번경우 문자열을 StrCombine에 담아줌)
		//methodExample.StrCombine2("리턴형으로 문자열을 ", "합치는 기능") 이거 자체가 메소드를 쓰는 실행구문이 된거고 이거 자체가 String이다.
	
	
	}//main 끝
	
	//===============================
	//1. 메소드 선언해주기 - 변수에 기능 담기
	//===============================
	//두가지 문자열을 합하는 메소드 만들기 : 메소드 이름 StrCombine 
	
	// void : 실행형 메소드 -> 그냥 {}내부의 실행구문을 실행하고 결과값을 뽑아버림.
	//매개변수 : 소괄호 안에 메소드를 호출할 때 같이 넣어줄 친구들의 타입과 변수명을 넣어줌. =>c,d 문자형
	public void StrCombine (String c, String d) {
		String result = c+d; //result라는 문자형 변수는 c랑 d를 더한값을 담는다.
		System.out.println(result);
	}
	

	//===============================
	//4.void와 return
	//===============================
	// void : 실행형 메소드 -> 그냥 {}내부의 실행구문을 실행하고 결과값을 뽑아버림.
	// return : 리턴형 메소드 -> 어디선가 실행되면 결과값 다시 가져옴.
	public String StrCombine2 (String e, String f) { //리턴 써주라고 에러남.
		String result = e+f;
		return result;//StrCombine2로 돌려주고 난 뒤 다시 메인으로 가서 찍어줌.
	}
	
	
}


//결론
//void는 일단 메소드를 만든다. 그리고 그 메소드가 어떤 역할을 하는지 다 적어준다. 그저 실행만 하는 실행형 메소드이기 때문에,
//뭐가 어떻게 되던지간에, 다른 곳에서 c,d 값만 정해주면 우리가 만든 메소드가 실행만 된다.
//+++추가로 void는 자식클래스는 부모클래스의 method를 재정의할 수 있는데 그걸 못하게 한다.

//return은 값을 다시 가져와서 저장된다. 여기서 메소드는 String StrCombine2 = "리턴형으로 문자열을 합치는 기능";
//이렇게 선언한것과 같다. 단지, 메인메소드에서 문자열을 받았고, 그 원소를 다시 가져와서 StrCombine2의 result라는 곳에 담아주기만 했다.
//그리고 다시 리턴하니까, StrCombine2를 실행한 곳에 값이 다시 변한다. 그걸 sysout함.
//return은 "메소드 중지"를 의미한다. 오른쪽 result를 주고 끝내거나, return;하면 그자리에서 메소드 중지. 리턴 이후 코드 사용 불가.

package java1;

public class java04_Constructor {
	//-----------------------------------------------
	//0.기본 생성자는 원래 숨겨져있다. 단, 클래스 이름과 동일하다.
	//-----------------------------------------------
	public java04_Constructor() {}
	//생성자 : 이 클래스가 처음으로 누군가에 의해서 처음 생성(new) 되었을 때 가장 먼저 이 안의 코드를 실행한다.
	
	
	//-------------
	//1. 기본정보 선언
	//-------------
	//전역변수 선언.(값을 넣은게 아니라 선언만 해줌)
	String name;
	int age;
	String hobby;
	
	//이 클래스가 어디선가 선언이 되었을 때, 이 정보들이 들어갈 자리가 필요함.
	
	
	//-----------------------------------
	//2. 생성자에서 클래스의 생성자 자리를 만들어줌.
	//-----------------------------------
	//다른곳에서 java04_Constructor 클래스가 생성될 때, 선언한 변수가 들어갈 자리가 필요하다.
	//그걸 생성자에서 만들어준다. => 생성자 기능 정의 : 멤버변수를 초기화하는 역할을 해준다.
	public java04_Constructor(String space_name, int space_age, String space_hobby) {
		
		//얘네는 null이다가 클래스가 생성되는 시점에서 값이 들어온다.
		//space가 붙은 애들은 매개변수이다. 이곳에서만 사용됨.

//		name = space_name;
//		age = space_age;
//		hobby = space_hobby;
		
		//그래서 구분을 위해 this를 붙여준다.
		this.name = space_name;
		this.age = space_age;
		this.hobby = space_hobby;
		
					//->단축키 : generate Constructor 하면 생성자 자동생성된다.
		
	}


//	public java04_Constructor(String name, int age, String hobby) {
//		super();
//		this.name = name;
//		this.age = age;
//		this.hobby = hobby;
//	}
	
	//이렇게 만들어진다.
	
	//-----------------------------------
	//3. 다른 클래스에서 이 클래스를 가져와보자.
	//-----------------------------------
	//public이니까 가능함.
	
	
	//여기서는 main함수가 없다.(실행할만한 것이 없다) 따라서 틀만 만든 것. 다른곳에서 new를 해서 써먹어보자.


	
	//-----------------------------------
	//6. getter/setter : 가져오고 설정하고. 단축키로 가능.
	//-----------------------------------
	
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	public String getHobby() {
		return hobby;
	}

	public void setHobby(String hobby) {
		this.hobby = hobby;
	}
	
	
}

//생성자는 클래스가 실행될 때 값을 넣을 수 있게 자리를 만들어놓는 것이다. 클래스가 생성이 되었을 때 가장 먼저 실행된다.
//그 생성자 함수에 자리를 만들어준다. 그 자리에는 보통 this로 표시해준다.
//그 후에 시행해줄 때, 선언시 괄호에 값을 넣어줄 수 있다. 단, 자료형이 맞아야함.

//getter/setter를 쓰면 개별로 꺼낼 수 있다. 
//생성자는 String,int,String이든, String뿐이든 상황에 맞게 자료형의 구조를 여러가지로 만들 수 있다.
//따라서 getter.setter를 이용해서 값을 개별로 넣고 꺼낼 수 있다.

package java1;

public class java04_Constructor2 {

    //멤버변수(속성변수)
    String name2;
    int number;
    int grade;
	
	//생성자니까 이름이 같아야함.
	public java04_Constructor2(String studentName2, int studentNumber, int studentGrade) {
        name2 = studentName2;
        grade = studentNumber;
        number = studentGrade;
        
      System.out.println("학생의 이름은 " + name2);
      System.out.println("학생의 번호는 " + number);
      System.out.println("학생의 성적은 " + grade);

    }

    public static void main(String[] args) {
    	java04_Constructor2 student1 = new java04_Constructor2("영희", 1, 50);
    	java04_Constructor2 student2 = new java04_Constructor2("철수", 2, 40);
    	
    	
    	

//        System.out.println("학생의 이름은 " + name2);
//        System.out.println("학생의 번호는 " + number);
//        System.out.println("학생의 성적은 " + grade);
    	
    	//이런식으로 쓰려면 static 쓰라고 한다. -> 왜?
    	//static : 객체를 생성하지 않고도 호출이 가능하다. static이 붙은 메소드 안에 동료속성변수도 static 이 붙어있어야함.
    	//멤버변수(속성변수)에 static을 붙이면 철수 정보만 나온다. 왜? 덮어쓰니까.
    	//메인부터 실행해서 선언하러 생성자 가지만 데이터가 먼저 들어가서 영희 넣고, 철수는 그 다음 메인에서 실행하기 때문에 덮어써짐.
    }


}

 

package java1;

public class java04_Constructor_test {
	
		//제일먼저 실행되는 메인 메소드(실행영역)
	public static void main(String[] args) {
		
		//-------------------------------
		//4.잘 만든 틀을 선언해서 값을 넣어 써보자.
		//-------------------------------
		
		//java04_Constructor C_test = new java04_Constructor(space_name, space_age, space_hobby);

		//===================================================================================
		//정리 : 클래스명 변수명 = new 생성자명(생성자 속성변수 자리)
		//이 클래스에서 생성자명을 찾아서 속성변수에 데이터 값을 부여해주고, 그 클래스를 메모리 공간에 올려라(new).
		//그리고 그 올라간 클래스(=객체)를 변수명으로 해라. 앞으로 변수명 부르면 메모리공간에 저장된 클래스 부르는거임.
		//===================================================================================
		
		
		//이렇게 자동으로 선언할 때 만들어둔 자리가 함께 뜬다.(단, 자료형은 뜨지 않으므로 잘 맞춰서 써야함)
		java04_Constructor C_test = new java04_Constructor("김뫄뫄", 25, "코딩");
		
		
		//-------------------------------
		//5.틀은 똑같이 여러개 만들수도 있다.
		//-------------------------------
		java04_Constructor C_test2 = new java04_Constructor("김봐봐", 26, "기타");
		java04_Constructor C_test3 = new java04_Constructor("김솨솨", 27, "주먹다짐");
		
		
		//이런식으로 결과가 출력이 가능하다.
		System.out.println(C_test.name);	
		System.out.println(C_test.age);	
		System.out.println(C_test.hobby);
		
		
	
		//-------------------------------------
		//7.getter/setter로 개별로 데이터를 넣고싶으면?
		//-------------------------------------	
		//만약 클래스에 빈 생성자가 있다. -> 0번처럼 이경우 디폴트 생성자 따로 선언해줘야함.
		java04_Constructor C_test4 = new java04_Constructor();
		
		//빈 생성자에 개별로 값을 넣어주고 꺼내보자.
		// 1) 값 넣기
		C_test4.setName("김세터게터");
		
		//2) 값 꺼내기
		System.out.println(C_test4.getName());
		
		
		//원리를 살펴보면
		//여기서 name에 값 getName으로 넣어서 꺼내준다.
//		public String getName() {
//			return name;
//		}
//		
		//여기서 this로 값을 넣어주고
//		public void setName(String name) {
//			this.name = name;
//		}
		
		
		
	
	}//main 끝
}