728x90
반응형
■ HelloClass
package review.jav;
public class HelloClass {
public static void main(String[] args) {
// 오늘부터 달리기 100분 ==> 화면출력
System.out.println("오늘부터 달리기 100분");
}
}
패키지는 지금 자바가 들어가있는 방을 표현, 생략가능하다.
이 코드의 실행과정은 다음과 같다.
javac HelloClass 명령어를 통해 compile 진행 HelloClass.java 파일이 HelloClass.class로 변환된다.
이때의 .class 파일은 bytecode(기계어)다.
이후 java HelloClass(.class는 생략) 명령어를 통해 해당 클래스파일이 실행된다. (Interpreter)
■ Operator
package day01;
public class Operator {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 산술연산자
// + - * / %(나머지연산자)
System.out.println(10*3);
System.out.println(10/3);
System.out.println(10/3.0);
// 정수/정수 => 정수
// 정수/실수 => 실수 10/3.0 = 3.3333333333333335
// 실수/정수 => 실수
// 실수/실수 => 실수
System.out.println(10%3);
// 관계연산자
// > < >= <= 같냐? == !=
System.out.println(10>3); // true
System.out.println(10==3);
System.out.println(10!=3);
// 산>관>논
// 10이 3의 배수
System.out.println(10%3 == 0);
// 논리연산자 (and(&&) or(||) not(!))
System.out.println(10>3 && 10<5);
System.out.println(10>3 || 10<5);
System.out.println(10>3 && !(10<5));
}
}
■ Operator2
package day01; // barbage idea
public class Operator2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int aaa = 100;
aaa = aaa + 1; // 101
aaa++; // 102 후치연산자
++aaa; // 103 전치연산자
}
<자바의 기억창고 4가지>
1. stack memory : 썼다 지웠다를 반복
2. static memory : 한번 만들어놓으면 프로그램이 끝날 때까지 살아있는 것
3. code memory : 소스코드가 들어가는 메모리
4. heap memory : 문자열하고 배열 등이 들어가는 메모리, 용량이 메모리가 허락하는 한 사용할 수 있다.
■ 자바의 자료형
Primitive type
reference type
primitive type (stack, 기본형 8가지) => 자료 type, 자료길이
int : 정수, 4바이트 (-2147483648 ~ +2147483647)
byte : 정수, 1바이트 (-128 ~ +127)
short : 정수, 2바이트 (-32768 ~ +32767)
long : 정수, 8바이트
double : 실수, 8바이트
float : 실수, 4바이트
char : 문자형, 2바이트
boolean : 논리형, 1바이트 (true, false)
reference type(heap)
String : 문자열, 배열. .
package review.jav;
public class PrimitiveType {
public static void main(String[] args) {
int aa = 100;
byte bb = 100;
short cc = 100;
long dd = 100;
long dd2 = 2147483648L; // 인트의 범위를 벗어났기 때문에
double ee = 100.78; // 배정도 실수
float ff = 100.78F; // 단정도 실수
System.out.println(10/3.0);
System.out.println(10/3.0f);
char hh = 'A';
// char hh3 = "A"; 오류, char는 stack에 들어가는데 "A"는 heap
// String hh3 = "A"; // heap 영역에 "A"가 저장되고 hh3는 stack영역에 생기며 "A"값이 저장되어있는 번지수가 저장된다.
// 객체도 참조타입이다.
boolean ii = true;
boolean ii2 = false;
}
}
■ 문자열 기본
package day01;
public class StringKibon {
public static void main(String[] args) {
// TODO Auto-generated method stub
int pp = 100; // stack
String aaa = "ondal"; // heap
// NPE (Null Pointer Exception)
String ppp = null; // 값이 존재할 수가 없는 상태, heap 메모리에 아무것도 없다.
String qqq = ""; // 빈 문자열(길이가 0인 문자열) -> heap 메모리에 빈문자열이 들어간다.
System.out.println(qqq.length() > 0);
// System.out.println(ppp.length() > 0); java.lang.NullPointerException
String irum1 = "ondal";
String irum2 = "ondal";
// iruml 이 1000이고 irum2에도 1000이 들어가있다. 1000은 임의의 주소값.
if(irum1 == irum2) { // 번지 비교
System.out.println("같다.");
} else {
System.out.println("다르다");
}
// 번지수를 비교하는 것이다. 그렇다면 같은 ondal을 비교하려면?
if(irum1.equals(irum2)) { // 내용비교
System.out.println("같다.");
} else {
System.out.println("다르다");
}
String st1 = new String("ondal");
String st2 = new String("ondal");
if(st1 == st2) {
System.out.println("참");
} else {
System.out.println("거짓");
}
if(st1.equals(st2)) {
System.out.println("참");
} else {
System.out.println("거짓");
}
}
}
결과
false
같다.
같다.
거짓
참
■ Printf
package review.jav;
import java.util.Scanner;
public class Printf { // 사용자 정의 클래스 (userdefined class)
public static void main(String[] args) {
// 3과목 총점 점수를 소수이하 둘째 자리까지 출력하시오
// printf의 원리
// printf("문자열 format", value, value);
System.out.printf("뭐라고 %s 말이야 %s 시간이야 %n", "지금은", "쉬는");
double dd = 3.1415926536828; // %lf c언어에서는 double일 때 lf를 사용한다.
System.out.printf("%.14f / %d = %.14f이라는\n", dd, 2, dd/2);
int tot = 257; // 3과목 총점
double avg = tot / 3.0;
System.out.printf("총점 = %d 평균 = %.2f \n", tot, avg);
// 3과목 총점 점수를 입력받아 둘째 자리까지 출력하시오
// 자바에서 출력응ㄴ sysout
// 입력은 1) File 형식으로 2) Scanner 3) GUI
// Scanner는 내장 클래스
Scanner sc1 = new Scanner(System.in);
// ctrl + shift + o
System.out.print("3과목 총점을 입력하세요");
int bada = sc1.nextInt(); // 정수를 입력하라
double avg2 = bada / 3.0;
System.out.printf("총점 = %d 평균 = %.2f \n", bada, avg2);
// ----------------------------------------------------------------
System.out.print("3과목 총점을 입력하세요");
int bada2 = sc1.nextInt(); // 정수를 입력하라
System.out.print("3과목 평균을 입력하세요");
double avg3 = sc1.nextDouble(); // 정수를 입력하라
System.out.printf("총점 = %d 평균 = %.2f \n", bada2, avg3);
// ----------------------------------------------------------------
System.out.print("3과목 총점을 입력하세요");
String bada5 = sc1.next(); // "257"
// int wrap
int tot5 = Integer.parseInt(bada5);
System.out.print("3과목 평균을 입력하세요");
String avg5 = sc1.next(); // "90.245"
double avg55 = Double.parseDouble(avg5);
System.out.printf("총점 = %d 평균 = %.2f \n", bada5, avg5);
}
}
■ 배수
package day01;
public class Baesoo {
public static void main(String[] args) {
// 10이 3의 배수냐?
if (10 % 3 == 0)
System.out.println("10은 3의 배수입니다.");
else
System.out.println("10은 3의 배수가 아닙니다.");
// ctrl + shift + F ==> 포맷이 맞춰짐
// ctrl + shift + L
}
}
■ BMI
package day01;
import java.util.Scanner;
public class Bmi {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc1 = new Scanner(System.in);
System.out.print("키는? : ");
int ki = sc1.nextInt(); // 180
System.out.print("몸무게는? : ");
int mom = sc1.nextInt(); // 65
// bmi = 몸무게 / 키(M)의 제곱
double mKi = ki / 100.0;
// double bmi = mom /(mKi * mKi);
double bmi = mom / Math.pow(mKi, 2);
System.out.println(bmi);
// 30 이상 : 비만
// 18.5 ~ 25 : 보통
String result;
if(bmi >= 30.0) {
result = "비만";
} else if(bmi >= 25.0) {
result = "과체중";
} else if(bmi >= 18.5) {
result = "보통";
} else {
result = "저체중";
}
System.out.println(result);
}
}
■ 반복문 For
- 빨리 변하는 것이 이중 for문의 안쪽이다.
package day01;
public class ForFor {
public static void main(String[] args) {
// TODO Auto-generated method stub
// for(초기치;목적지;증가치){
// STMT;
// }
for(int i=1; i<=5; i++) {
System.out.print(i + "\t");
}
System.out.println();
// random number (난수)
// 임의의 수가 0~1
// * 45 0~44.xxx
// 올림
for(int i=0; i<=6; i++) {
System.out.print((int)Math.ceil(45 * Math.random()) + "\t");
}
System.out.println(); // line-skip
// nested 기법
/*
* 학년 반
* 1 - 1
* 1 - 2
* 2 - 1
* 2 - 2
* 3 - 1
* 3 - 2
* */
// 법칙 : 빨리 변하는 게 이중 for문의 안쪽이다.
for(int i=1; i<=3; i++) {
for(int j=1; j<=2; j++) {
System.out.println(i + " - " +j);
}
}
}
}
■ 반복문 Do while
package day01;
import java.util.Scanner;
public class Dowhile {
public static void main(String[] args) {
// head에는 절대 세미콜론 x
// do while은 body가 먼저 나오고 뒤에 head가 나온다.
// 회원관리 검색, 수정, 삭제, 입력
// CRUD create, read, update, delete
// 메뉴 외에는 절대 사용하지 않는다.
// do {
// 문장들;
// } while();
// 맛있게 드세요.
// 다시 선택하세요.
/*
* 메뉴 1. 짜장 2. 짬뽕
*
* 선택(1-2)
*
* 1, 2중 하나를 눌렀다면 맛있게 드세요 라고 출력하고 프로그램 종료
*
* 3 - 0번까지 누르면 다시 메뉴화면이 나오도록
*/
Scanner sc = new Scanner(System.in);
String bada2;
do {
System.out.println("메뉴선택");
System.out.println("1. 짜장");
System.out.println("2. 짬뽕");
System.out.print("선택(1-2) : ");
bada2 = sc.next();
// sc.nextLine() I love you1
} while(!bada2.equals("1") && !bada2.equals("2")); // 잘못 누르는 동안 반복해
// 제대로 선택한 경우 : 1번이거나 2번일 때
// 메뉴가 다시 나오게 하는 경우 : 1 or 2의 반대의 경우
// 즉, !1 and !2
System.out.println("맛있게 드세요!");
}
}
■ Switch
package day01;
import java.util.Scanner;
public class Switch {
public static void main(String[] args) {
// 점수를 입력받아 학점을 구하는 프로그램을 작성하시오
// 단, 90-100 A
// 80-89 B
// 70-79 C
// 60-69 D
// 나머지 F학점
// if - else 문 사용
Scanner sc = new Scanner(System.in);
System.out.print("점수를 입력하세요 : ");
int j = sc.nextInt();
if(j >= 90) { // 다중 if, 중첩 if
System.out.println("A등급입니다.");
} else if(j >= 80) {
System.out.println("B등급입니다.");
} else if(j >= 70) {
System.out.println("C등급입니다.");
} else if(j >= 60) {
System.out.println("D등급입니다.");
} else {
System.out.println("F등급입니다.");
}
// switch문
System.out.print("점수를 입력하세요 : ");
String jumsu = sc.next();
int jum = Integer.parseInt(jumsu);
switch(jum/10) {
case 10:
case 9:
System.out.println("A등급입니다.");
break;
case 8:
System.out.println("B등급입니다.");
break;
case 7:
System.out.println("C등급입니다.");
break;
case 6:
System.out.println("D등급입니다.");
break;
default:
System.out.println("D등급입니다.");
// break;
}
// Q) 2023년 각 월의 날짜수를 출력하는 switch 프로그램을 작성하시오
// 단, 그러니까 다시 말해서 switch의 특성을 사용하여 출력문장 3종류로 작성하시오.
System.out.print("월을 입력하세요 : ");
int mon = sc.nextInt();
switch(mon) {
case 2:
System.out.println("해당 월은 28일까지 있습니다.");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println("해당 월은 30일까지 있습니다.");
break;
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println("해당 월은 31일까지 있습니다.");
break;
default:
System.out.println("1~12 사이의 값만 넣어주시기 바랍니다.");
}
}
}
■ while 문
package day03;
public class WhileEx {
public static void main(String[] args) {
/*
* for( ; ; ){ 무한루프
*
* }
*
* while(조건){
* 문장들;
* }
* */
int i = 1;
while(i <= 10) { // 목적지
System.out.println("왕복달리기");
i++; // 증가치
}
}
}
■ 메소드 - 1
package day03;
public class Method1type {
public static void main(String[] args) {
// 2023년이 윤년인지 알아내는 프로그램을 작성하시오.
// 윤년 : 365.2422 일
// 0.2422 * 4 = 0.9688 = 약 1일
// 300년 주===에
// 윤년은?
// 4로 나누어 떨어지"고"
// 100으로 나누어 떨어지지 않"거나"
// 400으로 나누어 떨어지는 해
// 1, 2형식은 출발했던 문장 다음 문장으로 간다.
// 3형식은 출발했던 그 문장으로 돌아가는데 출발한 문장을 지우고 들어간다.
// Q) 위 소스를 메소드 1형식으로?
// 1형식 : 그냥 처리하고(시키고) 바로 돌아오는
System.out.println("2023년이 윤년인지 평년인지를 알아보자는");
yoonnyuen();
// Q) 이제는 우아하게 메소드 2형식으로?
// 2형식 : 뭔가를 주면서 시키는 것
kajaYoonnyuen(2023);
// Q) 3형식으로~
// 3형식 : 반환값이 중요
// String bada = ddokaja();
// // ㄴ String bada = "2023년 윤년평년 처리 끝";
// System.out.println(bada);
System.out.println(ddokaja());
}
// 3형식
private static String ddokaja() {
int i = 2023;
if(i%4 == 0 && i%100 != 0 || i%400 == 0) {
System.out.println(i + "년은 윤년");
} else {
System.out.println(i + "년은 평년");
}
return "2023년 윤년평년 처리 끝";
// 반드시 return type 필요.
}
// 2형식
private static void kajaYoonnyuen(int i) {
if(i%4 == 0 && i%100 != 0 || i%400 == 0) {
System.out.println(i + "년은 윤년");
} else {
System.out.println(i + "년은 평년");
}
}
// 1형식
private static void yoonnyuen() {
int i = 2023;
if(i%4 == 0 && i%100 != 0 || i%400 == 0) {
System.out.println(i + "년은 윤년");
} else {
System.out.println(i + "년은 평년");
}
}
} // end class
■ 메소드 - 2
package day03;
public class Method2 {
public static void main(String[] args) {
// 초기작업
// 처리작업
// 마무리작업
/*
* (모듈을 만들 때)
* 1. 메소드 호출문
* kaja();
*
* 2. 메소드 정의문
* kaja(){
* 서류처리합니다.
* }
*
* 메소드가 호출되면 비서개념의 정의문을 찾아가서 실행한 후 다시 되돌아온다. (
*/
choki(); // 초기작업
cheori(); // 처리작업
mamoori(); // 마무리작업
} // end main
private static void mamoori() {
System.out.println("뭐야 마무리가 최고지");
}
private static void cheori() {
System.out.println("훗 나는 처리 잘하거든");
}
private static void choki() {
System.out.println("나 초기작업 잘해");
} // end class
}
■ 메소드 오버라이딩
package day03;
public class MethodOverloading {
public static void main(String[] args) {
kaja();
kaja2(20);
kaja(20, 50);
kaja(20, 7.8);
}
// double, float의 차이는 허용가능한 범위내에서는 가능
private static void kaja(int i, double d) {
// TODO Auto-generated method stub
}
private static void kaja(int i, int j) {
// TODO Auto-generated method stub
}
private static void kaja2(int i) {
// TODO Auto-generated method stub
}
private static void kaja() {
// TODO Auto-generated method stub
}
} // end class
■ 배열 - 1
package day03;
// 배열
public class A200_bae {
public static void main(String[] args) {
// int jum[]; // jum은 정수가 들어가는 아파트다.
// int jum[] = new int[10]; // heap에 기억창고가 잡힌다.
int [] jum = new int[10]; // 권장하는 방법
jum[0] = 100;
System.out.println(jum[0]);
jum[8] = 20;
jum[9] = 200;
// jum[10] = 300; error
// 1차원 배열
int [] kab = {10, 20, 30, 40, 50}; // new가 없어도 자동으로 new가 생략된 것으로 인식.
for(int i=0; i<5; i++) {
System.out.print(kab[i] + " ");
}
System.out.println();
for(int i=0; i<kab.length; i++) {
System.out.print(kab[i] + " ");
}
System.out.println();
// for 치고 ctrl + space 누르면
for (int i = 0; i < kab.length; i++) {
}
}
}
■ 배열 - 2
package day03;
import java.util.Scanner;
public class A210_bae_method_call {
public static void main(String[] args) {
// Q) 10개의 데이터를 배열에 입력받은 후 method 호출문 2형식을 사용하여
// 메소드 정의문으로 배열전체를 보낸 후 정의문에서 배열의 값을 반복문으로 출력하는
// 자바 프로그램을 작성하시오
// 1. call by value - 값에 의한 호출
// hap(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6]...)
// 2. call by reference - 참조에 의한 호출
// 내용이 아닌 번지를 전달.
// 입력 부분
Scanner sc = new Scanner(System.in);
int [] arr = new int[10];
for(int i=0; i<arr.length; i++) {
System.out.print(i + 1 + "번째 값의 값을 입력해주세요. : ");
arr[i] = Integer.parseInt(sc.next());
}
// 정의문 호출
// 배열 전달시 알아야 할 한 줄의 속담은?
// ㄴ "배열의 대표명은 그 배열의 시작번지이다"
// arr의 시작번지는 1000번지, 다른 말로 arr번지
hap(arr);
}
private static void hap(int[] arr) { // 1000번지로 찾아가는 개념
int sum = 0;
for(int i=0; i<arr.length; i++) {
sum = sum + arr[i];
}
System.out.println("배열의 수 합은 = " + sum + "입니다.");
}
}
■ 행맨 - 1 (내 풀이)
package day03;
import java.util.Arrays;
import java.util.Scanner;
public class A250_hangman_game {
public static void main(String[] args) {
// Q) picture를 문자열 배열에 넣고 글자를 알아맞추는 hangman program을 작성하시오.
// (단, 13번 안에 맞추어야 한다)
// (참고) char과 String 배열
//char [] chararr = {'p', 'i', 'c', 't', 'u', 'r', 'e'};
//double [] soo2 = {1.1, 1.2, 1.3, 1.4, 1.5, 1.6};
Scanner sc = new Scanner(System.in);
int cnt = 0; // 횟수 변수
String [] arr = {"p", "i", "c", "t", "u", "r", "e"}; // 정답배열
String [] ans = {"_", "_", "_", "_", "_", "_", "_"}; // 문제배열
while(cnt<13) {
System.out.println("----------------------------");
System.out.println("\t<Hangman>");
System.out.println("----------------------------");
System.out.print("문제 : ");
for(int i=0; i<ans.length; i++) {
System.out.print(ans[i] + " ");
}
System.out.println();
System.out.println("잔여횟수 : " + (13-cnt));
System.out.print("알파벳을 입력해주세요 : ");
String ins = sc.next();
for(int i=0; i<arr.length; i++) { // 일치여부확인
if(arr[i].equals(ins)) {
ans[i] = arr[i];
}
}
System.out.print("입력결과 : ");
for(int i=0; i<ans.length; i++) {
System.out.print(ans[i] + " ");
}
System.out.println();
if(Arrays.equals(arr, ans)) { // 두 배열이 완전히 일치할 경우
System.out.println("정답입니다. 참 잘했어요");
break;
}
cnt++;
if(cnt == 13)
System.out.println("잔여횟수 초과! 다음 기회에..");
}
}
}
■ 행맨 - 2 (강사님 풀이)
package day03;
import java.util.Scanner;
public class A250_hangman_game2 {
// 행맨 강사님 풀이
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String [] moonja = {"p", "i", "c", "t", "u", "r", "e"}; // 정답배열
String [] jool = {"_", "_", "_", "_", "_", "_", "_"}; // 문제배열
String ip;
int cnt, sw = 0; // 초기치 및 선언은 나중에
for(int i=1; i<=13; i++) { // 13번 체크
cnt =0;
System.out.println("예상글자 입력 :");
ip = sc.next();
for(int j=0; j<7; j++) { // 예상 글자가 문제 단어에 있어?
if(ip.equals(moonja[j])) { // == 은 번지비교
jool[j] = moonja[j];
}
}
for(int j=0; j<7; j++) { // 있건 없건 한 줄 출력
System.out.print(jool[j]); // 줄 출력
}
System.out.println("\t" + i + "번시도");
for(int j=0; j<7; j++) { // 문제단어와 줄글자가 7개 같아?
if(jool[j] == moonja[j]) {
cnt++;
}
}
if(cnt == 7) { // 딱 맞췄으니 끝내자
System.out.println("Good");
sw = 1;
break;
}
} //13-for-end
if(sw == 0) {
System.out.print("다음 기회에");
}
}
}
■ 2차원 배열
package day04;
public class AJ004_01_2chabae {
public static void main(String[] args) {
int [][] jum = new int[2][3];
jum[0][0] = 100;
jum[1][2] = 85;
// 메모리는 2차원 배열의 개념이 없다.
// 따라서 강제로 끊어서 만들어줘야 한다.
int [][] jum2 = {{10, 20, 30},
{40, 50, 60}};
// 1 2 3 4 5
// 1 2 3 4 5
// 1 2 3 4 5
int [][] jum3 = new int[3][5];
// 반복문을 이용해서 배열에 넣기
for(int i=0; i<3; i++) {
for(int j=0; j<5; j++) {
jum3[i][j] = j+1;
}
}
// 반복문을 이용해서 배열 출력
for(int i=0; i<3; i++) {
for(int j=0; j<5; j++) {
System.out.print(jum3[i][j] + "\t");
}
System.out.println(); // line-skip
}
for (int i=0; i<jum3.length; i++) {
for (int j=0; j<jum3[i].length; j++) {
System.out.print(jum3[i][j] + "\t");
}
System.out.println(); // line-skip
}
// length는 2차원 배열에서는 '층'을 의미한다. (행), 즉 층의 대표명은 jum3
// 첫 번째 행의 대표명은 jum3[0]
// 두 번째 행의 대표명은 jum3[1]
// 세 번째 행의 대표명은 jum3[2]
} // end main
} // end class
■ sort 함수
package day04;
import java.util.Arrays;
public class AJ004_02_Arrays1 {
public static void main(String[] args) {
// sort 자료의 정렬
// key(기준), 차순(오름, 내림) ascending, descending
// 1) 내부 소트 : memory, radix sort, selection sort, bubble sort, quick sort
// 2) 외부소트 : 보조기억장치, 2-way merge sort
// 다음 배열을 소트하여 오름차순및 내림차순으로 출력하시오.
int [] bae = {10, 90, 100, 60, 70};
// shuffle()
Arrays.sort(bae); // ctrl + shift + o
// 기본 오름차순 : 10, 60, 70 , 90, 100
for (int i=0; i<bae.length; i++){
System.out.print(bae[i] + "\t");
}
System.out.println();
// 내림차순
for (int i=bae.length-1; i>=0; i--){
System.out.print(bae[i] + "\t");
}
System.out.println();
}
}
■ 객체지향 프로그래밍 - 1
package day04;
class Car { // 사물
// 속성
String color;
int door;
// 행동(메소드)
public void drive() {
System.out.println("드라이브 가자");
}
}
public class AJ004_03_OOP {
public static void main(String[] args) {
// 클래스 => 객체(인스턴스)
// new 클래스명(); 만 해도 메모리에 들어가지만 이렇게만 하면 위치를 찾을 수 없다.
// 클래스명 객체참조변수 = new 클래스명();
Car myCar = new Car(); // 생성 이렇게 하면 위치를 찾을 수 있다.
// 사용방법 3가지
// 1. 객체.속성 = 값
myCar.color = "white";
myCar.door = 4;
// 2. 객체.메소드()
myCar.drive();
// 3. 객체.속성
System.out.println(myCar.color);
// OOP : Object Oriented Programming
// OOL : Object Oriented Language
// 절차형 언어
// 객체지향 언어
// 객체는 사물.
// 사물의 특징은
// (1) 속성 : 성격, 특징
// (2) 메소드 : 행동
// 객체 : (1) 사물 (2) 클래스-객체 (클래스와 연관된 객체, 인스턴스)
// OOP 만드는 3단계 (핸드메이드 car)
// (1) 설계도 : 정의
// (2) 제작 : 생성 - 설계도 그대로 메모리에 들어가는 것
// (3) 사용 : 사용
// 1. 정의
// class로 설계도를 만든다.
}
}
■ 객체지향 프로그래밍 - 2
package day04_1;
class Car { // 사물
// 속성(field)
private String color;
private int door;
// 행동(메소드)
public void drive() {
System.out.println("드라이브 가자");
}
// 출력 전문 메소드
public void chool() {
System.out.println("자동차 색은 " + color + "이고, 문의 개수는 " + door + "개입니다.");
}
// 상속관련 출력전문 메소드 (getter)
public String toString() { // overriding
return "자동차 색은 " + color + "이고, 문의 개수는 " + door + "개입니다.";
}
// setter
public void setColor(String color) {
this.color = color; // this -> 자기 자신을 참조하는 객체
}
public void setDoor(int door) {
this.door = door;
}
// getter
public int getDoor() {
return door;
}
public String getColor() {
return color;
}
}
public class AJ004_03_OOP {
public static void main(String[] args) {
Car myCar = new Car();
// 사용방법 3가지
// 1. 객체.속성 = 값
myCar.setColor("white");
myCar.setDoor(4);
// 2. 객체.메소드()
myCar.drive();
// 3. 객체.속성
// System.out.println(myCar.getColor() + "," + myCar.getDoor());
// myCar.chool();
System.out.println(myCar.toString());
System.out.println(myCar);
Car yourCar = new Car();
yourCar.setColor("black");
yourCar.setDoor(2);
yourCar.drive();
// System.out.println(yourCar.getColor() + "," + yourCar.getDoor());
// yourCar.chool();
System.out.println(yourCar.toString());
System.out.println(yourCar);
// encapsulation(캡슐화)
// 속성 + 메소드의 묶음, 정보은닉
// 접근지정자(access modifier)
// private : 같은 클래스 내에서만 접근 가능
// public : 외부 클래스에서도 접근 가능
// default : 같은 패키지 안에서, default 용어는 안 씀.
// protected : 상속에서
// 속성은 기본적으로 무조건 private을 하는 것이 좋다.
}
}
■ 객체지향 프로그래밍 - 3
package day04_1;
class Bread{
private String jong;
private int price;
//public String toString() {
// return "빵의 종류는 " + jong + "이고 가격은 " + price + "입니다.";
//}
public String getJong() {
return jong;
}
public void setJong(String jong) {
this.jong = jong;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Bread [jong=" + jong + ", price=" + price + "]";
}
}
public class AJ004_04_OOP {
public static void main(String[] args) {
// Question
// 빵 종류와 가격을 속성으로 가지는 class를 만들고 이를 생성하고 사용하는 oop 프로그램을 작성하시오
// (조건) 빵 종류 속성명 : jong / 가격 속석명 : price
Bread myBread = new Bread();
myBread.setJong("바게트빵");
myBread.setPrice(5000);
System.out.println(myBread.toString());
Bread yourBread = new Bread();
yourBread.setJong("단팥빵");
yourBread.setPrice(2500);
System.out.println(yourBread);
}
}
■ 객체지향 프로그래밍 - 4
package day04_2;
class Car { // 사물
// 속성(field)
private String color;
private int door;
// 생성자 중복 , 생성자는 클래스 이름과 같아야 한다.
public Car() {} // default constructor
public Car(String color, int door) {// 생성자 // void X, return X
this.color = color;
this.door = door;
}
// 행동(메소드)
public void drive() {
System.out.println("드라이브 가자");
}
// 출력 전문 메소드
public void chool() {
System.out.println("자동차 색은 " + color + "이고, 문의 개수는 " + door + "개입니다.");
}
// 상속관련 출력전문 메소드 (getter)
public String toString() { // overriding
return "자동차 색은 " + color + "이고, 문의 개수는 " + door + "개입니다.";
}
// getter, setter
public void setColor(String color) {
this.color = color; // this -> 자기 자신을 참조하는 객체
}
public void setDoor(int door) {
this.door = door;
}
public int getDoor() {
return door;
}
public String getColor() {
return color;
}
}
public class AJ004_03_OOP {
public static void main(String[] args) {
Car myCar = new Car();
myCar.setColor("white");
myCar.setDoor(4);
myCar.drive();
System.out.println(myCar.toString());
System.out.println(myCar);
Car myCar2 = new Car("red", 2);
myCar2.drive();
// 객체의 life cycle
// c : malloc() ==> free
// c++ : p=NULL
// => memory leak, dangling pointer problem 발생
// Garbage Collection:
// new(객체생성) - 기본 초기치 처리 - .... - 소멸자 - 객체해제
}
}
■ Swap
package day04_3;
public class AJ_004B_01_swap {
public static void main(String[] args) {
// swap
int a = 50;
int b = 70;
// zigzag
int imsi = a;
a = b;
b= imsi;
System.out.println(a);
System.out.println(b);
}
}
■ 버블정렬 (3단계)
package day04_3;
public class AJ_004B_01_bubblesort {
public static void main(String[] args) {
int imsi;
int [] k = {90, 100, 35, 78, 34, 97};
// 버블정렬 1단계
for(int i=0; i<5; i++) {
for(int j=0; j<5; j++) {
if(k[j] < k[j+1]) {
imsi = k[j];
k[j] = k[j+1];
k[j+1] = imsi;
}
}
}
for(int i=0; i<k.length; i++) {
System.out.println(k[i]);
}
System.out.println();
// 버블정렬 2단계
// 끝값을 점진적으로 반복대상에서 제외
for(int i=0; i<k.length-1; i++) {
for(int j=0; j<k.length-1-i; j++) {
if(k[j] < k[j+1]) {
imsi = k[j];
k[j] = k[j+1];
k[j+1] = imsi;
}
}
}
for(int i=0; i<k.length; i++) {
System.out.println(k[i]);
}
System.out.println();
// 버블정렬 3단계
int sw = 0;
for(int i=0; i<k.length-1 && sw==0; i++) {
sw = 1;
for(int j=0; j<k.length-1-i; j++) {
if(k[j] < k[j+1]) {
imsi = k[j];
k[j] = k[j+1];
k[j+1] = imsi;
sw = 0;
}
}
}
for(int i=0; i<k.length; i++) {
System.out.println(k[i]);
}
}
}
■ 상속 - 1
package review.jav;
class Boomo{
// int diamond; // 속성
protected int diamond; // 상속에 있어서만 사용 가능.
public void don() { // 메소드
System.out.println("나 재산 많아.");
}
} // end 부모 class
class Janyu extends Boomo{
public void car() {
diamond = 3;
System.out.println("중형자동차 있다.");
}
} // end 자녀 class
public class Sangsok {
public static void main(String[] args) {
// 상속
// (1) 100 상속
// (2) 자녀의 재산은 부모와 같거나 더 많다.
// (3) 상속의 keyword는 extends
// A extends B --> A가 자녀, B가 부모
// A if kind of B
// fish extends Animal
Boomo b1 = new Boomo();
b1.don();
Janyu j1 = new Janyu();
j1.don();
j1.car();
System.out.println(j1.diamond); // 객체.속성
// 부모는 자녀의 메소드를 사용할 수 없다.
}
}
728x90
반응형
'IT&코딩 > 국비지원' 카테고리의 다른 글
| SQL - 2 (0) | 2023.04.13 |
|---|---|
| SQL - 1 (0) | 2023.04.13 |
| 네트워크 - 2 (네트워크) (0) | 2023.03.23 |
| 네트워크 - 1 (네트워크 이론 및 스레드) (0) | 2023.03.22 |
| Java - 2 (0) | 2023.03.22 |