学习目标：

                >.  可变个数的形参方法

                >.  Java的值传递机制

                >.  面向对象的特征一：封装性

                >.  构造器


              ##. 可变个数的形参方法：

                        1.格式：对于方法的形参，数据类型...形参名

                        2.可变个数的形参的方法与同名方法之间构成重载

                        3.可变个数的形参在调用时。个数从0开始，到无穷多个都可以。

                        4.使用可变多个形参的方法与方法的形参使用数组是一致的。

                        5.若方法中存在可变个数的形参，那么一定要声明在方法形参的最后

                        6. 在一个方法中，最多声明一个可变个数的形参 

                        例子：

                            public void sayHello(String[] args){

                                for( int i=0 ; i < args.length ; i++ ){

                                     System.out.println( args[i] + "$" );

                                 }

                             }

                             //方法调用时，必须使用数组声明参数,也只能使用数组声明参数

                              TestArgs t = new  TestArgs( );

                               t.sayHello( new String[ ]{ "hello China", "hello Beijing" });

                            //使用可变形参列表时，不止可以使用数组声明参数，空参调用也可以，来看代码

                                t.sayHello( )

                                t.sayHello( new String[ ]{ "hello China", "hello Beijing" });

                                t.sayHello( "hello China", "hello Beijing" );

                                public void sayHello( String ... args ){

                                     for( int i=0; i< args.length; i++ ){

                                           System.out.println( args[i] + "$" );

                                      }

                                 }

                                 

                                public void sayHello( int i ,String ... args ){

                                     System.out.pintln( i );

                                     for( int i=0 ; i< args.length ;  i++ ){

                                           System.out.println( args[i] + "$" );

                                      }

                                 }

                          ##. java的值传递机制（基础，必须掌握）

                                >. 基本数据类型的

                                >. 引用数据类型的

                          ##. 面向对象的特征一: 封装与隐藏

                                问题：当创建了类的对象以后，如果直接通过"对象.属性"的方式对相应的对象属性赋值的话，

                                          可能会出现不满足实际情况的意外，考虑不让对象来直接作用属性，

                                          而是通过“对象.方法”的形式，来控制对象对属性的访问。

                                          实际情况中，对属性的要求就可以通过方法来体现。

                                解决的方法: (封装性的思想) ①.将类的属性私有化，②.提供公共的方法(setter & getter)来实现调用。

                                例子：

                                            private int  legs;     

                                            /*这是定义动物类里面的动物腿的条数声明，不能把腿数声明为负数或者奇数，

                                               也就是不能让其他人调用"对象.属性"的方式随意修改，可以提供set和get方法

                                                进行判断设置以后，才可以公开的通过“对象.方法”的方式调用这个被私有化的属性。*/

                                            //设置类的属性

                                             public void  setLegs(int l){

                                                  if( l > 0 && l%2 == 0){

                                                      legs = l;

                                                   }else{

                                                        System.out.println("输入的数据错误...")

                                                    }

                                              }                               

                                            //获取类的属性

                                            public int getLegs(){

                                                return legs;

                                             }

                          ##.类的构造器：

                                构造器的作用：①. 创建对象  ②. 给创建对象的属性赋值

                                >. 设计类时，若不显示声明类的构造器的话，程序会默认提供一个空参构造器

                                >.  一旦显示的定义类的构造器， 那么默认的构造器就不再提供。

                                >.  如何声明类的构造器。格式: 权限修饰符 类名(形参){ }

                                >.  类的多个构造器之间构成重载