인자 전달 방식
- 값 호출 (Call by value)
- 기본 자료형의 값을 인자로 전달하는 방식이다. 값을 복사하여 전달한다.
package kr.s08.object.method;
public class MethodArgMain01 {
public int increase (int n) {
++n; //1증가 후 반환
return n;
}
public static void main(String[] args) {
int var1 = 100;
MethodArgMain01 ma = new MethodArgMain01();
int var2 = ma.increase(var1);
System.out.println("var1 : "+ var1 + ", var2 : " + var2);
}
}- 참조 호출 (Call by reference)
- 메소드 호출시 전달하려는 인자를 참조(객체) 자료형을 사용할 경우를 의미한다. 주소(reference)를 복사하여 전달한다.
package kr.s08.object.method;
public class MethodArgMain02 {
// 배열(객체) 주소가 전달된다.
public void increase (int [] n) {
for(int i = 0; i < n.length; i++) {
n[i]++;
}
}
public static void main(String[] args) {
//배열 선언 및 생성, 초기화
int [] ref1 = {100, 200, 300}; //암시적 방법으로 배열 생성
System.out.println("====데이터 변경 전====");
for(int i = 0; i < ref1.length; i++) {
System.out.println("ref1[" + i + "] : " + ref1[i]);
}
MethodArgMain02 marg = new MethodArgMain02();
marg.increase(ref1);
System.out.println();
System.out.println("===데이터 변경 후====");
for(int i = 0; i < ref1.length; i++) {
System.out.println("ref1[" + i + "] : " + ref1[i]);
}
}
}- Varargs (Variable Arguments)
- 자료형이 일치할 때 전달하고자 하는 값의 갯수를 다르게 지정할 수 있다. 전달되는 데이터는 내부적으로 배열로 인식한다.
package kr.s08.object.method;
public class MethodArgMain03 {
//데이터를 전달하는 배열이고 배열명이 n이다.
public void argTest (int ... n) {
for(int i =0; i <n.length; i++) {
System.out.println("n[" + i + "] : " + n[i]);
}
System.out.println("=============");
}
public static void main(String[] args) {
MethodArgMain03 ma = new MethodArgMain03();
ma.argTest();
ma.argTest(1);
ma.argTest(10,20,30);
}
}
메소드 오버로딩
Overloading(중복정의)이라는 것은 하나의 클래스 내에서 같은 이름을 가지는 메서드가 여러 개 정의되는 것을 말한다. 이것은 컴파일 시 컴파일러에 의해 각 메서드들이 구별되며 기준은 인자가 된다 . 인자의 타입 또는 갯수, 배치된 순서가 다를 경우 다른 메서드로 인식함.
package kr.s08.object.method;
public class OverloadingMain01 {
// 아주 중요한 문법!
/*
Method Overloading(중복 정의)
하나의 클래스 내에서 같은 이름을 가지는 메소드가 여러개 정의되는 것을 말한다.
메소드 명은 동을하게 하고 인자의 타입 또는 개수, 배치된 순서가 다를 경우 다른 메소드로 인식한다.
*/
public void print(int n) {
System.out.println("정수 n = " + n);
}
public void print (double n) {
System.out.println("실수 n = " + n);
}
public void print (double n , long a) {
System.out.println("실수 n = " + n + ", 정수 a = " + a);
}
public void print (long a , double n) {
System.out.println("정수 a = " + a + ", 실수 n = " + n);
}
public static void main(String[] args) {
OverloadingMain01 om = new OverloadingMain01();
om.print(20);
om.print(5.6);
om.print(3.7, 1234L);
om.print(5678L, 5.8);
}
}package kr.s08.object.method;
public class OverloadingMain02 {
//문자열의 길이 -> length
public void getLength(String s) {
System.out.println(s + "의 길이 : " + s.length());
}
public void getLength (int n) {
String s = String.valueOf(n); // int => String
getLength(s);
}
public void getLength (float a) {
String s = String.valueOf(a);
getLength(s);
}
public static void main(String[] args) {
OverloadingMain02 om = new OverloadingMain02();
om.getLength("Hello");
om.getLength(500000);
om.getLength(3.14f);
}
}패키지 & import문
-
패키지(Package)
서로 관련 있는 클래스와 인터페이스를 하나의 단위로 붂는 것을 의미한다. 서로 관련있는 파일을 보관할 때 디렉토리를 사용하는 것처럼 동일 작업을 패키지로 그룹핑하는 작업을 할 수 있다. -
Import 문
같은 패키지의 클래스들은 클래스명만 명시해서 호출 가능하지만 다른 패키지에 있는 특정한 클래스를 사용하려면 패키지까지 명시해서 클래스를 호출해야 한다.
package kr.s09.object.p1;
//호출하고자하는 클래스에 패키지를 등록
import kr.s09.object.p2.PackTwo;
public class PackMain {
public static void main(String[] args) {
//kr.s09.object.p1.PackOne p1 = new kr.s09.object.p1.PackOne();
// 같은 패키지의 클래스를 호출해서 객체 생성을 할 때는 패키지를 생략가능하다.
PackOne p1 = new PackOne();
//다른 패키지의 클래스를 호출할 때 반드시 패키지를 명시해야한다.
//kr.s09.object.p2.PackTwo p2 = new kr.s09.object.p2.PackTwo();
//import 문을 이용해서 호출하고자 하는 클래스의 패키지를 등록했기때문에 클래스 명만 기재해도 호출가능해짐
PackTwo p2 = new PackTwo();
}
}
캡슐화
캡슐화란 객체의 필드, 메서드를 하나로 묶고, 실제 구현 내용을 감추는 것을 말한다. 외부 객체는 객체 내부의 구조를 알지 못하며 객체가 노출해서 제공하는 필드와 메서드만 이용할 수 있다. 필드와 메서드를 캡슐화하여 보호하는 이유는 외부의 잘못된 사용으로 인해 객체가 손상되지 않도록 하는데 있다.
package kr.s10.object.capsule;
class Capsule {
//private은 같은 클래스내에서만 접근이 가능함
//은닉화
private int a;
//캡슐화
public void setA (int n) {
if(n >=0) {
a = n;}
else {
System.out.println("음수는 허용되지 않습나다.");
}
}
public int getA () {
return a;
}
}
public class CapsuleMain {
public static void main(String[] args) {
Capsule cap = new Capsule () ;
//변수 a의 접근 지정자(제한자) private이기 때문에
//같은 클래스에서는 호출이 가능하지만 다른 클래스에서는 호출이 불가능
//System.out.println(cap.a));
cap.setA(20); //데이터 저장
System.out.println(cap.getA()); //데이터 호출
}
}
생성자
생성자는 객체가 생성될 때 자동적으로 단 한번 호출되어 필드의 초기화하거나 객체 생성시 반드시 호출되어야 하는 메소드를 호출하는 역할을 한다. 생성자의 구조는 메소드와 비슷하지만 메소드명이 반드시 클래스와 동일해야 하고 리턴타입이 없다.
-
특징
- return Type이 전혀 정의되지 않는다.
- 생성자의 이름이 클래스 명과 같아야 한다.
- 생성자 내부에서 특정 작업을 수행할 수 있고 데이터를 인자에 전달하여 전달받은 데이터를 활용할 수도 있다.
-
생성자 오버로딩
- 기본 생성자 하나만을 명시할 수 있는 것이 아니라 다양한 인자를 전달 받아 가공할 수 있는 생성자를 여러개 만들어 사용할 수 있다. 메서드 오버로딩처럼 인자의 타입, 갯수, 배치 순서의 다를 경우 다른 생성자로 인식한다.
package kr.s11.object.constructor;
class Car {
String color;
String gearType;
int door;
//생성자 , 기본 생성자는 생략 가능
public Car() {}
}
public class CarMain01 {
public static void main(String[] args) {
//생성자는 객체 생성시 단 한 번만 실행되고 객체 생성 이후에는 호출이 불가능하다
// 멤버 변수를 초기화하는 역할을 수행한다.
Car c1 = new Car ();
System.out.println(c1.color + ", " + c1.gearType + ", " + c1.door);
//객체의 멤버 변수에 값을 할당
c1.color = "red";
c1.gearType = "Auto";
c1.door = 5;
System.out.println(c1.color + ", " + c1.gearType + ", " + c1.door);
}
}
package kr.s11.object.constructor;
class Car2 {
String color;
String gearType;
int door;
// 생성자 오버로딩
// 생성자를 여러개 정의하는데 인자의 타입과 개수, 배치 순서를 기준으로 생성자를 구분
public Car2() {}
public Car2(String c, String g, int d) {
color = c;
gearType = g;
door = d;
}
}
public class CarMain02 {
public static void main(String[] args) {
//객체 선언 및 생성
Car2 car2 = new Car2();
car2.color = "Gold";
car2.gearType = "Auto";
car2.door = 4;
Car2 car3 = new Car2("Black" , "Manual" , 4);
System.out.println(car2.color + " , " + car2.gearType + " , " + car2.door);
System.out.println(car3.color + " , " + car3.gearType + " , " + car3.door);
}
}
this
객체 내부에서 객체 자신을 칭하고 싶을 때나 아니면 지역변수와 멤버변수를 구별해야 할 때도 있을 것이다. 이럴 때 사용하는 객체 자신을 가리킬 수 있다.
package kr.s11.object.constructor;
class Student {
int kor; int eng; int math;
int history; int science;
int num; // 과목수
//3과목
public Student(int kor , int eng, int math) {
this.kor = kor; this.eng = eng; this.math = math;
num = 3; //과목 수 지정
}
//5과목
public Student (int kor, int eng, int math, int history, int science) {
this.kor = kor; this.eng = eng; this.math = math; this.history = history; this.science = science;
num = 5; // 과목 수 지정
}
public int getTotal() {
int total;
if(num == 3) {
total = kor + eng + math;
}
else {
total = kor + eng + math + history + science;
}
return total;
}
public int getAvg() {
return getTotal () / num;
}
}
public class StudentMain {
public static void main(String[] args) {
//3과목 시험보기
Student s1 = new Student(90, 97, 95);
System.out.printf("합계 = %d점%n" , s1.getTotal());
System.out.printf("평균 = %d점%n" , s1.getAvg());
System.out.println("-------------------------------");
// 5과목 시험보기
Student s2 = new Student(88, 82, 84, 87, 90);
System.out.printf("합계 = %d점%n" , s2.getTotal());
System.out.printf("평균 = %d점%n" , s2.getAvg());
}
}
package kr.s12.object.constructor;
public class AccountMain {
String accountNo; //계좌 번호
String ownerName; //예금주
int balance; //잔고
//생성자 *일치시켜야함
public AccountMain(String a, String o,int b) {
accountNo = a;
ownerName = o;
balance = b;
System.out.println(ownerName + "님 계좌가 개설되었습니다.");
}
//입금하기
public void deposit (int amount) {
if(amount <= 0) {
System.out.println("0원보다 큰 금액을 입력해주세요.");
//void형 메소드에서 특정 조건일 때 메소드를 빠져나간다.(메소드 종료)
return; // 함수가 종료되어 아래 코드 실행 안 함
}
balance += amount;
System.out.println(amount + "원 입급되었습니다. 현재 계좌 잔액은" + balance+"입니다.");
}
//출금하기
public void withdraw (int amount) {
if (amount <= 0) {
System.out.println("0원은 출금이 불가능합니다. 더 큰 금액을 입력해주세요.");
return ;
}
if (amount > balance) {
System.out.println("계좌 잔액이 부족합니다. 다음에 다시 이용해주세요.");
return;
}
balance -= amount;
System.out.println(amount +"원 출금하였습니다. 현재 계좌 잔액은" + balance + "입니다.");
}
public static void main(String[] args) {
//계좌 생성
AccountMain account1 = new AccountMain("123-456" , "이동욱" , 10000);
System.out.println("계좌 번호 : " + account1.accountNo);
System.out.println("예금주 : " + account1.ownerName);
System.out.printf("계좌 잔고 : %,d원%n", account1.balance);
System.out.println("---------------------------------------");
//예금하기
account1.deposit(5000);
//출금하기
account1.withdraw(10000);
System.out.println("==============================");
AccountMain account2 = new AccountMain("123-4567-890" , "이수혁" , 1000000);
System.out.println("계좌 번호 : " + account2.accountNo);
System.out.println("예금주 : " + account2.ownerName);
System.out.printf("계좌 잔고 : %,d원%n", account2.balance);
}
}
package kr.s13.object.array;
class Book{
String category;
String name;
private int price;
private double discount;
public Book (String c , String n , int p , double d) { //생성자
category = c; name = n;
price = p; discount = d;
}
public String getCategory() {
return category;
}
public String getName() {
return name;
}
public int getPrice() {
return price;
}
public double getDiscount() {
return discount;
}
}
public class BookMain {
public static void main(String[] args) {
Book [] bookArray = new Book[3];
//Book 객체를 3개 생성하여 배열에 저장
bookArray[0] = new Book ("IT" , "Java" , 50000, 0.05); //객체의 주소가 대입이 된다
bookArray[1] = new Book ("IT", "Oracle", 40000, 0.03);
bookArray[2] = new Book ("Art", "Gogh", 60000, 0.06);
//반복문을 이용하여 객체의 요소 출력
for(int i = 0 ; i <bookArray.length; i++) {
System.out.printf("%s \t" , bookArray[i].getCategory());
System.out.printf("%s \t" , bookArray[i].getName());
System.out.printf("%d \t" , bookArray[i].getPrice());
System.out.printf("%.2f%n" , bookArray[i].getDiscount());
}
}
}
package kr.s13.object.array;
public class Score {
//은닉화
private String name;
private int kor;
private int eng;
private int math;
//생성자
public Score (String name , int kor ,int eng, int math) {
//멤버 변수 = 지역 변수
this.name = name;
this.kor = kor;
this.eng = eng;
this.math = math;
}
//총점 구하기
public int makeSum () {
return kor + eng + math;
}
//평균 구하기
public int makeAvg() {
return makeSum() / 3;
}
//등급 구하기
public String makeGrade() {
//String grade;
switch (makeAvg() / 10) {
case 10:
case 9:
//grade = "A"; break;
return "A"; //변수를 만들지 않고 반환 가능함
case 8:
//grade = "B"; break;
return "B";
case 7:
//grade = "C"; break;
return "C";
case 6:
//grade = "D"; break;
return "D";
default:
//grade = "F";
return "F";
}
//return grade;
}
// 메소드
public String getName() {
return name;
}
public int getKor() {
return kor;
}
public int getEng() {
return eng;
}
public int getMath() {
return math;
}
}
package kr.s13.object.array;
public class ScoreMain {
public static void main(String[] args) {
Score [] scoreArray = new Score[3];
//반복문을 이용한 배열의 요소 출력
System.out.println("이 름 국어 영어 수학 총 점 평균 등급");
System.out.println("=====================");
scoreArray[0] = new Score("이동욱" , 99 , 98, 97);
scoreArray[1] = new Score("이수혁" , 89 , 91, 92);
scoreArray[2] = new Score("유재석" , 79 , 81, 85);
for(int i = 0; i <scoreArray.length; i++) {
System.out.printf("%s " , scoreArray[i].getName());
System.out.printf("%d " , scoreArray[i].getKor());
System.out.printf("%d " , scoreArray[i].getEng());
System.out.printf("%d " , scoreArray[i].getMath());
System.out.printf("%d " , scoreArray[i].makeSum());
System.out.printf("%d " , scoreArray[i].makeAvg());
System.out.printf("%s %n" , scoreArray[i].makeGrade());
}
System.out.println("-----------------------------------------");
//확장 for문을 이용한 배열의 요소 출력
for(Score s : scoreArray) {
System.out.printf("%s " , s.getName());
System.out.printf("%d " , s.getKor());
System.out.printf("%d " , s.getEng());
System.out.printf("%d " , s.getMath());
System.out.printf("%d " , s.makeSum());
System.out.printf("%d " , s.makeAvg());
System.out.printf("%s%n" , s.makeGrade());
}
}
}
Lucky Things🍀