Java(생성자, 객체지향 패러다임)

<생성자>

객체를 생성할 때 호출죄는 특별한 유형의 메서드

객체가 올바르게 사용될 수 있도록 필요한 값들을 설정하고, 필요한 초기화 코드를 실행함.

생성자의  특징 객체 생성 시 반드시 존재해야 함. 생성자의 이름은 클래스의 이름과 동일해야함. 생성자는 반환 타입을 가지지 않으며, 심지어 void 도 사용하지 않음. 객체 생성 시 new 키워드와 함께 자동으로 호출됨. 생성자는 기본 생성자와 사용자 정의 생성자로 구분할 수 있음.

 

예시)

Student라는 class 파일

public class Student { // <- class 이름: Student
	String name;
	int number;
	int grade;
	public Student() { } // <- 기본 생성자 // <- 생성자 이름: Student
	public Student(String s, int n1, int n2) { // <- 사용자 정의 생성자(매개변수 3개)
		name = s;
		number = n1;
		grade = n2;
		showInfo();
 	}
	// 메서드 정의(멤버 변수에 의해 정의됨)
	public void showInfo() {
		System.out.println("학생의 이름은 "+ name); // name: 멤버변수
		System.out.println("학생의 번호는 " + number);
		System.out.println("학생의 학년는 " + grade);
 	}

 

메모리에 객채를 생성 한 후 class Student 에서 호출하는 Main 함수가 포함된 StudentMainTest 파일 생성하기

public static void main(String[] args) {

		Student s1 = new Student("홍길동", 101, 3);
        // 메모리에 올리고 호출함.
		Student s2 = new Student("이순신", 102, 2);
        
        //  변수에 직접 접근(. 연산자를 사용)해서 값을 초기화하기
		Student s3 = new Student();
		s3.name = "야스오";
		s3.number  = 103;
		s3.grade = 1;
}

 

 

<기본 생성자>

• 클래스에는 반드시 적어도 하나 이상의 생성자가 존재함.
• 클래스에 생성자를 구현하지 않아도 new 키워드와 함께 생성자를 호출할 수 있음.
• 컴파일러가 .class 파일을 만들때 클래스에 (사용자 정의) 생성자가 하나도 없다면 자동으로  기본 생성자를 넣어준다.
• 생성자는 여러개 만들 수 있음.(이를 생성자 오버로딩이라함)(위의 코드는 생성자가 2개임)

publc User() { }

 

 

< 사용자 정의 생성자>

• 매개변수가 있는 생성자
• 객체 생성 시 특정 값으로 초기화 가능함.
• 선언 시 컴파일러는 기본 생성자를 제공하지 않음.
• 클래스 설계자가 인스턴스화 했을 때 정상적으로 동작해야 하는 초기값들이 필요하다면 강제성을 부여하는 것 

 

 

 

<객체지향 패러다임>

객체지향 패러다임(Object-Oriented Paradigm)은 소프트웨어를 설계하고 구현하는 방법론 중 하나로, 실세계의 객체를 모델링하여 소프트웨어의 복잡성을 관리하고 코드의 재사용성을 높이는 데 중점을 둡니다. 이 패러다임의 핵심은 프로그램을 상호작용하는 객체들의 집합으로 보고, 각 객체는 자신의 데이터와 행위를 갖는 독립적인 엔티티로 취급하는 것입니다.

 

객체지향 패러다임의 주요 원칙 캡슐화(Encapsulation): 객체는 데이터(변수)와 그 데이터를 조작하는 함수(메서드)를 하나로 묶습니다. 이를 통해 데이터 구조와 데이터를 조작하는 방법을 결합하여 데이터의 추상화를 가능하게 하고, 외부에서의 직접적인 접근을 제한합니다. 상속(Inheritance): 이미 작성된 클래스(부모 클래스)의 특성을 물려받아서 새로운 클래스(자식 클래스)를 생성( 코드의 재사용성을 높이고, 중복을 줄이며, 유지 보수가 쉬움) 다형성(Polymorphism): 하나의 메서드나 클래스가 다양한 방식으로 동작하는 능력을 말합니다. 오버라이딩(Overriding)과 오버로딩(Overloading)은 다형성을 구현하는 일반적인 방법입니다. 추상화(Abstraction): 복잡한 현실의 개체를 단순화된 모델로 표현하는 것으로, 핵심적인 개념 또는 기능에만 집중하여 필요한 정보는 숨기고 중요한 정보만을 표현함으로써 프로그램의 복잡성을 줄입니다.

 

객체지향이란 객체와 객체간에 관계를 형성하고 상호작용하게 코드를 작성하는 것

 

<실행 흐름 보기>

예시1)

 

