4. 객체 지향형 데이터 모델 객체 지향 프로그래밍에서 사용하는 객체 개념을 기반으로 한 데이터 모델로 데이터를 독립된 객체로 구성하고 상속, 오버라이드 같이 객체 지향 프로그래밍에서 사용되는 기능 사용이 가능하다.

사용자가 애플리케이션을 사용 -> 미들웨어가 뒤에서 데이터 요청을 전달 서버에서 응답을 받음 -> 미들웨어 사용자가 이해할 수 있는 형태로 전달

라우팅 방식은 정적 라우팅과 동적 라우팅으로 구분이 가능하다.

정적 라우팅 : 라우팅 방식을 관리자가 수동으로 제어하는 방식 -> 소규모 네트워크에 적합

동적 라우팅 : 라우터가 자동으로 최적의 경로를 계산해 라우팅 정보를 교환하는 방식 -> 중/대규모 네트워크에 적합

1. RIP 최초의 동적 라우팅 프로토콜이지만 현재는 거의 사용되지 않는다.

2. IGRP RIP의 단점을 보완하기 위해 만들어진 프로토콜로 RIP와 같이 현재는 거의 사용되지 않는다.

3. OSPF 링크 상태 기반의 라우팅 프로토콜이며, 국제 표준 프로토콜로 현재 가장 대중적으로 사용된다.

4. BGP 경로 거리보다 경로 자체 분석을 통해 라우팅 정보를 업데이트하는 경로 벡터 기반의프로토콜로 인터넷 핵심 라우팅에 사용된다.

1. 물리 계층 전기적으로 신호를 전송한다. (오로지 데이터 전송의 역할만을 수행) 장비: 허브, 리피터

2. 데이터링크 계층 물리적인 연결을 통해 정보를 전달한다. 장비: 브릿지, 스위치

3. 네트워크 계층 중계노드를 통해 전송하는 경우 어떻게 중계할 것인지 규정한다. 전송 단위는 패킷이며, 목적지까지의 경로를 설정한다. 장비: 라우터

4. 전송 계층 정확하고 신뢰성있는 데이터 전송을 담당한다. (에러 복구, 제어를 담당) 장비: TCP, UDP

5. 세션 계층 장치 간 상호작용을 제공하며, 연결 세션에서 데이터 교환과 에러 발생 시 복구를 관리한다. 장비: 게이트 웨이

6.표현 계층 전송하는 데이터의 형식 변환, 암화화 코드 변환 등을 수행한다. 장비: 게이트 웨이

7. 응용 계층 사용자와 가장 밀접한 계층으로 인터페이스 역할을 수행한다. 장비: 웹브라우저, 앱

1. 자바는 객체로 시작해서 객체로 끝남
2. 객체지향 프로그래밍에 특화된 언어 → 사람이 쓰기 편하게 만들어진 언어
3. 자바는 클래스 없이 코드를 작성할 수 없음 → 클래스가 객체고, 객체가 클래스

객체 (OBJECT)

주체(스스로)를 제외한 모든 것

언어에서의 객체

• 모든 것 → 모든 것을 언어로 표현
• 연관성이 있는 복수개의 데이터를 다루기 위해 사용하는 문법

