JAVA面向对象编程(2)
補充:咱們的instanceof是Java中保留的關鍵字，它的作用是進行檢測它左邊的對象是否是右邊的類的實例，如果表達式是true，那么就直接可以安全轉換
抽象類:抽象類最大的作用就是被繼承使用
1)抽象方法:如果一個方法被abstract修飾，它里面連一條語句都沒有，那么這個方法叫做抽象方法，可以沒有具體的實現，抽象方法中可以不用給出具體的實現體，多了一層抽象類的校驗
2)抽象類:包含抽象方法的類，就叫做抽象類，只是多了一個抽象方法-----被public abstract所修飾
3)我們的抽象類也是類，內部可以包含著普通方法和屬性，甚至是構造方法，只是多了一個抽象方法，類名加了一個abstract修飾
4)抽象類可以被抽象類繼承，
abstract class Shape{public abstract void draw(); } abstract class Shape{public Shape(){System.out.println("我是這個抽象類的構造方法");}//抽象方法,被abstract修飾的方法,沒有方法體abstract public void draw();abstract void run();//抽象類也是類,也是可以增加普通方法和屬性的protected double area;public void sayHi(){System.out.println("我愛你");} } abstract class Shape{public abstract void draw();public void run(){System.out.println("我是一個抽象類");} } class Red extends Shape{public void draw(){System.out.println("生命在于運動");this.run();//優先在自己的這個各類中找run方法,在這個類中找不到// 就會在父類中找這個run方法} }抽象類的一些特性:
1)我們的抽象類使用abstract來進行修飾的，里面包含方法也是被abstract所修飾，沒有具體的實現
2)類中的成員可以有public，private字段和方法,也就是說可以包括其他的非抽象方法，這個非抽象方法和普通方法的規則都是一樣的，可以被重寫，也可以被子類直接調用，可以包含普通類所能包含的成員
3)抽象類不可以被實例化，不可以new，況且說當我們的抽象方法沒有加訪問修飾限定符的時候，我們默認是public，我們的抽象類要想使用，只能創建該抽象類的子類，讓我們的子類去重寫抽象類中的抽象方法
4)抽象類就是為了被繼承的，如果一個類繼承了抽象類，那么這個類必須重寫抽象類中所有的抽象方法，如果不想重寫，那么還可以在被一個抽象類繼承；所以說一個抽象類A，如果實現了抽象類B，那么這個抽象類A可以不實現抽象類B的抽象方法，那么在后續過程中，當A類被一個普通的類C繼承之后，那么A和B的這兩個抽象類的抽象方法，必須被C類所重寫
abstract class Father1{public abstract void run();public void start(){System.out.println("abc");} } abstract class Father2{//在這里面可以不需要重寫Father1里面的抽象方法public abstract void run(); } class Phone extends Father2{public void start(){System.out.println("生命在于運動");}public void run(){System.out.println("生命在于吃飯");} } public class HelloWorld { }5)抽象類和抽象方法，一定是不可以被final所修飾的，被final修飾的類，是不可以被繼承的，被final修飾的方法，是不可以被重寫的，就不能發生運行時綁定，抽象方法還不可以被private和static修飾;
import javax.servlet.http.HttpServlet;abstract class Father{public String username;public String password;public abstract void run();public Father(String username,String password){this.username=username;this.password=password;} } class ChildServlet extends Father{public ChildServlet(String username,String password){super(username,password);//幫助父類進行構造}public void run(){//重寫抽象類的抽象方法System.out.println("我是子類的run方法");} }接口:
1)接口是抽象類的更進一步的抽象，抽象類中還可以包含非抽象方法和字段，但是接口中的包含的方法都是抽象方法，字段只能包含靜態常量
2)接口中的普通方法是不能在接口中實現的，只能由實現接口中的類實現，重寫接口中的類的抽象方法，必須加上public來進行修飾，因為重寫的方法的訪問修飾限定符必須大于等于父類的訪問修是限定符
interface Father{public abstract void start();public static void run(){//不能被重寫System.out.println("我是一個接口");}default public void Eat(){//不能被重寫System.out.println("我是接口中的一個Defalut方法");} // static { // System.out.println(1); // } // public Father() // { // // } }況且接口中不能含有靜態代碼塊和構造方法
3)接口中的方法，都是抽象方法，可以有具體的實現方法(JDK1.8可以實現，里面可以有default字段)----不可以被重寫，使用interface來進行修飾，接口也是不能進行實例化的，類實現一個接口之間用implements實現
4)接口中的成員變量，默認是常量，在抽象類中，什么樣的成員變量都可以被定義，所有的成員變量都被默認成public static final，必須進行初始化，抽象方法默認是public abstarct，這些東西都不用寫
5)接口是不可以通過new關鍵字實例化的
interface Father {int a=90;void run();default void start(){} } class Child implements Father{public void run(){System.out.println("好人");} }6)接口和類之間用implements，一個類中實現了接口，一定要重寫接口里面的抽象方法
7)它的存在就是為了解決java中的單繼承問題，在java中，可以實現多個接口，仍然可以實現向上轉型，一個類可以繼承普通類或者抽象類，同時還可以實現多個接口，先是extends,還有implements;此時在這個類中，要重寫幫助父類進行構造，還要重寫抽象類和接口中的抽象方法；
8)通過接口的引用，可以引用一個具體的對象，也可以發生動態綁定
9)當一個類實現一個接口之后，重寫這個接口里面的方法之后，這個方法前面必須加public
10)接口中的方法一定是抽象方法，因此可以省略abstract
11)接口中的方法一定是public，因此可以省略public
12)一個類只能通過關鍵字extends繼承一個抽象類或者普通類，但是去可以實現多個接口，用，來進行隔開
13)在Java中類和類是單繼承的，一個類可以實現多個接口，接口與接口之間可以使用多繼承，使用extends關鍵字
interface Father {int a=90;void run();default void start(){} } interface Child1{ } interface Child2{ } interface Child3 extends Child1,Child2,Father{}14)接口雖然不是類，但是接口編譯完成之后的字節碼文件的后綴格式也是.class
15)一個接口B通過extends來進行擴展另一個接口C的功能，此時當另一個普通類C通過implments實現這個接口的時候，此時重寫的方法不僅僅是B的抽象方法，還有從C接口中擴展出來的功能和方法
16)JDK1.8以后接口中可以進行創建static和default方法了,并且這兩種方法可以有具體的代碼實現
17)子類可以不重寫接口中的static和default方法，不重寫的話，默認是調用接口的方法實現
都不能進行實例化，況且接口的實現類或者抽象類的子類只有全部實現了接口或者抽象類中的抽象方法才可以進行實例化
抽象類和接口有什么區別？?
0)修飾關鍵字不同，繼承使用的關鍵字不同，抽象類使用sbstract class來進行修飾，接口是用interface來進行修飾
1)核心區別:抽象類中可以包含普通方法和字段，這樣的普通方法和字段可以被子類直接進行調用，而接口中不可以包含普通方法，子類必須重寫所有的抽象方法
2)子類擴展的數目不同，接口的實現類可以有多個，而抽象類的子類，只能繼承一個
抽象類，繼承多個抽象類就會發生報錯，在JAVA語言中，一個類只能繼承一個父類，主要是通過但既成的方式來實現的，但是可以實現多個接口
3)屬性訪問控制符不同，接口中屬性字段的訪問修限定符只能是public，接口中的屬性默認是public static final修飾的，但是我們的抽象類屬性訪問控制符沒有任何限制，可以為任意控制符
4)方法控制符不同，接口中方法的默認控制符是public,并且不能定義為其他控制符，抽象類的方法控制符沒有限制，抽象類的方法不能用private修飾
5)抽象類中可以有構造方法，但是接口中不能含有構造方法,接口中不能有靜態代碼塊，但是抽象類中可以有靜態代碼塊
6)接口只能定義只能定義抽象方法不能實現方法，抽象類既可以定義抽象方法，也可以實現方法，我們從JDK1.8開始，是允許有可以實現的方法的，但是這個方法只能是有default方法修飾的，接口中還可以含有靜態的方法
7)抽象類中可以有普通成員變量，接口中沒有普通成員變量，接口中的所有成員變量都是public static final修飾的靜態常量
8)接口可以被多重實現，抽象類只能被單一繼承
擴展:在JAVA里面為什么不同的返回值類型不算方法重載？
1)方法重載本質上是說在同一個類里面，定義了多個重名方法，但是每一個方法的參數類型或者說是參數個數不同就被稱之為方法重載
2)方法簽名:方法名稱，參數個數，參數類型，咱們的JVM也就是JAVA虛擬機就是通過這個方法簽名來進行調用哪一個方法的，咱們的返回值類型是不在方法簽名里面的，所以說當同一個類里面出現了多個方法名和參數相同，但是返回值的類型不同的方法的時候，JVM就沒有辦法通過方法簽名來進行判斷到底要調用哪一個方法了
3)那么為什么返回值類型不可以作為方法簽名的一部分呢？原因其實也很簡單，因為如果方法簽名里面有方法的返回類型，那么下面的代碼就會出現歧義:
public class HelloWorld{class Student{public int method(String name){return 6666;}public String method(String name){return "aabbbcc";}}public static void main(String[] args) {Student student=new Student();student.method("lijiawei");} }方法重載的常見使用方法就是:使用String類型的ValueOf()方法，valueOf方法有九種實現場景，他可以將數組，對象和基礎數據類型裝化成字符串
方法重載的匹配原則
方法重載的匹配原則是有前后之分的:
public class HelloWorld{static class Student{public String method(int num){return "返回調用的int方法";}public String method(Integer num){return "返回調用的Integer方法";}public String method(long num){return "返回調用的調用的long方法";}public String method(Object num){return "返回調用的Object方法";}}public static void main(String[] args) {Student student=new Student();String str= student.method(10);System.out.println(str); //打印結果:返回調用的int方法} }匹配類型原則1:精準類型匹配
方法重載會優先調用和方法參數類型相同的一模一樣的方法，這是第一優先匹配原則，精準類型匹配
匹配類型原則2:基本類型自動轉換成更大的基本數據類型，如果我們把精準類型匹配方法原則刪掉，那么第二匹配類型順序就是自動轉換成更大的基礎數據類型
public class HelloWorld{static class Student{public String method(Integer num){return "返回調用的Integer方法";}public String method(long num){return "返回調用的調用的long方法";}public String method(Object num){return "返回調用的Object方法";}}public static void main(String[] args) {Student student=new Student();String str= student.method(10);System.out.println(str); //打印結果:返回調用的調用的long方法} }匹配類型原則3:自動裝箱拆箱
我們現在將第二匹配原則的long方法也刪除掉，實現代碼如下:
public class HelloWorld{static class Student{public String method(Integer num){return "返回調用的Integer方法";}public String method(Object num){return "返回調用的Object方法";}}public static void main(String[] args) {Student student=new Student();String str= student.method(10);System.out.println(str); //打印結果:返回調用的調用的Integer方法} }匹配類型4:按照繼承路線向上繼承，接下來是可變參數類型
可選參數:
1)它是指一個方法的參數中可以用.....來進行表示此方法可以進行接收無窮個參數，這種方法就叫做可選參數
2)基本的語法就類似于:
public void method(數據類型.... 參數名稱){ //方法體 }3)注意一下可選參數是從0到無窮:從下面代碼可以看出，可選參數即使不進行傳遞任何參數，也就是0各參數也是可以被調用到的
public class HelloWorld{static class Student{public void run(int... num){//此時把num當成一個數組System.out.println("可選參數的數量是"+num.length);}}public static void main(String[] args) {Student student=new Student();student.run();//此時打印的結果是0} }實現克隆接口:clone方法是默認是Object的方法，把對象產生一個副本，這個新拷貝的副本地址也就不一樣了
1)這個接口是一個標記性的接口(空接口)，他們內部都沒有方法和屬性，實現這個接口表示這個對象都可以進行克隆，我們調用Object對象的Object.clone()方法，如果沒有實現Cloneable的類對象調用clone()就會拋出CloneNotSupportedException異常
2)我們想要一個類具備拷貝實例的功能，除了要實現Cloneable接口，還必須要重寫Object類的clone()方法
3)我們可以看到Object類的clone()方法是被protected修飾的，我們需要在重寫的clone()方法通過super關鍵字調用Object的clone()方法
Cloneable接口發揮的是標記功能，自定義類型需要用戶自己去標記哪些類是可以被clone的，這個標記就是去實現Cloneable接口，試下了該接口的類就表示該類創建的對象可以被克隆
想要克隆自定義類型，就要實現克隆接口public interface Cloneable(){};空接口也叫作標記接口
1.淺拷貝:我們在拷貝一個對象的時候，對對象的基本數據類型的成員變量進行拷貝，但是對引用類型的成員變量只進行引用的傳遞，并沒有創建一個新的對象，當對引用類型的修改會影響到要拷貝的對象，簡而言之，淺拷貝只是復制所拷貝的地址，而不復制他的所引用的對象
package com.example.demo; import lombok.Data; @Data class Student implements Cloneable{public String username;public String password;public Student(String username, String password) {this.username = username;this.password = password;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} } public class HelloWorld{public static void main(String[] args) throws CloneNotSupportedException {Student student1=new Student("李佳偉","12503487");Student student2= (Student) student1.clone();System.out.println(student1==student2);//false} } false Student{username='李佳偉', password='12503487'} Student{username='李佳偉', password='12503487'} class Money{public double m=100.5;} class Student implements Cloneable {String name; //實現這個接口要重寫克隆方法 Money money=new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} }public class Tomact {public static void main(String[] args) throws CloneNotSupportedException {Student student1=new Student();Student student2= (Student) student1.clone();System.out.println(student1.money.m);System.out.println(student2.money.m);student2.money.m=199;System.out.println(student1.money.m);System.out.println(student2.money.m); //都變成了199} }1)此時我們單純的修改student1的username此時是不會修改student2的username的
2)?我們觀察下面的代碼，我們將Money類的實例引用作為了Student類的一個字段，new 一個Student類型的對象，將這個student1對象拷貝到student2對象，這里面的拷貝就是淺拷貝了，只是將student1的對象的money的引用進行拷貝了一份，此時student1和student2指向的都是同一個對象
package com.example.demo; import lombok.Data; @Data class Student implements Cloneable{public String username;public String password;public Student(String username, String password) {this.username = username;this.password = password;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} } public class HelloWorld{public static void main(String[] args) throws CloneNotSupportedException {Student student1=new Student("李佳偉","12503487");Student student2= (Student) student1.clone();System.out.println(student1==student2);//false} }由此看出，只是拷貝了money對象的地址，他們仍然指向的是同一個對象，此時原來的對象和新被克隆出來的對象的成員變量money指向地址的都是 0x100,重寫克隆方法，這是Object里面的方法
下面我們來實現一個真正意義上的深拷貝:
深拷貝:
我們在拷貝對象的時候，除了對基本的數據類型的成員變量進行拷貝的時候，對引用類型的成員變量進行拷貝的時候，創建一個新的對象來進行保存引用類型的成員變量，簡單來說深拷貝把要進行復制的對象里面的引用所指向的對象也拷貝了一份
class Money implements Cloneable{public double m=100.5;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} } class Student implements Cloneable {String name;//實現這個接口要重寫克隆方法Money money=new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {//return super.clone();正常情況下，Person的克隆是在這里面執行//Student s=(Student) super.clone();//return s;//1克隆PersonStudent s= (Student) super.clone();//2克隆當前的Money對象s.money= (Money) this.money.clone();return s;// 由于下面要進行Money的克隆} }public class Tomact {public static void main(String[] args) throws CloneNotSupportedException {Student student1=new Student();Student student2= (Student) student1.clone();System.out.println(student1.money.m);System.out.println(student2.money.m);student2.money.m=199;System.out.println(student1.money.m);System.out.println(student2.money.m);//這里面只是克隆了一個person，我們要想實現深拷貝，就要把money這個對象也克隆一份} }Java中的clone方法是一個淺拷貝，引用類型仍然在傳遞引用，我們可以通過繼續調用clone方法，對該對象的引用類型變量在實現一次clone的方法來實現深拷貝
1)讓我們的兩個類都實現cloneable接口
2)在我們的Student類里面不光克隆Student對象里面的屬性，還進行克隆Student類中的引用類型所指向的對象也進行克隆一份
class Money implements Cloneable{public int money;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();} } class Student implements Cloneable{public String username;public String password;public Student(String username, String password) {this.username = username;this.password = password;}Money money=new Money();@Overrideprotected Object clone() throws CloneNotSupportedException {Student student=(Student)super.clone();student.money=(Money)money.clone();return student;}@Overridepublic String toString() {return "Student{" +"username='" + username + '\'' +", password='" + password + '\'' +'}';} } public class HelloWorld{public static void main(String[] args) throws CloneNotSupportedException {Student student1=new Student("李佳偉","12503487");Student student2= (Student) student1.clone();student1.money.money=999;System.out.println(student1.money.money);//999System.out.println(student2.money.money);//0} }我們拷貝簡單類型是深拷貝，拷貝引用類型是淺拷貝，我們要想實現深拷貝，就要拷貝一下這個對象，只是拷貝地址值，是不能實現真正意義上的深拷貝的
1)咱們的數組的四種拷貝方法都是淺拷貝，因為我們大部分情況下是拷貝地址的，而現在是拷貝數據
2)深拷貝:如果我們拷貝完成之后，我們通過一個引用去訪問去修改拷貝完成之后的值，是不會修改原來的值
3)淺拷貝:相反拷貝通過引用來進行修改，原來的值發生變化，就叫做淺拷貝
如果問數組的拷貝是什么拷貝？先問問到底是再拷貝什么？？？
static關鍵字修飾的成員是屬于類的，而abstract一般是用來修飾普通方法目的是為了讓子類繼承后重寫該方法，而static修飾的方法是不存在繼承重寫的
創建對象的方式:
?5.自定義類型的比較：
1）繼承comparable接口，里面的泛型參數要寫里面的比較的類型，重寫CompareTo方法，里面加上泛型參數，泛型參數里面加上要比較的類型，這種寫法，對類的侵入性比較強,如果一個類實現了這個Comparable接口，那么就意味著該類支持排序，或者說對象的列表或者數組可以進行自動排序,一旦寫好之后，不敢輕易改動
實現了這個Comparzble接口的類的對象的列表或者數組可以通過Collections.sort(里面直接傳入一個集合類list)或者是Arrays.sort(里面傳入的是一個數組)來進行自動排序
Comparable接口的源碼:
public interface Comparable<T>{public int compareTo(T o); }我們為什么要實現Comparable接口？
我們的一個類型實現了Comparator接口，表明這個類具有了可排序的功能或者標準，兩個對象可以通過Compareable接口中的compareTo方法的返回值來進行比較大小
1)我們首先定義一個學生對象，再定義一個學生對象數組，我們將對象數組中的元素繼續進行排序(按照年齡來進行排序，比如說按照年齡進行升序排序，直接傳入數組名就可以了)
我們操作數組的工具包里面有一個Arrays.sort方法
package com.example.demo; import lombok.Data; import java.util.Arrays; @Data class Student{public String username;public String password;public int age;public Student(String username, String password, int age) {this.username = username;this.password = password;this.age = age;} } public class HelloWorld {public static void main(String[] args) {Student student1=new Student("李佳偉","12503487",12);Student student2=new Student("李佳鑫","778891",89);Student student3=new Student("張鐘俊","9090",86);Student[] students=new Student[3];Arrays.sort(students);} }2)當我們調用Arrays.sort(arr1)的時候，可以發現我們的源碼類型可以將數組元素強制轉換成Comparable類型，而我們自定義的類和我們的Comparable毫不相關，Student類是沒有compareTo方法的
package com.example.demo;import lombok.Data;import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List;@Data class Student implements Comparable<Student>{public String username;public String password;public int age;public Student(String username, String password, int age) {this.username = username;this.password = password;this.age = age;}@Overridepublic int compareTo(Student o) {return this.age-o.age;} } public class HelloWorld {public static void main(String[] args) {Student student1=new Student("李佳偉","12503487",12);Student student2=new Student("李佳鑫","778891",89);Student student3=new Student("張鐘俊","9090",86);Student[] students=new Student[3];students[0]=student1;students[1]=student2;students[2]=student3;// Arrays.sort(students);List<Student> list=new ArrayList<>();list.add(student1);list.add(student2);list.add(student2);Collections.sort(list);System.out.println(Arrays.toString(students));System.out.println(list);} }3)現在我們寫一個字符串數組進行輸出:
Arrays.sort()也可以傳入一個Compareator接口
誰調用compareTo方法，誰就是this
package com.example.demo; import java.util.Arrays; public class HelloWorld{public static void main(String[] args) {String[] strings={"a","aa","aaa","aaaa"};Arrays.sort(strings);System.out.println(Arrays.toString(strings));} }我們再去觀察String類的源碼，我們發現我們的String類也實現了Comparable接口重寫了里面的compareTo方法
Comparator接口
2)定義一個新的類，讓他繼承Comparator接口，里面要有一個泛型參數，放比較的類型，之后在我們的main方法里面直接可以new一個比較器，里面的參數就是我們想要比較的類型
咱們的Comparator的接口的源碼:
public interface Comparator<T>{int compare(T o1,T o2);boolean equals(Object obj) }Comparator是一個可比較接口，我們如果說想要控制某一個類的次序，但是這個類不支持排序，沒有實現Comparable接口，那么我們在這個類外面創建一個類的比較器來進行排序，實現Comparator接口
實現Comparator的接口的實際應用:
Arrays.sort()里面有下面的給出的重載，可以用來排序自定義類型
Arrays.sort(T[] arr1,Comparator<? super T> c) 第一個參數傳入數組,第二個參數傳入一個Comparator接口也可以對實現Comparable的類實現比較
comparator對類的侵入性比較強，但是使用起來非常靈活，我們用Comparator實現比較器，當某一個自定義對象需要進行比較的時候，把比較器和對象一起傳入過去就大小了
static class AgeComparator implements Comparator<Student>{public int compare(Student o1, Student o2) {return o1.age- o2.age;}}static class Student {public String name;public int age;public Double score;public Student(String name, int age, Double score) {this.name = name;this.age = age;this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}}public static void main(String[] args) {Student student1 = new Student("李佳偉", 15, 23.9);Student student2 = new Student("李佳鑫", 4, 89.9);Student student3 = new Student("周云剛", 89, 10.9);Student[] arr1 = {student1, student2, student3};Arrays.sort(arr1,new AgeComparator());System.out.println(Arrays.toString(arr1));//或者也可以這么進行比較AgeComparator ageComparator=new AgeComparator();if(ageComparator.compare(student1,student2)>0){System.out.println(1);}}?Comparable(對內實現)和Comparator(對外實現)的區別
1)Comparable翻譯成中文是比較的意思，而Comparator翻譯成中文是比較器的意思
2)實現Comparable接口并重寫compareTo方法就可以實現某一個類來進行排序了,他支持Collections.sort()和Arrays.sort()的排序，如果說自定義對象沒有實現Comparable接口，在Arrays.sort()方法的底層，都把數組每一個元素轉化成了Compareable元素,或者傳入一個比較器
3)Comparator通過匿名內部類的方式來進行比較:支持list.sort進行排序
package Demo;import java.util.ArrayList; import java.util.Comparator; import java.util.List;class Task{public String name;public int age;public Task(String name,int age){this.name=name;this.age=age;}@Overridepublic String toString() {return "Task{" +"name='" + name + '\'' +", age=" + age +'}';} } public class DemoKail{public static void main(String[] args) {List<Task> list=new ArrayList<>();Task task1=new Task("李佳偉",19);Task task2=new Task("李嘉欣",20);Task task3=new Task("及時雨",88);list.add(task1);list.add(task2);list.add(task3);list.sort(new Comparator<Task>() {@Overridepublic int compare(Task o1, Task o2) {return o1.age-o2.age;}});System.out.println(list);}} default void sort(Comparator<? super E> c) {Object[] a = this.toArray();Arrays.sort(a, (Comparator) c);上面是list.sort()
Arrays.sort()和list.sort()都可以對Compareable和Compareator接口的類實現自定義比較
public static <T> void sort(List<T> list, Comparator<? super T> c) {list.sort(c);}上面是Collections.sort()
類和類的關系:單繼承
類和接口的關系:多實現
接口和接口的關系:多繼承,一個接口可以繼承多個接口
1)包是一組類的集合，包是能夠防止類的名字沖突，import static能夠導入一些靜態方法，但是我們說import能夠導入一個具體的包，是錯誤的，通過import不可以導入一個具體的包，只能導入這個包某一個具體的類:java.util.collections
2)下面的這個代碼不能通過編譯:因為當我們進行構建Derived類的時候，因為他的父類是有構造方法的，所以說Derived類要先幫助父類來進行構造，所以應該寫super(s);
class Base{ public Base(String s) {System.out.println("B"); }} public class Derived extends Base{public Derived(String s){System.out.println("D");} } public static void main(String[] args){new Derived("C"); }父類靜態代碼塊
子類靜態代碼塊
父類實例代碼塊
父類構造方法
子類實例代碼塊
子類構造方法
import java.util.*; class A{B b=new B();------相當于是實例代碼塊public A(){System.out.println("A");} } class B{public B(){System.out.println("B");}} class C extends A{B b=new B();-----子類的實例代碼塊public C(){System.out.println("C");}public static void main(String[] args) {new C();} } //所以最終打印結果是B A B C super關鍵字實在子類對象里面指代父類對象的引用接口的訪問修是限定符不可以是private protected final，但是可以是abstract來進行修飾接口
總結
以上是生活随笔為你收集整理的JAVA面向对象编程(2)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 各种位运算的使用
- 下一篇： 《解忧杂货店》读书笔记