<class Bus 생성>

public class Bus {
	int busNumber; 
	int passengerCount; 
	int money;
	
	// 버스 번호
	public Bus(int number) { //<- 기본 생성자이며, int number는 버스 번호로 객체 생성시 필수 입력)
		busNumber = number;
	}
	
	// 승객을 태운다. 
	public void take(int pay) { // 메소드명 take는 다른 class에서 호출할 수 있음.
		money += pay;
		passengerCount++;
	}
	//현황 확인
	public void showInfo() { // 메소드명 showInfo는 다른 class에서 호출할 수 있음.
		System.out.println("버스 번호 : " + busNumber);
		System.out.println("버스 승객수 : " + passengerCount);
		System.out.println("버스 수익금 : " + money);
	}
}

 

<class Subway 생성>

public class Subway {
	int lineNumber;
	int passengerCount;
	int money;
	
	public Subway(int line) { // 기본 생성자
		lineNumber = line;
	}
	// 지하철에 승객을 태운다.
	public void take(int pay) { 
		money += pay;
		passengerCount++;
	}
	
	//현황 확인
	public void showInfo() {
		System.out.println("지하철 번호 : " + lineNumber);
		System.out.println("지하철 승객수 : " + passengerCount);
		System.out.println("지하철 수익금 : " + money);
	}

}

 

<class Student 생성>

public class Student {

	String name;
	int money;

	// 학생 이름과 소지금
	public Student(String myName, int myMoney) {
		name = myName;
		money = myMoney;
	}

	// 학생이 버스를 탄다.
	public void takeBus(Bus bus) {
		bus.take(1500); // .take로 Bus.java의 메소드 public void take(int pay){}를 호출함.
		money -= 1500; // int pay 값 입력
	} //-> 즉 학생이 버스를 타면 소지금이 차감되는 동시에 .take 호출로 인해 
    버스는 수익금을 벌고 승객수가 1씩 상승하는 구조임.

	// 학생이 지하철을 탄다.
	public void takeSubway(Subway subway) {
		subway.take(2000); //.take로 Subway.java의 메소드 public void take(int pay){}를 호출함.
		money -= 2000;
	} // -> 즉 학생이 지하철을 타면 소지금이 차감되는 동시에 .take 호출로 인해 
    지하철은 수익금을 벌고 승객수가 1씩 상승하는 구조임
    
	// 현황 확인
	public void showInfo() {
		System.out.println("학생 이름 : " + name);
		System.out.println("학생 소지금 : " + money);
	}
	}

 

<객체 생성 및 흐름 파악을 위해 class GoingToSchool 생성> 

package basic.ch09;

public class GoingToSchool {

