* 對象
    * 類
    * 成員方法
    * 構造方法
    * 常量
    * 變量：局部變量、類變量(靜態變量)、成員變量
    * Java大小寫敏感，類名首字母大寫，方法名首字母小寫，源文件名與類名相同，主方法口：public static void main(String []args)
    * Java標識符：以字母 $ _ 開頭,首字符之后可以是字母 $ _ 數字
    * 訪問控制符：public protected default private
    * 修飾符：static final abstract synchronized transient volatile
    * 八種基本數據類型：byte short int long float double boolean char
    * 類型轉換
    * 算術運算符： + - * / % ++ --
    * 關系運算符: ==  !=  >  <  >=  <=
    * 邏輯運算符：&&  ||  ！
    * 位運算符
    * 賦值運算符：=  +=  -=  *=  /=  %=  等
    * 三元運算符：c = a>b ? d : e
    * 循環結構：while循環    do...while循環    for循環
    * 分支結構：if語句  switch語句
    * Number類 Math類 Character類 String類 StringBuffer類  Scanner類
    * Java異常處理
    * Java繼承
    * Java Override/Overload
    * Java多態
    * Java抽象類
    * Java封裝
    * Java接口
    * Java package
    * Java 網絡編程
    * Java多線程
    * Java數據結構
    * 迭代器

1.類和對象

package test;
/*
 * Java對象和類：
 *      對象：對象是類的一個實例，有狀態和行為。
 *      類：類是一個模板，描述一類對象的行為和狀態。
 * Java中的類
 *      類包含以下類型變量：
 *          局部變量：在方法、構造方法或者語句塊中定義的變量被稱為局部變量。變量聲明和初始化都是在方法中，方法結束后，變量就會自動銷毀。
 *          成員變量：成員變量是定義在類中，方法體之外的變量。這種變量在創建對象的時候實例化。成員變量可以被類中方法、構造方法和特定類的語句塊訪問。
 *          類變量：類變量也聲明在類中，方法體之外，但必須聲明為static類型。
 * 構造方法：每個類都有構造方法。如果沒有顯式地為類定義構造方法，Java編譯器將會為該類提供一個默認構造方法。在創建一個對象的時候，至少要調用一個構造方法。構造方法的名稱必須與類同名，一個類可以有多個構造方法。
 * 創建對象：
 *      聲明：聲明一個對象，包括對象名稱和對象類型。
 *      實例化：使用關鍵字new來創建一個對象。
 *      初始化：使用new創建對象時，會調用構造方法初始化對象。
 * */
public class Test {
    //兩個成員變量
    int age;
    String sex;
    
    //兩個構造方法：一個不帶參數，一個帶參數
    public Test(){
        System.out.println("構造方法一！");
    }
    public Test(String name){
        System.out.println("構造方法二：" + name);
    }
    //定義一個方法
    public void huhu(){
        int h = 11;//定義一個局部變量
        System.out.println("調用方法，局部變量值："+h);
    }
    
    public static void main(String []args){
        //下面兩個對象在創建的時候使用了不同的構造方法
        
        Test myTest = new Test();//創建一個myTest對象
        myTest.age = 11;//給對象的屬性設定值
        myTest.sex = "男";
        myTest.huhu();//調用方法
        System.out.println("myTest的age和sex分別是："+myTest.age+','+myTest.sex);//訪問成員變量
        
        Test myTest2 = new Test("狗狗");
        myTest2.age = 13;
        myTest2.sex = "女";
        myTest2.huhu();//調用方法
        System.out.println("myTest2的age和sex分別是："+myTest2.age+','+myTest2.sex);//訪問成員變量
    }
}

Snip20170918_1.png

2.java基本數據類型

/*
 *Java基本數據類型
 *  byte：有符號整數，一個字節，(-2^7 ~ 2^7-1)
 *  short:有符號整數，兩個字節，(-2^15 ~ 2^15-1)
 *  int:有符號整數，四個字節，(-2^31 ~ 2^31-1)
 *  long:有符號整數，八個字節，(-2^63 ~ 2^63-1)
 *  float:單精度浮點數，四個字節
 *  double:雙精度浮點數，八個字節
 *  boolean:true/false
 *  char:兩個字節
 *Java 中使用 final 關鍵字來修飾常量
 * */
public class Test {
    