class Main {
    public static void main(String[] args) [

    int a = 10;
    // 변수 선언 및 초기화

    int[] arr = new int[3];
    // 변수 선언 및 초기화
    // 객체 - 배열(데이터의 순서 존재 -> index)
    // int[] : 정수들
    // arr : 변수명
    // = : 대입연산자
    // new : 객체 하나를 만들겠다
    // int[3] : new를 통해 만들어질 객체의 모양

    int[0] = 10;
    int[1] = 20;
    int[2] = 30;

    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    // 각각 10,20,30 출력
    // 인덱스에 접근하기 위해 배열이 리모컨을 누르는 방법

    System.out.println(arr.length);
    // 객체에 접근하기 위해서 리모컨을 누르는 방법

    System.out.println(arr);
    // arr의 주소 출력

    int[] arr2 = {10,20,30};
    // 배열 객체를 만드는 방법 -> 비어있는 공간을 만들 수 없어 잘 사용하지 않음
    // 자바에서 유일하게 new 없이 객체를 만드는 방법 (배열)

    int[][] arr3 = new int[3][5];
    // 이차원배열 -> 정수 배열들 -> 객체 안에 객체를 저장

    arr3[0][0] = 10;
    arr3[0][1] = 20;
    arr3[0][2] = 30;
    arr3[0][3] = 40;
    arr3[0][4] = 50;

오직 정수형 데이터들만 들어갈 수 있는 arr이라는 변수(하나의 공간)를 만들고, int[3]모양으로 된 객체 하나를 만들고 해당 객체를 컨트롤 할 수 있는 리모컨을 연결 시킴

객체를 사용하는 이유

다량의 데이터를 한번에 빠르게 처리하기 위해서

ㄴ 객체를 사용하는 것이 무조건 좋은 것은 아님

배열 문제

public class Main{
    public static void main(String[] args) {

        // 크기 10짜리 배열 생성하기
        int[] arr = new int[10];

        // 10씩 증가하는 값을 하나씩 직접 넣기
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        arr[3] = 40;
        arr[4] = 50;
        arr[5] = 60;
        arr[6] = 70;
        arr[7] = 80;
        arr[8] = 90;
        arr[9] = 100;

        // 반복문으로 값 넣기
        for(int i = 0; i < arr.length; i ++) {
            arr[i] = (i + 1) * 10; 
            // 인덱스는 0부터 1씩 증가, 값은 10부터 10씩 증가
        }

        // 배열 값 순서대로 출력하기
        for(int i = 0; i < arr.length; i ++) {
            System.out.println(arr[i]);
        }

        // 배열의 모든 값 합계 구하기
        int s = 0;
        for (int i = 0; i <arr.length; i ++) {
            s += arr[i];
        }
        System.out.println("합계: " + s);

        // 배열의 모든 값 평균 구하기
        System.out.println("평균: ": + s / arr.length);
    }
}

예외처리

• 예외가 발생하면 프로그램이 바로 종료될 수 있는데, 예외처리를 통해 프로그램이 안전하게

  실행 / 종료하게 만들어줌

• 먼저 발생한 문제에 대해서 예외처리 → 캐치 블럭은 여러 개의 일을 동시에 처리하지 않음

• finally는 예외 상관없이 무조건 출력

public class Main{
    public static void main(String[] args) {

        try {
            int[] arr = new int[5];

            for(int i = 0; i < 10; i ++) {
                arr[i] = (i + 1) * 10;
                    System.out.println(arr[i]);  // 예외가 발생할 가능성이 있는 코드 
            }
        } catch (ArrayIndexOutOfBoundsException e) {  // 예외가 발생했을 때 처리할 코드
            System.out.println("배열의 인덱스 범위초과");
        } catch (NumberFormatException e) {
            System.out.println("숫자 양식 예외 발생");
        } catch (Exception e) {
            System.out.println("포괄적인 예외 발생");
        } finally {
            System.out.println("???");  // 선택 사항: 예외 발생 여부와 상관없이 항상 실행되는 코드
    }
}

전역변수

• 전 지역에서 사용 가능한 변수
• 변수의 생명주기가 전 지역에서 사용 가능하게끔 설정되어 있음
• 자바에는 실질적인 전역변수가 존재하지 않음
  • 자바는 클래스없이 코드를 작성할 수 없기 때문

자바에서 전역변수의 개념을 대체할 수 있는 변수

클래스 변수 (static변수)

• 멤버변수, 필드
  • 클래스 안에서, 메서드 밖에서 선언된 변수
  • 같은 클래스 내부의 전 지역에서 사용 가능
  • 변수를 선언하고 최초 초기화를 하지 않으면, 기본값으로 초기화 됨
    • 값이 없다면 기본 값이 출력됨

지역변수

• 제한된 지역 (본인이 만들어진 지역)에서 사용 가능한 변수
• 메서드 안에서 선언된 변수 → 코드 블럭 내에서 선언된 변수 ( class Main{ } 제외)
• 지역변수는 값을 초기화 하지 않으면 사용 불가
  • 값이 없다면 사용 불가

같은 공간 내에서 동일한 이름으로 변수를 선언할 수 없음

전역변수와 지역변수명이 값다면 지역변수가 쓰임

기본 자료형 타입

데이터 타입은 모두 클래스로 존재함

byte -> Byte short -> Short int -> Integer long -> Long floar -> Float double -> Double boolean -> Boolean char -> Character

객체지향 프로그래밍의 특징 (OOP)

1. 추상화
2. 상속
3. 다형성
4. 캡슐화

사용자 정의 객체

변수, 메서드

객체의 속성

변수(속성) → 객체를 표현하기 위한 데이터를 저장

public class Main {
    public static void main(String[] args) {

        // 사용자 정의 객체
        // 각각의 이름과 나이

        사람 a철수 = new 사람();
        a철수.이름 = "철수";
        a철수.나이 = 10;

        System.out.println(a철수.이름 + ": " + a철수.나이);

        사람 a영수 = new 사람();
        a영수.이름 = "영수";
        a영수.나이 = 20;

        System.out.println(a영수.이름 + ": " + a영수.나이);

        사람 a영희 = new 사람();
        a영희.이름 = "영희";
        a영희.나이 = 30;

        System.out.println(a영희.이름 + ": " + a영희.나이);
    }
}

// 설계도
class 사람 {
    String 이름;
    int 나이;
}

위 코드에는 3개의 객체가 존재 → new가 3번 쓰였기 때문

객체의 기능

메서드(기능) → 실행을 위한 기능, 동작

메서드를 만드는 방법

class 사람 {
    String 이름;
    int 나이;

    void 메서드명() {
        System.out.prinln(이름 + ": " + 나이)
    }
}

// 메인클래스에 사용 불가
// 이름, 나이와 순서는 상관없지만, 일반적으로 메서드를 아래에 사용
// 메서드 안에 출력문, 조건문, 반복문 등 다 사용 가능

void : 허공이라는 의미 → 리턴을 안하겠다

메서드 활용법

public class Main {
    public static void main(String[] args) {

        // 사용자 정의 객체
        // 각각의 이름과 나이
        사람 a철수 = new 사람();
        a철수.이름 = "철수";
        a철수.나이 = 10;

        a철수.메서드명();  // 메서드 호출문, 메서드 실행문, 함수 호출문, 함수 실행문

        사람 a영수 = new 사람();
        a영수.이름 = "영수";
        a영수.나이 = 20;

        a영수.메서드명();
    }
}

// 설계도
class 사람 {
    String 이름;
    int 나이;

    void 메서드명() {
        System.out.println(이름 + ": " + 나이);
    }
}

함수

전역공간에서 만들어진 함수

메서드

클래스 내부에서 만들어진 함수

→ 자바에서는 함수, 메서드를 같은 의미로 사용함

public class Main{
    public static void main(String[] args) {
        사람 a사람 = new 사람();
        a사람.name = "Tom";
        a사람.test();
    }
}

class 사람{
    String name;
    int age;

    void test() {
        String name = "John";
        System.out.println(this.name);        
    }
}
// this가 없다면 John이 출력됨

조건을 만족하는 동안 반복하는 문법 (while / for)

반복문의 필수 3요소

1. 종료 조건
2. 초기값
3. 스텝 (증감)

구구단 출력하기

public class Main {
    public static void main(String[] args) {

        int dan = 8;
        // 반복문 사용X
        System.out.println(dan + " * 1 = " + dan*1 );
        System.out.println(dan + " * 2 = " + dan*2 );
        System.out.println(dan + " * 3 = " + dan*3 );
        System.out.println(dan + " * 4 = " + dan*4 );
        System.out.println(dan + " * 5 = " + dan*5 );
        System.out.println(dan + " * 6 = " + dan*6 );
        System.out.println(dan + " * 7 = " + dan*7 );
        System.out.println(dan + " * 8 = " + dan*8 );
        System.out.println(dan + " * 9 = " + dan*9 );

        // 1만 사용
        int i = 1;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;
        System.out.println(dan + " * " + i + " = " + dan*i);
        i ++;


        // for문 사용
        for (int i = 1; i <= 9; i ++) {
            System.out.println(dan + " * " + i + " = " + dan *i); 
        }

        // while문 사용
        int i = 1;
        while (i <= 9) {
            System.out.println(dan + " * " + i + " = " + dan * i);
            i ++;
        }
    }
}

while문 문제 풀이

public class Main {
    public static void main(String[] args) {
        // 1부터 5까지 출력
        int i = 1;
        while(i <= 5) {
            System.out.println(i);
            i ++;
        }

        // -100부터 25까지 출력
        int i = -100;
        while (i <= 25) {
            System.out.println(i);
            i ++;
        }

        // 구구단 8단 출력, 1000부터 1까지 곱하기
        int i = 1000;
        int dan = 8;
        while (i >= 1) {
            System.out.println(dan + " * " + i + " = " + dan * i);
            i--;
        }

        // 구구단 8단 출력, 1000부터 -500까지 곱하기
        int i = 1000;
        int dan = 8;
        while (i >= -500) {
            System.out.println(dan + " * " + i + " = " + dan * i);
            i--;
        }

        // 1부터 3까지 출력하는 작업 10번 (2중 while문)
        int i = 1;
        while (i <= 10) {
            int j = 1;
             while (j <= 3) {
                 System.out.println(j);
                 j ++;
             }
             System.out.println("==");
            i ++;
        }

        // 1부터 5까지 합 구하기
        int i = 1;
        int s = 0;
        while (i <= 5) {
            s += i;
            i ++;
        }
        System.out.println(s);

        // 음수 100부터 25까지의 합 구하기
        int i = -100;
        int s = 0;
        while (i <= 25) {
            s += i; 
            i ++;
        }
        System.out.println(s);
    }
}

for문 문제풀이

public class Main{
    public static void main(String[] args) {

        // 1부터 5까지 출력
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }

        // -100부터 25까지 출력
        for (int i = -100; i <= 25; i++) {
            System.out.println(i);
        }

        // 구구단 8단 출력, 1000부터 1까지
        int dan = 8;
        for (int i = 1000; i >= 1; i--) {
            System.out.println(dan + " * " + i + " = " + dan*i);
        }

        // 구구단 8단 출력, 1000부터 -500까지
        for (int i = 1000; i >= -500; i-- ) {
            System.out.println(dan + " * " + i + " = " + dan*i);
        }

        // 1부터 3까지 출력하는 작업 10번 하기
        for (int i = 1; i <= 10; i++) {
            for (int j = 1; j <= 3; j++) {
                System.out.println(j);
            }
            System.out.println("==");
        }

        // 1부터 5까지 합 구하기
        int s = 0;
        for (int i = 1; i <= 5; i++) {
            s += i;
        }
        System.out.println(s);

        // 음수 100부터 25까지 합 구하기
        int sum = 0;
        for (int i = -100; i <= 25; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

중첩 반복문

2중 반복문의 경우 바깥에 있는 큰 반복문이 한번 실행될 때,

안쪽에 있는 작은 반복문이 본인 횟수만큼 반복

입력문 문법

import java.util.Scanner;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("입력: ");
        String cmd = sc.nextLine();

        System.out.println("출력: " + cmd);

        sc.close();
    }
}

업다운 게임 프로그램

조건문, 반복문, 입력문 활용

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 1~100사이 랜덤한 숫자 생성 코드
        int rs = (int) (Math.random() * 100) + 1;
        System.out.println(rs);

        // 도전 횟수 카운트 변수
        int cnt = 0;

        while (true) {
            System.out.print("숫자를 입력해 주세요: ");
            int num = sc.nextInt();
            cnt ++;


            if (num > rs) {
                System.out.println("down");
                System.out.println("도전 횟수: " + cnt);
            } else if (num < rs) {
                System.out.println("up");
                System.out.println("도전 횟수: " + cnt);
            } else {
                System.out.println("정답입니다. " + cnt + "번 만에 맞추셨네요!");
                break;
            }
        }
        sc.close();
    }
}

int cnt를 while문 안에 쓰면 숫자를 입력할 때마다 초기화가 되어 누적이 되지 않으므로,

while문 바깥에 써야한다.

AI로 바이브 코딩을 해서 개발 -> 코드 자체는 괜찮 ㄴ 전문적인 지식이 없다면 한계가 분명함 -> 단편적 -> 웹은 보다 입체적이어야 함

AI의 활용 요즘 개발자에게 필수 덕목 -> 많이 사용해 볼 것을 권장

BUT 주의점 GPT 거짓말 잘 함 -> 정보를 주더라도 검증은 필요함

AI를 활용하는 것과 바이브 코딩은 다른 것

OS : 운영체제 CLI (Command Line Interface) : 명령어를 입력할 수 있는 환경 ex) cmd GUI (Graphic User Interface) : 눈에 보이는 환경

