第五節：詳細講解Java中的接口與繼承

前言

大家好，我是 

Vic

，今天給大家帶來

詳細講解Java中的接口與繼承

的概述，希望你們喜歡

什麼是接口（interface）

接口中的方法都是抽象方法，public權限，全是抽象函數，不能生成對象

interface Student{
public void read();
public void write();
}

class ChineseStudent implements Student{
//複寫
public void read(){
 System.out.println("read");
}
public void write(){
 System.out.println("write");
}
}

class Test{
public static void main(String args[]){
 ChineseStudent chinesestudent = new ChineseStudent();
 Student student = chinesestudent;
 
 student.read();
 student.write();
}
}
                

實作接口用implements關鍵字，
一個接口可以實作多個接口，
一個接口可以繼承多個接口
interface Student{
public void read();
public void write();
}

interface Teacher{
public void teach();
public void test();
}

class Person implements Student,Teacher{
public void read(){
 System.out.println("read"):
}
public void write(){
 System.out.println("write");
}
public void teach(){
 System.out.println("teach"):
}
public void test(){
 System.out.println("test"):
}
}

class Test{
public static void main(String args[]){
 Person person = new Person();

 Student student = person;
 student.read();
 student.write();

 Teacher teacher = person;
 teacher.teach();
 teacher.close();
}
}
                

swith( char byte short int)隻允許四種類型

public class Test{
public static void main(String args[]){
 int score = ;
 if(score >  && score <= ){
  System.out.println("成績為優");
 }
 else if(score >  && score <= ){
  System.out.println("成績為良");
 }
 else if(score >  && score <= ){
  System.out.println("成績為中");
 }
 else if(score <=  && score >= ){
  System.out.println("成績為差");
 }
 else if(score >  || score < ){
  System.out.println("成績不在正常的範圍之内");
 }
}
}
                

對象就是引用資料類型

class Test{
public static void main(String args[]){
 Dog d = new Dog();
 d.name="哈哈";
 d.age=;
 d.jump();
 System.out.println("名字是"+d.name);
 }
}
                

重載的表達

class A{
void funA(){
 System.out.println("沒有參數的funA函數");
}
void funA(int i){
 System.out.println("有參數的funA函數");
}
void funA(int i,double d){
 System.out.println("擁有兩個參數的funA函數");
}
}
                

什麼是繼承

在現實世界當中，繼承就是兒子得到老子的東西，在面向對象的世界當中，繼承就是一個類得到了另一個類當中的成員變量和成員方法

Java隻支援單繼承，不允許多繼承，繼承是為了減少重複代碼

使用super調用父類構造函數的方法

class Person{
String name;
int age;
Person(){
 System.out.prinltn("Person的無參數構造函數");
}
Person(String name,int age){
 this.name=name;
 this.age=age;
 System.out.println("Person有參數的構造函數");
}

void eat(){
 System.out.println("定義吃飯的方法");
}
}
                

class Student extends Person{
//子類繼承父類
Student(){
 //父類
 super();
 System.out.println("Student的無參數構造函數");
}
Student(String name,int age,int id){
 super(name,age);
 this.id=id;
}
}
                

在Java中的繼承，其實就是繼承全部屬性和方法(除了構造方法)，除了private修飾的變量或者方法，子類無法進行通路

什麼是複寫

具有父子關系的兩個類中，父類和子類各有一個函數，這兩個函數的定義（傳回值類型，函數名，參數清單）完全相同

對象的轉型（多态性地展現）

父類引用指向子類對象，同一個類型，調用同一個方法，卻能呈現不同的狀态

• 什麼是向上轉型:

  向上轉型就是将子類的對象指派給父類的引用。

• 什麼是向下轉型:

  向下轉型就是将父類的對象指派給子類的引用。

Student s1 = new Student();
Person p = s1;
Student s2 = (Student)p;
                

類的多态

• 父類引用指向子類對象
• 調用的方法有重寫

所謂的轉型

• 類型轉換指:

  把一個引用所指向的對象的類型，轉換為另一個引用的類型

• 沒有繼承關系的類型進行轉換,一定會失敗

了解Object類

• Object類是所有類的父類
• Object類提供一個toString方法，傳回目前對象的字元串表達
• equals() 判斷兩個對象的内容是否相同

詳解final

• final可以修飾類（該類不能夠被繼承），成員變量（修飾基本類型變量，該變量隻有一次指派機會，修飾引用，該引用隻有一次指向對象的機會），成員方法（不能夠被重寫）
• String類是public final class String,不能被繼承

什麼是抽象函數

沒有函數體的函數被稱為抽象函數

什麼是抽象類

使用abstract定義的類稱為抽象類

• 抽象類不能夠生成對象
• 抽象類不能執行個體化，繼承抽象類，那麼該類必須為抽象類
• 一個類被聲明為抽象類，不能夠被直接執行個體化

abstract class Person{
abstract void eat();
}

class Chinese extends Person{
void eat(){
 System.out.pritln("hhh");
}
}

class Test{
public static void main(String args[]){
 Person p = new Chinese();
 p.eat();
}
}
                

abstract class Person{
Person(){
 System.out.println("Person沒有參數的構造函數");
}

Person(String name,String age){
 this.name=name;
 this.age=age;
}

String name;
int age;
void introduce(){
 System.out.println("我的名字是"+name+"，我的年齡是"+age);
}
abstract void eat();
}
}

class Chinese extends Person{
String address;
Chinese(){
 super();
 System.out.println("Chinese的構造函數"); 
 }
 
 Chinese(String name,int age,String address){
  super(name,age);
  this.address=address;
 }
 void eat(){
  //複寫
  System.out.println("吃飯");
 }
}

class Test{
public static void main(String args[]){
 Person p = new Chinese();
 p.eat();
 }
}
                

如何生成内部類的對象

class Test{
public static void main(String args[]){
 A a = new A();
 
 A.B b = new A().new B();
 //或者A.B b = a.new B();
}
}

class A{
int i;
class B{
 int j;

 int funB(){
  int result = i+j;
  return result;
 }
}
}

class Test{
public static void main(String args[]){
 A a = new A();
 A.B b = a.new B();

 a.i=;
 a.j=;
 
 int result = b.funB();
 System.out.println(result);
 }
}

class A{
int i;
class B{
 int j;
 int funB(){
  int result = A.this.i+this.j;
  return result;
 }
}
}
                

内部類

内部類有 非靜态，靜态，匿名類

文法: new 外部類().new 内部類()

匿名内部類

interfacce A{
public void doSomething();
}

class B{
public void fun(A a){
 System.out.println("B函數");
 a.doSomething();
}
}

class Work implements A{
public void doSomething(){
 System.out.println("doSomething");
}
}

class Test{
public static void main(String args[]){
 Work work = new Work();
 A a = work;

 B b = new B();
 b.fun(a);
 }
}
                

class Test{
public static void main(String args[]){
 B b = new B();
 b.fun(new A(){
  public void doSomething(){
   System.out.println("匿名内部類");
  }
 });
}
}
                

總結

• 本文講了詳細講解Java中的接口與繼承，如果您還有更好地了解，歡迎溝通
• 定位：分享 

  Android

  &

  Java

  知識點，有興趣可以繼續關注