    public static void main(String []args){
        System.out.println("基本類型：byte,short,int,long,float,double,char的位數："+Byte.SIZE+','+Short.SIZE+','+Integer.SIZE+','+Long.SIZE+','+Float.SIZE+','+Double.SIZE+','+Character.SIZE);
        final double PI = 3.1415927;
        System.out.println("常量PI的值："+PI);
    }
}

Snip20170918_3.png

3.Java變量類型

/*
 *Java變量
 *  聲明變量的基本格式：type identifier = value;
 *  變量類型：
 *      類變量：獨立于方法之外的變量，用 static 修飾。
 *          類變量也稱為靜態變量，在類中以static關鍵字聲明，但必須在方法構造方法和語句塊之外。
 *          無論一個類創建了多少個對象，類只擁有類變量的一份拷貝。
 *          靜態變量除了被聲明為常量外很少使用。常量是指聲明為public/private，final和static類型的變量。常量初始化后不可改變。
 *          靜態變量儲存在靜態存儲區。經常被聲明為常量，很少單獨使用static聲明變量。
 *          靜態變量在程序開始時創建，在程序結束時銷毀。
 *          與實例變量具有相似的可見性。但為了對類的使用者可見，大多數靜態變量聲明為public類型。
 *          默認值和實例變量相似。數值型變量默認值是0，布爾型默認值是false，引用類型默認值是null。變量的值可以在聲明的時候指定，也可以在構造方法中指定。此外，靜態變量還可以在靜態語句塊中初始化。
 *          靜態變量可以通過：ClassName.VariableName的方式訪問。
 *          類變量被聲明為public static final類型時，類變量名稱一般建議使用大寫字母。如果靜態變量不是public和final類型，其命名方式與實例變量以及局部變量的命名方式一致。
 *      實例變量：獨立于方法之外的變量，不過沒有 static 修飾。
 *          實例變量聲明在一個類中，但在方法、構造方法和語句塊之外；
 *          當一個對象被實例化之后，每個實例變量的值就跟著確定；
 *          實例變量在對象創建的時候創建，在對象被銷毀的時候銷毀；
 *          實例變量的值應該至少被一個方法、構造方法或者語句塊引用，使得外部能夠通過這些方式獲取實例變量信息；
 *          實例變量可以聲明在使用前或者使用后；
 *          訪問修飾符可以修飾實例變量；
 *          實例變量對于類中的方法、構造方法或者語句塊是可見的。一般情況下應該把實例變量設為私有。通過使用訪問修飾符可以使實例變量對子類可見；
 *          實例變量具有默認值。數值型變量的默認值是0，布爾型變量的默認值是false，引用類型變量的默認值是null。變量的值可以在聲明時指定，也可以在構造方法中指定；
 *          實例變量可以直接通過變量名訪問。但在靜態方法以及其他類中，就應該使用完全限定名：ObejectReference.VariableName。
 *      局部變量：類的方法中的變量。
 *          局部變量聲明在方法、構造方法或者語句塊中；
 *          局部變量在方法、構造方法、或者語句塊被執行的時候創建，當它們執行完成后，變量將會被銷毀；
 *          訪問修飾符不能用于局部變量；
 *          局部變量只在聲明它的方法、構造方法或者語句塊中可見；
 *          局部變量是在棧上分配的。
 *          局部變量沒有默認值，所以局部變量被聲明后，必須經過初始化，才可以使用。
 *          
 * */
public class Test {
    static int age ;//類變量
    String sex;//實例變量
    
    public void pup(){
        int a = 0;//局部變量
        a = a + 7;
        System.out.println("局部變量a的值："+a);
    }
    
    public static void main(String []args){
        Test test = new Test();
        age = 10;
        test.sex = "男";
        System.out.println("類變量age的值："+age+"成員變量sex的值："+test.sex);
        test.pup();
    }
}

Snip20170918_4.png

4.Java修飾符