운영체제 종류

PC Windows - 일반적인 프로그램과 호환성이 좋음 -> 사람 친화적 (용량이 큼) Mac - 개발에 사용되는 주요 프로그램과 호환성이 좋음 -> 기계 친화적 (용량이 적음) Linux - 서버 Unix - Mac은 unix기반 (기계 친화적인 운영체제 -> GUI가 없음) ㄴ 리눅스와 유닉스는 호환성은 좋음

개발자들은 windows보다 mac을 더 선호한다? -> 반반

서버란? server - 제공자 사용자가 요청한 것에 대한 응답 제공

모바일 Android IOS

프로세스란? 프로그램 실행 -> 프로세스 생성 -> 어떤 ip, port로 실행 (포트번호 중복 불가)

프로세스 목록, 우선 순위 cmd에서 목록은 나오지만 우선 순위는 나오지 않음

작업관리자 -> 세부정보 -> 원하는 파일 우클릭 후 우선 순위 설정 (대부분 보통으로 설정되어 있음)

개발 환경 구축 운영체제 파악, CLI 환경

실제 개발에 필요한 도구 설치 및 버전 확인 ㄴ 자바 : java -version

저급언어 (컴퓨터 친화적), 임베디드 C언어 - 모든 프로그래밍 언어의 시작

고급언어 (사람 친화적) 자바 - 제한사항이 많음 (개발 단계에 고려해야 할 사항들이 많음), 웹에 특화 ㄴ 처음 만들 때 어렵지만 만들어 놓고 나면 관리 편함 (유지보수에 용이) 웹은 트렌드에 민감 -> 빠른 변화

파이썬 - 제한사항이 거의 없음, 웹에 특화X -> 인공지능 프로토타입(실험 모델), 빅데이터에 특화

자바 설치 Java Development Kit - JDK (개발, 실행 가능) Java Runtime Envirenment - JRE (실행만 가능)

JAVA의 대표적인 IDE (통합 개발 환경) 이클립스 - 무료 인텔리J - 유료

디드라이브에 내 파일 만들고 거기다 압축 풀어주기

ini에서 -Xms 둘다 4096으로 바꿔주기

설치 후 상단 윈도우 > 쇼뷰 > 콘솔 윈도우 > 프리퍼런시스 > enco > workspace utf-8인지 확인 content types > text > default encoding에 UTF-8입력 text좌측 화살표 누르고 JAVA 프로퍼틱스 파일 누르기 디폴팅 엔코딩에 8입력 스프링프로퍼틱스도 동일하게 진행

폰트설정 - D2코딩 버전 1.3.2다운 font검색 > 베이직옆 화살표 클릭후 텍스트 폰트 선택 > d2코딩선택

컨트롤 + n > 자바프로젝트 >버전 11 > 아래 체크 해제 > 피니쉬 src > 클래스 > 패키지는 제거 > 이름 Main 컨트롤 + 스페이스 = 자동완성

윈도우 > 제너럴 > 다크모드

하드디스크나 SSD에 데이터를 저장할 때, 그 저장 공간을 나누거나 묶어서 사용하는데, 이를 볼륨이라고 함

• 파일 시스템이 올라갈 수 있는 논리적 저장 공간의 단위
• 물리적인 하드디스크 전체가 하나의 볼륨일 수도 있고, 하나의 하드디스크를 여러 볼륨으로 나눌 수도 있음

파일 시스템 : 데이터를 저장하고 읽는 규칙

=> 쉽게 말해서 저장 공간의 단위

Docker에서의 볼륨

컨테이너의 데이터 저장을 위한 외부 저장소임

볼륨을 사용하는 이유

• 데이터 보존 : 컨테이너를 삭제하거나 재시작해도 데이터가 사라지지 않음
• 호스트와 공유 : 호스트 시스템과 파일을 쉽게 공유 가능
• 백업 / 복원 쉬움 : 다른 컨테이너에서도 쉽게 재사용 가능
• 성능 향상 : 일부 파일 시스템에서는 바인드 마운트보다 빠를 수도 있음

바인트 마운트란?
리눅스의 특정 디렉토리나 파일을 컨테이너 내부 경로에 직접
연결시키는 방식

볼륨과 바인드 마운트 차이점

볼륨은 docker가 설정 / 관리하고 바인드 마운트는 사용자가 직접함

cd /web/site1/public 으로 이동 
vim gugudan_1.html 

<meta charset ="UTF-8">
<div> 1 * 1 = 1 </div>
... 저장 => localhost:8011/gugudan_1.html


- Remi 저장소 설치
sudo dnf -y install https://rpms.remirepo.net/enterprise/remi-release-9.rpm

- dnf-utils 설치
sudo dnf -y install dnf-utils

sudo dnf -y install php php-{common,cli,fpm,mysqlnd,zip,devel,gd,mbstring,curl,xml,pear,bcmath,json,opcache,mcrypt}

설치 후 위치는 /web/site1/public => rm *

vim gugudan.php

<meta charset="UTF-8">
<?php
$dan = 1; 
?>
<h1><?=$dan?>단</h1>

<?php for ( $i = 1; $i <= 10; $i++ ) { ?>
<div><?=$dan?> * <?=$i?> = <?=$dan * $i?></div>
<?php } ?>
ㄴ 저장

php gugudan.php > gugudan_1.html

ㄴ localhost:8011/gugudan_1.html 접속하면 구구단 1단 출력

구구단 페이지 만들기 (동적)

- php-fpm설치
sudo dnf install php php-fpm

php 시작, 활성화 이후 상태 확인

sudo vim /etc/nginx/conf.d/php_vhost.conf.include

location ~ \.php$ {
    root $documentRoot;
    fastcgi_pass unix:/run/php-fpm/www.sock; 
    fastcgi_index index.php;
    fastcgi_param SCRIPT_FILENAME $documentRoot$fastcgi_script_name;
    include /etc/nginx/fastcgi_params;
    fastcgi_read_timeout 600;
}
저장 후 나오기

- vhost.conf 설정파일 생성

sudo vim /etc/nginx/conf.d/vhost.conf

server {
    listen 8011;
    server_name _;

    set $documentRoot /web/site1/public;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    include /etc/nginx/conf.d/php_vhost.conf.include;
}
저장 후 나오기 => php-fpm과 nginx 재실행

/web/site1/public으로 이동 후 파일 전부 삭제


vim gugudan.php 

<?php
$dan = intval($_GET['dan']);
$limit = intval($_GET['limit']);

// 파일 이름을 설정.
$filename = "gugudan_{$dan}_{$limit}.html";

