Java 기본 문법 복습

Dec 27, 2023

자바의 자료형

자료형	설명	크기(바이트)	범위
int	부호있는 정수	4바이트	21억까지
long	부호있는 정수	8바이트	경까지
double	부동소수점형	8바이트	21억까지
char	문자형	2바이트	ㅤ
boolean	논리형	1비트	true(1) or false(0)

String은 char의 배열

var : 모든 타입을 다 받을 수 있음

형 변환

형 변환 : 다른 자료형으로 변환

묵시적 형변환 : 큰 걸 바라봄

예시) int를 string으로 변환

n+””에서 +는 결합 연산자

명시적 형변환 : 다운 캐스팅

💡

상속) 다형성 → 자식을 부모에게 넣는 것은 가능

부모를 자식에게 넣으려면 다운 캐스팅 해야 함

스캐너

Scanner : 키보드로 값을 입력받을 수 있음

형태 : Scanner 변수명 = new Scanner(System.in);

변수 = 변수명.next자료형(); // 변수에 입력받은 값 집어넣기

산술 연산자, 관계 연산자, 논리 연산자

산술 연산자 : +(더하기), -(빼기), *(곱하기), /(몫), %(나머지)

x++ : x=x+1

관계 연산자 : ==, !=, >, <, >=, <=

논리 연산자 : &&(and), ||(or), !(not)

if문

1줄 일 때 {} 생략 가능

걸러낼 땐 else 사용 안함

참 혹은 거짓 같은 경우에는 else 사용

형태 : if(){} 메서드는 아니나 메모리 구조는 동일 → 큐, 스택 생성

💡

{} → 큐, 스택 생성

스택의 생명주기 : 메인 큐가 끝날 때까지


package ex03;

import java.util.Scanner;

public class EvenOdd {
    public static void main(String[] args) {
        int number; // mian에 뜸 -> main 스택은 4Byte
        Scanner sc = new Scanner(System.in); // sc는 main 스택, Scanner는 힙에 뜸
        System.out.println("정수를 입력하시오: ");

        number = sc.nextInt();

        if(number % 2 == 0){
            System.out.println("짝수");
        } else{
            System.out.println("홀수");
        }
    }
}

if문이 참일 때 스택이 열림

if문 안에는 main 스택의 모든 것 사용 가능

if문 안에 변수 → 지역 변수

지역변수는 if 스택 안에 들어오고 main에서 사용 불가

for문과 while문

for문 : 끝을 알 수 있을 때 사용

while문 : 끝을 알 수 없을 때 사용

스코프 : 메모리에 떠 있는 기간

static 사용시) 클래스명.변수명

heap 사용시) heap의 변수(stack에 있음)

💡

{}안에 만들어지면 다 스택!


package ex03;

public class ForExample1 {
    public static void main(String[] args) {
        for(int i = 0; i <5; i++){
            System.out.println("i의 값은: " + i); // 큐에 담김
        }
    }
}

for문 안에 i : 지역변수 → 스택에 저장

스택이 실행후 닫혀서 다른 곳에서 사용 불가

for문 {}안에 내용 : 큐에 담김

1) a메서드 호출 후 내부 스택이 닫히기에 heap에 있는 Dog에 접근이 불가



    public static void a() {
        Dog d1 = new Dog();
    }

    public static void b() {
        Dog d2 = new Dog();
    }

    public static void main(String[] args) {
        a();
    }

2) a 호출 후 내부 스택이 닫히기에 heap에 있는 Dog에 접근하기 위해 return 값으로 변수를 받아서 heap에 있는 Dog에 접근 가능

new Dog는 가비지 컬렌션의 대상이 됨



    public static void a() {
        Dog d1 = new Dog();
        return d1;
    }

    public static void b() {
        Dog d2 = new Dog();
    }

    public static void main(String[] args) {
        a(); // a() = d1
        b(d1);
    }

배열

벡터 : 같은 타입이 연속된 것

💡

같은 타입으로만 되어야 엑세스가 빠름

배열은 인덱스에 저장

맨 처음은 0번지

최대번지 n-1

그 이상은 오류 발생

객체

