* 对象
    * 类
    * 成员方法
    * 构造方法
    * 常量
    * 变量：局部变量、类变量(静态变量)、成员变量
    * 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.