// 헤더를 설정하여 파일 다운로드를 유도.
header('Content-Type: text/html');
header('Content-Disposition: attachment; filename="' . $filename . '"');
header('Pragma: no-cache');
header('Expires: 0');

// HTML 콘텐츠 생성
echo "<h1>== {$dan}단 ==</h1>";

for ($i = 1; $i <= $limit; $i++) {
    echo "<div>{$dan} * {$i} = " . ($dan * $i) . "</div>";
}
?>
위 내용 저장 후 나오기

 localhost:8011/gugudan.php?dan=3&limit=33 
구구단 3단의 곱이 33까지 나오는 html 파일이 다운로드 됨

Remi 저장소

추가 패키지 장소로 최신버전의 php, MySQL등 웹 관련 소프트웨어를 제공하는 장소

dnf-utils

RHEL계열 리눅스에서 사용되는 dnf의 보조 유틸리티 도구 모음

PHP

웹페이지를 동적으로 만들어주는 스크립트 언어로, 대표적인 웹 백엔드 언어 중 하나

php-fpm (PHP Fast CGI Process Manager)

php를 웹서버에서 빠르게 실행할 수 있도록 도와주는 프로세스 관리자 ㄴ 속도 향상, 동시 접속 처리, 보안 향상 ㄴ nginx와 함께 자주 사용 됨

FTP서버프로그램: 컴퓨터를 파일 전송용 서버로 만들어주는 프로그램 FTP: 컴퓨터 간 파일을 전송할 때 사용하는 프로토콜(규칙)

ex) 서버에 웹페이지 파일을 올릴 때, 파일질라같은 프로그램으로 서버에
접속해 파일을 올리거나 받을 때 사용하는게 FTP

pure-ftpd 설치 및 세팅

- sudo dnf install pure-ftpd -y

- sudo dnf vim /etc/pure-ftpd/pure-ftpd.conf
MySQLConfigFile 앞에 주석 제거 후
/etc/pure-ftpd/pureftpd-mysql.conf로 수정

- sudo vim /etc/pure-ftpd/pureftpd-mysql.conf
MYSQLSocket /var/lib/mysql/mysql.sock
MYSQLUser pureftpd    //사용할 ID
MYSQLPassword korea1231     //비밀번호
MYSQLDatabase pureftpd     // 사용자 DB정보
MYSQLCrypt cleartext    // 비번을 평문으로 저장

저장 후 나와서  pure-ftpd 활성화 & 실행


MariaDB에 pureftpd 계정 생성
- mysql root 계정으로 실행(mysql -u root -p)
ㄴ기존 koreast계정과 달리 pureftpd는 pureftpd DB에 대한 
권한만 가짐

- GRANT ALL PRIVILEGES ON pureftpd.* TO pureftpd@`localhost` IDENTIFIED BY 'korea1231';
- FLUSH PRIVILEGES;

SQLyog 세팅

- CREATE DATABASE pureftpd;


DROP DATABASE IF EXISTS pureftpd;

CREATE DATABASE pureftpd;

USE pureftpd;

CREATE TABLE users (
  uidx int(10) unsigned NOT NULL AUTO_INCREMENT,
  `user` varchar(100) NOT NULL,
  `password` varchar(100) NOT NULL,
  `gid` int(10) unsigned NOT NULL,
  `uid` int(10) unsigned NOT NULL,
  `occurDate` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `status` tinyint(1) unsigned NOT NULL DEFAULT '1',
  `ipaccess` varchar(15) NOT NULL,
  `comment` varchar(100) NOT NULL,
  `ulBandWidth` smallint(5) unsigned NOT NULL,
  `dlBandWidth` smallint(5) unsigned NOT NULL,
  `quotaSize` smallint(5) unsigned NOT NULL,
  `quotaFiles` int(10) unsigned NOT NULL,
  `dir` varchar(100) NOT NULL,
  PRIMARY KEY (`uidx`)
);

insert  into `users`(`uidx`,`user`,`password`,`gid`,`uid`,`occurDate`,`status`,`ipaccess`,`comment`,`ulBandWidth`,`dlBandWidth`,`quotaSize`,`quotaFiles`,`dir`) values 
(1,'site1','korea1231',1001,1001,NOW(),1,'*','',0,0,0,0,'/web/site1'),
(2,'site2','korea1231',1001,1001,NOW(),1,'*','',0,0,0,0,'/web/site2'),
(3,'site3','korea1231',1001,1001,NOW(),1,'*','',0,0,0,0,'/web/site3');



SELECT * FROM users;    // 확인
위에 1000,1000 확인하려면
vim /etc/passwd 하면 koreast 보면 옆에 나옴 그거와 동일하게 맞춰줘야된다.



접속테스트

cd / => 루트디렉토리이동
cd web
cp -r site0 site3
sudo dnf install ftp
ftp 127.0.0.1
계정1 : site1 / korea1231
계정2 : site2 / korea1231
계정3 : site3 / korea1231
접속이 안된다면 잘 못 한것 => 전 과정 다시 해보기

외부에서 접속

포트포워딩 : FTP / 0.0.0.0 / 2121 / 10.0.2.16 / 21
확인 2번
파일질라 열기
좌측상단 파일 => 사이트관리자
새사이트 : site1@127.0.0.1
프로토콜 : FTP
HOST : 192.168.56.1
ㄴvirtual box 환경에서는 127.0.0.1과 같은 의미
pureftpd의 버그로 인해 FTP 접속시에는 127.0.0.1 대신 이걸 사용해야 함
포트 : 2121
사용자 : site1
전송설정 : 능동형 선택
전송설정 후 연결

private 필드에 안전하게 접근하기 위해 사용하는 메서드

왜 사용하는가?

클래스 안의 변수에 바로 접근하게되면, 누구나 값을 변경하거나 볼 수 있어서 보안에 취약한데 변수를 private로 접근 범위를 제한해 숨기고 외부에서 값을 바꾸거나 가져올 수 있도록 public (getter / setter) 메서드를 사용함

=> private + getter/setter는 안전하고 객체지향적

• setter : 변수의 데이터를 저장하는 메서드

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

• getter : 저장된 변수의 데이터를 가져오는 메서드

  public String getName( ) {
       return name; 
  }
  