/*
 *Java修飾符
 *  訪問控制修飾符
 *      default (即缺省，什么也不寫）: 在同一包內可見，不使用任何修飾符。使用對象：類、接口、變量、方法。
 *      private : 在同一類內可見。使用對象：變量、方法。 注意：不能修飾類（外部類）
 *      public : 對所有類可見。使用對象：類、接口、變量、方法
 *      protected : 對同一包內的類和所有子類可見。使用對象：變量、方法。 注意：不能修飾類（外部類）。
 *  非訪問修飾符
 *      static 修飾符，用來修飾類方法和類變量。
 *          靜態變量：static 關鍵字用來聲明獨立于對象的靜態變量，無論一個類實例化多少對象，它的靜態變量只有一份拷貝。 靜態變量也被稱為類變量。
 *          靜態方法：static 關鍵字用來聲明獨立于對象的靜態方法。靜態方法不能使用類的非靜態變量。
 *      final 修飾符，用來修飾類、方法和變量，final 修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量為常量，是不可修改的。
 *      abstract 修飾符，用來創建抽象類和抽象方法。
 *      synchronized 和 volatile 修飾符，主要用于線程的編程。
 *          
 * */

5.Java運算符

/*
 *Java運算符
 *      算術運算符
 *          + - *  /  % ++ --
 *      關系運算符
 *          ==  !=  >  <  >=  <=
 *      位運算符
 *          &  |  ^  ~  <<  >>  >>>
 *      邏輯運算符
 *          &&(邏輯與)  ||(邏輯或)  !(邏輯非)
 *      賦值運算符
 *          =  +=  -=  *=  /=  
 *      其他運算符
 *          三元運算符：variable x = (expression) ? value if true : value if false
 *          instanceof運算符：檢查該對象是否是一個特定類型
 *          
 * */

6.Java循環

/*
 *Java循環結構
 *      while
 *      do...while
 *      for 
 *  break關鍵字    主要用在循環語句或者 switch 語句中，用來跳出整個語句塊。
 *  continue關鍵字  適用于任何循環控制結構中。作用是讓程序立刻跳轉到下一次循環的迭代。
 * */
public class Test {
    
    public static void main(String []args){
        
        //while循環
        int x = 0;
        while(x < 10){
            if(x == 5){
                break;//結束循環
            }
            System.out.println("value of x :"+x);
            x++;
        }
        //do...while循環
        System.out.println();
        int y = 1;
        do{
            System.out.println("value of y :"+y);
            y++;
        }while(y<5);
        //for循環
        System.out.println();
        for(int i = 0; i<5; i++){
            if(i == 3){
                continue;//結束本次循環，繼續循環
            }
            System.out.println("value of i :"+i);
        }
        //增強for循環
        String [] names = {"a", "b", "c", "d", "e"};
        for(String name: names){
            System.out.println(name);
        }
    }
}

Snip20170918_5.png

7.Java分支結構

/*
*Java分支結構
*  if語句
*  switch語句
* */
public class Test {
   
   public static void main(String []args){
       
       int x = 30;
       if(x == 10){
           System.out.println("value of x is 10");
       }else if(x == 20){
           System.out.println("value of x is 20");
       }else if(x == 30){
           System.out.println("value of x is 30");
       }else{
           System.out.println("這是 else 語句");
       }
       
       char grade = 'C';
       switch(grade){
       case 'A':
           System.out.println("優秀");
           break;
       case 'B':
           System.out.println("良好");
           break;
       case 'C':
           System.out.println("及格");
           break;
       case 'D':
           System.out.println("不及格");
           break;
       default:
           System.out.println("未知等級");
       }
   }
}

Snip20170918_6.png

8.Java Number & Math 類

/*
 *Java Number & Math 類
 *  Number & Math 類方法
 *      xxxValue():將 Number 對象轉換為xxx數據類型的值并返回  byteValue()  doubleValue() floatValue() intValue() longValue() shortValue()
 *      compareTo():將number對象與參數比較。兩個不同類型的數據不能用此方法來比較
 *      equals():判斷number對象是否與參數相等。
 *      valueOf():返回一個 Number 對象指定的內置數據類型
 *      toString():以字符串形式返回值。
 *      parseInt():將字符串解析為int類型。
 *      abs():返回參數的絕對值。
 *      ceil():對整形變量向左取整，返回類型為double型。對一個數進行上舍入,返回值大于或等于給定的參數
 *      floor():對整型變量向右取整。返回類型為double類型,小于或等給定的參數
 *      rint():返回與參數最接近的整數。返回類型為double。
 *      round():返回一個最接近的int、long型值。
 *      min():返回兩個參數中的最小值。
 *      max():返回兩個參數中的最大值。
 *      exp():返回自然數底數e的參數次方。
 *      log():返回參數的自然數底數的對數值。
 *      pow():返回第一個參數的第二個參數次方。
 *      sqrt():求參數的算術平方根。
 *      sin():求指定double類型參數的正弦值。
 *      cos():求指定double類型參數的余弦值。
 *      tan():求指定double類型參數的正切值。
 *      asin():求指定double類型參數的反正弦值。
 *      acos():求指定double類型參數的反余弦值。
 *      atan():求指定double類型參數的反正切值。
 *      atan2():將笛卡爾坐標轉換為極坐標，并返回極坐標的角度值。
 *      toDegrees():將參數轉化為角度。
 *      toRadians():將角度轉換為弧度。
 *      random():返回一個隨機數。
 * */
