[Java]Class(2)

박진우·2022년 9월 8일
Java복습
0

[Java]자바의 기초

목록 보기
7/16

method overloading

자바에서 한 클래스 내에서 이미 사용하려는 이름과 같은 이름을 가진 메소드가 있더라도 매개변수의 개수 또는 타입이 다르면, 같은 이름을 사용해서 메소드를 정의할 수 있다.
한 클래스 내에 같은 이름의 메소드를 여러 개 정의하는 것을 메소드 오버로딩(Method Overloading)" 혹은 "오버로딩(Overloading)이라 한다.

public class Calculator {
	double area;
	
	// 정사각형 넓이
	double areaRectangle(double width) {
		return width*width;
	}

	// 직사각형 넓이
	double areaRectangle(double width, double height) {
		return width*height;
	}
}

public class CalculatorEx {

	public static void main(String[] args) {
		Calculator cal = new Calculator();
		double area=0;
		
       
		area = cal.areaRectangle(10);
		System.out.println("정사각형 넓이 : " + area);
		
		area = cal.areaRectangle(10, 20);
		System.out.println("직사각형 넓이 : " + area);
	}

}

field

  1. instance field
    • heap memory에서 생성된 인스턴스 안에 있는 field
    • 인스턴스 생성할 때 마다 field가 따로 생성됨
    • 항상 인스턴스를 생성한 후, 인스턴스를 통해 field 사용해야만 함
  2. static field ('static' 키워드가 붙어 있는 field)
    • heap memory의 인스턴스 안에 존재하지 않음. 별도 다른 메모리 영역에 보관
  • new로 인스턴스를 여러개 만들더라도 오직 1개만 존재
  • program application 전체에서 공통으로 사용되는 변수 (변수값은 변경 가능)
    (예를 들면, version, application에서 공통으로 사용하는 folder directory)
    • 클래스 이름으로 static field를 사용하는 것이 원칙 (예 : Earth.EARTH_RADIUS 를 사용 가능)
    • new로 인스턴스를 생성하여 static field를 사용하는 것도 가능
  1. static final을 같이 사용 경우 : 상수(constant)
    • 상수는 한개만 필요한데, 만약 final만 사용할 경우는 인스턴스마다 상수가 반복 생성되고
      항상 인스턴스 생성후에 상수를 사용해야만 하는 문제 발생
      => 상수는 메모리에 오직 1개만 생성이 되면 되기 때문에 static final을 사용할 것을 권장
public class Earth {
	static final double EARTH_RADIUS = 6400;	// static field
	static final double EARTH_SURFACE_AREA = 4*Math.PI*EARTH_RADIUS; // static field
	int age;	// instance field

}

추가

  1. instance method를 선언하고 사용하는 목적
    • heap memory에 생성된 instance field들을 사용하겠다는 의미
    • intance method안에서 static field, static method 사용 가능
  2. static method를 선언하고 사용하는 목적
  • heap memory에 생성된 instance field들을 사용하지 않겠다는 의미
  • 공통으로 변함없이 사용되는 메소드 (예를 들면 Math안에 있는 메소드들)
    => 많이 사용되지 않는 메소드
  • static field는 같이 사용 가능
  • 굳이 instance field나 instance method를 사용하고 싶은 경우에는 static method안에서 new로 인스턴스 생성후에 인스턴스를 사용하면 됨
public class Car {
	int speed;
	String name;
	static String color;

	public Car() {
		
	}
	
	// this는 인스턴스를 의미
	public Car(String color) {
		Car.color = color;
	}
	
	// static method
	public static void printStaticHello() {
//		speed = 10;
		System.out.println("Hello, static method");
	}
	// instance method
	// instance method안에서는 instance field, 다른 instance method 사용 가능
	public void printInstanceHello() {
		this.speed = 5;
		System.out.println("Hello, instance method");
		dummy();
	}
	
	public static void dummy() {
		System.out.println("this is dummy static method");
	}
	
	public static void main(String[] args) {
		// static method에서 static field나 다른 static method 사용 가능
//		Car.color = "red";
//		Car.printStaticHello();
		color = "red";
		printStaticHello();

		// static method에서 instance field나 다른 instance method 사용 불가능
//		speed = 10;
//		printInstanceHello();

		// instance field나 instance method는 반드시 new로 인스턴스 생성후에 사용해야만 함
		Car car = new Car();
		car.speed = 10;
		car.printInstanceHello();
		
//		Math.cos(50);
	}

}

캡슐화

private 키워드

  • 대상 : field, method에 사용 가능 (constructor도 사용 가능)
  • 사용 목적 :
    1) class를 사용하는 다른 class에서 사용하지 못하게 하는 것이 목적
    => 하지만, class내부에서는 제한없이 사용 가능
    2) 일반적으로 object oriented programming을 할 때, field는 private으로 선언하는 것이 일반적임
    => 대신에 private으로 선언한 field들에 대해서, 다른 class에서 해당 field를 사용하기 위해
    public으로 선언한 getter/setter method를 제공함
    method에 대해서는 만약 private으로 선언한 것은 class 내부적으로만 사용하고 외부에 오픈않하겠다는 의미
    Encapsulation(캡슐화) : class에서 field, method등을 private으로 선언을 해서 외부에 공개하지 않는 것
    => information hiding (정보 은닉)

