인스턴스 필드(변수)
static으로 선언되지 않은 모든 변수(필드)는 인스턴스필드
public double r;
클래스의 인스턴스와 연관, 생성된 모든 객체는 자신만의
복사본을 가진다.
클래스 내부에서 이름하나만으로 지칭된다.
public double r;
public double area() {
return PI * r * r;
}
클래스 외부에서는 클래스를 인스턴스화한 객체.변수명 형
태로 사용한다. 인스턴스 필드(변수)의 값은 한객체를
다른
객체와 구분한다.
Circle c = new Circle(); c.r=2.0;
Circle c1 =
new Circle(); c1.r=5.0;
인스턴스 메소드
static으로 선언되지 않은 모든 메소드
public double area();
클래스의 인스턴스(객체)와 연관된다.
static이든, 아니든 모든
클래스멤버 사용가능
클래스 외부에서는 클래스를 인스턴스화한 객체.메소드명 형태로 사용한다.
인스턴스 필드(변수)의 값은
한객체를 다른객체와 구분한다.
Circle c = new Circle(); c.r=2.0;
double a =
c.area(); //객체 c에는 이미 r 값이 setting됨
- 매개변수가 없는 c.area()가
어떤 데이터에 대해 수행될건지 어떻게 아는가? 사실 모든 인스턴스 메소드는 암시적인 this 매개변수를 가지고 실행된다. This는 메소드가
호출되는 객체(Circle)이다. This 매개변수는 항상 필요하지는 않기에 메소드 시그네쳐에 보이지 않는다.
메소드가 그자신의
필드(변수)등을 접근한다는것을 명시적으로 this를 이용하여 지정할수 있다.
public double area() {
return Circle.PI * this.r * this.r;
}
클래스
멤버예제(Circle1.java)
class Circle {
//클래스 변수(필드), 상수정의
public
static final double PI = 3.141592;
//클래스 메소드
public static double
radianToDegree(double rads) {
return rads * 180 / PI;
}
//인스턴스
필드(변수), 원의반지름
public double r;
//인스턴스 메소드, 원의 면적계산
public double
area() { return PI * r * r; }
//인스턴스 메소드,원주계산
public double
circumference() { return 2 * PI * r; }
}
public class Circle1
{
public static void main(String[] args) {
Circle c = new Circle();
c.r = 4.0;
//인스턴스 메소드 이용
System.out.println("반지름이 4인 원의 면적은 : " +
c.area());
System.out.println("반지름이 4인 원의 원주는 : " + c.circumference());
//클래스 메소드및 클래스변수(필드) 이용
System.out.println("2 * PI의 Degree는 : "
+
Circle.radianToDegree(2.0*Circle.PI) + "도 입니다.");
}
}
3D프린팅,아두이노알고리즘프로그래밍,로봇제작,스프링프레임워크,스프링시큐리티,스프링소셜,NODE.JS,AngulerJS,안드로이드 마시멜로,아이폰 Swift,닷넷, C#, Xamarin 실무개발바교육,구로디지털단지역2분,초역세권
2013년 8월 1일 목요일
자바인터페이스(java interface)
자바와 다중상속
- 다중 상속이라는 것은 말 그대로 하나의 클래스가 여러개의 수평적 상위클래스를 갖는 것이다.
- 다중 상속은 사용이 어렵고 오류를 범하기 쉬울 뿐 아니라 만약 사용한다고 하더라도 문법이 복잡해져 객체지향 기술 중에서도 많이 사용되지 않는 기능이다. 물론 다중 상속을 이용하면 하나의 클래스가 여러가지 일을 할 수 있는 기능을 제공할 수 있고 덕분에 유연한 프로그래밍이 가능해진다는 장점이 있다.
- C++과 같은 언어는 이러한 다중상속을 지원하지만 Java는 다중상속을 지원하는 것을 포기했다. 자바를 만든 이유는 작고 단순하고 안전한 프로그램을 만들자는 것이었다. 다중상속은 이러한 프로그램의 안정성을 저해하는 요소가 될 수 있기에 다중상속을 포기하게 된 것이다.
- 하지만 여전히 여러가지 기능을 가지는 클래스의 존재는 객체지향언어인 자바에서는 자주 필요하게 된다. 여러가지 기능을 가진 유연한 클래스를 만들기 위해 다중상속만을 지원하는 자바는 또 다른 방법을 고안해야 했다. 이것이 바로 인터페이스이다.
인테페이스
- 인터페이스라는 단어는 두개의 장치 및 시스템을 결합하고 있는 소프트웨어 또는 하드웨어라는 의미이다.
- 상수와 추상메소드의 집합
- 인터페이스를 사용할려면 클래스에서 구현해야 한다.(implements)
- 클래스가 인터페이스를 구현하게 되면 인터페이스 내에 정의된 상수는 상속된 것 처럼 직접 사용할수 있다.
- 인터페이스의 모든 메소드는 abstract가 생략되었다고 해도 암시적으로 abstract이다.
- 메소드의 구현을 갖지 않으며, 몸체부분은 세미콜론으로 대체된다.
- 오직 abstract 메소드만을 포함할수 있으며 클래스 메소드는 abstract가 될수 없으므로 인터페이스의 모든 메소드는 인스턴스 메소드 이다.
- 직원 중 운전을 할 수 있는 직원이 있으며 이 직원은 회사에서 보유하고 있는 차량을 사용할 수 있다. 만약 모든 직원이 자동차 면허를 가지고 있다면 Employee 클래스에서 자동차 면허에 대한 필드와 메소드를 만들면 되지만 모든 직원이 자동차 면허를 가지고 있을리는 없을 것이다. 때문에 다중 상속이 지원되지 않는 자바에서 자동자 면허를 가지고 있는 직원 클래스를 따로 만들고 그 클래스를 이용해 면허를 가진 영업팀 직원, 면허를 가진 Manager, 면허를 가진영업팀장 이라는 식의 클래스를 만들어야 구현이 가능하다.
Employee 클래스와 DriverEmployee 클래스가 서로 큰 연관성이 없으며 운전을 할 줄 아는 직원을 만들기 위해DriverEmployee 클래스를 따로 만들고 각 팀 직원들도 운전하는 직원을 따로 만들어야 한다면 프로그램 개발 시 일관성이 없고 복잡해 진다. 이런 문제를 해결하기 위해 운전하는 직원을 클래스로 따로 만드는 대신 운전이라는 인터페이스를 만들어 필요할 때 사용할 수 있으면 위와 같은 문제점을 해결할 수 있을 것이다.
인터페이스는 모양은 클래스와 비슷하지만 다른 점이 있다. 클래스는 필드와 메소드로 구성되어 있고 또 그 메소드는 자신이 할 일을 구현하고 있다. 하지만 인터페이스는 선언만을 하게 된다. 만약에 2종 운전 면허에 대한 인터페이스 SmallDriver를 작성한다면 다음과 같다.
public interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
클래스는 필드로 기본자료형, 클래스 등이 올 수 있지만 인터페이스는 int, double 등의 기본 자료형만이 필드로 사용될 수 있다. 또한 각 필드는 반드시 초기화가 되어야 한다. 초기화가 되어야 하는 이유는 인터페이스의 필드는 암시적으로 final과 static이 설정되어 있기 때문이다.
int maxSmall = 5 static final int maxSmall = 5;
인터페이스는 메소드를 선언만 하고 구현하지는 않는다. 그리고 인터페이스의 모든 메소드는 접근지정이 기본적으로 public으로 설정된다. 그리고 모든 메소드는 추상메소드이다. 즉 위에서 void driveSmallCar();라고 선언하고 있는데 암시적으로 설정되는 public과 abstract 키워드를 추가하면 다음과. 같이 선언되어 있는 것과 같다.
public abstract void driveSmallCar();
앞에서 만든 SmallDriver 인터페이스를 상속한 1종 운전면허 인터페이스 BigDriver를 만든다면 다음과 같다.
public interface BigDriver extends SmallDriver {
void driveBigCar();
void driveSmallCar(); // 다시 선언하는 경우
int maxBig = 15;
}
상위 인터페이스에서 선언된 메소드를 하위클래스에서 동일한 명칭으로 선언한 경우 경우에 따라 두가지로 나눌 수 있다.
첫째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드 선언이 완전히 동일한 경우이다. 상위 인터페이스의 메소드만 유효한 것으로 인정하고 컴파일 에러는 발생하지 않는다.
둘째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드가 가지는 매개변수의 갯수가 서로 틀린 경우인데 이 경우는 각각 서로 다른 메소드가 선언된 것으로 간주한다. 즉 메소드가 오버로딩 된 것으로 인식하는 것이다.
하지만 위 두가지의 경우에 해당되지 않고 이름과 매개변수가 같은데 반환형만 다른 경우는 컴파일 에러가 발생하게 된다
예를 들어 SmallDriver에 선언되어 있는 상수 maxSmall을 BigDriver에서 다시 선언한다면? 이 경우 메소드는 하나만 인정하지만 상수의 경우는 범위 규칙에 의해서 SmallDriver의 maxSmall과 BigDriver의 maxSmall을 서로 다른 것으로 인식하여 두개의 상수가 선언된 것으로 인정한다. 사용시에는 상수의 위치에 따라 인터페이스명.상수명의 형태로 사용해야 한다.
인터페이스에서 선언된 메소드의 구현은 인터페이스를 구현하도록 허락된 클래스에서 구현하게 된다. 인터페이스를 상속받는 클래스는 컴파일러에게 "나는 A 라는 클래스인데 인터페이스 B를 완성해서 도구로 사용할꺼야"라고 알려준다.
public class A implements B {
만약 영업팀 직원이 운전을 하는것을 구현할려고 하면 기존의 영업팀직원 클래스가 driveSmallCar()를 구현해야 하며 그렇게 하기 위해서는 interface를 implement한다고 클래스에 표시해야 한다.
//인터페이스 선언
interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
//직원 Class
abstract class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() { System.out.println(name+"님 출근하였습니다..."); }
public void gotoHome() { System.out.println(name+"님 퇴근하였습니다..."); }
public String toString() { return "직원의 이름은 " + name + "이다."; }
abstract public void startJob();
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee implements SmallDriver{
//영업담당지역, 차종류 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea, carName;
public SalesEmployee(String newName,String newID,String newArea,String carName) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea; this.carName = carName;
}
// SmallDrive 인터페이스의 메소드 구현
public void driveSmallCar() {
System.out.println("영업팀 직원 " + name + "은 " + this.carName + "를 운전한다.");
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//Main Class
class InterfaceSample1 {
public static void main(String[] args) {
// 인터페이스가 클래스의 객체를 참조하도록...
SmallDriver sm1 = new SalesEmployee("홍길동", "11111","서울", "아반테");
// 인터페이스의 메소드 사용
sm1.driveSmallCar();
}
}
- 다중 상속이라는 것은 말 그대로 하나의 클래스가 여러개의 수평적 상위클래스를 갖는 것이다.
- 다중 상속은 사용이 어렵고 오류를 범하기 쉬울 뿐 아니라 만약 사용한다고 하더라도 문법이 복잡해져 객체지향 기술 중에서도 많이 사용되지 않는 기능이다. 물론 다중 상속을 이용하면 하나의 클래스가 여러가지 일을 할 수 있는 기능을 제공할 수 있고 덕분에 유연한 프로그래밍이 가능해진다는 장점이 있다.
- C++과 같은 언어는 이러한 다중상속을 지원하지만 Java는 다중상속을 지원하는 것을 포기했다. 자바를 만든 이유는 작고 단순하고 안전한 프로그램을 만들자는 것이었다. 다중상속은 이러한 프로그램의 안정성을 저해하는 요소가 될 수 있기에 다중상속을 포기하게 된 것이다.
- 하지만 여전히 여러가지 기능을 가지는 클래스의 존재는 객체지향언어인 자바에서는 자주 필요하게 된다. 여러가지 기능을 가진 유연한 클래스를 만들기 위해 다중상속만을 지원하는 자바는 또 다른 방법을 고안해야 했다. 이것이 바로 인터페이스이다.
인테페이스
- 인터페이스라는 단어는 두개의 장치 및 시스템을 결합하고 있는 소프트웨어 또는 하드웨어라는 의미이다.
- 상수와 추상메소드의 집합
- 인터페이스를 사용할려면 클래스에서 구현해야 한다.(implements)
- 클래스가 인터페이스를 구현하게 되면 인터페이스 내에 정의된 상수는 상속된 것 처럼 직접 사용할수 있다.
- 인터페이스의 모든 메소드는 abstract가 생략되었다고 해도 암시적으로 abstract이다.
- 메소드의 구현을 갖지 않으며, 몸체부분은 세미콜론으로 대체된다.
- 오직 abstract 메소드만을 포함할수 있으며 클래스 메소드는 abstract가 될수 없으므로 인터페이스의 모든 메소드는 인스턴스 메소드 이다.
- 직원 중 운전을 할 수 있는 직원이 있으며 이 직원은 회사에서 보유하고 있는 차량을 사용할 수 있다. 만약 모든 직원이 자동차 면허를 가지고 있다면 Employee 클래스에서 자동차 면허에 대한 필드와 메소드를 만들면 되지만 모든 직원이 자동차 면허를 가지고 있을리는 없을 것이다. 때문에 다중 상속이 지원되지 않는 자바에서 자동자 면허를 가지고 있는 직원 클래스를 따로 만들고 그 클래스를 이용해 면허를 가진 영업팀 직원, 면허를 가진 Manager, 면허를 가진영업팀장 이라는 식의 클래스를 만들어야 구현이 가능하다.
Employee 클래스와 DriverEmployee 클래스가 서로 큰 연관성이 없으며 운전을 할 줄 아는 직원을 만들기 위해DriverEmployee 클래스를 따로 만들고 각 팀 직원들도 운전하는 직원을 따로 만들어야 한다면 프로그램 개발 시 일관성이 없고 복잡해 진다. 이런 문제를 해결하기 위해 운전하는 직원을 클래스로 따로 만드는 대신 운전이라는 인터페이스를 만들어 필요할 때 사용할 수 있으면 위와 같은 문제점을 해결할 수 있을 것이다.
인터페이스는 모양은 클래스와 비슷하지만 다른 점이 있다. 클래스는 필드와 메소드로 구성되어 있고 또 그 메소드는 자신이 할 일을 구현하고 있다. 하지만 인터페이스는 선언만을 하게 된다. 만약에 2종 운전 면허에 대한 인터페이스 SmallDriver를 작성한다면 다음과 같다.
public interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
클래스는 필드로 기본자료형, 클래스 등이 올 수 있지만 인터페이스는 int, double 등의 기본 자료형만이 필드로 사용될 수 있다. 또한 각 필드는 반드시 초기화가 되어야 한다. 초기화가 되어야 하는 이유는 인터페이스의 필드는 암시적으로 final과 static이 설정되어 있기 때문이다.
int maxSmall = 5 static final int maxSmall = 5;
인터페이스는 메소드를 선언만 하고 구현하지는 않는다. 그리고 인터페이스의 모든 메소드는 접근지정이 기본적으로 public으로 설정된다. 그리고 모든 메소드는 추상메소드이다. 즉 위에서 void driveSmallCar();라고 선언하고 있는데 암시적으로 설정되는 public과 abstract 키워드를 추가하면 다음과. 같이 선언되어 있는 것과 같다.
public abstract void driveSmallCar();
앞에서 만든 SmallDriver 인터페이스를 상속한 1종 운전면허 인터페이스 BigDriver를 만든다면 다음과 같다.
public interface BigDriver extends SmallDriver {
void driveBigCar();
void driveSmallCar(); // 다시 선언하는 경우
int maxBig = 15;
}
상위 인터페이스에서 선언된 메소드를 하위클래스에서 동일한 명칭으로 선언한 경우 경우에 따라 두가지로 나눌 수 있다.
첫째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드 선언이 완전히 동일한 경우이다. 상위 인터페이스의 메소드만 유효한 것으로 인정하고 컴파일 에러는 발생하지 않는다.
둘째는 상위 인터페이스의 메소드와 하위 인터페이스의 메소드가 가지는 매개변수의 갯수가 서로 틀린 경우인데 이 경우는 각각 서로 다른 메소드가 선언된 것으로 간주한다. 즉 메소드가 오버로딩 된 것으로 인식하는 것이다.
하지만 위 두가지의 경우에 해당되지 않고 이름과 매개변수가 같은데 반환형만 다른 경우는 컴파일 에러가 발생하게 된다
예를 들어 SmallDriver에 선언되어 있는 상수 maxSmall을 BigDriver에서 다시 선언한다면? 이 경우 메소드는 하나만 인정하지만 상수의 경우는 범위 규칙에 의해서 SmallDriver의 maxSmall과 BigDriver의 maxSmall을 서로 다른 것으로 인식하여 두개의 상수가 선언된 것으로 인정한다. 사용시에는 상수의 위치에 따라 인터페이스명.상수명의 형태로 사용해야 한다.
인터페이스에서 선언된 메소드의 구현은 인터페이스를 구현하도록 허락된 클래스에서 구현하게 된다. 인터페이스를 상속받는 클래스는 컴파일러에게 "나는 A 라는 클래스인데 인터페이스 B를 완성해서 도구로 사용할꺼야"라고 알려준다.
public class A implements B {
만약 영업팀 직원이 운전을 하는것을 구현할려고 하면 기존의 영업팀직원 클래스가 driveSmallCar()를 구현해야 하며 그렇게 하기 위해서는 interface를 implement한다고 클래스에 표시해야 한다.
//인터페이스 선언
interface SmallDriver {
void driveSmallCar(); // 메소드 선언
int maxSmall = 5; // 필드(상수)
}
//직원 Class
abstract class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() { System.out.println(name+"님 출근하였습니다..."); }
public void gotoHome() { System.out.println(name+"님 퇴근하였습니다..."); }
public String toString() { return "직원의 이름은 " + name + "이다."; }
abstract public void startJob();
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee implements SmallDriver{
//영업담당지역, 차종류 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea, carName;
public SalesEmployee(String newName,String newID,String newArea,String carName) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea; this.carName = carName;
}
// SmallDrive 인터페이스의 메소드 구현
public void driveSmallCar() {
System.out.println("영업팀 직원 " + name + "은 " + this.carName + "를 운전한다.");
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//Main Class
class InterfaceSample1 {
public static void main(String[] args) {
// 인터페이스가 클래스의 객체를 참조하도록...
SmallDriver sm1 = new SalesEmployee("홍길동", "11111","서울", "아반테");
// 인터페이스의 메소드 사용
sm1.driveSmallCar();
}
}
자바 상속(JAVA EXTENDS), 자바실무강좌,오라클실무강좌,OnJ,ORACLEJAVA
상속 개념 이해 바랍니다.
상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(SubClass)라고 부른다. 그리고 원래의 클래스는 상위클래스(SuperClass)라고 부른다. 하위클래스는 상위클래스에서 정의한 메쏘드와 변수들을 그대로 가지고 있을 수 있다. (물론 이것도 접근변경자를 통해 조절이 가능하다) 여기에 추가로 하위 클래스 자체적으로 정의된 메쏘드와 변수들을 가질 수 있다. 어떤 클래스에 대해서, 상속받는 하위 클래스는 여러 개가 될수 있다.
이미 만들어놓은 클래스를 기반으로 원하는 기능이 추가된 새로운 클래스를 쉽게 만들어낼 수 있다
자바의 모든 클래스는 상속의 대상이 되는 상위클래스(SuperClass)가 반드시 하나 존재한다
프로그램의 재사용성과 확장성을 높인다.
class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
Employee Class를 상속한 Manager Class가 있다….
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 관리업무를 시작합니다...");
}
}
Employee Class를 상속한 SalesEmployee Class가 있다….
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 “ + this.chargeArea + “ 지역으로 영업업무를 나갑니다...");
}
}
상속을 위해서는 extends keyword를 사용한다. (class a extends b b로 부터 상속을 받음)
extends키워드를 이용해 클래스를 상속받으면 상속받은 클래스는 상위클래스의 필드와 메소드를 상속받는다.
(예) 앞의 Manager Class instance화 했다면
Manager m = new Manager(“홍길동”, “12345”,”관리부”);
String id = m.id;
m.gotoOffice();
등과 같이 사용이 가능하다… 물론 m.startJob() 처럼 자신의 Method를 사용이 가능하다.
하위클래스는 객체를 생성할 때 상위클래스의 객체를 먼저 생성해야 한다. 하위클래스는 크게 상위클래스 객체부와 자기 자신의 객체부로 나눌 수 있다. 즉 new 키워드를 사용하여 하위클래스를 생성하면 상위클래스의 부분과 하위클래스 고유의 부분이 나뉘어 생성된다는 것이다. 이때 상위클래스 부분을 super라고 한다. 그리고 상위클래스 객체부를 생성하기 위해 사용하는 것이 바로 상위클래스 생성자 super()이다.
(예) 만약 Manager Class에서 super(newName, newID)를 생략하면 다음과 같은 에러가 난다. 생략시에는 default로 super() 이 삽입되는데ㅡ Employee에는 파라미터가 없는 생성자가 선언되지 않았기때문에 ….
Example.java:22: cannot resolve symbol symbol : constructor Employee ()
location: class Employee public Manager(String newName,String newID,String newDept) {
하위클래스에서 상위클래스의 멤버를 호출하고자 할때는 .(점) 연산자를 사용하여 나타낼 수 있다.
(예) Manager Class에서 super.name
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리 업무 를 시작합니다...");
}
이제 SaleEmployee(영업부직원)을 상속한(확장한) SalesChief(영업팀장) Class를 만들어보자.
영업팀장 Class는 영업부직원과 같이 id,이름,영업담당 지역을 가지면서 자신만의 속성을 가진다.
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
//super는 상위클래스의 생성자를 의미
super(newName, newID, newArea);
this.salesTarget = newSalesTarget;
}
//영업팀장의 업무는 더이상 확장이 안된다는 의미, 상속할수가 없다는 의미
final public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
SalesChief Class의 경우 SalesEmployee의 startJob() 메소드를 재정의(Override) 했다.
메소드의 재정의라고 하는 것은 상속의 관계에 있는 클래스들 사이에서 상위클래스에 있는 메소드를 하위클래스에서 다시 정의하여 사용하는 것을 말한다. 이 경우 하위클래스의 메소드는 상위클래스의 메소드와 이름도, 매개변수 타입도, 그리고 반환형도 같다. 하지만 내부적으로 하는 일은 다르다.
만약 SalesChief Class의 startJob 메소드에서 다음과 같이 정의한다면,,,
public void startJob() {
System.out.println(super.chargeArea);
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
아래와 같은 오류발생…
Example.java:59: chargeArea has private access in SalesEmployee
System.out.println(super.chargeArea);
객체지향 언어에서는 정보의 은닉(캡슐화,Encapsulation) 을 위해서 위와 같은 접근지정을 할 수 있다. 즉 SaleEmployee의 자료중 정보 은닉의 필요가 있는 필드나 메소드는 접근지정자를 사용해 접근을 제한할 수 있는 것이다.
현재 작성한 클래스나 클래스의 멤버를 다른 클래스에게 상속시키고자 하지 않을경우엔 final 키워드를 사용한다.예를 들어 한 회사에 영업팀장은 그 만의 고유한 업무를 가지고 영업팀장의 업무를 관리하는 또 다른 개체가 없을 때는 영업팀장을 상속하여 더 확장된 기능을 가진 클래스를 만들 필요가 없을 것이다. 이럴 경우 final 키워드를 사용한다.
메소드의 경우도 이와 같이 상속을 완전히 금지하는 경우가 있는데 이러한 메소드도 final이라는 키워드와 같이 사용하게 되고 종단 메소드(final method)라고 부른다.
-------------------------------
/* Class의 상속에 관한 예제 Example1.*/
//직원 Class
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 일을 시작합니다...");
}
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
super(newName, newID, newArea); this.salesTarget = newSalesTarget;
}
public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
//Main Class
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발");
m.gotoOffice(); m.startJob(); m.gotoHome();
SalesEmployee se = new SalesEmployee("차두리","23456","서울");
se.gotoOffice(); se.startJob(); se.gotoHome();
SalesChief sc = new SalesChief("홍길동","34567","전국",9000);
sc.gotoOffice(); sc.startJob(); sc.gotoHome();
}
}
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(SubClass)라고 부른다. 그리고 원래의 클래스는 상위클래스(SuperClass)라고 부른다. 하위클래스는 상위클래스에서 정의한 메쏘드와 변수들을 그대로 가지고 있을 수 있다. (물론 이것도 접근변경자를 통해 조절이 가능하다) 여기에 추가로 하위 클래스 자체적으로 정의된 메쏘드와 변수들을 가질 수 있다. 어떤 클래스에 대해서, 상속받는 하위 클래스는 여러 개가 될수 있다.
이미 만들어놓은 클래스를 기반으로 원하는 기능이 추가된 새로운 클래스를 쉽게 만들어낼 수 있다
자바의 모든 클래스는 상속의 대상이 되는 상위클래스(SuperClass)가 반드시 하나 존재한다
프로그램의 재사용성과 확장성을 높인다.
class Employee {
String name; String id;
//생성자
public Employee(String name1, String id1) {
name = name1; id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
Employee Class를 상속한 Manager Class가 있다….
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 관리업무를 시작합니다...");
}
}
Employee Class를 상속한 SalesEmployee Class가 있다….
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 “ + this.chargeArea + “ 지역으로 영업업무를 나갑니다...");
}
}
상속을 위해서는 extends keyword를 사용한다. (class a extends b b로 부터 상속을 받음)
extends키워드를 이용해 클래스를 상속받으면 상속받은 클래스는 상위클래스의 필드와 메소드를 상속받는다.
(예) 앞의 Manager Class instance화 했다면
Manager m = new Manager(“홍길동”, “12345”,”관리부”);
String id = m.id;
m.gotoOffice();
등과 같이 사용이 가능하다… 물론 m.startJob() 처럼 자신의 Method를 사용이 가능하다.
하위클래스는 객체를 생성할 때 상위클래스의 객체를 먼저 생성해야 한다. 하위클래스는 크게 상위클래스 객체부와 자기 자신의 객체부로 나눌 수 있다. 즉 new 키워드를 사용하여 하위클래스를 생성하면 상위클래스의 부분과 하위클래스 고유의 부분이 나뉘어 생성된다는 것이다. 이때 상위클래스 부분을 super라고 한다. 그리고 상위클래스 객체부를 생성하기 위해 사용하는 것이 바로 상위클래스 생성자 super()이다.
(예) 만약 Manager Class에서 super(newName, newID)를 생략하면 다음과 같은 에러가 난다. 생략시에는 default로 super() 이 삽입되는데ㅡ Employee에는 파라미터가 없는 생성자가 선언되지 않았기때문에 ….
Example.java:22: cannot resolve symbol symbol : constructor Employee ()
location: class Employee public Manager(String newName,String newID,String newDept) {
하위클래스에서 상위클래스의 멤버를 호출하고자 할때는 .(점) 연산자를 사용하여 나타낼 수 있다.
(예) Manager Class에서 super.name
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리 업무 를 시작합니다...");
}
이제 SaleEmployee(영업부직원)을 상속한(확장한) SalesChief(영업팀장) Class를 만들어보자.
영업팀장 Class는 영업부직원과 같이 id,이름,영업담당 지역을 가지면서 자신만의 속성을 가진다.
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
//super는 상위클래스의 생성자를 의미
super(newName, newID, newArea);
this.salesTarget = newSalesTarget;
}
//영업팀장의 업무는 더이상 확장이 안된다는 의미, 상속할수가 없다는 의미
final public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
SalesChief Class의 경우 SalesEmployee의 startJob() 메소드를 재정의(Override) 했다.
메소드의 재정의라고 하는 것은 상속의 관계에 있는 클래스들 사이에서 상위클래스에 있는 메소드를 하위클래스에서 다시 정의하여 사용하는 것을 말한다. 이 경우 하위클래스의 메소드는 상위클래스의 메소드와 이름도, 매개변수 타입도, 그리고 반환형도 같다. 하지만 내부적으로 하는 일은 다르다.
만약 SalesChief Class의 startJob 메소드에서 다음과 같이 정의한다면,,,
public void startJob() {
System.out.println(super.chargeArea);
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
아래와 같은 오류발생…
Example.java:59: chargeArea has private access in SalesEmployee
System.out.println(super.chargeArea);
객체지향 언어에서는 정보의 은닉(캡슐화,Encapsulation) 을 위해서 위와 같은 접근지정을 할 수 있다. 즉 SaleEmployee의 자료중 정보 은닉의 필요가 있는 필드나 메소드는 접근지정자를 사용해 접근을 제한할 수 있는 것이다.
현재 작성한 클래스나 클래스의 멤버를 다른 클래스에게 상속시키고자 하지 않을경우엔 final 키워드를 사용한다.예를 들어 한 회사에 영업팀장은 그 만의 고유한 업무를 가지고 영업팀장의 업무를 관리하는 또 다른 개체가 없을 때는 영업팀장을 상속하여 더 확장된 기능을 가진 클래스를 만들 필요가 없을 것이다. 이럴 경우 final 키워드를 사용한다.
메소드의 경우도 이와 같이 상속을 완전히 금지하는 경우가 있는데 이러한 메소드도 final이라는 키워드와 같이 사용하게 되고 종단 메소드(final method)라고 부른다.
-------------------------------
/* Class의 상속에 관한 예제 Example1.*/
//직원 Class
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
//직원클래스를 상속한 일반관리자 Class
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept + " " + super.name + "님이 일을 시작합니다...");
}
}
//직원클래스를 상속한 영업팀직원 클래스
class SalesEmployee extends Employee {
//영업담당지역, 메소드내에서만 변수에 접근이 가능하다.
private String chargeArea;
public SalesEmployee(String newName,String newID,String newArea) {
//super는 상위클래스의 생성자를 의미
super(newName, newID); this.chargeArea = newArea;
}
public void startJob() {
System.out.println(super.name + "님이 " + this.chargeArea + " 지역으로 영업업무를 나갑니다...");
}
}
//영업팀직원 클래스를 상속한 영업팀장 클래스
class SalesChief extends SalesEmployee {
int salesTarget; //영업팀 목표 매출액
public SalesChief(String newName,String newID,String newArea, int newSalesTarget) {
super(newName, newID, newArea); this.salesTarget = newSalesTarget;
}
public void startJob() {
System.out.println(super.name + "님이 영업팀 직원을 관리한다...");
System.out.println(super.name + "님이 관리하는 영업팀의 매출목표는 "+ this.salesTarget + "만원 입니다...");
}
}
//Main Class
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발");
m.gotoOffice(); m.startJob(); m.gotoHome();
SalesEmployee se = new SalesEmployee("차두리","23456","서울");
se.gotoOffice(); se.startJob(); se.gotoHome();
SalesChief sc = new SalesChief("홍길동","34567","전국",9000);
sc.gotoOffice(); sc.startJob(); sc.gotoHome();
}
}
2013년 7월 28일 일요일
오라클,자바,닷넷,안드로이드, 아이폰, iOS, AJAX, jQuery, SQL 실무교육, 구로디지털가산에위치, 개발자전문교육,오엔제이프로그래밍실무교육센터
1998년부터 운영된 오라클자바커뮤니티(www.oraclejavacommunity.co.kr)에서 설립 운영되고 있는 오엔제이
프로그래밍실무학원(www.onjprogramming.co.kr )은 개발자를 위한 실무 SKILL UP 전문 교육센터 입니다.
(2008년5월부터 오엔제이시스템즈에서 운영하던 "오라클자바교육센터"는 2013년5월 양도 하였으며 새로운 오엔제이 프로그래밍 실무교육센터에서 개발자 실무 교육을 이어갈 수 있도록 더욱 더 노력 하겠습니다.)
자바, 오라클의 기초부터 자바프레임워크(Struts, Spring), 오라클 튜닝, 모델링, 고급SQL, Xinternet(GAUCE, Miplatform, XPlatform), 닷넷(C#, ASP.Net), 스마트폰앱개발교육(안드로이드, 아이폰)까지 실무전문 교육을 진행하고 있습니다.
(본원은 TOBESOFT에서 공인 교육기관 입니다.)
자바, 스프링, 오라클 교육 받으셨는데 이론으로 교육을 받으셨다고요? IT프로그래밍 교육은 실전예제, 실습을 통해 이론을 습득을 해야 합니다. 본원은 모든 강좌가 실습을 통해 이론을 취득하는 실무중심 교육 입니다.
한번 방문 하시어 실무전문 교육의 진수를 느껴 보시기 바랍니다.
(2008년5월부터 오엔제이시스템즈에서 운영하던 "오라클자바교육센터"는 2013년5월 양도 하였으며 새로운 오엔제이 프로그래밍 실무교육센터에서 개발자 실무 교육을 이어갈 수 있도록 더욱 더 노력 하겠습니다.)
자바, 오라클의 기초부터 자바프레임워크(Struts, Spring), 오라클 튜닝, 모델링, 고급SQL, Xinternet(GAUCE, Miplatform, XPlatform), 닷넷(C#, ASP.Net), 스마트폰앱개발교육(안드로이드, 아이폰)까지 실무전문 교육을 진행하고 있습니다.
(본원은 TOBESOFT에서 공인 교육기관 입니다.)
자바, 스프링, 오라클 교육 받으셨는데 이론으로 교육을 받으셨다고요? IT프로그래밍 교육은 실전예제, 실습을 통해 이론을 습득을 해야 합니다. 본원은 모든 강좌가 실습을 통해 이론을 취득하는 실무중심 교육 입니다.
한번 방문 하시어 실무전문 교육의 진수를 느껴 보시기 바랍니다.
(오라클자바개발자실무교육,오엔제이프로그래밍실무교육센터)자바의 객체지향적 특징
******** 자바의 특성(객체지향적) ************
오라클자바커뮤니티에서 설립한
오엔제이프로그래밍 실무교육센터
(오라클SQL, 튜닝,
힌트,자바프레임워크, 안드로이드, 아이폰, 닷넷 실무전문 강의)
추상화(Abstraction) : 실제 사물을 명사화/동사화 시켜서 프로그램에 적용할수 있는 형태로 만드는 것
상속성(Inheritance) : 미리 만들어진 소스를 가지고 공유하며 재사용하고, 또한 특별한 부분에 대 해서는 다시 재정의해서 사용하는 것 자바에서 상속은 한 클래스를 확장하여 새로운 클래스를 만드는 것을 말한다. 이렇게 새로 만들어지는 클래스를 하위클래스(subclass)라고 부른다. 그리고 원래의 클래스는 상위클래스(superclass)라고 부른다.
다형성(Polymorphism) : 상속을 받은 것을 그대로 사용하지 않고 입맛에 맞게 바꾸어 줄 수 있도록 하는것이며 이 때문에 다형성 함수는 전달하는 변수의 타입을 고려하지 않게된다.
캡슐화(Encapsulation) : 캡슐화는 사용자로부터 객체 내부의 데이터를 감추는 것이다. 데이터를 변수로 나타내며, 클래스의 함수와 프로시저는 메소드(Method)라고 한다. 클래스가 다른 클래스의 데이터를 다루려면 메소드를 통해야 한다. 이러한 캡슐화는 객체 내부의 처리과정을 알 필요없이 그것을 다루는 메소드에 대해서만 알면 된다는 점에서 편리하다. 변수들(외부에서 임의로 조작되었을때 원하지 않는 결과가 나오는것들 또는 잘못된 결과가 나오는것들) 에대해서 외부로 부터 접근제한을 시키는 것이 바로 encapsulation, 즉 객체내부의 데이터와 메소드 항목을 정의할때 private로 지정하여 클래스 외부에서의 접근을 제한하는것.
다중 쓰레드를 지원한다.
- 프로세스는 실행중인 프로그램을 뜻하는 말입니다. 보통 프로세스가 운영 체제의
여 러 자원을 사용하는 기본 단의 입니다.
- 쓰레드(Thread)란 프로세스 내부에서 실행되는 일련의 명령 흐름을 뜻합니다.
프로세스내의 제어의 단일 순차 흐름을 의미하며, 때때로 수행 문맥
(execution context)또는 가벼운 프로세스(lightweight peocess)라함
- 프로세스가 실행되면서 하나의 흐름만을 갖는 것이 아니라 여러 개의 흐름으로
분기할 수 있으며 하나의 프로세스가 같은 시간에 여러 가지 일을 수행하기
위해서 여러 개의 스레드를 만들게 됩니다.
- 다중 쓰레드란 하나의 프로그램내에서 동시에 수행되며 서로 다른 작업들을
수행하는 복수개의 쓰레드들을 의미한다.
[예제]
class Employee {
String name;
String id;
//생성자
public Employee(String name1, String id1) {
name = name1;
id = id1;
}
public void gotoOffice() {
System.out.println(name+"님 출근하였습니다...");
}
public void gotoHome() {
System.out.println(name+"님 퇴근하였습니다...");
}
}
class Manager extends Employee {
String chargeDept;
public Manager(String newName,String newID,String newDept) {
//super는 상위클래스의 생성자를 의미
super(newName, newID);
this.chargeDept = newDept;
}
public void startJob() {
System.out.println(this.chargeDept +” “+ super.name + "님이 직원관리를 시작합니다...");
}
}
class Example {
public static void main(String args[]) {
Manager m = new Manager("이종철","12345","솔루션개발부");
m.gotoOffice();
m.startJob();
m.gotoHome();
Manager m1 = new Manager("홍길동","12346","고객관리부");
m1.gotoOffice();
m1.startJob();
m1.gotoHome();
}
}
피드 구독하기:
글 (Atom)