public class Test {
    
    public static void main(String []args){
        Integer x = 5;
        System.out.println(x.doubleValue());//返回double原生數據類型
        System.out.println(x.compareTo(3));//相等返回0，小于返回-1，大于返回1.
        Integer y = 5;
        System.out.println(x.equals(y));//與方法的參數類型與數值都相等返回 True，否則返回 False。
        System.out.println(Float.valueOf("80"));//參數為 Integer 對象的整數或者字符串
        System.out.println(x.toString());
        System.out.println(Double.parseDouble("5"));
        System.out.println(Math.abs(-6));//返回參數的絕對值
        System.out.println(Math.ceil(3.43));
        System.out.println(Math.ceil(-3.43));//參數為double 或 float
        System.out.println(Math.floor(4.6));
        System.out.println(Math.floor(-4.6));//返回 double 類型數組，小于或等于給定的參數
        System.out.println(Math.rint(100.6));
        System.out.println(Math.rint(100.5));//返回 double 類型數組，是最接近參數的整數值
        System.out.println(Math.round(100.6));
        System.out.println(Math.round(100.5));//參數為double,float,返回一個最接近的int、long型值
        System.out.println(Math.min(12.3, 12.4));
        System.out.println(Math.max(12.3, 12.4));
        System.out.println(Math.exp(2));//返回自然數底數e的2次方
        System.out.println(Math.log(7.38905609893065));//返回參數的自然數底數的對數值。
        System.out.println(Math.pow(3, 3));//返回第一個參數的第二個參數次方。
        System.out.println(Math.sqrt(4));//返回參數的算術平方根。
        System.out.println(Math.random());//用于返回一個隨機數，隨機數范圍為 0.0 =< Math.random < 1.0。
        
    }
}

Snip20170919_7.png

9.Java Character類

/*
 *Java Character類
 *  Character 類用于對單個字符進行操作，Character 類在對象中包裝一個基本類型 char 的值
 *  Character方法
 *      isLetter():是否是一個字母
 *      isDigit():是否是一個數字字符
 *      isWhitespace():是否是一個空格
 *      isUpperCase():是否是大寫字母
 *      isLowerCase():是否是小寫字母
 *      toUpperCase():指定字母的大寫形式
 *      toLowerCase():指定字母的小寫形式
 *      toString():返回字符的字符串形式，字符串的長度僅為1
 * */
public class Test {
    
    public static void main(String []args){
        System.out.println(Character.isLetter('c'));
        System.out.println(Character.isLetter('5'));
        System.out.println();
        System.out.println(Character.isDigit('c'));
        System.out.println(Character.isDigit('5'));
        System.out.println();
        System.out.println(Character.isWhitespace('c'));
        System.out.println(Character.isWhitespace(' '));
        System.out.println(Character.isWhitespace('\n'));
        System.out.println(Character.isWhitespace('\t'));
        System.out.println();
        System.out.println( Character.isUpperCase('c'));
        System.out.println( Character.isUpperCase('C'));
        System.out.println();
        System.out.println( Character.isLowerCase('c'));
        System.out.println( Character.isLowerCase('C'));
        System.out.println();
        System.out.println(Character.toUpperCase('a'));
        System.out.println();
        System.out.println(Character.toLowerCase('A'));
        System.out.println();
        System.out.println(Character.toString('a'));
    }
}

Snip20170919_8.png

10.Java數組

/*
 *Java數組 用來存儲固定大小的同類型元素。
 * */
public class Test {
    