public class Circle {
	private double radius;
	private String name;
	
	
	public Circle() {
		this.radius = 1;
			
	}

	public Circle(double newRadius) {
		this.radius = newRadius;
			
	}

	// getter method
	public double getRadius() {
		printPrivateHello();
		return radius;
	}

	// setter method
	public void setRadius(double radius) {
		if (radius >= 0) {
			this.radius = radius;
		} else {
			this.radius = 0;
		}
	}


	// 원의 면적 구하는 method 선언
	public double getArea() {
		return radius*radius*Math.PI;
	}
	
	// 원의 둘레 구하는 method 선언
	public double getPerimeter() {
		return 2*Math.PI*radius;
	}
	
	private void printPrivateHello() {
		System.out.println("Hello, this is private method");
	}
}

CircleEx

public class CicleEx {

	public static void main(String[] args) {
		Circle circle = new Circle(5.0);
		
		// Circle class에서 private으로 선언된 field, method는 사용 불가
//		circle.radius = 10;
//		circle.name = "홍길동";
//		circle.numberOfObjects = 10;
//		circle.printPrivateHello();
		
		System.out.println("circle radius : " + circle.getRadius() + ", area : " 
				+ circle.getArea() + ", 생성인스턴스 갯수 : " + circle.getNumberOfObjects());
		
        //setter 메소드로 Radius 10으로 설정
		circle.setRadius(10);

		System.out.println("circle radius : " + circle.getRadius() + ", area : " 
				+ circle.getArea() + ", 생성인스턴스 갯수 : " + circle.getNumberOfObjects());
	}

}

import

  1. 다른 package에 있는 class를 사용할려면 import 키워드를 사용해야 함
  2. class이름은 package이름과 결합되어 있음
  • 같은 class이름이라도 package가 틀리면 다른 class로 인식됨.
import p08.import_ex.hankook.SnowTire;
import p08.import_ex.hankook.Tire;
import p08.import_ex.hyundai.Engine;
import p08.import_ex.kumho.BigWidthTire;


public class Car {

	public static void main(String[] args) {
		Engine engine = new Engine();
		SnowTire snowTire = new SnowTire();
		BigWidthTire bigTire = new BigWidthTire();
		Tire hankookTire = new Tire();
        //직접 선언할 수도 있음
		p08.import_ex.kumho.Tire kumhoTire = new p08.import_ex.kumho.Tire();

	}

}

접근 제한자

  1. public : 같은 package, 다른 package 모두 사용 가능
  2. default : 같은 package내에서만 사용 가능 (다른 package 사용 불가능)
    • 사용 의미 : 같은 package (전체 application에서 같은 기능을 구현하는 class들)만 쓰겠다는 의미
      => 다른 말로 하면, 같은 기능을 구현하는 개발자 들끼리 공유해서 사용할 경우에 사용
  3. private : class 내부에서만 사용 가능

public class A {
	int a = 10;				// default (access modifier) field
	public int b = 20;		// public field
	private double c = 30;		// private field
	
	// default constructor
	A() {
		
	}

	public A (int b) {
		this.b = b;
	}
	
	private A (double c) {
		this.c = c;
	}
	
	public void printPublic() {
		System.out.println("public method");
	}
	
	void printDefault() {
		System.out.println("default method");
	}
	
	private void printPrivate() {
		System.out.println("private method");
	}
}

아래 코드에서 주석을 한 곳은 오류가 나는 부분들이다

public class B {
	A a1 = new A();		// default constructor 호출
	A a2 = new A(1);	// public constructor 호출
//	A a3 = new A(1.0);	// private constructor 호출

	public B() {
		a1.a = 1;		// default field 사용
		a1.b = 2;		// public field 사용
//		a1.c = 3;		// private field 사용
		
		a1.printDefault();
		a1.printPublic();
//		a1.printPrivate();
	}
}

import를 할때

위와 마찬가지로 주석처리 한 부분들은 모두 오류가 나는 부분들이다.

  1. 다른 package에서 default로 선언된 field, constructor, method 사용 불가 

public class C {
//	A a1 = new A();		// default constructor 호출
	A a2 = new A(1);	// public constructor 호출
//	A a3 = new A(1.0);	// private constructor 호출
	
	public C() {
//		a2.a = 1;		// default field 사용
		a2.b = 2;		// public field 사용
//		a2.c = 3;		// private field 사용
		
		a2.printPublic();
//		a2.printDefault();
//		a2.printPrivate();
	}
}

강의를 듣고 느낀점

클래스 강의를 들은 후 부터는 대략 머리가 멍해지는 기분이 들엇다.
내가 아는 것은 굉장히 적구나 라는 생각이 들었는데 이떄부터 따로 정리를 시작하였다

profile
박진우
개발자를 꿈꾸는 사람입니다
이전 포스트

[Java]Class(1)

다음 포스트

[Java]String

0개의 댓글