-----
### GETTER SETTER 활용
```java
- Student 클래스
package student;

public class Student {
  private String name;
  private int age;
  public int grade;

  public void setName(String name) {
    this.name = name;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public int getAge() {
    return age;
  }
}


- Main클래스
import student.Student;

class Main {
  public static void main(String[] args) {
    Student st = new Student();

    st.setName("홍길동");
    System.out.println("이름 : " + st.getName());

    st.setAge(25);
    System.out.println("나이 : " + st.getAge());

    st.grade = 3;
    System.out.println("학년 : " + st.grade);
  }
}

class Solution {
    public int solution(int n) {
        int answer = (int)Math.ceil((double)n / 7);
        // 올림을 하기 위해선 실수여야 하기에 (double)로 
        // 형변환을 해주고, 올림된 실수를 answer는 int 타입
        // 이기에 (int)로 다시 한 번 형변환
        return answer;
    }
}

Math.round : 반올림 Math.ceil : 올림 Math.floor : 내림 ㄴ 모두 실수 타입이여야 함, 정수면 형변환 해주기

시간 당 2배씩 증가하는 세균 n의 t시간 뒤 마릿수

class Solution {
    public int solution(int n, int t) {
        int answer = (int)Math.pow(2, t)*n;
        // 처음 n마리 시간당 2배씩 t 시간 
        return answer;
    }
}

Math.pow(값, 지수) : 값이 2이고 지수가 2라면 2의2승, Math.pow는 double형으로 값을 반환함 따라서 정수형을 원한다면 (int)로 형변환이 필요

배열에서 제일 큰 수와 2번째로 큰 수 곱하기

import java.util.Arrays;
class Solution {
    public int solution(int[] numbers) {
        int answer = 0;

        Arrays.sort(numbers);
        answer = numbers[numbers.length-1] * numbers[numbers.length - 2];
        return answer;
    }
}

배열을 오름차순으로 정렬하면 작은 수부터 큰 수 순서대로 정렬이 되는데,
정렬 뒤 마지막 수와 그 전수를 곱해준다.

Arrays.sort(배열 변수) : 오름차순 정렬 ㄴ 사용하려면 import java.util.Arrays 필요함

오픈소스 관계형 데이터베이스 관리 시스템(RDBMS)

데이터를 테이블 형식으로 저장하고 관리해주는 프로그램으로 명령어는 my sql과 거의 비슷

MariaDB 설치

sudo vim /etc/yum.repos.d/MariaDB.repo =>

# MariaDB 11.4 CentOS repository list - created 2024-11-30 06:31 UTC
# https://mariadb.org/download/
[mariadb]
name = MariaDB
# rpm.mariadb.org is a dynamic mirror if your preferred mirror goes offline. See https://mariadb.org/mirrorbits/ for details.
# baseurl = https://rpm.mariadb.org/11.4/centos/$releasever/$basearch
baseurl = https://tw1.mirror.blendbyte.net/mariadb/yum/11.4/centos/$releasever/$basearch
# gpgkey = https://rpm.mariadb.org/RPM-GPG-KEY-MariaDB
gpgkey = https://tw1.mirror.blendbyte.net/mariadb/yum/RPM-GPG-KEY-MariaDB
gpgcheck = 1

위 내용 삽입 후 저장

sudo vim /etc/my.cnf =>
ㄴ cnf는 config의 약자로 cnf는 db에서 쓰임

!includedir /etc/my.cnf.d 
위 내용 삽입 후 저장

sudo dnf install MariaDB-server MariaDB-client -y (설치)

sudo vim /etc/my.cnf.d/server.cnf =>

[mysqld]
character-set-server=utf8mb4
collation-server=utf8mb4_unicode_ci
skip-character-set-client-handshake
bind-address = 0.0.0.0
위 내용 삽입 후 저장

sudo vim /etc/my.cnf.d/mysql-clients.cnf =>

[mysql]
default-character-set = utf8mb4

...

[mysqldump]
default-character-set = utf8mb4
위 두 곳 아래에만 삽입 후 저장

이후 MariaDb 활성화하고 켜기
ㄴ 매 부팅시 자동으로 켜짐

MariaDB 초기세팅 및 접속

설치 후 최초 1회만 하면 됨

- 초기세팅

sudo /usr/bin/mariadb-secure-installation
ㄴ switch unix_socket 제외 전부 Y로 설정
새로운 비밀번호 설정


- 접속

mysql -h 127.0.0.1 -u root -p

FTP방식으로 서버와 내 컴퓨터 사이에 파일을 주고 받을 수 있게 해주는 도구

서버에 웹사이트 / 파일을 업로드 / 다운로드 할 때 마우스로 편하게 옮길 수 있는 프로그램으로 웹 개발 때 자주 쓰임

• 설치 사이트

  https://filezilla-project.org/download.php?show_all=1

  ---

  파일질라 사용법

  파일 => 사이트 관리자 => 새 사이트 => 파일명 : koreast@127.0.0.1
  

프로토콜 : SFTP 호스트 : 127.0.0.1 포트 : 2222 (자신 포트 입력) 로그인 유형 : 비밀번호 묻기 사용자 : koreast => 연결

----

### 이미지 업로드

파일질라에 이미지 업로드 후 ls를 통해 잘 들어왔는지 확인 =>

mv 파일명 /web/site1/pulbic (이동할 경로) ㄴ mv : 파일이나 디렉토리를 이동 또는 이름 바꾸는 명령어

cd /web/site1/public => ls ㄴ 파일명 뜸

localhost:8011/123.jpg => 사이트에 이미지 뜸

sudo vim 123.html ㄴ html : 웹페이지를 구성하는 문서 형식 브라우저가 파일을 읽고 웹페이지처럼 보여주는 역할을 함

localhost:8011/jpg.html에 접속했을 때 출력되면 성공

자바 클래스들을 정리하는 폴더 ㄴ패키지로 클래스들을 나눠서 정리

패키지를 사용해야 되는 이유

1. 클래스를 논리적으로 그룹화하여 프로젝트 구조 깔끔하게 정리 가능
2. 클래스 이름이 겹쳐도 구분 가능 ```

