728x90
Java 메모리 구조 행 결과 ``` 차량 구입, 이름: K3 차량 구입, 이름: G80 차량 구입, 이름: Model Y 구매한 차량 수: 3

메소드 영역 - 클래스 정보를 보관

스택 영역 - 실제 프로그램이 실행되는 영역

힙 영역 - 객체(인스턴스)가 생성되는 영역

 

스택 구조

= 후입 선출

= LIFO

= Last In First Out

 

1 → 2 → 3 → 3 → 2 → 1 

 

큐 구조

= 선입 선출

= FIFO

= First In First Out

 

1 → 2 → 3 → 1 → 2 → 3 

 

 

 

스택 영역

 

● 자바는 스택 영역을 사용해서 메소드 호출과 지역 변수(매개변수 포함)를 관리함

  메소드를 계속 호출하면 스택 프레임이 계속 쌓임

  지역 변수(매개변수 포함)는 스택 영역에서 관리함

  스택 프레임이 종료되면 지역 변수도 함께 제거됨

  스택 프레임이 모두 제거되면 프로그램도 종료됨

 


Static 변수

Static을 사용하면 공용으로 함께 사용하는 변수를 만들 수 있다.

 

package static1;

public class Data3 {
    public String name; // 인스턴스 변수
    public static int count; // static이 붙으면 static변수, 정적변수, 클래스 변수라고 한다

    public Data3(String name){
        this.name=name;
        count++;
    }
}
package static1;

public class DataCountMain3 {
    public static void main(String[] args) {
        Data3 data1 = new Data3("A");
        System.out.println("A count="+Data3.count);

        Data3 data2 = new Data3("B");
        System.out.println("B count="+Data3.count);

        Data3 data3 = new Data3("C");
        System.out.println("C count="+Data3.count);
    }
}

 

 

 

 

필드의 종류

 

인스턴스 변수 - Static이 붙지 않은 멤버 변수

→ 인스턴스 변수는 인스턴스를 만들 때마다 새로 만들어진다

→ 인스턴스를 생성해야 사용이 가능하다

 

  클래스 변수(=Static변수, 정적변수) - Static이 붙은 변수

→ Java를 시작할 때 딱 1개가 만들어진다, 여러 곳에 공유할 목적으로 사용된다

→ static이 붙은 멤버 변수는 인스턴스와 무관하게 클래스에 바로 접근해서 사용할 수 있고, 클래스 자체에 소속되어 있다.      그래서 클래스 변수라고 한다

 


Static 메소드

package static2;

public class DecoData {

    private int instanceValue;
    private static int staticValue;

    public static void staticCall(){
        //instanceValue++; //인스턴스 변수 접근 불가 , 컴파일 에러
        //instanceMethod();//인스턴스 메소드 접근 불가, 컴파일 에러

        staticValue++; // 정적 변수 접근
        staticMethod(); // 정적 메소드 접근
    }

    public void instanceCall(){
        instanceValue++; // 인스턴스 변수 접근
        instanceMethod(); // 인스턴스 메소드 접근

        staticValue++; // 정적 변수 접근
        staticMethod(); // 정적 메소드 접근

    }

    private void instanceMethod(){
        System.out.println("instanceValue="+instanceValue);
    }
    private static void staticMethod(){
        System.out.println("ststicValue="+ staticValue);
    }
}
package static2;

public class DecoDataMain {
    public static void main(String[] args) {
        System.out.println("1. 정적 호출");
        DecoData.staticCall();

        System.out.println("2. 인스턴스 호출1");
        DecoData data1 = new DecoData();
        data1.instanceCall();

        System.out.println("3. 인스턴스 호출1");
        DecoData data2 = new DecoData();
        data2.instanceCall();
    }
}
---------------------------------------------

1. 정적 호출
ststicValue=1
2. 인스턴스 호출1
instanceValue=1
ststicValue=2
3. 인스턴스 호출1
instanceValue=1
ststicValue=3

 

 

 

Static import

package static2;

import static static2.DecoData.staticCall;
//import static static2.DecoData.*;


public class DecoDataMain {
    public static void main(String[] args) {
        System.out.println("1. 정적 호출");
        staticCall();
        staticCall();
        staticCall();

 

 

main() 메소드는 정적 메소드!

 

정적 메소드는 같은 클래스 내부에서 정적 메소드만 호출할 수 있다.

 

 


예시)

다음 코드를 참고하여 Class 작성하기

package static2.ex;

public class CarMain {
 	public static void main(String[] args) {
        
 	Car car1 = new Car("K3");
 	Car car2 = new Car("G80");
	Car car3 = new Car("Model Y");
            
            
 	Car.showTotalCars(); //구매한 차량 수를 출력하는 static 메서드
           
 }
}

 

실행결과

차량 구입, 이름: K3

차량 구입, 이름: G80

차량 구입, 이름: Model Y

구매한 차량 수: 3

 

package static2.ex;

public class Car {

    private static int totalCars;
    private String name;

    public Car(String name){
        System.out.println("차량 구입, 이름:"+name);
        this.name=name;
    }

    public static void showTotalCars() {
        System.out.println("구매한 차량 수: "+totalCars);
    }
}

 

 

 

 

예시) 수학 유틸리티 클래스

실행 코드

package static2.ex;
public class MathArrayUtilsMain {
    
    public static void main(String[] args) {
        
        int[] values = {1, 2, 3, 4, 5};
        
        System.out.println("sum=" + MathArrayUtils.sum(values));
        System.out.println("average=" + MathArrayUtils.average(values));
        System.out.println("min=" + MathArrayUtils.min(values));
        System.out.println("max=" + MathArrayUtils.max(values));
    }
}

package static2.ex;

public class MathArrayUtils {
    private MathArrayUtils() {
        //인스턴스생성을 private로 막기
    }

    public static int sum(int[] values) {
        int total = 0;
        for (int value : values) {
            total += value;
        }
        return total;
    }

    public static double average(int[] values) {
        return (double) sum(values) / values.length;
    }


    public static int min(int[] values) {
        int minValue = values[0];
        for (int value : values) {
            if (value < minValue) {
                minValue = value;
            }

        }
        return minValue;
    }


    public static int max(int[] values) {
        int maxValue = values[0];
        for (int value : values) {
            if (value > maxValue) {
                maxValue = value;
            }
        }
        return maxValue;
    }
}
package static2.ex;

import static static2.ex.MathArrayUtils.*;

public class MathArrayUtilsMain {

    public static void main(String[] args) {

        int[] values = {1, 2, 3, 4, 5};

        System.out.println("sum=" + sum(values));
        System.out.println("average=" + average(values));
        System.out.println("min=" + min(values));
        System.out.println("max=" + max(values));
    }
}
728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] 상속★  (1) 2024.03.05
[JAVA] Final 변수  (0) 2024.03.05
[JAVA] 접근 제어자  (0) 2024.03.03
[JAVA] 패키지  (0) 2024.03.02
[JAVA] 생성자  (0) 2024.03.02
728x90

해당 클래스 외부에서 특징필드나 메서드에 접근하는 것을 허용 or 제한이 가능

 

접근 제어자의 종류

● Private - 모든 외부 호출을 막음

● Default(package-private) - 같은 패키지 안에서 호출은 허용

● Protected - 같은 패키지 안에서 호출은 허용, 패키지가 달라도 상속 관계의 호출은 허용

● Public - 모든 외부 호출을 허용

 

◎ private > default > protected > public

 

 

접근제어자 - 필드, 메소드

 

예시)

package access.a;

public class AccessData {
    public int publicField;
    int defaultField;
    private int privateField;
    public void publicMethod() {
        System.out.println("publicMethod 호출 "+ publicField);
    }
    void defaultMethod() {
        System.out.println("defaultMethod 호출 " + defaultField);
    }
    private void privateMethod() {
        System.out.println("privateMethod 호출 " + privateField);
    }
    public void innerAccess() {
        System.out.println("내부 호출");
        publicField = 100;
        defaultField = 200;
        privateField = 300;
        publicMethod();
        defaultMethod();
        privateMethod();
    }
}
package access.a;

public class AccessInnerMain {
    public static void main(String[] args) {
    
        AccessData data = new AccessData();
        
        //public 호출 가능
        data.publicField = 1;
        data.publicMethod();
    
    	//같은 패키지 default 호출 가능
        data.defaultField = 2;
        data.defaultMethod();
       
       	//private 호출 불가
        //data.privateField = 3;
        //data.privateMethod();
          data.innerAccess();
    }
}
package access.b;

import access.a.AccessData;

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

        AccessData data = new AccessData();

        //public 호출 가능
        data.publicField = 1;
        data.publicMethod();

        //다른 패키지 default 호출 불가
        //data.defaultField = 2;
        //data.defaultMethod();

        //private 호출 불가
        //data.privateField = 3;
        //data.privateMethod();

        data.innerAccess();
    }
}

 

 

접근 제어자 - 클레스 레벨

public, default 만 사용이 가능하다 

 

publie 클래스는 반드 시 파일명과 이름이 같아야한다.

하나의 자바 파일에 public 클래스하나만 등장 가능

하나의 자바 파일에 default 접근 제어자를 사용하는 클래스는 무한정 생성 가능

 

예시)

package access.a;

public class PublicClass {
    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();
        DefaultClass1 class1 = new DefaultClass1();
        DefaultClass2 class2 = new DefaultClass2();

    }
}

class DefaultClass1{

}

class DefaultClass2{
    
}

 

예시) 같은패키지! 접근 가능!

package access.a;

public class PublicClassInnerMain {
    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();
        DefaultClass1 class1 = new DefaultClass1();
        DefaultClass2 class2 = new DefaultClass2();
    }
}

 

예시) 다른패키지! 접근 불가!

package access.b;

import access.a.PublicClass;

public class PublicClassOuter {

    public static void main(String[] args) {
        PublicClass publicClass = new PublicClass();

        //다른 패키지 접근 불가
        DefaultClass1 class 1 = new DefaultClass1();
        
    }
}

 

 

 

캡슐화(Encapsulation)

속성과 기능을 하나로 묶고, 외부에 꼭 필요한 기능만 노출하고 나머지는 모두 내부로 숨기는 것

 

 

1. 데이터(속성)를 숨긴다

2. 기능을 숨긴다 

 

예시)

package access;

public class BankAccount {

    private int balance;
    public BankAccount() {
        balance = 0;

}


    // public 메서드: deposit
    public void deposit(int amount) {
        if (isAmountValid(amount)) {
            balance += amount;
        } else {
            System.out.println("유효하지 않은 금액입니다.");
        }
    }


    // public 메서드: withdraw
    public void withdraw(int amount) {
        if (isAmountValid(amount) && balance - amount >= 0) {
            balance -= amount;
        } else {
            System.out.println("유효하지 않은 금액이거나 잔액이 부족합니다.");
        }
    }


    // public 메서드: getBalance
    public int getBalance() {
        return balance;
    }


    // private 메서드: isAmountValid
    private boolean isAmountValid(int amount) {
        // 금액이 0보다 커야함
        return amount > 0;
    }
}

 

package access;

public class BankAccountMain {

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(10000);
        account.withdraw(3000);
        System.out.println("balance = " + account.getBalance());
    }
}

 

 

 

 

예시)쇼핑카트

package access.ex;

public class Item {

    private String name;
    private int price;
    private int quantity;

    public Item(String name, int price, int quantity){
        this.name=name;
        this.price=price;
        this.quantity=quantity;
    }

    public String getName(){
        return name;

    }

    public int getTotalPrice(){
        return price*quantity;

    }
}
package access.ex;

public class ShoppingCart {
    private Item[] items = new Item[10];
    private int itemCount;

    public void addItem(Item item){
        //검증로직
        if(itemCount >= items.length){
            System.out.println("장바구니가 가득 찼습니다.");
            return;
        }
        //실행로직
        items[itemCount] = item;
        itemCount++;
    }

    public void displayItems() {
        System.out.println("장바구니 상품 출력");
        for(int i = 0;i<itemCount; i++){
            Item item = items[i];
            System.out.println("상품명 : "+item.getName()+", 합계: "+item.getTotalPrice());
        }
        System.out.println("전체 가격 합 : "+calculateTotalPrice());
    }

    private int calculateTotalPrice() {
        int totalPrice = 0;
        for (int i = 0; i < itemCount; i++) {
            Item item = items[i];
            totalPrice += item.getTotalPrice();
        }
        return totalPrice;

        }
    }
package access.ex;

public class ShoppingCartMain {

    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();

        Item item1 = new Item("마늘", 2000, 2);
        Item item2 = new Item("상추", 3000, 4);


        cart.addItem(item1);
        cart.addItem(item2);

        cart.displayItems();

    }
}
728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] Final 변수  (0) 2024.03.05
[JAVA] Static  (0) 2024.03.04
[JAVA] 패키지  (0) 2024.03.02
[JAVA] 생성자  (0) 2024.03.02
[JAVA] 절차 지향 프로그래밍  (0) 2024.03.02
728x90

Import

코드에서 첫 줄에는 package를 사용하고, 다음 줄에는 import를 사용할 수 있다

import를 사용하면 다른 패키지에 있는 클래스를 가져와 사용이 가능, 그 덕분에 코드에서 패키지 명을 생략하고 클래스 이름만 적으면 된다.

ps) 특정 패키지에 포함된 모든 클래스를 사용하고 싶으면 * 을 사용하면 된다

package pack;

import pack.a.*; //pack.a의 모든 클래스 사용

	public class PackageMain2 {

	 public static void main(String[] args) {
 
 		Data data = new Data();
		User user = new User(); //import 사용으로 패키지 명 생략 가능
	 }
}

 

 

클래스 이름 중복

 

같은 이름의 클래스가 있다면 import는 n개 중 하나만 선택하여 작성해야 하고, 자주 사용하는 것을 import 하고 나머지는 패키지를 포함한 전체경로를 작성해 주면 된다

 

 

패키지 규칙

● 패키지 이름은 모두 소문자 ( 관례상 )

패키지 이름 앞부분은 일반적으로 회사의 도메인 이름을 거꾸로 사용 (관례상)

   cf) com.tistory.harrykang

패키지 이름과 위치는 디렉토리 위치와 동일해야함

728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] Static  (0) 2024.03.04
[JAVA] 접근 제어자  (0) 2024.03.03
[JAVA] 생성자  (0) 2024.03.02
[JAVA] 절차 지향 프로그래밍  (0) 2024.03.02
[JAVA] 변수와 초기화  (0) 2024.03.01
728x90

This

멤버 변수와 메소드의 매개변수 이름이 같다면 어떻게 구분하는가?

> 멤버 변수보다 매개변수가 코드가 블럭의 { } 의 더 안쪽에 있기 떄문에 매개변수가 우선순위를 가짐

> 멤버 변수에 접근하려면 앞에 this. 이라고 쓰면된다, this는 인스턴스 자신의 참조값을 가진다.

 

생략도 가능함

> 변수를 찾을때 가까운 지역변수를 먼저 찾고 없으면 그 다음으로 멤버 변수를 찾음.

  그러나 멤버 변수도 없다면 에러 발생

 

예시)

pacakage construct;

public class MemberThis {

 	String nameField;
    
 	void initMember(String nameParameter) {
 	nameField = nameParameter;
    //(this.)nameField =nameParameter;
 }
}

 

 

생성자

생성자의 이름은 클래스 이름과 같아야한다 (첫글자도 대문자)
생성자는 반환타입이 없다
나머지는 메소드와 동일하다

 

예시)

package construct;

public class MemberConstruct {

    String name;
    int age;
    int grade;

    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name="+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade=grade;
    }
}

 

 

이 부분이 바로 생성자이다

package construct;

public class ConstructMain1 {
    public static void main(String[] args) {
        MemberConstruct member1 = new MemberConstruct("user1",15,90);
        MemberConstruct member2 = new MemberConstruct("user2",16,80);

        MemberConstruct[] members = {member1, member2};

        for (MemberConstruct member : members) {
            System.out.println("이름: "+ member.name+"나이: "+member.age+"성적: "+member.grade);


        }

    }
}

 

생성자는 객체를 생성할 때 직접 정의한 생성자가 있다면 직접 정의한 생성자를 반드시 호출해야 한다 는 점이다

ps) 생성자를 메소드 오버로딩 처럼 여러개 정의할 수 있는데, 이 경우는 하나만 호출 된다.

 

 

 

 

기본생성자

 

매개변수가 없는 생성자

클래스에 생성자가 하나도 없으면 자바 컴파일러는 매개변수가 없고, 작동하는 코드가 없는 기본 생성자를 자동으로 만듦

생성자가 하나라도 있으면 자바는 생성자를 만들지 않음

 

예시)

package construct;

public class MemberDefault {
    String name;

//-----------------------------------
// 생성자를 직접 정의
//   public MemberDefault(){
//      System.out.println("생성자 호출");
    }
}
package construct;

public class MemberDefatulMain {
    public static void main(String[] args) {
        MemberDefault memberDefault = new MemberDefault();

    }
}

 

 

생성자 오버로딩과 This

예시)

package construct;

public class MemberConstruct {

    String name;
    int age;
    int grade;

    //추가
    MemberConstruct(String name, int age){
        this.name=name;
        this.age=age;
        this.grade=50;
    }


    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name="+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade=grade;
    }
}
package construct;

public class ConstructMain2 {
    public static void main(String[] args) {
        MemberConstruct member1 = new MemberConstruct("user1",15,90);
        MemberConstruct member2 = new MemberConstruct("user2",16);

        MemberConstruct[] members = {member1, member2};

        for (MemberConstruct member : members) {
            System.out.println("이름: "+ member.name+"나이: "+member.age+"성적: "+member.grade);


        }

    }
}
생성자 호출 name=user1, age=15, grade=90
이름: user1나이: 15성적: 90
이름: user2나이: 16성적: 50

 

 

this()를 사용하기

package construct;

public class MemberConstruct {

    String name;
    int age;
    int grade;

    MemberConstruct(String name, int age){
        this(name, age, 50);//변경
    }


    MemberConstruct(String name, int age, int grade){
        System.out.println("생성자 호출 name="+name+", age="+age+", grade="+grade);
        this.name=name;
        this.age=age;
        this.grade=grade;
    }
}

 

this() 는 생성자 코드의 "첫줄에만"  작성이 가능하다 

 

 

예시 ) Book

 

package construct.ex;

	public class Book {
    
		 String title; //제목
		 String author; //저자
		 int page; //페이지 수

}
package construct.ex;
	public class BookMain {
	 public static void main(String[] args) {
 	
    // 기본 생성자 사용
 	Book book1 = new Book();
 	book1.displayInfo();
 	
    // title과 author만을 매개변수로 받는 생성자
 	Book book2 = new Book("Hello Java", "Seo");
 	book2.displayInfo();
 
 	// 모든 필드를 매개변수로 받는 생성자
	 Book book3 = new Book("JPA 프로그래밍", "kim", 700);
 	book3.displayInfo();
   }
}

 

 

예시1) 생성자를 이용하여 클래스 완성

package construct.ex;

	public class Book {
    
	 String title;
	 String author;
	 int page;
 	
    // 기본생성자
	 Book() {
 		 this("", "", 0);
	 }
     
 	// title과 author만을 매개변수로 받는 생성자
 	Book(String title, String author) {
 		this(title, author, 0);
 	}
    
 	// 모든 필드를 매개변수로 받는 생성자
	 Book(String title, String author, int page) {
 		this.title = title;
 		this.author = author;
  	  this.page = page;
	 }
     
     
	 void displayInfo() {
 		System.out.println("제목: " + title + ", 저자: " + author + ", 페이지: " + page);
	 }
}

 

728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] 접근 제어자  (0) 2024.03.03
[JAVA] 패키지  (0) 2024.03.02
[JAVA] 절차 지향 프로그래밍  (0) 2024.03.02
[JAVA] 변수와 초기화  (0) 2024.03.01
[JAVA] 기본형, 참조형/ Method 호출  (0) 2024.03.01
728x90

프로그래밍 방식

● 절자 지향 프로그래밍

● 객체 지향 프로그래밍

 

 

구분

● 절차 지향 프로그래밍 [데이터와 해당 데이터에 대한 처리 방식이 분리되어 있음]

- 실행 순서를 중요하게 여김

- 프로그램의 흐름을 순차적으로 따르며 처리함

- " 어떻게"를 중심으로 프로그래밍함

 

●객체 지향 프로그래밍 [데이터와 그 데이터에 대한 행동(메소드)이 하나의 "객체"안에 포함되어 있음]

- 객체를 중요하게 생각하는 방식

- 실제 세계의 사물이나 사건을 객체로 판단하여 이러한 객체들 간의 상호작용을 중심으로 프로그래밍 하는 방법

- "무엇을"을 중심으로 프로그래밍

객체 - 물리적으로 존재하거나 개념적인 것 중에서 다른 것과 식별 가능한 것

cf)
사람
속성 - 이름, 나이 등 = 필드 
동작 - 웃다, 걷다 = 메소드

자동차
속성 - 색상, 속도
동작 - 엑셀, 브레이크, 문열고 닫기

게임 캐릭터
속성 - 레벨, 경험치, 소지한 아이템
동작 - 이동, 공격, 아이템 획득

 

절차 지향 프로그래밍

 

예시)

package oop1;

public class MusicPlayerMain1 {
	
	public static void main(String[] args) {
		
		int volume = 0;
		boolean isOn = false;
		
		//음악플레이어 켜기
		isOn = true;
		System.out.println("음악 플레이어를 시작합니다");
		
		//볼륨 증가
		volume++;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//볼륨 증가
		volume++;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//볼륨 감소
		volume--;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//플레이어 상태
		System.out.println("음악 플레이어 상태 확인: ");
		if(isOn) {
			System.out.println("음악 플레이어 상태 확인 : 켜짐"+volume);
		} else {
			System.out.println("음악 플레이어 상태 확인 : 꺼짐");			
		}
		
		//플레이어 끄기
		isOn = false;
		System.out.println("음악 플레이어를 종료합니다");
		
		
		
	}
}

 

 

예시-1)

MusicPlayerData라는 클래스를 만들어 다양한 변수들이 추가되더라도 쉽게 구분이 가능함

package oop1;

	public class MusicPlayerData {
 		int volume = 0;
		boolean isOn = false;
}
package oop1;

public class MusicPlayerMain1 {
	
	public static void main(String[] args) {
		
		MusicPlayerData data = new MusicPlayerData();
		
		
		//음악플레이어 켜기
		data.isOn = true;
		System.out.println("음악 플레이어를 시작합니다");
		
		//볼륨 증가
		data.volume++;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//볼륨 증가
		data.volume++;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//볼륨 감소
		data.volume--;
		System.out.println("음악 플레이어 볼륨: " + volume);
		
		//플레이어 상태
		System.out.println("음악 플레이어 상태 확인: ");
		if(data.isOn) {
			System.out.println("음악 플레이어 상태 확인 : 켜짐"+volume);
		} else {
			System.out.println("음악 플레이어 상태 확인 : 꺼짐");			
		}
		
		//플레이어 끄기
		data.isOn = false;
		System.out.println("음악 플레이어를 종료합니다");
		
		
		
	}
}

 

예시-2)

각각의 기능 모듈화를 통해 최적화

package oop1;

public class MusicPlayerMain3 {
    public static void main(String[] args) {
        MusicPlayerData data = new MusicPlayerData();
        //음악 플레이어 켜기
        on(data);
        //볼륨 증가
        volumeUp(data);
        //볼륨 증가
        volumeUp(data);
        //볼륨 감소
        volumeDown(data);
        //음악 플레이어 상태
        showStatus(data);
        //음악 플레이어 끄기
        off(data);
    }
    static void on(MusicPlayerData data) {
        data.isOn = true;
        System.out.println("음악 플레이어를 시작합니다");
    }
    static void off(MusicPlayerData data) {
        data.isOn = false;
        System.out.println("음악 플레이어를 종료합니다");
    }
    static void volumeUp(MusicPlayerData data) {
        data.volume++;
        System.out.println("음악 플레이어 볼륨:" + data.volume);
    }
    static void volumeDown(MusicPlayerData data) {
        data.volume--;
        System.out.println("음악 플레이어 볼륨:" + data.volume);
    }
    static void showStatus(MusicPlayerData data) {
        System.out.println("음악 플레이어 상태 확인");
        if (data.isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + data.volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }
    }
}

 

 

 

클래스와 메소드

클래스는 속성(데이터, 멤버 변수)과 기능(메소드)을 정의할 수 있다

.

객체는 자신의메소드를 통해 자신의 멤버 변수에 접근할 수 있다

 객체의메소드 내부에서 접근하는 멤버 변수는 객체 자신의 멤버 변수이다

 

 

 

객체 지향 프로그래밍

프로그램의 실행 순서보다는 클래스를 만드는것에 집중해야한다!

 

예시) MusicPlayer 클래스에 음악 플레이어에 필요한 속성과 기능을 모두 정의

package oop1;

public class MusicPlayer {

    int volume = 0;
    boolean isOn = false;

    void on() {
        isOn = true;
        System.out.println("음악 플레이어를 시작합니다");
    }

    void off() {
        isOn = false;
        System.out.println("음악 플레이어를 종료합니다");
    }

    void volumeUp() {
        volume++;
        System.out.println("음악 플레이어 볼륨:" + volume);
    }

    void volumeDown() {
        volume--;
        System.out.println("음악 플레이어 볼륨:" + volume);
    }

    void showStatus() {
        System.out.println("음악 플레이어 상태 확인");
        if (isOn) {
            System.out.println("음악 플레이어 ON, 볼륨:" + volume);
        } else {
            System.out.println("음악 플레이어 OFF");
        }

    }
}

 

예시-1)  객체를 생성하고 필요한 기능(메서드)을 호출

package oop1;

public class MusicPlayerMain4
{
    public static void main(String[] args) {
        MusicPlayer player = new MusicPlayer();

        //음악 플레이어 켜기
        player.on();
        //볼륨 증가
        player.volumeUp();
        //볼륨 증가
        player.volumeUp();
        //볼륨 감소
        player.volumeDown();
        //음악 플레이어 상태
        player.showStatus();
        //음악 플레이어 끄기
        player.off();

    }
}

 

 

캡슐화(=Emcapsulation)

속성과 기능을 하나로 묶어서 필요한 기능을 메소드를 통해 외부에 제공하는 것!

 

정보은닉을 위해서 / 접근 제한자(private, dafault, public)를 사용함

 

 

 

 

 

절차 지향 직사각형 프로그램을 객체 지향으로 변경하기

 

예시)

절차 지향 직사각형 프로그램

package oop.ex;
public class RectangleProceduralMain {
    public static void main(String[] args) {
        int width = 5;
        int height = 8;
        int area = calculateArea(width, height);
        System.out.println("넓이: " + area);
        int perimeter = calculatePerimeter(width, height);
        System.out.println("둘레 길이: " + perimeter);
        boolean square = isSquare(width, height);
        System.out.println("정사각형 여부: " + square);
    }
    static int calculateArea(int width, int height) {
        return width * height;
    }
    static int calculatePerimeter(int width, int height) {
        return 2 * (width + height);
    }
    static boolean isSquare(int width, int height) {
        return width == height;
    }
}

 

예시1)  객체 지향 직사각형 프로그램으로 변경

package oop1;

public class Rectangle {
    int width;
    int height;

    int calculateArea(){
        return width * height;
    }

    int calculatePerimeter(){
        return 2 * (width * height);
    }

    boolean isSquare(){
        return width == height;
    }
}
package oop1;

public class RectangleOopMain {

    public static void main(String[] args) {

        Rectangle rectangle = new Rectangle();
        rectangle.width = 5;
        rectangle.height = 8;

        int area = rectangle.calculateArea();
        System.out.println("넓이: " + area);

        int perimeter = rectangle.calculatePerimeter();
        System.out.println("둘레 길이: " + perimeter);

        boolean square = rectangle.isSquare();
        System.out.println("정사각형 여부: " + square);
    }
}

 

 

예시) 은행 계좌 객체 지향 프로그램으로 만들기

조건;
Account 클래스 생성
AccountMain 클래스 생성 후 main() 메소드를 통해 프로그램 작성

 

 

package ref.ex;

public class AccountMain {

    public static void main(String[] args) {
        Account account = new Account();
        account.deposit(10000);
        account.withdraw(9000);
        account.withdraw(2000); // 오류 메세지 출력
        System.out.println("잔고 : "+account.balance);
    }
}
package ref.ex;

public class AccountMain {

    public static void main(String[] args) {
        Account account = new Account();
        account.deposit(10000);
        account.withdraw(9000);
        account.withdraw(2000); // 오류 메세지 출력
        System.out.println("잔고 : "+account.balance);
    }
}
728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] 패키지  (0) 2024.03.02
[JAVA] 생성자  (0) 2024.03.02
[JAVA] 변수와 초기화  (0) 2024.03.01
[JAVA] 기본형, 참조형/ Method 호출  (0) 2024.03.01
[JAVA] 클래스와 데이터  (2) 2024.03.01
728x90
  멤버변수 (field variable) 지역변수 (location variable)
구분 클래스에서 선언 메소드에 선언,
매개변수도 지역변수의 한 종류
변수 값 초기화 자동 초기화,
개발자가 초기값 직접 지정 가능
수동 초기화

 

 

 

Null = (참조 하지 않음!)

 

null 값 할당

package ref;

public class Data {
    int value;
}
package ref;

public class NullMain1 {
    public static void main(String[] args) {
        Data data = null;
        System.out.println("1. data = "+data);
        data = new Data();
        System.out.println();
        System.out.println("2. data = "+data);
        data= null;
        System.out.println("3. data = "+data);
    }
}

 

 

NullPointerException

참조값 없이 객체를 찾아가면 NullPointerException 이라는 예외가 발생

이때 발생하는 예외는 null , 즉 없다는 뜻이다

 

객체를 참조할 때는 .을 사용하는데 참조값이 null 이라면 값이 없다는 뜻이므로, 찾아갈 수 있는 인스턴스(객체)가 없는것이다

NullPointerException은 이처럼 null에 .을 찍었을 때 발생된다

 

 

 

 

 

 

종합 예시)

package ref.ex;

public class ProductOrder {
    String productname;
    int price;
    int quantity;

}

 

기본정보) 저번에 사용했던 상품주문

package class1.ex;

public class ProductOrderMain {

    public static void main(String[] args) {
        ProductOrder orders[] = new ProductOrder[3];

        ProductOrder order1 = new ProductOrder();
        order1.productname = "두부";
        order1.price = 2000;
        order1.quantity = 2;
        orders[0] = order1;


        ProductOrder order2 = new ProductOrder();
        order2.productname = "김치";
        order2.price = 5000;
        order2.quantity = 1;
        orders[1] = order2;


        ProductOrder order3 = new ProductOrder();
        order3.productname = "콜라";
        order3.price = 1500;
        order3.quantity = 2;
        orders[2] = order3;

        int totalAmount = 0;
        for (ProductOrder order : orders) {
            System.out.println("상품명: "+order.productname+", 가격: "+order.price+", 수량: "+order.quantity);
        totalAmount += order.price*order.quantity;
        }

        System.out.println("총 결제 금액: "+totalAmount);
    }
}

 

응용 ) 배열을 사용하여 최적화

package ref.ex;

public class ProductOrderMain2 {

    public static void main(String[] args) {



        ProductOrder orders[] = new ProductOrder[3];

        orders[0] = createOrder("두부", 2000, 2);
        orders[1] = createOrder("김치", 5000, 1);
        orders[2] = createOrder("콜라", 1500, 2);

        printOrders(orders);
        int totalAmount = getTotalAmount(orders);
        System.out.println("총 결제 금액: " + totalAmount);
    }

    static ProductOrder createOrder(String productName, int price, int quantity) {
        ProductOrder order = new ProductOrder();
        order.productname = productName;
        order.price = price;
        order.quantity = quantity;
        return order;
    }

    static void printOrders(ProductOrder[] orders) {
        for (ProductOrder order : orders) {
            System.out.println("상품명: " + order.productname + ", 가격: " + order.price + ", 수량: " + order.quantity);

        }
    }
    static int getTotalAmount(ProductOrder[] orders){
        int totalAmount = 0;
        for (ProductOrder order : orders) {
            totalAmount += order.price*order.quantity;

        }
        return totalAmount;
    }
}

 

 

응용2) 입력값을 받아서 정보를 입력

package ref.ex;

import java.util.Scanner;

public class ProductOrderMain3 {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("입력할 주문의 개수를 입력하세요: ");
        int n = scanner.nextInt();
        scanner.nextLine();

        ProductOrder orders[] = new ProductOrder[n];
        for(int i = 0; i < orders.length; i++){
            System.out.println((i+1)+"번째 주문 정보를 입력하세요: ");

            System.out.print("상품명: ");
            String productName = scanner.nextLine();
            System.out.print("가격: ");
            int price = scanner.nextInt();
            System.out.print("수량: ");
            int quantity = scanner.nextInt();
            scanner.nextLine();

            orders[i] = createOrder(productName, price, quantity);
        }

        printOrders(orders);
        int totalAmount = getTotalAmount(orders);
        System.out.println("총 결제 금액: " + totalAmount);
    }

    static ProductOrder createOrder(String productName, int price, int quantity) {
        ProductOrder order = new ProductOrder();
        order.productname = productName;
        order.price = price;
        order.quantity = quantity;
        return order;
    }

    static void printOrders(ProductOrder[] orders) {
        for (ProductOrder order : orders) {
            System.out.println("상품명: " + order.productname + ", 가격: " + order.price + ", 수량: " + order.quantity);

        }
    }
    static int getTotalAmount(ProductOrder[] orders){
        int totalAmount = 0;
        for (ProductOrder order : orders) {
            totalAmount += order.price*order.quantity;

        }
        return totalAmount;
    }
}
728x90

'Language > JAVA' 카테고리의 다른 글

[JAVA] 생성자  (0) 2024.03.02
[JAVA] 절차 지향 프로그래밍  (0) 2024.03.02
[JAVA] 기본형, 참조형/ Method 호출  (0) 2024.03.01
[JAVA] 클래스와 데이터  (2) 2024.03.01
[JAVA] 메소드(Mathod)  (0) 2024.02.29

+ Recent posts