    public static void main(String []args){
        int[] myList = new int[5];//創建數組
        myList[0] = 0;
        myList[1] = 1;
        myList[2] = 2;
        myList[3] = 3;
        myList[4] = 4;
        
        int total = 0;
        for(int i = 0; i < myList.length; i++){
            total += myList[i];
        }
        System.out.println("總和為:"+total);
        
        double[] myList2 = {1.1, 2.2, 3.3, 4.4, 5.5};//創建數組
        for(double element: myList2){//遍歷數組
            System.out.println(element);
        }
        
        String s[][] = new String[2][];//二維數組
        s[0] = new String[2];
        s[1] = new String[3];
        s[0][0] = new String("Good");
        s[0][1] = new String("Luck");
        s[1][0] = new String("to");
        s[1][1] = new String("you");
        s[1][2] = new String("!");
        for(String[] element: s){
            for(String ele: element){
                System.out.println(ele);
            }
        }
    }
}

Snip20170919_9.png

11.Java String類

/*
 *Java String 類 
 *  String 類是不可改變的，所以你一旦創建了 String 對象，那它的值就無法改變了
 *Java StringBuffer 和 StringBuilder 類
 *  和 String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，并且不產生新的未使用對象。
 * */
public class Test {
    
    public static void main(String []args){
        String site = "www.baidu.com";
        int len = site.length();//字符串長度
        System.out.println("網址長度：" + len);
        System.out.println(site.indexOf('b'));//字符b在site中的位置
        System.out.println(site.substring(4, 9));//子字符串
        System.out.println(site.toUpperCase());//大寫
        
        float x = 1.1f;
        int y = 2;
        String z = "haha";
        String fs = String.format("x,y,z三個變量的值為: %f, %d, %s", x, y, z);//創建格式化字符串
        System.out.println(fs);
        
        StringBuffer sb = new StringBuffer("官網：");
        sb.append("www");
        sb.append(".baidu.com");
        System.out.println(sb);
    }
}

Snip20170919_10.png

12.Java方法

/*
 *Java 方法
 *      Java方法是語句的集合，它們在一起執行一個功能。
 *          方法是解決一類問題的步驟的有序組合
 *          方法包含于類或對象中
 *          方法在程序中被創建，在其他地方被引用
 *      一個方法的所有部分：修飾符 返回值類型 方法名(參數類型 參數名){方法體 return 返回值；}
 *          修飾符：可選，定義了該方法的訪問類型。
 *          返回值類型：returnValueType或者void
 *          方法名：是方法的實際名稱。方法名和參數表共同構成方法簽名。
 *          參數類型：參數是可選的。
 *          方法體：方法體包含具體的語句，定義該方法的功能。
 *      方法的重載：方法重載是指在一個類中定義多個同名的方法，但要求每個方法具有不同的參數的類型或參數的個數。
 *      變量作用域：變量的范圍是程序中該變量可以被引用的部分。
 *      構造方法：當一個對象被創建時候，構造方法用來初始化該對象。構造方法和它所在類的名字相同，但構造方法沒有返回值。
 *      finalize()方法：它在對象被垃圾收集器析構(回收)之前調用，這個方法叫做 finalize( )，它用來清除回收對象。
 * */
public class Test {
    int age;
    //構造方法
    Test(int i){
        age = i;
    }
    public static void main(String []args){
        int i = 5;
        int j = 2;
        int k = max(i, j);
        System.out.println(i + " 和 " + j + " 比較，最大值是：" + k);
        
        double x = 5.5;
        double y = 6.6;
        double z = max(x,y);
        System.out.println(x + " 和 " + y + " 比較，最大值是：" + z);
        
        Test myTest = new Test(10);
        System.out.println(myTest.age);
        
        myTest = null;
        System.gc();//調用Java垃圾收集器
        
        
    }
    
    public static int max(int num1, int num2){
        int result;
        if(num1 > num2){
            result = num1;
        }else{
            result = num2;
        }
        
        return result;
    }
    
    //方法的重載：方法重載是指在一個類中定義多個同名的方法，但要求每個方法具有不同的參數的類型或參數的個數。
    public static double max(double num1, double num2){
        double result;
        if(num1 > num2){
            result = num1;
        }else{
            result = num2;
        }
        
        return result;
    }
    //指定在對象銷毀時候要執行的操作。
    protected void finalize(){
        System.out.println("對象銷毀");
    }
}

Snip20170919_11.png

13.Java異常處理

/*
 *Java異常處理
 * */
public class Test {
    public static void main(String []args){
        int a[] = new int[2];
        try{
           System.out.println("Access element three :" + a[3]);
        }catch(ArrayIndexOutOfBoundsException e){
           System.out.println("Exception thrown  :" + e);
        }
        finally{
           a[0] = 6;
           System.out.println("First element value: " +a[0]);
           System.out.println("The finally statement is executed");
        }
    }

}