• com.naver.User
• com.kakao.User ```

3. 접근 제어자와 함께 사용해 캡슐화를 도와줌

- 내가 만든 프로그램에 있는 클래스들
1. Game.java
2. GameSound.java
3. Member.java
4. Member.Login.java

한 곳에 두면 처음엔 괜찮지만 나중에는 복잡해짐
=> 다른 패키지에 분리해서 저장

- game 폴더(패키지)
1. Game.java
2. GameSound.java

- member 폴더(패키지)
1. Member.java
2. MemberLogin.java

이렇게 하면 보기도, 유지보수도 쉬워짐

리팩토리해서 클래스가 따로 분리되는것 = 패키지를 분리한 것

리팩토리 하지 않고 한 페이지에 여러 클래스를 작성하는 것은 패키지로 분리된 것이 아님

단순히 클래스만 리팩토리하는 것이 아닌 패키지를 따로 만들어 패키지 안에 클래스를 리팩토리하여 완전히 분리해야 함

기본 패키지 (default package)

public class Test {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

위처럼 package문이 없는 클래스는 기본 패키지임

• package를 안 쓰면 기본 패키지
• 규모가 작을 때만 사용하고, 실제 프로젝트에서는 거의 사용 안 함

패키지 선언

- 선언문 문법
package 패키지명;


- 선언문은 반드시 자바 파일 최상단에 있어야 함
package 패키지명;
import java.util.Scanner;

public class Main{
}

- 파일 위치와 패키지명은 같아야 함

패키지명                파일 경로
package com.test;    com/test/파일명.java
package game;        game/파일명.java
(패키지 없음)        프로젝트 루트(최상위 폴더)

위치가 맞지 않으면 컴파일 오류 발생하거나,
실행 시 클래스를 찾지 못 할 수도 있음

패키지 호출

다른 패키지에 있는 클래스를 내 코드에서 사용하는 경우 import를 통해 호출함

- game/Game.java
package game;

public class Game {
    public void start() {
        System.out.println("게임 시작!");
    }
}


- Main.java
import game.Game;  // 패키지 호출

public class Main {
    public static void main(String[] args) {
        Game g = new Game();
        g.start();
    }
}

접근제어자(Access Modifier)

클래스, 변수, 메서드 등을 누가 어디까지 접근 가능한지 정해주는 제어장치 보안, 유지보수, 역할구분에 편리함

public

public class Car {
    public String brand = "Hyundai";
    public void drive() {
        System.out.println("달립니다!");
    }
}

어디서든 이 클래스를 사용 가능
다른 패키지에서도 호출을 통해 자유로운 사용 가능

private

public class BankAccount {
    private int balance = 10000;

    public void showBalance() {
        System.out.println("잔액: " + balance);
    }
}

같은 클래스 내부에서만 접근 가능
외부에서는 직접 접근이 불가
외부에서 접근하려면 public메서드를 통해서만 가능

default

class Dog {
    String name = "푸들"; 
}

접근제어자를 안 붙이면 default임
같은 패키지 안에서 접근이 가능하며, 다른 패키지에선 불가

protected

public class Animal {
    protected String sound = "멍멍";
}

같은 패키지에서 접근 가능
다른 패키지여도 상속받은 자식클래스는 접근 가능
다른 패키지와 일반 클래스에서는 접근 불가

접근제어자 문제

1) private과 public 실습 (기초)

class Main {
  public static void main(String[] args) {
    User u = new User("jsw");
    System.out.println("초기 이름: " + u.getName());

    u.setName("jsu");
    System.out.println("변경된 이름: " + u.getName());
  }
}

public class User {
  private String name;
  public User(String name) {
    this.name = name;
  }
  public String getName() {   // return값이 name인 메서드
    return name;
  }
  public void setName(String name) {  // return 값이 없는 void 타입의 메서드
    this.name = name;
  }
}

2) default 접근제어자 실습 (중간)

class Main{
  public static void main(String[] args) {
    Person p = new Person();
    p.address = "Seoul";
    System.out.println(p.address);
  }
}

class Person {
  String address;
}

앞에 아무것도 붙지 않으면 default 접근제어자로 같은 클래스와
패키지에서만 접근이 가능함

3) protected 접근제어자 실습 (중상)

- 같은 패키지에서 사용하는 경우
class Main{
  public static void main(String[] args) {
    Dog d = new Dog("멍멍");
    System.out.println(d.sound);
  }
}
class Animal {
  protected String sound;
  Animal(String sound) {
    this.sound = sound;
  }
}
class Dog extends Animal {
  Dog(String sound) {
    super(sound);
  }
}

- 다른 패키지에서 사용하는 경우

Main class)

import animal.Dog;    // animal 패키지의 Dog클래스 호출
public class Main{
  public static void main(String[] args) {
    Dog d = new Dog("멍멍");    // Dog타입 d 객체 선언
    System.out.println(d.getSound());    
  }
}

Animal class)

package animal;     // animal 패키지 선언

public class Animal {
  protected String sound;    
  // sound는 같은 패키지 또는 자식 클래스에서만 접근 가능
  public Animal(String sound) {    
  // public 생성자 생성
    this.sound = sound;
  }

  public String getSound() {
    return sound;
  }
  // sound값을 반환하는 public 메서드 생성
}

Dog class)

package animal;        // animal 패키지 선언

public class Dog extends Animal {    // Animal클래스 상속
  public Dog(String sound) {    // public 생성자 생성
    super(sound);    // 상속받은 생성자 정보
  }
}

4) 각 접근제어자 테스트

public class Main {
  public static void main(String[] args) {
    Sample1 s1 = new Sample1();
    Sample2 s2 = new Sample2();
    Sample3 s3 = new Sample3();
    Sample4 s4 = new Sample4();

    System.out.println(s1.a);
    System.out.println(s2.b);
    System.out.println(s3.c);
    System.out.println(s4.getD());
  }
}
class Sample1 {        
  public int a = 1;    // 어디서든 접근 가능
}

class Sample2{
  protected int b = 2;    // 같은 패키지, 상속받은 클래스에서 접근 가능
}

class Sample3{    
  int c = 3;    // 같은 패키지에서 접근 가능
}

class Sample4 {
  private int d = 4;    // 같은 클래스에서만 접근 가능
  public  int getD() {    // public 메서드를 통해서 접근은 가능함
    return d;
  }
}

자바에서 일종의 설계도로 클래스가 인터페이스를 implements하면, 인터페이스에 정의된 모든 메서드를 반드시 구현해야 함

사용하는 목적

1. 개발자 간의 약속
2. 다형성 => 인터페이스 타입으로 여러 구현 객체를 처리 가능
3. 결합도 낮추기 => 객체들 간 연결을 느슨하게 만들어 유지보수 유리

기본 문법

interface 인터페이스명 {
    추상 메서드();
}
// 몸체가 없는 추상 메서드 구현
// 구현하는 클래스에서 반드시 구현해야 함

class Dog implements Animal {
    public void sound() {
        System.out.println("멍멍");
}
// implements 키워드를 반드시 사용해야 함
// 인터페이스의 모든 메서드를 반드시 오버라이딩

// 인터페이스의 모든 메서드는 자동으로 public abstract으로 
// 선언되어 반드시 메서드 선언 시 앞에 public을 붙여야 함

유용 문제

1번 )

class Main {
  public static void main(String[] main) {
    Soundable[] animals = {new Dog(), new Cat(), new Duck()};

    for (Soundable s : animals) {
      s.sound();
    }
  }
}
interface Soundable {
  void sound();
}
class Dog implements Soundable {
  public void sound() {
    System.out.println("멍멍");
  }
 }
class Cat implements Soundable {
  public void sound() {
    System.out.println("야옹");
  }
}
class Duck implements Soundable {
  public void sound() {
    System.out.println("꽥꽥");
  }
}

2번 )

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    System.out.print("면적을 구할 도형을 입력해 주세요 :");
    String shape = sc.nextLine();

    if (shape.equals("원")) {
      System.out.print("원의 반지름을 입력해 주세요 : ");
      int r = sc.nextInt();
      sc.nextLine();
      Circle c = new Circle(r);
      c.cal();
    }
    else if (shape.equals("삼각형")) {
      System.out.print("삼각형의 밑변 길이를 입력해 주세요 : ");
      int u = sc.nextInt();
      sc.nextLine();

      System.out.print("삼각형의 높이를 입력해 주세요 : ");
      int h = sc.nextInt();
      sc.nextLine();

      Triangle t = new Triangle(u, h);

      t.cal();
    } else {
      System.out.println("원, 삼각형만 가능합니다.");
    }

  }
}
interface Shape {
  void cal();
}
class Circle implements Shape {
  int r;
  Circle(int r) {
    this.r = r;
  }
  public void cal () {
    System.out.println("면적 : " + 3.14 * r * r);
  }
}
class Triangle implements Shape {
  int u;
  int h;
  Triangle (int u, int h) {
    this.u = u;
    this.h= h;
  }
  public void cal () {
    System.out.println("면적 : " + u * h /2);
  }
}

같은 자료형의 값들을 순차적으로 저장하는 크기가 고정적인 자료 구조

• 크기는 변경 불가

• 인덱스 0부터 시작

• 한가지 타입만 저장 가능

• 여러 개의 데이터를 한 번에 저장하며 빠른 접근이 가능

• 코드의 가독성과 유지보수성 향상

숫자 10개를 입력받고 배열에 저장 뒤 출력 프로그램

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] arr = new int[10];

    for (int i = 0; i < 10; i ++) {
      System.out.printf("%d번째 숫자 : ", i + 1);
      arr[i] = sc.nextInt();
      sc.nextLine();
    }
    for (int i = 0; i < 10; i ++) {
      System.out.printf("%d번째 숫자 : %d\n", i +1, arr[i]);
    }
  }
}

배열에서 최소값 최대값 구하기

class Main {
  public static void main(String[] args) {
    int[] arr = new int[5];
    arr[0] = 1;
    arr[1] = 3;
    arr[2] = 2;
    arr[3] = 8;
    arr[4] = 9;

    // int[] arr = {1,3,2,8,9}; 와도 같음

    int min = arr[0];
    int max = arr[0];

    for (int i = 0; i < arr.length; i ++) {
      if (min > arr[i]) {
        min = arr[i];
      }
      if (max < arr[i]) {
        max = arr[i];
      }
    }
    System.out.println("최대값 : " + max + "\n최소값 : " + min);
  }
}

배열 모든 값들의 평균 구하기

class Main {
  public static void main(String[] args) {
    int arr[] = {2,5,1,8,6};
    int s = 0;

    for (int i = 0; i < arr.length; i ++) {
      s += arr[i];
    }
    System.out.println("평균 : " + s/arr.length);
  }
}

클래스

• 클래스와 객체의 차이 클래스는 객체(인스턴스)를 만들기 위한 설계도이고, 객체는 설계도(클래스)의 정의로 만들어진 제품

• 클래스의 구성 요소

1. 속성 : 클래스의 포함된 변수로 객체의 데이터를 저장
2. 메서드 : 클래스 내 함수로 객체의 기능을 정의
3. 생성자 : 객체를 만들 때 호출되는 특별한 함수

Car 클래스를 정의하고, 속성(모델, 색상, 연식)과 메서드(정보 출력)를 구현

class Main {
  public static void main(String[] args) {
    Car kia = new Car("k5", "white", 2025);
    kia.introduce();
  }
}
class Car {
  String model;
  String color;
  int year;

  Car(String model, String color, int year) {
    this.model = model;
    this.color = color;
    this.year = year;
  }

  void introduce () {
    System.out.println("모델명 : " + model + "\n색상 : " + color + "\n연식 : " + year);
  }
}

Student 클래스를 정의하고, 학생의 이름과 점수를 입력받아 평균 점수를 계산하는 프로그램

class Main {
  public static void main(String[] args) {
    Student jsw = new Student("장성욱",95,88);
    jsw.avg();
  }
}
class Student {
  String name;
  int korean_score;
  int math_score;

  Student(String name, int korean_score, int math_score) {
    this.name = name;
    this.korean_score = korean_score;
    this.math_score = math_score;
  }

  void avg () {
    System.out.println("이름 : " + name + "\n국어 : " + korean_score + "점" + "\n수학 : " + math_score + "점\n평균 : " + (korean_score + math_score) /2 + "점");
  }
}

은행 계좌를 나타내는 BankAccount 클래스를 정의하고, 입금과 출금 기능을 구현

class Main{
  public static void main(String[] args) {
    BankAccount ba = new BankAccount("카카오뱅크", 123456123, 56000);
    ba.입금(25000);
  }
}
class BankAccount {
  String bank;
  int account_num;
  int able;

  BankAccount(String bank, int account_num, int able) {
    this.bank = bank;
    this.account_num = account_num;
    this.able = able;
  }

  void 입금(int 입금금액) {
    System.out.println(bank + " " +account_num + "\n" + 입금금액 + "원이 입금 되었습니다." );
  }
  void 출금(int 출금금액) {
    System.out.println(bank + " " +account_num + "\n" + 출금금액 + "원이 입금 되었습니다." );
  }
}

상속

• 상속의 개념 부모클래스에 정의된 속성, 메섣, 생성자 등의 기능을 자식클래스가 물려받아 사용하는 것

• 상속의 장점

1. 공통된 기능을 부모클래스에 정의해 중복 없이 사용해 가독성이 높아짐
2. 수정이 필요한 경우 부모클래스만 수정하면 됨
3. 물려받는 것과 별도로 자식클래스 고유의 기능도 추가 가능

• super의 역할 자식클래스에서 부모클래스의 속성, 메서드, 생성자에 접근하게 해줌

1. super() : 부모클래스 생성자 호출 // super(name,age)
2. super.속성 or 메서드 : 부모클래스 속성, 메서드에 접근 // super.name, super.cry()..

생성자를 생성했다면 객체 생성 시 인자에 속성값 꼭 적어주기!!

Animal 클래스를 정의하고, 이를 상속받는 Dog와 Cat 클래스를 정의하여 각 동물의 소리를 출력하는 프로그램

class Main {
  public static void main(String[] args) {
    Dog d = new Dog("흰둥이", "멍멍");
    Cat c = new Cat("야옹이", "야옹");

    d.짖다();
    c.짖다();
  }
}
class Animal {
  String name;
  String crying;

  Animal(String name, String crying) {
    this.name = name;
    this.crying = crying;
  }

  void 짖다 () {
    System.out.println(name + "가 " + crying + " 짖는다.");
  }
}
class Dog extends Animal {
  Dog(String name, String crying) {
    super(name, crying);
  }
}
class Cat extends Animal {
  Cat(String name, String crying) {
    super(name, crying);
  }
}

Person 클래스를 정의하고, 이를 상속받는 Student와 Teacher 클래스를 정의하여 각각의 정보 출력 메서드를 구현

class Main{
  public static void main(String[] args) {
    Student st = new Student("톰", 19, "학생");
    Teacher tc = new Teacher("존", 33, "선생");

    st.introduce();
    tc.introduce();
  }
}
class Person {
  String name;
  int age;
  String job;

  Person(String name, int age, String job) {
    this.name = name;
    this.age = age;
    this.job = job;
  }
  void introduce () {
    System.out.println("이름 : " + name + "\n나이 : " + age + "\n직업 : " + job);
  }
}
class Student extends Person {
  Student (String name, int age, String job) {
    super(name, age, job);
  }
}
class Teacher extends Person {
  Teacher (String name, int age, String job) {
    super(name, age, job);
  }
}

Vehicle 클래스를 정의하고, 상속받는 Car와 Bike 클래스를 만들어 정보를 출력하는 프로그램을 작성

class Main {
  public static void main(String[] args) {
    Car c = new Car("기아","k5", 150);
    Bike b = new Bike("삼천리", "자전거", 25);

    c.introduce();
    b.introduce();
  }
}
class Vehicle {
  String brand;
  String model;
  int speed;

  Vehicle(String brand, String model, int speed) {
    this.brand = brand;
    this.model = model;
    this.speed = speed;
  }
  void introduce() {
    System.out.println(brand + " " + model+ "이 최고속도 " +  speed + "km로 달립니다.");
  }
}
class Car extends Vehicle {
  Car(String name, String model, int speed) {
    super(name, model, speed);
    }
  }

class Bike extends Vehicle {
  Bike(String name, String model, int speed) {
    super(name, model, speed);
  }

}

put(key, value) : 키와 값 넣기 get(key) : 키로 값 꺼내기 remove(key) : 키로 값 삭제하기 containsKey(key) : 해당 키가 있는지 확인하기 containsValue(value) : 해당 값이 있는지 확인하기 keySet() : 모든 키 반환 values() : 모든 값 반환 size() : 저장된 쌍의 개수 반환 entrySet() : 전체 조회

Hashmap

어떤 key값(이름)에 value값(내용)을 저장 => 이름으로 내용 찾기 편함 정해진 순서가 없으며, value값은 중복이 가능해도 key값은 중복 불가

import java.util.HashMap;    // 기능 호출하기

HashMap<String, Integer> map = new HashMap <> ();

map.put("a", 100)    // a, 100 추가, a는 키값
map.size()        // 크기를 알려줌
map.get("a")    // 100출력
map.remove("a") // 키값만 입력하면 됨, 삭제
map.clear()        // 전체 삭제

전화번호부

import java.util.Scanner;
import java.util.HashMap;
class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    HashMap<String, String> map = new HashMap<> ();

    System.out.print("이름을 입력해 주세요 : ");
    String name = sc.nextLine();
    System.out.print("전화번호를 입력해 주세요 : ");
    String number = sc.nextLine();

    map.put(name, number);

    if (map.containsKey(name)) {
      for (String key : map.keySet())  {
        System.out.println(key + " " + map.get(key));
      }
    }
  }
}

HashSet

순서, 중복을 허용하지 않는 데이터의 집합

import java.util.HashSet;    // 기능 호출하기


HashSet<String> set = new HashSet<> ();

set.add("a")    // a추가
set.contains("a")     // a가 있는지 여부 판단 => true
set.size    // 크기 알려줌
set.remove("a")        // a삭제
set.clear()     // 전체 삭제

LinkedList

연결리스트, 데이터의 빠른 삽입 + 삭제

LinkedList<String> list = new LinkedList<> ();

list.add // 추가
list.get()     // 가져오기
list.getFirst     // 처음 요소 가져오기
list.getLast    // 마지막 요소 가져오기
list.addFirst    // 맨 앞에 추가
list.addLast    // 맨 뒤에 추가

Iterator

컬렉션의 모든 데이터를 순회

import java.util.Iterator;    // 기능 호출하기


public class Main{
  public static void main(String[] args){
    ArrayList<String> list  = new ArrayList<>();
    list.add("철수");
    list.add("영희");
    //이터레이터로 변경
    Iterator<String> it = list.iterator(); 
    //리스트로부터 이터레이트를 얻어온다. 
   while(it.hasNext()){ 
     System.out.println(it.next());
   }
  }
}

hasNext - 다음 요소 확인 // it.hasNext() //true
next - 다음 요소 가져오기 // it.next() // "철수"
remove - 삭제 it.remove() // {}

sudo sh -c ' echo "내용 입력" > / (index.html의 위치)
ㄴ 띄어쓰기 주의

index.html의 위치는 locate를 통해 찾음 
ㄴ locate전에 updatedb를 사용해 데이터 최신화를 먼저 해주기

localhost:8010

localhost = 내 컴퓨터의 주소 (127.0.0.1) :8010 = 내가 설정한 포트의 번호 index.html = 웹 사이트의 첫 페이지 역할

localhost 내용 바꾸기

sudo locate index.html (nginx 찾기) =>
cd /usr/share/nginx/html
ls 
sudo cp index.html index.html.origin =>

sudo vim index.html
문서 내용 중 하나를 수정해서 저장 후 localhost에 들어가
수정되었는지 확인 => 수정이 되었다면 잘 찾은 거!

sudo vim index.html
d를 꾹 눌러 내용 전부 삭제하고 내용 입력해주고 저장

chmod

• 체인지모드로 index.html 파일을 koreast가 수정할 수 있도록 퍼미션 변경

ls -al

- 퍼미션 변경 전
rw-/r--/r-- : 644        // **r=4, w=2, x=1**
ㄴ 3개씩 끊어 읽음
sudo chmod 646 index.html

- 퍼미션 변경 후
rw-/r--/rw- : 646
ㄴ 646으로 변경

sudo echo "hi" > index.html
=> 성공

• 체인지모드로 html 폴더에서 koreast가 파일 생성 가능하게 퍼미션 변경 ```

