1.接口是什么？

　　接口可以理解為一個特殊的抽象類，是由全局常量和公共抽象方法組成的。

　　所以，如果，一個抽象類的方法都是抽象的，那么就可以通過接口的形式來表示。

　　class 用于定義類

　　interface 用于定義接口

2.接口中成員定義的格式：

　　常量　　public static final

　　抽象方法　　public abstract（這里的抽象方法必須有public修飾）

3.接口是不可以創(chuàng)建對象的，因為有抽象方法，必須被子類實現(xiàn)，子類對接口中的方法全部覆蓋后，子類才可以實例化。（抽象類是不可以實例化的）

4.接口的最大任務(wù)就是實現(xiàn)多態(tài)。

interface Inter{public static final int NUM=3；public abstract void show(); } interface InterA{public abstract void show(); } class Demo{public void function(){}; } class Test extends Demo implements Inter,InterA{public void show(){}; } //可以看到這個Test類既繼承了Demo類，又實現(xiàn)了Inter,InterA接口，所以既具備了Demo的功能，又具備了接口的功能，這樣就擴展了Test的功能 class InterfaceDemp{public static void main(String[] args){Test t=new Test();System.out.println(t.NUM);} }

5.關(guān)于抽象類

栗子1：

abstract class Student{abstract void study();abstract void study1(); } class BaseStudent extends Student{void study(){System.out.println("base study");}void study1(){System.out.println("base study1");} } //可以看到子類必須覆蓋抽象類中所有的方法，如果子類只覆蓋了部分抽象方法，則該子類還是個抽象類。

　　注意：（1）抽象類中可以不存在任何成員，可以有非抽象方法。

　　　　　（2）抽象類可以被抽象類繼承，結(jié)果還是抽象類。

　　　　　（3）抽象類只能作為其他類的基類，不能直接被實例化。

　　　　　（4）如果一個非抽象類從抽象類這派生，則其必須通過覆蓋來實現(xiàn)所有繼承而來的抽象成員。

栗子2：