Snip20170919_12.png

14.Java繼承

/*
 *Java繼承
 *  繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。
 *  繼承的特性：
 *      子類擁有父類非private的屬性，方法。
 *      子類可以擁有自己的屬性和方法，即子類可以對父類進行擴展。
 *      子類可以用自己的方式實現父類的方法。
 *      Java的繼承是單繼承，但是可以多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如A類繼承B類，B類繼承C類，所以按照關系就是C類是B類的父類，B類是A類的父類，這是java繼承區別于C++繼承的一個特性。
 *      提高了類之間的耦合性（繼承的缺點，耦合度高就會造成代碼之間的聯系）。
 *  繼承關鍵字：
 *      extends關鍵字：在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，所以 extends 只能繼承一個類。
 *      implements關鍵字：使用 implements 關鍵字可以變相的使java具有多繼承的特性，使用范圍為類繼承接口的情況，可以同時繼承多個接口（接口跟接口之間采用逗號分隔）。
 *      super與this關鍵字：
 *          super關鍵字：我們可以通過super關鍵字來實現對父類成員的訪問，用來引用當前對象的父類。
 *          this關鍵字：指向自己的引用
 *      final關鍵字：final 關鍵字聲明類可以把類定義為不能繼承的，即最終類；或者用于修飾方法，該方法不能被子類重寫。
 * */
//父類
class Animal{
    protected int age;
    void go(){
        System.out.println("animal go:");
    }
}
//子類繼承父類
class Dog extends Animal{
    void go(){
        //調用父類方法
        super.go();
    }
}

public class Test {
    public static void main(String []args){
        Dog dog = new Dog();
        dog.age = 10;
        System.out.println("age:"+dog.age);
        dog.go();
    }
}

Snip20170920_1.png

15.Java 重寫(Override)與重載(Overload)

/*
 *Java 重寫(Override)與重載(Overload)
 *  重寫：重寫是子類對父類的允許訪問的方法的實現過程進行重新編寫, 返回值和形參都不能改變。即外殼不變，核心重寫！
 *      重寫規則：
 *          參數列表必須完全與被重寫方法的相同；
 *          返回類型必須完全與被重寫方法的返回類型相同；
 *          訪問權限不能比父類中被重寫的方法的訪問權限更低。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected。
 *          父類的成員方法只能被它的子類重寫。
 *          聲明為final的方法不能被重寫。
 *          聲明為static的方法不能被重寫，但是能夠被再次聲明。
 *          子類和父類在同一個包中，那么子類可以重寫父類所有方法，除了聲明為private和final的方法。
 *          子類和父類不在同一個包中，那么子類只能夠重寫父類的聲明為public和protected的非final方法。
 *          重寫的方法能夠拋出任何非強制異常，無論被重寫的方法是否拋出異常。但是，重寫的方法不能拋出新的強制性異常，或者比被重寫方法聲明的更廣泛的強制性異常，反之則可以。
 *          構造方法不能被重寫。
 *          如果不能繼承一個方法，則不能重寫這個方法。
 *  重載：重載(overloading) 是在一個類里面，方法名字相同，而參數不同。返回類型可以相同也可以不同。
 *      重載規則：
 *          被重載的方法必須改變參數列表(參數個數或類型或順序不一樣)；
 *          被重載的方法可以改變返回類型；
 *          被重載的方法可以改變訪問修飾符；
 *          被重載的方法可以聲明新的或更廣的檢查異常；
 *          方法能夠在同一個類中或者在一個子類中被重載。
 *          無法以返回值類型作為重載函數的區分標準。
 * */

16.Java多態

/*
 *Java 多態
 *   多態是同一個行為具有多個不同表現形式或形態的能力
 *  多態的優點：
 *      1. 消除類型之間的耦合關系
 *      2. 可替換性
 *      3. 可擴充性
 *      4. 接口性
 *      5. 靈活性
 *      6. 簡化性
 *  多態存在的三個必要條件
 *      繼承
 *      重寫
 *      父類引用指向子類對象
 * */

class Animal{
    public void eat(){
        System.out.println("haha");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("吃魚");
    }
}
public class Test {
    public static void main(String []args){
        Animal a = new Cat();
        a.eat();
    }
}

Snip20170920_2.png

17.