	public static void main(String[] args) {

		Bus bus1 = new Bus(100); // 버스 타입의 버스1은 100번 버스다.
		Bus bus2 = new Bus(200); // 버스2는 200번 버스다.
		Subway subway1 = new Subway(1); 지하철 타입의 지하철1은 1번 지하철이다.
		Subway subway2 = new Subway(2);
		Student s1 = new Student("학생1", 10_000);
		Student s2 = new Student("학생2", 5_000);
        //-> new Student(생성자)를 통해 Student.java의 메서드 public Student(String myName, int myMoney){}를 호출함.
		s1.showInfo(); // -> Student.java의 public void showInfo() {} 메소드를 호출함.
		
		// 학생이 버스를 탄다
		s1.takeBus(bus2);
        // -> takeBus에 ctrl + 우측 마우스 클릭 시 Student.java의 메서드 public void takeBus(Bus bus) {}를 호출함.
		student1.showInfo(); // -> 학생 프로필(이름과 소지금이 호출됨)
        
		// 버스의 상태값을 확인해보자.
		System.out.println("----------------");
		bus2.showInfo(); 
        // -> showInfo 클릭 시 Bus.java의 메서드 public void showInfo() {}를 호출함.
		System.out.println("----------------");
		student1.takeSubway(subway1); //-> Student.java의 메서드 public void takeSubway(Subway subway) {}를 호출함.
		student1.showInfo();
		subway1.showInfo(); //-> Subway.java의 메서드 public void showInfo() {}를 호출함.
		System.out.println("-----------------");
		subway2.showInfo(); //-> subway2를 타지 않았기 때문에  Subway.java의 메서드 public void showInfo() {} 호출 결과 승객수와 수익금이 0임.
		
	}//end of main

}// end of class

 

예시2)

<class Warrior 생성>

public class Warrior {

	String name;
	int power;
	int hp;
	
	public Warrior(String myName, int myPower) {
		name = myName;
		power = myPower;
		hp = 100;
	}
	//위자드를 공격함.
	public void attackWizard(Wizard wizard) {
		System.out.println("마법사를 공격(" + this.power + ") 합니다.");
		wizard.BeAttacked(this.power); // -> 위자드를 공격하는 메소드 내에는 위저드가 워리어의 power에 공격받았다는 의미
        //-> .BeAttacked는 wizard.java의 메서드 public void BeAttacked(int power) {}를 호출함.
	}
	//워리어가 공격 받음.
	public void BeAttacked(int power) { // -> 위저드가 공격했을 때 위자드의 power를 받음.
		if(hp<0) {
			System.out.println("이미 죽었습니다.");
			return;
		}
		hp -= power;
	}
}

 

<class Wizard 생성>

public class Wizard {
	String name;
	int power;
	int hp;

	public Wizard(String myName, int myPower) {// -> 객체 생성 시 name, power 입력/ hp도 선언됨.
		this.name = myName;
		this.power = myPower;
		hp = 50;
	}

	// 전사를 공격함.
	public void attackWarrior(Warrior warrior) {
		warrior.BeAttacked(this.power); //-> 워리어는 마법사의 power 공격을 받음.
        // -> .BeAttacked를 통해 Warrior.java의 메서드 public void BeAttacked(int power) {}를 호출함.
	}

	// 마법사가 공격받음.
	public void BeAttacked(int power) { // -> 마법사가 워리어의 power 공격을 받음.
		if (hp < 0) {
			System.out.println("이미 죽었습니다.");
			return;
		}
		hp -= power;
	}
}

 

<class MainTest 생성>

public class MainTest {

	public static void main(String[] args) {

		Warrior warrior = new Warrior("전사", 20);
		Wizard wizard = new Wizard("마법사", 30);

		System.out.println("전사가 마법사를 몇 번 공격하시겠습니까?");
		Scanner sc = new Scanner(System.in);
		int inputData = sc.nextInt();
        // Scanner 클래스 사용

		for (int i = 0; i < inputData; i++) {
			warrior.attackWizard(wizard);
		} // -> .attackWizard 를 통해 Warrior.java의 메소드 public void attackWizard(Wizard wizard) {}를 호출함.
        // -> 워리어가 위자드를 공격한 횟수는 inputData 만큼 반복됨.
		System.out.println("마법사 hp 확인 : " + wizard.hp);
	}

}