개인적으로, 프로그래밍의 소위 클래스는 객체를 분류하는 실제 세계의 클래스와 동일한 개념이지만 프로그래밍에서 빌려줍니다. 클래스는 일련의 공통점과 동일한 작업 또는 동일한 작업을 나타내며 프로그래밍의 추상 데이터 유형입니다. 각 특정 개인 (실제 세계) 및 인스턴스 변수 (프로그래밍 용)는 객체입니다.
클래스는 현실 세계의 특정 객체의 공통 특징 (속성 및 작업)을 나타내는 것이며, 객체는 클래스의 인스턴스입니다.
클래스 속성 : 클래스의 정적 속성의 약어는 변수 또는 기타 클래스 객체와 같은 클래스에 포함 된 다양한 데이터를 나타냅니다.
클래스 서비스 : 멤버 함수 또는 메소드라고합니다.
¨
Java에서 클래스의 정의 형식은 다음과 같습니다.
[수정 자] 클래스 클래스 이름 [학부모 클래스 확장] [인터페이스 이름 구현] {클래스 멤버 변수 선언 클래스 메소드 선언}이것의 각 부분에 대해 자세히 설명해 봅시다.
클래스 키워드 전에 클래스 수정자는 일반적으로 세 가지 유형으로 나뉩니다. 액세스 수정 자 공개 공개 클래스, 최종 수정 자 (최종 클래스 지정자) 및 초록 수정 자 (초록 클래스 지정자)
그중에서도 권한 수정자는 공개 또는 기본값 만 (즉, 비어있는 것, 아무것도, 친근한 것으로 정의됨), 공개는 동일한 패키지 또는 다른 패키지에 있든 클래스가 클래스의 위치를 찾을 수있는 한 클래스를 사용할 수 있음을 의미합니다. 이것은 C ++와 다릅니다. C ++에는 클래스에 대한 액세스 권한을 제한하는 수정자가 아니라 클래스 간 상속 관계에 대한 액세스 권한이 있습니다. 또한, 그들은 모두 클래스 속성 및 방법에 대한 액세스 권한을 가지고 있습니다. 기본 액세스 권한 (즉, 친숙한 것으로 정의 됨)은 동일한 패키지의 클래스에서만 참조 및 액세스 할 수 있지만 가져 오면 다른 패키지의 클래스에서 액세스하고 참조 할 수 없음을 의미합니다.
나중에 언급 될 것입니다. 클래스 속성 및 메소드의 기본 수정자가 사용되면 동일한 패키지의 클래스에서만 참조 및 액세스 할 수 있다고 표현됩니다.
Java에서는 다중 상속이 허용되지 않으며 이는 C ++와 다릅니다. Java는이 단점을 보충하기 위해 인터페이스의 개념을 소개했습니다.
위의 클래스의 정의에서, 클래스 본문은 주로 클래스의 속성과 클래스의 방법을 포함하여 클래스의 특정 내용을 포함합니다. 클래스의 속성은 간단한 변수 또는 특정 클래스의 인스턴스 일 수 있습니다. 클래스의 인스턴스 인 경우 다음과 같이 정의 할 수 있습니다.
[수정 자] 클래스 이름 객체 이름 = 새 클래스 이름 (매개 변수 목록);
객체와 복잡한 변수를 선언 할 때 선언 중에는 생성을 사용할 수 없지만 향후 생성자에서 만들 수 있습니다.
클래스에 정의 된 방법은 일반적으로 두 가지 역할을 수행합니다. 하나는 클래스의 속성에 대한 다양한 작업을 수행하는 것입니다. 다른 하나는 데이터 교환, 메시지 전달 및 다른 클래스 또는 객체와의 다른 작업을 수행하는 것입니다.
Java에서 방법을 선언하기위한 구문은 다음과 같습니다.
[수정 자] 반환 값 유형 메소드 이름 (매개 변수 목록)은 예외 이름 1, 예외 이름 2,… {메소드 바디 : 로컬 변수 선언; 진술 시퀀스;}멤버 함수라고도하는 클래스 방법은 클래스 속성에서 작업을 지정하고 클래스의 내부 기능을 구현하는 데 사용됩니다. 또한 수업이 외부 세계와 상호 작용할 수있는 중요한 창입니다.
Java 프로그래머는 클래스라는 사용자 정의 유형을 만드는 데 중점을 둡니다. 클래스를 프로그래머 정의 유형이라고도합니다. 각 클래스에는 데이터 및 데이터 조작 방법 세트가 포함되어 있습니다. 클래스의 데이터 부분을 인스턴스 변수라고합니다. 사용자 정의 유형 (즉, 클래스)의 인스턴스를 객체라고합니다.
객체는 클래스의 인스턴스입니다. 클래스는 동일한 유형의 객체의 추상화와 객체를 만드는 템플릿입니다. 프로그램에서 객체를 작성하면 객체의 속성 및 방법을 포함하여 메모리에서 공간이 열립니다. 키워드 연산자를 사용하여 객체를 작성하십시오.
생성자 (C ++와 비교할 수 있으며 C ++와 거의 동일합니다)
나만의 생성자를 만듭니다
• 생성자의 이름과 클래스 이름은 동일합니다. 직원 클래스의 객체를 구성 할 때이 생성자가 시작되고 인스턴스 필드에 초기 값이 할당됩니다. Java에서는 정의와 초기화가 통일되어 있습니다. 둘 다 없어서는 안될 것입니다.
예를 들어 다음 코드로 직원 클래스 인스턴스를 작성할 때
신주당 ( "제임스 본드", 100000,1950,1,1);
생성자의 특성은 다음과 같습니다.
(1) 생성자와 클래스의 이름이 동일합니다.
(2) 클래스는 여러 생성자를 가질 수 있습니다.
(3) 생성자는 0, 1 이상의 파라미터를 가질 수 있습니다.
(4) 생성자는 리턴 값이 없습니다.
(5) 생성자는 항상 새 연산자와 함께 호출됩니다.
생성자의 역할
(1) 객체 초기화
(2) 더 많은 유연성을 소개합니다 (가변 할당 또는 더 복잡한 운영)
(3) 생성자는 Java에서 정의 할 수 없습니다
생성자는 Java에서 정의 할 수 없으며 시스템은 시스템의 기본 생성자를 자동으로 생성합니다. 이 생성자의 이름은 클래스 이름과 동일하며 공식적인 매개 변수가 없으며 작업을 수행하지 않습니다.
메소드 개요
Java 프로그램은 클래스 정의로 구성되며 클래스에는 속성과 방법의 두 부분이 있습니다. 속성 설명 클래스는 무엇이며 메소드 설명 클래스가하는 방법은 무엇입니까? 모든 객체에는 특성을 저장할 독립적 인 메모리가 있습니다. 클래스의 모든 객체는 메모리에 저장된 메소드를 공유합니다.
다시 말해, 방법은 클래스의 주요 구성 요소입니다. 클래스에서 프로그램의 역할은이 방법에 반영됩니다.
이 방법은 Java에 의해 명명 된 서브 루틴을 만드는 것입니다. 주요 방법과 여러 하위 방법. 주요 방법은 다른 방법을 호출하고 다른 방법을 서로 호출 할 수 있으며, 동일한 방법을 하나 이상의 방법으로 언제든지 호출 할 수 있습니다.
한 메소드에서 다른 메소드를 정의하면 구문 오류가 발생합니다.
(1) 로컬 변수 "마스크"인스턴스 변수를 피하는 것이 가장 좋습니다. 클래스에서 동일한 이름의 식별자를 사용하지 않고 수행 할 수 있습니다. 메소드 호출의 매개 변수는 숫자 값과 참조를 전달하는 데 사용되며 중첩 및 재귀로 메소드를 호출 할 수도 있습니다.
(2) 메소드 본문에 비 전반 반환 값 유형이 지정된 경우,이 방법에는 반환 문이 포함되어야하며, 어떤 경우에는 리턴 값이 있는지 확인하고, return 문에 따라 어떤 표현식도 가능합니다.
Java 프로그램의 기본 구조는 다음과 같습니다.
Java 클래스 라이브러리 소개; 사용자 클래스 1 정의 {클래스 1의 여러 변수 또는 객체 정의 : 클래스 1의 메소드 1 정의; 클래스 1의 방법 2 정의; … 클래스 1의 메소드 M1 정의; } 사용자 클래스 2 정의 {클래스 2의 여러 변수 또는 객체 정의 : 클래스 2의 메소드 1 정의; 클래스 2의 방법 2 정의; … 클래스 2의 메소드 M2 정의}Java는 라이브러리 제작자가 클라이언트 프로그래머가 사용할 수있는 것과 사용할 수없는 것을 선언 할 수있는 "Access Control Modifier"개념을 도입했습니다.
이 수준의 액세스 제어는 : 공개 "기본값"(키워드 없음), 보호 및 개인을 포함하여 "최대 액세스"와 "최소 액세스"범위 사이입니다. 다음 목록은 액세스 제어 수정 자의 의미를 설명합니다.
공개 액세스 제어 문자
수업 :
Java에는 클래스에 대한 액세스 컨트롤러가 하나뿐입니다 : 공개. 수업은 공개 클래스로 선언되며, 다른 모든 클래스에서 액세스하고 참조 할 수 있음을 나타냅니다. 여기에서 액세스 및 참조는 클래스가 전체적으로 보이고 사용할 수 있음을 나타냅니다. 프로그램의 다른 부분은이 클래스의 객체를 생성하고 클래스 내에서 볼 수있는 멤버 변수에 액세스하고 가시 방법을 호출 할 수 있습니다.
클래스는 프로그램의 다른 부분에 전체적으로 볼 수 있으며, 클래스의 모든 속성과 방법이 프로그램의 다른 부분에도 볼 수 있음을 나타내지는 않습니다. 전자는 후자에 필요한 조건 일뿐입니다. 다른 모든 클래스에서 클래스의 속성과 방법에 액세스 할 수 있는지 여부는 이러한 속성 및 방법의 액세스 제어 문자에 따라 다릅니다.
수업 내 속성에 사용 :
대중으로 수정 된 수업 내 속성을 공개 속성이라고합니다. 이 수업이 공개 수업 인 경우 다른 모든 클래스에서 액세스 할 수 있습니다.
기본 액세스 제어
수업에 사용됩니다
클래스에 액세스 제어 문자가없는 경우 기본 액세스 제어 특성이 있음을 의미합니다. 이 기본 액세스 컨트롤은 클래스가 동일한 패키지의 클래스에서만 액세스하고 참조 할 수 있으며 다른 패키지의 클래스에서 사용할 수 없음을 규정합니다. 이 액세스 기능을 패키지 접근성이라고합니다. 클래스의 액세스 제어 문자를 선언함으로써 전체 프로그램 구조는 명확하고 엄격 할 수있어 가능한 클래스 간 간섭 및 오류를 줄입니다.
클래스 속성에 사용됩니다
클래스 내의 속성과 메소드가 액세스 제어 기호에 의해 제한되지 않으면 패킷 접근성임을 나타냅니다.
3 개인 액세스 제어 문자 비공개
비공개로 수정 된 속성 또는 방법은 클래스 자체에서만 액세스하고 수정할 수 있으며 클래스의 하위 클래스를 포함한 다른 클래스에서 얻고 참조 할 수 없습니다.
1). 예를 들어, 개인 데이터에는 직원 클래스의 인스턴스 내에서 작동되는 데이터가 포함 된 세 가지 인스턴스 필드가 있습니다.
개인 문자열 이름;
개인 이중 급여;
개인 날짜 고용;
개인 키워드는 직원 클래스 자체에서만이 인스턴스 필드에 액세스 할 수 있도록하는 데 사용됩니다.
2). 사료 방법 클래스를 구현할 때는 공개 데이터가 위험하기 때문에 모든 데이터 필드를 비공개로 만듭니다. 방법의 상황은 무엇입니까? 대부분의 방법은 공개적이지만 개인 방법도 자주 사용됩니다. 이 방법은 동일한 방법으로 만 분리 할 수 있습니다.
요컨대, 개인 방법은 다음 경우를 선택할 수 있습니다.
(1) 클래스 사용자와 관련이없는 방법.
(2) 클래스 구현이 변경되면 유지하기 쉽지 않은 방법.
보호 된 액세스 제어 문자 보호
보호로 수정 된 멤버 변수는 세 가지 유형의 세 가지 유형, 즉 클래스 자체, 다른 패키지의 다른 클래스 및 다른 패키지의 클래스 하위 클래스로 참조 할 수 있습니다. 보호 된 수정자를 사용하는 주요 목적은 다른 패키지의 서브 클래스가 부모 클래스의 특정 속성에 액세스 할 수 있도록하는 것입니다.
보호 된 키워드는 기존 클래스를 기반으로하는 "Inheritance"라는 개념을 소개하고 기존 클래스에 영향을 미치지 않고 새로운 멤버를 추가합니다.이 클래스를 "기본 클래스"또는 "기본 클래스"라고합니다. 또한 해당 클래스의 기존 구성원의 동작을 바꿀 수 있습니다. 기존 클래스의 상속을 위해 새로운 클래스가 기존 클래스를 "확장"한다고 말합니다.
개인 보호 액세스 제어 문자 개인 보호
비공개 및 보호는 순서대로 사용하여 완전한 액세스 제어 문자 인 개인 보호 액세스 제어 문자를 형성합니다. 개인 보호로 수정 된 멤버 변수는 두 클래스로 액세스하고 참조 할 수 있으며, 하나는 클래스 자체이며, 다른 하나는 클래스의 하위 클래스입니다. 이러한 서브 클래스는 클래스와 동일한 패키지 또는 다른 패키지에 있는지 여부에 관계없이 클래스의 모든 서브 클래스입니다.
보호 된 것과 비교하여 개인 보호 수정자는 접근 가능한 범위에서 동일한 패키지 내의 비 공동체를 제외하여, 멤버 변수가 느슨하게 그룹화되는 패키지보다는 명백한 상속 관계를 가진 클래스에보다 독점적으로 만듭니다.
정적 수정 자
정적을 정적 수정 자라고하며 클래스에서 속성과 메소드를 수정합니다.
정적 키워드를 사용하면 두 가지 요구 사항을 충족 할 수 있습니다.
(1) 한 가지 상황은 스토리지 영역을 사용하여 특정 데이터를 저장하기를 원한다는 것입니다. 생성하려는 객체 수에 관계없이 객체를 전혀 만들지도 않습니다. 정적으로 수정 된 속성을 정적 특성이라고하며, 이러한 유형의 속성의 가장 중요한 기능 중 하나는 클래스의 특정 객체가 아니라 클래스의 속성이라는 것입니다. 다시 말해,이 클래스의 특정 객체의 경우 정적 속성은 공통 저장 장치입니다. 클래스의 모든 객체가 액세스하면 동일한 숫자 값을 얻습니다. 클래스의 객체가 수정되면 동일한 메모리 장치에서 작업을 수행합니다.
(2) 또 다른 상황은이 클래스의 어떤 대상과 관련이없는 특별한 방법이 필요하다는 것입니다. 즉, 객체가 생성되지 않더라도 클래스에서 직접 호출 할 수있는 방법이 필요합니다.
STATIC의 중요한 목적은 객체를 만들지 않고도 해당 메소드를 호출하도록 돕는 것입니다.
정적 상수
정적 변수는 드물다. 그러나 정적 상수는 일반적입니다. 예를 들어, 정적 상수는 수학 클래스에 정의됩니다.
공공 계급 수학
{… 공개 정적 최종 이중 PI = 3.1.4159265358979323846;…} 정적 메소드는 메소드가 정적이라고 선언합니다.
(1)이 방법을 사용할 때 클래스 이름은 특정 객체 이름이 아닌 접두사로 사용해야합니다.
(2) 비 정적 방법은 물체에 속하는 방법입니다. 이 객체가 생성되면 객체의 메소드에는 자체 전용 코드 세그먼트가 메모리에 있습니다. 정적 메소드는 전체 클래스에 속하되고 메모리의 코드 세그먼트는 클래스의 정의에 따라 할당 및로드되며 어떠한 객체에도 배정됩니다.
(3) 정적 메소드는 전체 클래스에 속하므로 특정 객체에 속하는 멤버 변수를 조작하고 처리 할 수는 없지만 전체 클래스에 속하는 멤버 변수 만 처리 할 수 있습니다.
5 주요 방법
기본 메소드는 객체에 작업을 적용하지 않습니다. 실제로 프로그램이 실행되기 시작하면 아직 객체가 없습니다. 정적 방법이 실행되고 프로그램에 필요한 객체가 구성됩니다.
각 클래스가 주요 방법을 가질 수 있다고 촉구합니다. 이것은 단위 테스트 클래스에 매우 편리한 트릭입니다.
초록은 클래스 또는 메소드를 수정하는 데 사용할 수있는 추상 수정 자입니다.
초록 수업
수업이 추상으로 선언되면이 클래스를 추상 클래스라고합니다. 소위 추상 클래스는 구체적인 인스턴스 객체가없는 클래스입니다.
이 문제를 해결하기 위해 Java는 "Abstract Method"라는 메커니즘을 제공합니다. 그것은 하나의 선언 만있는 불완전한 방법에 속하며 방법 본문이 없습니다. 다음은 초록 방법을 선언 할 때 사용되는 구문입니다.
초록 void x ();
추상 방법
클래스 메소드 수정 자로, 초록은 메소드 헤더 만 있지만 특정 메소드 본문 및 작동 구현이없는 초록 메소드를 선언합니다.
추상 방법에는 메소드 헤더의 선언 만 있고 세미콜론은 메소드 본문의 정의를 대체하는 데 사용됩니다. 메소드 본문의 특정 구현은 해당 클래스 정의에서 현재 클래스의 다른 서브 클래스에 의해 완료됩니다.
모든 추상적 인 방법은 추상 클래스에 존재해야한다는 점에 유의해야합니다.
가운데.
추상적 인 방법 외에도 추상 클래스에는 구체적인 데이터와 방법이있을 수 있습니다.
초록 방법은 Java 프로그래밍 언어의 매우 중요한 개념입니다. 인터페이스에서 여러 가지 방법으로 사용합니다.
참고 : 여기서 인터페이스와 비교하고 암기해야합니다. 인터페이스의 메소드는 모두 추상적 인 방법입니다. 물론 인터페이스에는 속성이 있으며 특정 속성은 나중에 자세히 설명됩니다.
최종 클래스, 최종 속성, 최종 메소드 및 최종화기 (C ++에는 최종 수정자가 없습니다)
Final은 클래스, 속성 및 방법을 수정하는 최종 수정 자입니다. 또한 터미널의 키워드는 Final과 매우 유사하며 함께 소개됩니다.
최종 수업
클래스가 최종 선언 된 경우 새 하위 클래스를 도출 할 수 없으며 부모 클래스로 상속받을 수 없음을 의미합니다. 따라서 수업은 추상과 최종으로 선언 될 수 없습니다.
최종으로 정의 된 클래스는 일반적으로 표준 기능을 완료하는 데 사용되는 특수 기능을 가진 일부 클래스입니다. 클래스를 최종으로 정의하면 컨텐츠, 속성 및 기능을 수정하고 클래스 이름과 안정적인 매핑 관계를 형성 하여이 클래스를 참조 할 때 구현 된 기능이 정확합니다.
최종 속성
많은 프로그래밍 언어에는 컴파일러에게 특정 데이터가 "일정"임을 알리는 방법이 있습니다. 상수는 주로 다음 두 가지 측면에서 사용됩니다.
(1) 컴파일 기간이 일정하며 결코 변하지 않을 것입니다.
(2) 우리는 런타임 중에 초기화 된 값이 변경되기를 원하지 않습니다.
인스턴스 필드는 최종으로 정의 될 수 있습니다 (변경할 수 없음). 이 필드는 객체를 구성 할 때 초기화해야합니다. 즉, 각 생성자가 끝나기 전에 값이 설정되었는지 확인해야합니다. 미래에 필드의 가치는 변경 될 수 없습니다.
최종 방법
최종 방법을 사용하는 이유는 두 가지 이유로 고려 사항 때문일 수 있습니다.
첫 번째는 상속 클래스가 원래 의미를 바꾸지 않도록하는 방법을 "잠그는 것"입니다. 프로그램을 설계 할 때,이 연습은 상속 중에 변환되지 않은 방법을 유지하고 덮어 쓰거나 다시 작성할 수없는 경우 방법의 동작이 필요합니다.
최종 방법을 채택하는 두 번째 이유는 프로그램 실행 효율성 때문입니다.
터미네이터
터미네이터의 기능은 객체를 검색 할 때 실행되는 메소드입니다. 객체를 만들 때 생성자가 실행되는 방법과 유사합니다.
예
Protected voidfinalize () {System.out.println ( ""); }다른 수정 자
휘발성 물질
속성이 휘발성에 의해 수정되면이 속성을 동시에 여러 스레드로 제어하고 수정할 수 있음을 의미합니다.
동기화
주로 스레드 동기화에 사용됩니다
토종의
이 방법은 Java 언어로 작성되지 않았 음을 의미합니다 (C, C ++ 및 기타 언어로 작성됨).
온라인에서 발견 된 일부 정보 : - 내부 카테고리
간단히 말해서 내부 수업은 수업의 수업입니다.
클래스 A {private int i; private void m () {} class b {mm (int j) {i = j; m ();}}}여기서 B는 A의 내부 클래스이며 외부 클래스의 개인 방법 및 속성에 대한 편리한 액세스가 특징입니다. 예를 들어, 여기서 B는 개인 속성 I 및 개인 메소드 M ()에서 직접 액세스 할 수 있습니다.
객체 지향 프로그래밍의 가장 중요한 특징은 캡슐화 (추상화라고도 함), 상속 및 다형성입니다. 객체 지향 프로그래밍 언어로서 Java는 이와 관련하여 고유 한 이점이 있습니다.
"상속은 소프트웨어 재사용의 한 형태로, 소프트웨어 복잡성을 줄이는 데 효과적입니다. 상속은 또한 객체 지향 프로그래밍 언어의 특징입니다. 객체를 채택하지만 객체 기반 언어는 아니지만 객체 지향 언어가 아닙니다. 이는 둘 사이의 차이입니다."
계급 간의 상속 관계는 실제 세계에서 유전자 관계를 직접 시뮬레이션하는 것입니다. 클래스 간의 본질적인 연결과 속성 및 작업의 공유, 즉 서브 클래스는 상위 클래스의 특정 기능 (상속 클래스)을 따를 수 있습니다. 물론 서브 클래스는 자체 독립적 인 속성 및 작업을 가질 수 있습니다.
상속은 소프트웨어 재사용의 한 형태입니다. 새로운 클래스는 기존 클래스에 의해 생성되며, 새로운 속성과 행동은 속성과 행동을 유지하고 새로운 클래스의 요구 사항에 따라 성능을 수정하여 추가됩니다. 어린이 계급이 한 부모 클래스에서만 상속하는 경우이를 단일 상속이라고합니다. 아동 계급이 둘 이상의 부모 클래스에서 상속되는 경우이를 다중 상속이라고합니다. Java는 다중 상속을 지원하지 않지만 "인터페이스"의 개념을 지원합니다. 인터페이스를 통해 Java는 다중 상속의 많은 이점을 얻고 해당 단점을 포기할 수 있습니다. 참고 : C ++는 여러 상속을 지원합니다
상속 관계의 정의 :
[Modifier] 클래스 서브 클래스 이름 확장 부모 클래스 이름, 부모 클래스 이름 2
부모 클래스 이름은 확장됩니다
키워드는 현재 클래스의 하위 클래스가 이미 존재하는 것을 나타내는 데 사용되며 상속 관계가 있습니다.
직원 클래스 직원의 두 하위 클래스 정의 :
일반 직원 범주 : Common Employee
감독자 카테고리 : 관리자
학부모 클래스의 서브 클래스 상속의 두 가지 주요 측면이 있습니다.
(1) 속성 상속. 예를 들어, 회사는 부모 수업이며 회사에는 이름, 주소, 관리자, 직원 등이 있는데, 이는 모든 구조적 측면입니다.
(2) 방법 상속. 학부모 수업은 프로젝트, 이익, 관리자 임명, 채용 직원 등이 필요한 회사와 같은 여러 운영을 정의하며 자회사는 이러한 조치를 상속받을 것입니다.
ClassCommonemployeeeextends 직원 // 서브 클래스 1 : {intm_managerno; // 클래스 속성 M_Managerno 정의 M_Managerno} classmanageremployeeextends 직원 // 서브 클래스 2 : {intm_secretaryno; // Classe Attribute M_Secretaryno,} 속성 상속 및 숨기기
직원 수업은 부모 클래스이지만 부모 클래스이기 때문에 더 많은 기능이 있다는 것을 의미하지는 않습니다. 반대로, 하위 아날로그는 부모 클래스보다 더 많은 기능을 가지고 있습니다. 서브 클래스는 상위 클래스의 확장이기 때문에 부모 클래스가 추가되지 않은 속성 및 방법 (1) 하위 클래스는 부모 클래스의 개인 구성원에게 액세스 할 수 없지만 서브 클래스는 부모 클래스의 대중에게 액세스 할 수 있습니다.
(2) 보호 된 접근은 공공 및 민간 접근 사이의 보호 중간 수준입니다.
(3) 상속 된 부모 클래스 멤버는 서브 클래스 선언에 나열되지 않기 때문에이 구성원은 서브 클래스에 존재합니다.
여기서 우리는 상속, 덮어 쓰기 및 과부하, 몇 가지 혼란스러운 개념을 구별해야합니다.
개념적 수준에서만이 세 가지 개념을 쉽게 혼동 할 수 있습니다.
방법 상속
서브 클래스 객체의 경우 부모 클래스의 메소드를 사용할 수 있습니다. 이러한 메소드가 서브 클래스에서 명확하게 정의되지 않더라도 부모 클래스에서 자동으로 상속됩니다.
방법 커버리지
메소드 오버라이드는 다음을 나타냅니다. 다형성 기술의 구현 인 부모 클래스를 덮어 쓰는 동일한 이름의 메소드를 정의하는 메소드. 아동 클래스에서 부모 수업 메소드가 덮어 쓰는 경우 일반적으로 부모 클래스 버전을 호출하고 추가 작업을 수행하는 것은 아동 클래스 버전입니다.
주목해야 할 것이 많습니다. 여기, 나는 주로 이것과 슈퍼를 언급합니다. C ++에는 이것 (그리고 개념은 Java의 개념과 비슷하지만 슈퍼는 없습니다.
이것은 현재 객체 자체를 나타내며 현재 객체에 대한 참조를 나타냅니다. 객체의 다른 이름으로 이해할 수 있습니다. 이를 통해 현재 객체의 메소드와 속성을 호출 할 수 있습니다.
예를 들어 : this.getName () 및 getName ()은 클래스에서 동일합니다.
Super는 현재 객체의 직접 부모 클래스 객체를 나타내며 현재 객체의 부모 클래스 객체의 참조 메소드 과부하입니다.
오버로드의 정의 :이 메소드는 동일한 메소드 이름으로 정의 될 수 있지만 매개 변수 테이블 (매개 변수 테이블의 매개 변수의 숫자, 유형 또는 순서는 다른 값을 갖습니다)은 메소드 과부하라고합니다.
• 오버로드 : 오버로드는 여러 메소드의 이름이 동일하고 다른 매개 변수를 포함 할 때 발생합니다. 컴파일러는 호출 할 메소드를 선택해야합니다. 다른 메소드 헤더의 매개 변수 유형을 특정 메소드 호출에 사용 된 값 유형과 비교하여 올바른 방법을 선택합니다.
다형성을 사용하면 기존 변수 및 관련 클래스를 통합 스타일로 처리 할 수 있으므로 시스템에 새로운 기능을 쉽게 추가 할 수 있습니다. 여기에서 온라인에서 찾은 정보를 게시하면 상속에 특별한주의가 필요한 다형성 및 상속 문제를보다 명확하게 명확하게 할 수 있습니다.
자바의 다형성
객체 지향 프로그래밍에는 세 가지 특성, 즉 캡슐화, 상속 및 다형성이 있습니다.
캡슐화는 클래스의 내부 구현 메커니즘을 숨겨 데이터를 보호하면서 사용자에게 영향을 미치지 않고 클래스의 내부 구조를 변경할 수 있습니다.
상속은 다형성의 구현을 준비하는 동안 부모 클래스 코드를 재사용하는 것입니다. 그렇다면 다형성이란 무엇입니까?
방법 재 작성, 과부하 및 동적 연결은 다형성을 구성합니다. Java가 다형성의 개념을 도입 한 이유 중 하나는 클래스 상속 측면에서 C ++와 다르기 때문입니다. 후자는 여러 상속을 허용하여 매우 강력한 기능을 제공하지만 복잡한 상속 관계는 C ++ 개발자에게 더 큰 어려움을 초래합니다. 위험을 피하기 위해 Java는 단일 상속 만 허용하며, 파생 클래스와 기본 클래스 사이의 관계가 있습니다 (즉, "고양이"는 "동물"입니다). 이를 수행하면 상속 관계의 단순성과 명확성을 보장하지만 필연적으로 큰 기능적 한계가 있습니다. 따라서 Java는이 단점을 보충하기 위해 다형성의 개념을 도입했습니다. 또한 추상 클래스와 인터페이스는 단일 상속 규정의 한계를 해결하는 데 중요한 수단입니다. 동시에, 다형성은 객체 지향 프로그래밍의 본질이기도합니다.
다형성을 이해하려면 먼저 "상향 변환"이 무엇인지 알아야합니다.
나는 동물 계급을 물려받는 서브 클래스 고양이를 정의했고, 후자는 전자가 부모 클래스라는 것입니다. 나는 통과 할 수있다
cat c = 새로운 고양이 ();
고양이 물체를 인스턴스화하는 것은 이해하기 어렵지 않습니다. 그러나 내가 이것처럼 정의 할 때 :
동물 A = 새로운 고양이 ();
이것이 무엇을 의미합니까?
간단합니다. 그것은 새로 생성 된 고양이 유형의 객체에 대한 동물 유형 참조를 정의한다는 것을 의미합니다. 고양이는 부모 계급 동물에서 상속되기 때문에 동물 유형에 대한 참조는 고양이 유형의 대상을 가리킬 수 있습니다. 그래서 이것을하는 요점은 무엇입니까? 서브 클래스는 상위 클래스의 개선 및 확장이기 때문에 서브 클래스는 일반적으로 부모 클래스보다 강력하며 해당 속성은 부모 클래스보다 독특합니다.
상위 클래스 유형에 대한 참조를 정의하면 서브 클래스가있는 객체에 대한 지적은 서브 클래스의 강력한 기능을 사용할 수있을뿐만 아니라 부모 클래스의 공통점을 추출 할 수 있습니다.
따라서 부모 클래스 유형에 대한 참조는 부모 클래스에 정의 된 모든 속성과 방법을 호출 할 수 있으며, 아동 클래스에서 정의 된 방법은 부모 클래스에서는 그렇지 않습니다.
동시에, 부모 클래스의 메소드는 부모 클래스에서 정의되어 있지만 아동 클래스에서는 무시되지 않는 경우 부모 클래스 유형에 대한 참조로만 호출 할 수 있습니다.
부모 클래스에 정의 된 메소드의 경우, 메소드가 아동 클래스에 다시 작성되는 경우, 상위 클래스 유형에 대한 참조는 동적 연결 인 어린이 클래스 에서이 메소드를 호출합니다.
다음 프로그램을보십시오.
클래스 아버지 {public void func1 () {func2 (); } // 메소드가 아래의 서브 클래스에서 하위 클래스에서 재정의되기 때문에 부모 클래스 유형의 참조에서 호출되면이 메소드가 더 이상 유효하지 않기 때문에이 메소드가 더 이상 유효하지 않기 때문에이 메소드는 부모 클래스의 func2 () 메소드입니다.이 메소드는 더 이상 유효하지 않습니다. }} 클래스 아동을 확장 아버지 {// func1 (int i)은 func1 () 메소드의 과부하입니다. //이 메소드는 부모 클래스에서 정의되지 않기 때문에 부모 클래스 유형의 참조로 호출 할 수 없으므로 child.func1 (68)의 주요 메소드에서는 잘못된 공개 void func1 (int i) {bbbb "("bbb ")입니다. } // func2 ()는 부모 클래스 아버지에서 func2 () 메소드를 다시 작성합니다. // func2 () 메소드가 부모 클래스 유형에 대한 참조에서 호출되면 서브 클래스 공개 void func2 () {system.out.println ( "CCC")에 다시 작성된 메소드 여야합니다. }} 공개 클래스 다형성 테스트 {public static void main (String [] args) {affore child = new child (); child.func1 (); // 인쇄 결과는 무엇입니까? }}위의 프로그램은 다형성의 매우 전형적인 예입니다. 아동 클래스 아동은 부모 클래스 아버지를 물려 받고, 부모 클래스 func1 () 메소드를 과부하시키고 부모 클래스 func2 () 메소드를 덮어 씁니다. 과부하 된 func1 (int i) 및 func1 ()은 더 이상 동일한 방법이 아닙니다. 부모 클래스에는 func1 (int I)이 없기 때문에 부모 클래스 유형의 참조 자식은 func1 (int I) 메소드를 호출 할 수 없습니다. 서브 클래스가 func2 () 메소드를 재정의하면 모 메소드를 호출 할 때 상위 클래스 유형의 참조 자식이 서브 클래스에서 다시 작성된 func2 ()을 호출합니다.
그렇다면 프로그램은 어떤 결과를 인쇄합니까?
분명히 "CCC"여야합니다.
다형성의 경우 다음과 같이 요약 할 수 있습니다.
(1) 부모 클래스 유형의 참조를 사용하여 서브 클래스 (실제 객체)의 객체를 가리 킵니다.
(2)이 참조는 부모 클래스에 정의 된 방법과 변수 만 호출 할 수 있습니다.
(3) 부모 클래스의 메소드가 서브 클래스에 다시 작성되는 경우이 메소드를 호출 할 때 서브 클래스의 메소드가 호출됩니다. (동적 연결, 동적 통화)
(4) 변수를 다시 작성할 수 없습니다 (재정의). "다시 쓰기"의 개념은 메소드에만 해당됩니다. 상위 클래스의 변수가 서브 클래스에서 "다시 작성"하는 경우 편집 중에 오류가보고됩니다.
다형성은 다음과 같습니다.
(1) 인터페이스 및 인터페이스를 구현하고 인터페이스에서 동일한 방법을 다루는 여러 다른 클래스를 덮어 씁니다 (2) 부모 클래스 및 상위 클래스 및 상위 클래스 및 상위 클래스에서 동일한 방법을 다루는 여러 가지 하위 클래스를 덮어 씁니다.
1. 기본 개념
다형성 : 객체에 메시지를 보내고 대상이 응답 할 동작을 결정하게하십시오.
동적 메소드 호출은 슈퍼 클래스 객체 참조 변수에 서브 클래스 객체 참조를 할당하여 구현됩니다.
이 AVA 메커니즘은 원리를 따릅니다. 슈퍼 클래스 객체가 서브 클래스 객체를 참조하는 변수를 지칭하는 경우, 참조 변수의 유형보다는 참조 된 객체의 유형이 멤
(1) A가 클래스 A에 대한 참조 인 경우 A는 클래스 A 인스턴스 또는 클래스 A의 서브 클래스를 가리킬 수 있습니다.
(2) A가 인터페이스 A에 대한 참조 인 경우 A는 인터페이스 A를 구현하는 클래스의 인스턴스를 가리 킵니다.
Java 다형성 구현 메커니즘
Sun의 현재 JVM 구현 메커니즘, 클래스 인스턴스의 참조는 핸들에 대한 포인터이며, 이는 한 쌍의 포인터입니다.
포인터는 테이블을 가리키고 실제로이 테이블은 두 개의 포인터가 있습니다 (하나의 포인터는 객체를 포함하는 메소드 테이블을 가리키고 다른 하나는 클래스 객체에 대한 포인터가 객체가 속하는 유형을 나타냅니다);
또 다른 포인터는 Java 힙에서 할당 된 메모리 공간을 가리 킵니다.
요약
(1) 동적 메소드 호출은 슈퍼 클래스 객체 참조 변수에 서브 클래스 객체 참조를 할당하여 구현됩니다.
DERIVEDC C2 = NEW DERIVEDC (); 베이스 클래스 A1 = C2; // BaseClass Base Class, devivedc는 a1.play ()가 Baseclass에서 상속 된 것입니다. //play() is defined in BaseClass and DerivedC, that is, the subclass overrides the method
分析：
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
* a.play()将执行子类还是父类定义的方法？
아강. During the run time, the corresponding method will be obtained based on the object a reference to the actual type. That's why there is polymorphism. An object reference of a base class is given a different subclass object reference. When executing the method, it will show different behaviors.
在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。
（2）不能把父类对象引用赋给子类对象引用变量
BaseClass a2=new BaseClass(); DerivedC c1=a2;//出错
在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(DerivedC)a2; 进行强制转化,也就是向下转型.
（3）记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如myFun()）
分析：
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。
（4）Java与C++多态性的比较
jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。
Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。
Java的所有函数，除了被声明为final的，都是用后期绑定。
1个行为,不同的对象,他们具体体现出来的方式不一样,
比如: 方法重载overloading 以及方法重写(覆盖)override
class Human{ void run(){输出人在跑} } class Man extends Human{ void run(){输出男人在跑} } 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子) class Test{ void out(String str){输出str} void out(int i){输出i} }这个例子是方法重载,方法名相同,参数表不同
ok,明白了这些还不够,还用人在跑举例
Human ahuman=new Man();
这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象意思是说,把Man这个对象当Human看了.
比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
这个大熊猫对象,你把它当成其父类动物看,这样子合情合理.
这种方式下要注意new Man();的确实例化了Man对象,所以ahuman.run()这个方法输出的是"男人在跑"
如果在子类Man下你写了一些它独有的方法比如eat(),而Human没有这个方法,
在调用eat方法时,一定要注意强制类型转换((Man)ahuman).eat(),这样才可以...
对接口来说,情况是类似的...
예:
package domain; //Define superA class superA { int i = 100; void fun(int j) { j = i; System.out.println("This is superA"); } } //Define superA subclass subB class subB extends superA { int m = 1; void fun(int aa) { System.out.println("This is subB"); } } //Define superA subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subB"); } } //Define superA subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subC"); } } class Test { public static void main(String[] args) { superA a = new superA(); subB b = new subB(); subC c = new subC(); a = b; a.fun(100); a = c; a.fun(200); } } /*
* 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
* "为什么(1)和(2)不输出：This is superA"。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
* 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/
以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法
JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//父类public class Father{ //父类有一个打孩子方法public void hitChild(){ } } //子类1 public class Son1 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("为什么打我？我做错什么了！"); } } //子类2 public class Son2 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("我知道错了，别打了！"); } } //子类3 public class Son3 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("我跑，你打不着！"); } } //测试类public class Test{ public static void main(String args[]){ Father father; father = new Son1(); father.hitChild(); father = new Son2(); father.hitChild(); father = new Son3(); father.hitChild(); } }都调用了相同的方法，出现了不同的结果！这就是多态的表现！
import java.io.*;class Super{ Super(){ System.out.println("This is super class!"); } void method(){ System.out.println("Super's method"); }}class Sub extends Super{ Sub(){ super(); System.out.println("/n/t:and here is the child"); } void method(){ System.out.println("child's method"); }}public class Super_Sub{ public static void main(String[] args){ Super sup=new Sub(); sup.method(); Sub child=(Sub)new Super();//这里，实际分配的内存是Super的，但是却用Child来指代它，这就是“向下转型”(父类冒充子类，因为子类在UML中画时是在下的嘛),必经强制类型转换child.method(); }}对于数据来说，继承是否为正确的设计可以用一个简单的规则来判断。“is-a”规则表明子类的每一个对象都是一个超类的对象。例如，每一个经理是一个员工。然而，只有经理类是员工类的子类才是有意义的。很明显，反过来就不行了――并不是每个员工都是经理。
还有一个明确叙述“is-a”规则的方法是替代原则。该原则规定无论何时，如果程序需要一个超类对象，都可以用一个子类对象来代替
动态绑定
理解调用一个对象方法的机制是非常重要的。下面具体介绍：Xf；
（1）编译器检查对象的声明类型和方法名。
（2）接着，编译器检查方法调用中的参数类型。如果在所有的叫做f的方法中有一个其参数类型同调用提供的参数类型最匹配，那么该方法就会被选择调用。这个过程称作超载选择。（静态）
（3）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。
...
如果类中没有写构造函数，那么系统会自动为该类提供一个默认构造函数，该构造函数将所有的实例字段初始化为默认值：
...
包用途:
Java允许把多个类收集在一起成为一组，称作包（package）。包便于组织任务，以及使自己的任务和其他人提供的代码库相分离。
标准Java库被分类成许多的包，其中包括java.1ang、java.util和java.net等等。标准Java包是分层次的。就像在硬盘上嵌套有各级子目录一样，可以通过层次嵌套组织包。所有的Java包都在Java和Javax包层次内
创建包
已经看到，已有的库，比如JavaAPI中的类和接口，可以导入到Java程序中。
Java API中的每一个类和接口属于一个特定的包。它包含一组相关联的类和接口，实际是对类和接口进行组织的目录结构。
例如，假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass（包括大小写形式）：
packagemypackage;publicclass MyClass{……}创建可复用的类的步骤简要说明如下：
（1）定义一个public类。如果类不是public，它只能被同一包中的其他类使用。
（2）选择一个包名，并把package语句加到可复用的类的源代码文件中。
（3）编译这个类。这样，它就被放到适当的包目录结构中，以供编译器和解译器使用。
（4）把这个可复用的类导入到需要用它的程序中。现在就可以使用它了。
注意在Java语言中可以出现在类定义的括号外面的仅有两个语句，它们是package和import。
包引用---每个类名前加上完整的包名
例如，给出一个指向此包中的类的快捷方式。一旦使用import（导入）了以后，就不再需要给出完整的包名。
可以引入一个特定的类，也可以引入整个包。import语句要放在源文件的头部（但在所有package语句的下面）。例如，可以通过下面的语句引入在java.util包中的所有的类：
importjava.util.*;
然后，就可以使用
Datetoday=new Date();
而不需要在前面加上包名。也可以引入包中某个特定的类：
importjava.util.Date;
要把类放人一个包中，必须把此包的名字放在源文件头部，并且放在对包中的类进行定义的代码之前。例如，在文件Employee.java的开始部分如下：
packagecom.horstmann.corejava;publicclass Employee{……}把包中的文件放入与此完整的包名相匹配的子目录中。例如，在包com.horstmann.corejava中的所有的类文件都必须放在子目录com/horstmann/core.java（Windows下的com/horstmann/corejava）下。这是最简单的一种方法
类被存储在文件系统的子目录中。类的路径必须与所在包名相匹配。
在前面的例子中，包目录com/horstmann/corejava是程序目录的一个子目录。然而这样安排很不灵活。一般，有多个程序需要访问包文件。为了使包可以在多个程序间共享，需要做以下事情：
1）把类放在一个或多个特定的目录中，比如/home/user/classdir。此目录是包树的基本目录。如果加入了类com.horstmann.corejava.Employee，那么此类文件必须位于子目录/home/user/classdir/com/horstmann/corejava下。
2）设置类路径。类路径是其子目录包含类文件的所有基本目录的集合。classpath
已经接触过public和private访问指示符。
被标记为Public的部件可以被任何类使用，而私有部件只能被定义它们的类使用。如果没有指定public或private，那么部件（即类、方法或变量）可以被同一个包中的所有方法访问。
Java API包
为了简化面向对象的编程过程，Java系统事先设计并实现了一些体现了常用功能的标准类，如用于输入／输出的类，用于数学运算的类，用于图形用户界面设计的类，用于网络处理的类等。这些系统标准类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。
Java的类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序
接口主要作用是可以帮助实现类似于类的多重继承的功能。在Java中，出于简化程序结构的考虑，不再支持类间的多重继承而只支持单重继承，即一个类至多只能有一个直接父类。然而在解决实际问题的过程中，仅仅依靠单重继承在很多情况下都不能将问题的复杂性表述完整，需要其他的机制作为辅助。
接口声明
Java中声明接口的语法如下：
[public] interface 接口名[extends 父接口名列表]{ //接口体;//常量域声明[public] [static] [final] 域类型域名=常量值; //抽象方法声明[public] [abstract] 返回值方法名(参数列表) [throw异常列表];}从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类
（1）接口中的属性都是用final修饰的常量，
（2）接口中的方法都是用abstract修饰的抽象方法，在接口中只能给出这些抽象方法的方法名、返回值和参数列表，而不能定义方法体，即仅仅规定了一组信息交换、传输和处理的“接口”
接口的实现
一个类要实现某个或某几个接口时，有如下的步骤和注意事项：
（1）在类的声明部分，用implements关键字声明该类将要实现哪些接口；
如下：
class类名implements接口{ }（2）如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参数列表；
（3）如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。
（4）一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。
（5）接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法时，必须显式地使用public修饰符。
요약:
多重继承是指一个子类继承多个父类。Java不支持多重继承，但Java提供了接口。
子类不能访问父类的private成员，但子类可以访问其父类的public，protected和包访问成员；要访问父类的包访问成员，子类一定要在父类的包内。
子类构造函数总是先调用（显式的或隐式地）其父类的构造函数，以创建和初始化子类的父类成员。
子类的对象可以当作其父类的对象对待，反之则不行（即向上转型）
protected访问是public和private访问之间一个保护性的中间层次。父类方法、子类方法和在同一个包内类的方法都能访问父类的protected成员，但其他方法均不能访问
一个子类对象引用可以隐式地转换成一个父类对象引用。使用显式的类型转换，可以把父类引用转换成子类引用。如果目标不是子类对象，将产生ClassCastException例外处理。