abstract class Person{public abstract void sayHello();public void about(){System.out.println("sayHello");} } class Nurse extends Person{//建立實體類Nurse繼承Person//沒有覆蓋抽象方法sayHello,這個類是錯誤的。 } abstract class Worker extends Person{//建立抽象類Worker繼承Person//抽象類繼承抽象類，可以不覆蓋抽象方法sayHello，這個類是正確的。 }

也就是說，子類繼承父抽象類的時候，必須繼承父類里面的抽象方法。哪怕用空的表示也是可以的

如：父類中有abstract public void myfunc();

　　子類中，就可以這樣，public void myfunc(){};　　

栗子3：

關(guān)于抽象類與最終類（final修飾的類），下列說法錯誤的是？D錯誤

　　A.抽象類能被繼承，最終類只能被實例化。

　　B.抽象類和最終類都可以被聲明使用

　　C.抽象類中可以沒有抽象方法，最終類中可以沒有最終方法

　　D.抽象類和最終類被繼承時，方法可以被子類覆蓋

解釋：抽象類時專門拿來被繼承的，其實也可以沒有抽象方法。抽象類是不能實例化的，實例化必將加載類，然后根本不知道抽象方法的方法體大小，所以不能實例化。

而final類，之所以被定義為final類是認(rèn)為這個類已經(jīng)很完美了，不希望被繼承被擴展或者被修改。不可以被覆蓋。 栗子4：

　　方法的重寫（override）兩同兩小一大原則：

　　A.方法名相同，參數(shù)類型相同

　　B.子類返回類型小于等于父類方法返回類型，

　　C.子類拋出異常小于等于父類方法拋出異常，

　　D.子類訪問權(quán)限大于等于父類方法訪問權(quán)限。

　　已知如下類定義：

class Base { public Base (){ //... } public Base ( int m ){ //... } public void fun( int n ){ //... } } public class Child extends Base{ // member methods }

　　如下哪句可以正確地加入子類中？　　D

　　　A.private?void?fun(?int?n?){?//...}

　　 B.void fun ( int n ){ //... } 　　 C.protected void fun ( int n ) { //... }

　　　D.public void fun ( int n ) { //... }

子類方法的權(quán)限至少要大于父類方法的權(quán)限，只能選D

栗子5：

下面代碼運行結(jié)果是（A）

public class Test{ public int add(int a,int b){ try {return a+b; } catch (Exception e) { System.out.println("catch語句塊");}finally{ System.out.println("finally語句塊");}return 0;} public static void main(String argv[]){ Test test =new Test(); System.out.println("和是："+test.add(9, 34)); } }　

　　A.finally語句塊

　　　和是：43

　　B.和是：43

　　　finally語句塊

解釋：1.finally{}代碼塊比return先執(zhí)行。 2.多個return是按順序執(zhí)行的的，多個return執(zhí)行了一個后，后面的return就不會執(zhí)行了。 3.?記住一點，不管有不有異常拋出，?finally都會在return返回前執(zhí)行。

6.繼承

　　（1）在Java中，只支持單繼承（一個類只能有一個父類）

　　（2）字符類出現(xiàn)后，類中成員的特點也有所改變

　　　　1）變量：

　　　　　--- 如果子類中出現(xiàn)非私有的同名成員變量時，子類要訪問本類中的變量，用this（this代表本類對象的引用）

　　　　　--- 如果子類要訪問父類的同名變量，用super　（代表父類對象的引用）

class Fu{int num=4; } class Zi extends Fu{int num=5;void show(){System.out.println(super.num);//訪問父類中的同名變量，用superSystem.out.println(this.num);//訪問本類中的變量，用this} } class ExtendsDemo{public static void main(String[] args){Zi z=new Zi();//new一產(chǎn)生，就會先加載父類的class Fu,然后再加載子類class Ziz.show();} }

　　　　2）子父類函數(shù)的特點——覆蓋（重寫）

　　　　　　--- 子類覆蓋父類必須保證子類權(quán)限大于父類權(quán)限，如父類中定義void show(){}，而子類中確實private void show(){}，這樣子類就不能覆蓋父類

　　　　　　--- 靜態(tài)只能覆蓋靜態(tài)

　　　　3）字符類中的構(gòu)造函數(shù)

　　　　　　在子類對象進(jìn)行初始化時，父類的構(gòu)造函數(shù)也會運行，那是因為子類中所有的構(gòu)造函數(shù)默認(rèn)第一行有一條隱式語句super();

　　　　　　這個super()回訪問父類中空的構(gòu)造函數(shù)。super.屬性，可以訪問父類的屬性。

class Fu{Fu(int x){//父類的構(gòu)造函數(shù)System.out.println("Fu:"+x);} } class Zi extends Fu{Zi(){//子類構(gòu)造函數(shù)super(4);//這個要手動自己去定義，訪問指定的父類構(gòu)造函數(shù)}Zi(int x){this();//這個就是訪問自己本類中的構(gòu)造函數(shù)了,Zi(){}} }

　　總結(jié)：繼承會破壞封裝性，因為會將父類的實現(xiàn)細(xì)節(jié)暴露給子類

?栗子：

　　對文件名為Test.java的java代碼描述正確的是(C)

class Person {String name = "No name";public Person(String nm) {name = nm;} } class Employee extends Person {String empID = "0000";public Employee(String id) {empID = id;} } public class Test {public static void main(String args[]) {Employee e = new Employee("123");System.out.println(e.empID);} }

　　A.輸出：0000

　　B.輸出：123

　　C.編譯報錯

　　D.輸出：No name

解釋：

　　子類在實例化過程中，一定要訪問父類中的構(gòu)造函數(shù)。而且默認(rèn)都會訪問父類中空參數(shù)的構(gòu)造函數(shù)。如果父類中沒有空參數(shù)的構(gòu)造函數(shù)時，子類必須手動通過super語句形式訪問父類中的構(gòu)造函數(shù)。

　　所以題目中，子類Employee中沒有super(nm);所以編譯會有錯誤。

如：

class Person{private String name;private int age;public Person(String name,int age){this.setName(name);this.setAge(age); } } class Student extends Person{private String school;public Student(String name,int age,String school){super(name,age);this.setSchool(school); } }

　　可以看到子類Student中，有super(name,age)

?

?

?

　　　　

轉(zhuǎn)載于:https://www.cnblogs.com/GumpYan/p/5740048.html

《新程序員》：云原生和全面數(shù)字化實踐50位技術(shù)專家共同創(chuàng)作，文字、視頻、音頻交互閱讀

總結(jié)

以上是生活随笔為你收集整理的接口抽象类继承父类和子类的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。