객체 : 상태와 동작을 가지고 있음 = 오브젝트

new 할 수 있으면 오브젝트

존재 가능하면 다 오브젝트

💡

클래스 : 오브젝트

오브젝트로 만들기 싫으면 추상 클래스로 만들면 됨

유틸리티 클래스

유틸리티 클래스 : 상태가 없고 행위(메서드)만 있는 경우

사용하는 기법 : 기능만 수행함

💡

객체지향 코드는 아님

예시) 계산기, 복잡한 알고리즘 수행

캡슐화

캡슐화 : 클래스와 상태를 하나로 묶음

메서드의 책임을 하나씩 만듦 → 최대한 책임을 줄여야 분리 가능

객체가 하나의 캡슐

Protected : 접근 제어자, 상속 관계에 있는 클래스에서 사용

1) Private일 때 메서드 사용


package ex03.test;

class 라면 {
    private void 물끓이기() {
    }

    private void 스프넣기() {
    }

    private void 면넣기() {
    }

    private void 계란넣기() {
    }
}

class 신라면 implements 행위 {

    private void 물끓이기() {
    }

    private void 스프넣기() {
    }

    private void 면넣기() {
    }

    private void 계란넣기() {
    }
}

public class ScopeEx02 {
    public static void main(String[] args) {
        라면 la = new 라면();
			  물끓이기();
				스프넣기();
				면넣기();
			  계란넣기();
    }
}

2) Private일 때 하나만 Public으로 열어서 사용 → 정보 은닉


package ex03.test;

interface 행위 {
    void start();
}

class 삼양라면 implements 행위 {
    private void 물끓이기() {
    }

    private void 스프넣기() {
    }

    private void 면넣기() {
    }

    private void 계란넣기() {
    }

    @Override
    public void start() {
        물끓이기();
        면넣기();
        스프넣기();
        계란넣기();
    }
}

class 신라면 implements 행위 {

    private void 물끓이기() {
    }

    private void 스프넣기() {
    }

    private void 면넣기() {
    }

    private void 계란넣기() {
    }

    @Override
    public void start() {
        물끓이기();
        스프넣기();
        면넣기();
        계란넣기();
    }
}


public class ScopeEx02 {
    public static void main(String[] args) {
        삼양라면 la = new 삼양라면();
        la.start();
        
        신라면 la2 = new 신라면();
        la2.start();
    }
}

정보 은닉

상태의 접근 제어자 : Private

메서드를 은닉시켜놓고 하나만 public으로 열어서 사용할 수 있도록 하는 것

상속, 컴포지션

상속(is 관계)

다형성이 지켜져야 함 → 자식 클래스는 부모 클래스의 모든 속성(상태)과 동작(행위)를 물려받음

다형성 : 다양하게 부를 수 있고 타입 변경이 가능

자식이 부모의 클래스의 메서드를 재정의해서 호출할 경우

💡

동적 바인딩 : 부모 메서드 무효화 자식 메서드 실행

컴포지션(has 관계)

컴포지션 : 결합

💡

잘 만들어진 클래스를 쓰고 싶을 때 필요한 객체를 상태로 가지고 있음

1) 상속


package ex06.example7;

public class Burger { //private니까 생성자 필요
    private String name;
    private int price;

    public Burger(String name, int price) { // 생성자 : 초기화
        this.name = name;
        this.price = price; // 가격 고정 -> 재사용 불가, 할인x
        System.out.println(name + "가 만들어졌어요");
    }

    //무조건 getter(상태확인) 만들기
    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }
}


package ex06.example7;

public class ShrimpBuger extends Burger{
    private String material;

    public ShrimpBuger(String name, int price, String material) {
        super(name, price);
        this.material = material;
    }

    public String getMaterial() {
        return material;
    }
}


package ex06.example7;

public class Coke {
    private String name;
    private int price;

    public Coke(String name, int price) {
        this.name = name;
        this.price = price;
        System.out.println(name + "가 만들어졌어요");
    }

    public String getName() {
        return name;
    }

    public int getPrice() {
        return price;
    }
}


package ex06.example7;

