java interface abstract class tutorial with examples
이 비디오 자습서에서는 Java 인터페이스의 정의, 구현 방법 및 Java의 인터페이스를 사용한 다중 상속을 예제와 함께 설명합니다.
이전 튜토리얼 중 하나에서 추상화에 대해 자세히 논의했습니다. 여기서 우리는 추상 클래스와 추상 메서드에 대해 논의했습니다. 추상 클래스에서 추상이 아닌 메서드를 가질 수도 있으므로 추상 클래스가 추상을 제공한다는 것을 알고 있습니다.
Java에서 100 % 추상화를 제공하는 기능을 ' 상호 작용 ”. 이 튜토리얼에서는 Java의 인터페이스.
=> 여기에서 Java Beginners Guide를 살펴보십시오.
학습 내용 :
인터페이스 및 추상 클래스에 대한 비디오 자습서
Java의 인터페이스 및 추상 클래스 소개 – 1 부 :
Java의 인터페이스 및 추상 클래스 개요 – 2 부 :
Java의 추상화 및 상속 :
자바의 인터페이스 란?
Java의 인터페이스는 클래스 동작을 지정하는 추상 유형으로 정의됩니다. 인터페이스는 특정 클래스의 동작 방식에 관한 규칙을 설정하는 일종의 프로토콜입니다.
Java의 인터페이스에는 추상 메서드와 정적 상수가 포함될 수 있습니다. 기본적으로 인터페이스의 모든 메서드는 공개 및 추상입니다.
Java 인터페이스의 간단한 예가 아래에 나와 있습니다.
interface shape{ public static final String color = “Red”; public void calculateArea(); }위의 예는 정적 변수와 추상 메서드 인 'calculateArea ()'가있는 인터페이스 'shape'를 정의합니다.
인터페이스는 본문으로 추상 메서드 만있는 엔티티입니다. 또한 정적 최종 변수를 포함 할 수도 있습니다.
따라서 클래스와 마찬가지로 인터페이스도 메서드와 변수를 가질 수 있지만 메서드는 추상 (구현 없음)이고 변수는 정적입니다.
인터페이스와 관련하여 염두에 두어야 할 몇 가지 속성은 다음과 같습니다.
- 인터페이스는 클래스의 청사진입니다. 학생들은 자신의 방법을 통해 무엇을해야하는지 학생들에게 알려줍니다.
- 인터페이스는 추상 메서드를 지정하고 해당 인터페이스를 구현하는 클래스도 해당 메서드를 구현해야합니다.
- 인터페이스를 구현하는 클래스가 인터페이스의 모든 메서드를 정의하지 않으면 해당 클래스가 추상 클래스가됩니다.
인터페이스 선언의 일반적인 구문은 다음과 같습니다.
interface { //constant or static fields declaration //abstract method declaration //default declarations }위의 선언에서 볼 수 있듯이 우리는 현재 인터페이스를 선언하고 있음을 나타내는 Java 키워드 'interface'를 사용합니다.
C ++의 링크 목록
‘인터페이스’키워드 뒤에는 interface_name과 여는 중괄호가옵니다. 그런 다음 추상 메서드, 정적 필드 선언 등의 다양한 선언이 있습니다. 마지막으로 중괄호를 닫습니다.
예를 들면두 개의 메소드 즉, method_one과 method_two가있는 인터페이스 'TestInterface'를 선언하려는 경우 TestInterface의 선언은 다음과 같습니다.
interface TestInterface{ void method_one(); void method_two(); }Java에서 인터페이스 사용
- Java의 인터페이스는 추상 메서드 만 가질 수 있으므로 100 % 추상화를 제공합니다.
- 인터페이스를 사용하면 클래스를 사용하여 불가능한 Java에서 다중 상속을 얻을 수 있습니다.
- 느슨한 결합을 달성하기 위해 인터페이스를 사용할 수 있습니다.
Java에서 인터페이스를 구현하는 방법
인터페이스가 선언되면 클래스에서 사용할 수 있습니다. 'implements'키워드 사용 클래스 선언에서.
이 '구현'키워드는 아래와 같이 클래스 이름 뒤에 나타납니다.
class implements { //class body }인터페이스 구현은 계약서에 서명하는 것과 같습니다. 따라서 인터페이스를 구현하는 클래스는 계약에 서명하고 인터페이스의 추상 메서드를 구현하는 데 동의했음을 의미합니다. 즉, 인터페이스에서 지정한 동작을 수행합니다.
인터페이스를 구현하는 클래스가 인터페이스에 지정된 정확한 동작을 구현하지 않는 경우 클래스를 추상으로 선언해야합니다.
인터페이스 구현 예
다음은 Java 인터페이스의 간단한 예입니다.
//interface declaration interface Polygon_Shape { void calculateArea(int length, int breadth); } //implement the interface class Rectangle implements Polygon_Shape { //implement the interface method public void calculateArea(int length, int breadth) { System.out.println('The area of the rectangle is ' + (length * breadth)); } } class Main { public static void main(String() args) { Rectangle rect = new Rectangle(); //declare a class object rect.calculateArea(10, 20); //call the method } }산출:
위 프로그램은 Java 인터페이스의 간단한 예를 보여줍니다. 여기에서 Polygon_Shape라는 인터페이스를 선언 한 다음 Rectangle 클래스가이를 구현합니다.
Java의 인터페이스 명명 규칙
Java 이름 지정 규칙은 읽을 수있는 일관된 코드를 생성 할 수 있도록 프로그래머로서 따라야하는 이름 지정 지침입니다. Java는 이름 지정 클래스 및 인터페이스에 'TitleCase'표기법을 사용합니다. 변수, 메소드 등에 'CamelCase'표기법을 사용합니다.
인터페이스에 관한 한 인터페이스 이름은 제목 케이스에 있으며 인터페이스 이름의 모든 단어의 첫 글자는 대문자입니다. 인터페이스 이름은 일반적으로 형용사가되도록 선택됩니다. 그러나 인터페이스가 map 또는 list와 같은 클래스 패밀리를 나타내는 경우 명사를 따라 이름을 지정할 수 있습니다.
유효한 인터페이스 이름의 몇 가지 예는 다음과 같습니다.
public interface Iterable {} public interface List {} public interface Serializable {} public interface Clonable {} public interface Runnable {}인터페이스 생성자
다음 질문은 인터페이스에 생성자가 있는지 여부입니다.
우리는 메소드를 호출하기 위해 객체가 필요하다는 것을 알고 있습니다. 객체를 생성하려면 생성자가 필요합니다. 그러나 Java 인터페이스의 경우 메서드가 구현되지 않습니다.
인터페이스의 방법은 모두 추상적입니다. 따라서 인터페이스에서 이러한 메서드를 호출 할 필요가 없습니다. 둘째, 인터페이스는 기본적으로 추상이므로 인터페이스의 객체를 만들 수 없습니다. 따라서 인터페이스에 대한 생성자가 필요하지 않습니다.
인터페이스 방법
이 섹션에서는 인터페이스 메서드를 선언하는 방법에 대해 설명합니다. 규칙에 따라 인터페이스는 공용 메서드 만 가질 수 있으며 기본적으로 인터페이스 메서드는 공용입니다. 인터페이스 내에서 다른 액세스 수정자를 사용할 수 없습니다.
따라서 명시 적으로 선언하든 안하든 인터페이스의 모든 메서드는 기본적으로 공개적으로 표시되는 추상입니다.
따라서 void printMethod ()가 인터페이스에서 선언하려는 프로토 타입이면 다음 선언은 동일합니다.
void printMethod(); public void printMethod(); abstract void printMethod (); public abstract void printMethod ();인터페이스 메서드에 대한 인터페이스 내에서 다음 수정자를 사용할 수 없습니다.
- 결정적인
- 공전
- 은밀한
- 보호
- 동기화 됨
- 원주민
- strictfp
이제 인터페이스 메소드 가시성을 보여주기 위해 Java 프로그램을 구현해 보겠습니다.
//declare an interface interface TestInterface { void printMethod(); //default visibility is public. } //interface implementation class TestClass implements TestInterface { //if the access modifier is changed to any other, compiler generates error public void printMethod() { System.out.println('TestClass::printMethod()'); } } class Main { public static void main(String() args) { TestClass tc = new TestClass(); //create an object tc.printMethod(); //call concrete method } } 산출:
이미 언급했듯이 기본적으로 인터페이스 메서드는 공용입니다. 따라서 인터페이스 메소드에 대한 액세스 수정자를 지정하지 않으면 위의 프로그램에서와 같이 공개됩니다.
위 프로그램에서 인터페이스 메서드 선언을 다음과 같이 변경한다고 가정합니다.
private void printMethod ();
이것은 우리가 인터페이스 메소드 printMethod ()를 private으로 지정했음을 의미합니다. 프로그램을 컴파일 할 때 다음과 같은 컴파일러 오류가 발생합니다.
오류 : 여기에서는 수정 자 전용이 허용되지 않습니다.
private void printMethod ();
테스트 할 수있는 두 번째 경우는 TestClass 클래스에서 구현 된 메서드의 수정자를 public에서 private으로 변경하는 것입니다. 이제 클래스의 기본 수정자는 비공개입니다. 따라서 다음과 같이 클래스의 메서드 프로토 타입에서 public 키워드를 제거합니다.
void printMethod() { System.out.println('TestClass::printMethod()'); }이제 프로그램을 컴파일하면 다음과 같은 오류가 발생합니다.
오류 : TestClass의 printMethod ()는 TestInterface에서 printMethod ()를 구현할 수 없습니다.
void printMethod ()
^
더 약한 액세스 권한을 할당하려고 시도합니다. 공개되었다
따라서 여기서 주목해야 할 점은 인터페이스의 구현 된 메서드의 액세스 수정자를 다른 액세스 수정 자로 변경할 수 없다는 것입니다. 인터페이스 메서드는 기본적으로 공용이므로 인터페이스를 구현하는 클래스에 의해 구현 될 때 이러한 메서드도 공용이어야합니다.
자바의 인터페이스 필드
인터페이스에 선언 된 필드 또는 변수는 기본적으로 public, static 및 final입니다. 이것은 일단 선언 된 값은 변경할 수 없음을 의미합니다.
인터페이스 필드가 이러한 수정자를 지정하지 않고 정의 된 경우 Java 컴파일러는 이러한 수정자를 가정합니다. 예를 들면 인터페이스에서 필드를 선언 할 때 public 한정자를 지정하지 않으면 기본적으로 가정됩니다.
인터페이스가 클래스에 의해 구현되면 인터페이스의 모든 추상 메서드에 대한 구현을 제공합니다. 마찬가지로 인터페이스에 선언 된 모든 필드도 인터페이스를 구현하는 클래스에 상속됩니다. 따라서 인터페이스 필드의 복사본이 구현 클래스에 있습니다.
이제 인터페이스의 모든 필드는 기본적으로 정적입니다. 따라서 객체가 아닌 클래스 이름을 사용하여 클래스의 정적 필드에 액세스하는 것과 동일한 인터페이스 이름을 사용하여 직접 액세스 할 수 있습니다.
아래의 예제 Java 프로그램은 인터페이스 필드에 액세스하는 방법을 보여줍니다.
//interface declaration interface TestInterface{ public static int value = 100; //interface field public void display(); } //Interface implementation class TestClass implements TestInterface{ public static int value = 5000; //class fields public void display() { System.out.println('TestClass::display () method'); } public void show() { System.out.println('TestClass::show () method'); } } public class Main{ public static void main(String args()) { TestClass testObj = new TestClass(); //print interface and class field values. System.out.println('Value of the interface variable (value): '+TestInterface.value); System.out.println('Value of the class variable (value): '+testObj.value); } }산출:
위의 프로그램에서 볼 수 있듯이 인터페이스 이름과 점 연산자 (.), 실제 변수 또는 필드 이름을 사용하여 인터페이스 필드에 액세스 할 수 있습니다.
자바의 일반 인터페이스
이전 튜토리얼에서 Java 제네릭에 대해 논의했습니다. 제네릭 클래스, 메서드 등을 갖는 것 외에도 제네릭 인터페이스도 가질 수 있습니다. 제네릭 인터페이스는 제네릭 클래스를 지정하는 방식과 유사하게 지정할 수 있습니다.
일반 인터페이스는 데이터 유형과 독립적 인 유형 매개 변수로 선언됩니다.
일반 인터페이스의 일반 구문은 다음과 같습니다.
경험이 풍부한 오라클 인터뷰 질문 및 답변
interface { //interface methods and variables }이제 클래스에서 위의 일반 인터페이스를 사용하려면 아래와 같이 클래스 정의 :
class implements interface_name { //class body }인터페이스와 마찬가지로 클래스에 동일한 param-list를 지정해야합니다.
다음 Java 프로그램은 Java의 일반 인터페이스를 보여줍니다.
//generic interface declaration interface MinInterface>{ T minValue(); } //implementation for generic interface class MinClassImpl> implements MinInterface { T() intArray; MinClassImpl(T() o) { intArray = o; } public T minValue() { T v = intArray(0); for (int i = 1; i intMinValue = new MinClassImpl (intArray); MinClassImpl charMinValue = new MinClassImpl(charArray); //call interface method minValue for int type array System.out.println('Min value in intOfArray: ' + intMinValue.minValue()); //call interface method minValue for char type array System.out.println('Min value in charOfArray: ' + charMinValue.minValue()); } 산출:
위의 프로그램은 배열에서 최소값을 찾는 방법이 포함 된 인터페이스를 구현합니다. 이것은 일반적인 인터페이스입니다. 클래스는이 인터페이스를 구현하고 메서드를 재정의합니다. 메인 메소드에서는 인터페이스 메소드를 호출하여 정수와 문자 배열에서 최소값을 찾습니다.
Java의 다중 인터페이스
상속 주제에서 Java는 '다이아몬드 문제'라는 모호함을 유발하므로 클래스가 여러 클래스에서 상속되는 것을 허용하지 않음을 확인했습니다.
그러나 클래스는 둘 이상의 인터페이스를 상속하거나 구현할 수 있습니다. 이 경우 다중 상속이라고합니다. 따라서 클래스를 통해 Java에서 다중 상속을 구현할 수는 없지만 인터페이스를 사용하여 구현할 수 있습니다.
다음 다이어그램은 인터페이스를 사용한 다중 상속을 보여줍니다. 여기서 클래스는 Interface_one과 Interface_two라는 두 개의 인터페이스를 구현합니다.
클래스가 다중 인터페이스를 구현할 때 인터페이스 이름은 클래스 선언에서 쉼표로 구분됩니다. 복잡성을 처리 할 수있는 한 많은 인터페이스를 구현할 수 있습니다.
다중 인터페이스를 보여주는 Java 프로그램은 다음과 같습니다.
//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration interface Interface_Two{ void show(); } //multiple inheritance - DemoClass implementing Interface_One&Interface_Two class DemoClass implements Interface_One,Interface_Two{ public void print(){ //Override Interface_One print() System.out.println('Democlass::Interface_One_Print ()'); } public void show(){ //Override Interface_Two show() System.out.println('DemoClass::Interface_Two_Show ()'); } } public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } } 산출:
예제가있는 화이트 박스 테스트 기술
위와 같이 두 개의 인터페이스를 구현합니다. 그런 다음 각각의 메서드를 재정의하고 기본 메서드에서 호출합니다.
Java의 다중 상속은 C ++에서 다중 상속이 제공하는 모든 이점을 제공합니다. 그러나 클래스를 사용한 다중 상속과 달리 인터페이스를 사용한 다중 상속에는 모호성이 없습니다.
자바의 인터페이스 상속 : 인터페이스 확장 인터페이스
클래스가 인터페이스를 구현할 때‘ 구현 ’키워드입니다. Java에서 인터페이스는 다른 인터페이스를 상속 할 수 있습니다. 이 작업은‘ 연장하다 ’키워드입니다. 인터페이스가 다른 인터페이스를 확장하는 경우 ' 인터페이스 상속 ”입니다.
인터페이스 상속을 구현하는 Java 프로그램은 다음과 같습니다.
//Interface_One declaration interface Interface_One{ void print(); } //Interface_Two declaration; inherits from Interface_One interface Interface_Two extends Interface_One{ void show(); } //multiple inheritance - DemoClass implementing Interface_Two class DemoClass implements Interface_Two{ public void print(){ //Override Interface_Two print() System.out.println('Democlass public class Main{ public static void main(String args()){ DemoClass obj = new DemoClass(); //create DemoClass object and call methods obj.print(); obj.show(); } } 산출:
인터페이스 상속을 보여주기 위해 인터페이스를 사용하여 다중 상속에 사용한 것과 동일한 프로그램을 수정했습니다. 여기에서는 Interface_two에서 Interface_one을 확장 한 다음 클래스에서 Interface_two를 구현합니다. 인터페이스가 상속되므로 두 메서드를 모두 재정의 할 수 있습니다.
자주 묻는 질문
Q # 1) Java에서 인터페이스를 사용하는 것은 무엇입니까?
대답: Java의 인터페이스는 100 % 추상화를 달성하는 데 사용되는 엔티티입니다. 인터페이스를 구현하는 클래스에서 재정의 할 수있는 추상 메서드 만 포함 할 수 있습니다.
인터페이스는 클래스의 청사진처럼 작동하여 클래스에 추상 메서드 프로토 타입과 정적 상수를 제공 한 다음 클래스가 인터페이스를 구현하여 해당 메서드를 재정의해야합니다.
Q # 2) Java 인터페이스의 장점은 무엇입니까?
대답: Interface의 장점 중 일부는 다음과 같습니다.
- 인터페이스는 클래스의 청사진 역할을합니다.
- 인터페이스는 모든 추상 메소드를 가지고 있으므로 Java에서 100 % 추상화를 제공합니다.
- 인터페이스를 사용하여 Java에서 다중 상속을 수행 할 수 있습니다. Java는 둘 이상의 클래스에서 상속하는 것을 허용하지 않지만 클래스는 여러 인터페이스를 구현할 수 있습니다.
# 3) 인터페이스가 메소드를 가질 수 있습니까?
대답: 인터페이스에는 메서드의 프로토 타입과 정적 및 최종 상수가있을 수 있습니다. 그러나 Java 8부터 인터페이스에는 정적 및 기본 메서드가 포함될 수 있습니다.
Q # 4) 인터페이스를 최종적으로 선언 할 수 있습니까?
대답: 아니요. 인터페이스를 final로 선언하면 클래스에서 구현할 수 없습니다. 클래스에 의해 구현되지 않으면 인터페이스는 어떤 용도로도 사용되지 않습니다.
인터페이스에 대한 추가 정보
인터페이스는 클래스와 같은 청사진이지만 메서드 선언 만 있습니다. 구현 방법이 없습니다. 인터페이스의 모든 메소드는 기본적으로 공개 추상입니다. Java 1.8 인터페이스는 정적 및 기본 메소드를 가질 수 있습니다.
인터페이스는 주로 API에서 사용됩니다.
예를 들면 : 차량의 엔진을 설계하고 있다고 생각해보십시오.
하드웨어 부분에 대한 작업을 마치면 엔진을 사용하는 클라이언트가 일부 소프트웨어 기능을 구현하기를 원합니다. 따라서이 경우 인터페이스에서 엔진 기능을 정의 할 수 있습니다.
Interface Engine { void changeGear(int a); void speedUp(int a); } 인터페이스에 따라야 할 규칙
- 인터페이스를 구현하는 클래스는 인터페이스의 모든 메소드를 구현해야합니다.
- 인터페이스는 최종 변수를 포함 할 수 있습니다.
public class Vehicle implements Engine { int speed; int gear; @Override public void speedUp(int a) { this.speed=a; System.out.println('speed'+speed); } @Override public void changeGear(int a) { this.gear=a; System.out.println('gear'+gear); } public static void main(String() args) { // TODO Auto-generated method stub Vehicle objv=new Vehicle(); objv.changeGear(3); objv.speedUp(70); } } 
여기서 Vehicle 클래스는 엔진 인터페이스를 구현하는 하위 클래스입니다.
추상 클래스는 무엇입니까?
추상 클래스는 클래스와 비슷하지만 추상 메서드와 구체적인 메서드가 있습니다. 추상 메서드에는 구현이 없습니다. 메서드 선언 만 있습니다.
추상 클래스에 대해 따라야 할 규칙
- 추상 클래스는 인스턴스화 할 수 없습니다.
- 추상 클래스를 확장하는 자식 클래스는 부모 클래스의 모든 추상 메서드를 구현하거나 자식 클래스를 추상 클래스로 선언해야합니다.
부분 구현을 디자인하고 싶을 때 추상 클래스로 갈 수 있습니다.
추상 클래스 프로그램의 예 :
EmployeeDetails.java
public abstract class EmployeeDetails { private String name; private int emp_ID; public void commonEmpDetaills() { System.out.println('Name'+name); System.out.println('emp_ID'+emp_ID); } public abstract void confidentialDetails(int s,String p); } 
추상 클래스를 확장 할 클래스입니다.
HR.java
public class HR extends EmployeeDetails { private int salary; private String performance; @Override public void confidentialDetails(int s,String p) { this.salary=s; this.performance=p; System.out.println('salary=='+salary); System.out.println('performance=='+performance); } public static void main(String() args) { HR hr =new HR(); hr.confidentialDetails(5000,'good'); } } 
주목해야 할 핵심 사항 :
- 인터페이스에서 모든 메소드에는 메소드 구현이 없습니다.
- 인터페이스를 구현하는 클래스는 특정 인터페이스의 모든 메소드를 구현해야합니다.
- 추상 클래스는 추상 메서드와 일반 구체 메서드를 가질 수 있습니다. 추상 메서드에는 구현이 없습니다.
- 추상 클래스를 확장하는 클래스는 추상 클래스의 모든 추상 메서드에 대한 구현이 있어야합니다.
- 하위 클래스에 추상 메서드를 구현하는 데 필요한 정보가 충분하지 않은 경우 하위 클래스를 추상 클래스로 선언해야합니다.
결론
이 튜토리얼에서는 Java 인터페이스의 기본 개념을 제시했습니다. 인터페이스의 필요성과 함께 인터페이스의 정의에 대해 논의했습니다. 우리는 그들의 기본 구문과 정의를 탐구했습니다. 그런 다음 'implements'키워드를 사용하는 인터페이스를 사용하는 방법에 대해 논의했습니다.
Java에서 다중 인터페이스 및 인터페이스 상속을 사용하는 방법을 배웠습니다. 다중 인터페이스를 사용하여 Java에서 다중 상속을 구현할 수 있습니다. 인터페이스 상속은 한 인터페이스가 다른 인터페이스를 확장하는 경우입니다.
=> 모두를위한 Java 교육 시리즈를 보려면 여기를 방문하십시오.