• 퍼미션 변경 전 rwx/r-x/r-x => 퍼미션 755 sudo chmod 757 .(.은 현재 파일)

• 퍼미션 변경 후 rwx/r-x/rwx => 퍼미션 757

touch a.html

vim a.html => aaaaa => esc :wq!

=> localhost:8010/a.html 페이지(폴더) 생성 완료

----
### chown
**소유권 변경**

- chown으로 koreast가 html 폴더를 소유하게 하기

• 위에서 변경한 펴미션을 기존 퍼미션으로 변경 sudo chmod 644 index.html sudo chmod 757 .

sudo chown koreast:koreast . ㄴ 현재폴더의 소유권을 koreast(이름):koreast(그룹) 으로 바꾸겠다는 의미

- chown -R .로 html폴더 이하 모든 요소들의 소유권 한방에 변경

sudo chown koreast:koreast . ㄴ 현재 폴더 자체 소유권을 변경

sudo chown koreast:koreast * ㄴ 현재 폴더 안에 들어있는 파일들 소유권 변경

sudo chown koreast:koreast -R . ㄴ 이 폴더로 시작하는 그 안에 모든 것의 소유권을 전부 koreast로 변경

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int cnt = 1;

    while (true) {
      System.out.print("숫자를 입력해 주세요 : ");
      int num = sc.nextInt();
      sc.nextLine();

      System.out.printf("입력된 숫자의 개수 : %d\n", cnt);
      cnt ++;

      if (num == -1) {
        break;
      }
    }
  }
}

