[ java ]
[java] 자바 기초 공부
히앤님
2020. 12. 10. 20:47
반응형
SMALL
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 끝
}반응형
LIST