public class LotteApp {
    public static void main(String[] args) {
        Burger b1 = new Burger("기본버거", 1000); // [Burger]
        Burger b2 = new ShrimpBuger("새우버거", 2000, "새우"); // [Burger, ShrimpBuger]
        Coke c1 = new Coke("콜라", 1000);
        System.out.println();

        BurgerSet set1 = new BurgerSet(
                                new Burger("기본버거", 1000),
                                new Coke("콜라", 1000)
                        );
       /* System.out.println(set1.getBurger().getPrice());
        System.out.println(set1.getCoke().getPrice());*/
        System.out.println("총 가격은 : " + set1.getTotalPrice());
    }
}

2) 컴포지션 : 필요한 객체를 상태로 가지고 있으면 됨


package ex06.example7;

public class BurgerSet { // has : burger와 coke
    private Burger burger;
    private Coke coke; // 필요한 객체를 상태로 가지고 있으면 됨

    public BurgerSet(Burger burger, Coke coke) { // 레퍼런스 변수
        this.burger = burger;
        this.coke = coke;
        System.out.println("버거 세트가 만들어졌어요");
    }

    public int getTotalPrice(){
        return burger.getPrice() + coke.getPrice(); // this.burger, this.coke
    }

    public Burger getBurger() {
        return burger;
    }

    public Coke getCoke() {
        return coke;
    }
}

다형성

다양하게 부를 수 있는 것

타입변경 가능

추상화

추상 클래스 : 뼈대

추상화 : 공통적인 것만 끌어올리는 것

클래스

클래스 : 설계도

오버로딩

이름은 같으나 타입의 갯수가 다를 때

생성자 : 객체가 처음 만들어질 때 모든 상태값을 초기화

this

this : 인스턴스 변수를 가리킴 → 현재 객체를 가리킴

해당 메서드를 호출한 인스턴스 자신을 참조하는 데 사용

생성자가 있으면 힙에 뜸 → 객체가 만들어진 것 = new한 상태


public Circle(int radius){ // 파라미터 : 실행하는 시점에만 뜸
    this.radius = radius; // this는 힙
}

접근제어자

public : 공개할 때

private : 공개 안할 때

default : 기본값으로 아무것도 안 넣는 것 / 잘 안씀

private라서 값을 확인하고 설정하기 위해 사용

getter : 상태 확인 / 접근자 : 무조건 필요

setter : 기존 상태를 무시하고 상태 설정 / 설정자 : 필요한 것만 직접 생성

변경될 수 있는 것들만 생성

시간의 상태에 따라서 값이 변경됨


package ex03.test;


class Account {
    private int number; // 1111
    private String pw; // 8877
    private String author; // 최주호
    private int balance; // 1000

    public Account(int number, String pw, String author, int balance) {
        this.number = number;
        this.pw = pw;
        this.author = author;
        this.balance = balance;
    }

    public int getNumber() {
        return number;
    }

    public String getPw() {
        return pw;
    }
    
    
    public String getAuthor() {
        return author;
    }

    public int getBalance() {
        return balance;
    }


    public void chanagePassword(String pw){
        this.pw = pw;
    }

    public void changeAuthor(String author) {
        this.author = author;
    }

    public void deposit(int amount){
        this.balance = this.balance + amount;
    }

    public void withdraw(int amount){
        this.balance = this.balance - amount;
    }

    public void setBalance(int balance){
        this.balance = balance;
    }
}

public class ScopeEx02 {
    public static void main(String[] args) {
        // 1. 계좌생성 (2023.12.25)
        Account account = new Account(1111, "8877", "최주호", 1000);
        
        // 2. 입금 (2023.01.10) - 5000
        account.deposit(5000);
        
        // 3. 비밀번호 변경 (2023.01.20) - 9988
        account.chanagePassword("9988");
        
        // 4. 계명 - 이름 변경 (2023.02.20) - 홍길동
        account.changeAuthor("홍길동");
        
        // 5. 계좌번호변경 - 은행 - 불가능합니다.
        
        // 6. 출금 - 500원
        account.withdraw(500);
        
        // 7. 5000 원 입금
        int currentBalance = account.getBalance();
        int balance = currentBalance + 5000;
        account.setBalance(balance);
    }
}

See more posts