양수 5개를 입력받아 배열에 저장하고 제일 큰 수 출력

import java.util.Scanner;
import java.util.ArrayList;
class Main{
  public static void main(String[] args) {
    Scanner sc = new Scanner (System.in);
    ArrayList<Integer> list = new ArrayList<> ();

    for (int i = 0; i < 5; i ++) {
      System.out.printf("%d번째 양수를 입력해 주세요 : ", i +1);
      int num = sc.nextInt();
      sc.nextLine();

      list.add(num);
      }
    int max = list.get(0);
    for (int num  : list) {
      if (num > max) {
        max = num;
      }
    }
    System.out.println("제일 큰 수 : " + max);
    sc.close();
  }
}

배열의 크기만큼 정수를 입력받고 평균 구하기

import java.util.Scanner;
class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int[] nums = new int[3];
    int s = 0;

    for (int i = 0; i < nums.length; i ++) {
      System.out.printf("%d번째 정수를 입력해 주세요 : ", i + 1);
      nums[i] = sc.nextInt();
      sc.nextLine();

      s += nums[i];
    }
    double avg = s / nums.length;
    System.out.println("입력한 정수의 평균 : " + avg);
    sc.close();
  }
}

문제풀이

https://codepen.io/gykim93/full/KKjRzbR

문제2)

class Main {
  public static void main(String[] args) {
    int number = 5;
    int current = 25;

    for (int i = 1; i <= number; i ++) {
      for (int j = 4; j >= 0; j --) {   // j는 4에서 0까지 1씩 감소
        System.out.print(current -j + " "); // current -4 => -3.. 1씩 감소
      }
      current -= 5;     // j에서 5번 반복 했으니까 current에서 5를 빼 다음 반복엔 20부터 시작
      System.out.println();
    }
  }
}

문제3)

class Main{
  public static void main(String[] args) {
    int number = 5;
    int current = 1;

    for (int i = 1; i <= number; i ++) {  // 5번 반복
      for (int j = 1; j <= number; j ++) {  // 5번 반복
        System.out.print(current + " ");  
        current += 2;   // current는 2씩 증가
      }
      System.out.println();
    }
  }
}

문제4)

class Main {
  public static void main(String[] args) {
    int number = 5;
    int current = 1;

    for (int i = 0; i < number; i ++) {   // i는 0~4까지 반복
      for (int j = 0; j <= i; j ++ ) {    // j는 0부터 i까지 반복
        System.out.print(current + j +" "); // current는 j씩 증가
      }
      System.out.println(); // j반복문 종료 후 줄바꿈
    }
  }
}

문제5)

class Main{
  public static void main(String[] args) {
    int number = 5;
    int current = 1;

    for (int i = 0; i < number; i ++) { // i는 0~4까지 반복
      for (int j = 0; j <= i; j ++) {   // j는 0~i까지 반복
        System.out.print(current + " ");
        current ++;   // current는 1씩 증가
      }
      System.out.println();   // j반복문 종료 후 줄바꿈
    }
  }
}

문제6)

class Main{
  public static void main (String[] args) {
    int number = 5;
    int current = 1;

    for (int i = number; i > 0; i --) {
      for (int j = i; j > 0; j --) {
        System.out.print(current++ + " ");
      }
      current = 1;    // current는 j반복문 종료 후 1로 초기화 
      System.out.println();
    }
  }
}

문제7)

class Main{
  public static void main (String[] args) {
    int number = 5;
    int current = 1;

    for (int i = number; i > 0; i --) {    // i는 5부터 1까지 1씩 감소
      for (int j = i; j > 0; j --) {    // j는 i부터 1까지 1씩 감소
        System.out.print(current++ + " ");    //current는 1씩 증가
      }
      System.out.println();
    }
  }
}

문제8)

class Main{
  public static void main(String[] args) {
    int number = 5;

    for (int i = 1; i <= number; i ++) { // i는 1~5까지 1씩 증가
      int current = i;    // current는 i가 1일 때 1, 2일 때 2...
      for (int j = 0; j < number; j ++) {
        System.out.print(current++ + " "); //current는 i부터 1씩 증가
      }
      System.out.println();
    }
  }
}

문제9)

```java class Main{ public static void main(String[] args) { int number = 5;

for (int i = 1; i <= number; i ++) {
  int current = i;    // current는 i => i가 1이면 current도 1, 2이면 2..
  for (int j = 0; j <number; j ++) {
    if (current > number) {    
    // current가 5를 초과하면 5를 빼주기 6이면 -5해서 1, 7이면 -5해서 2...
      current -= number;
    }
    System.out.print(current++ + " ");
  }
  System.out.println();
}

} }