黑马程序员Java__集合（数组）和类

------- android培训、java培训、期待与您交流！ --------

java中数组的定义

　一维数组

      　１）一维数组的声明；

　　　格式一 ：数组的元素类型　　数组名[]

                            int  a[];

　　　格式二 ：数组的元素类型[]　　数组名  ;开发中常用此格式     

                            int[] a;

　　　２）数组的创建：

　　　格式一：数组名＝new 数组元素类型[数组的长度]    

                          a=new int[5];

　　　格式二：数组元素类型　数组名[]＝new 数组元素类型[数组长度]

　　　　　　　int a[]=new int[5] ;

       3)数组的初始化：

　　　格式：数组元素类型　数组名[]＝{元素１，元素２，……}

　　　　　       inta[]={1,3,4,7,8}

 数组的应用

　　１）遍历数组元素常用二种方法：

　　　1.public static void printArray(int[] a)

             {          //把x当作数组的一个元素号

　　　　　for(int x=0;x<a.length-1;x++){

                   //   if(x!=a.length-1)                    

                        system.out.print(a[x]+'');

                             else

                           system.out.print(a[x]) ;                      

                            }

                  }

             2. public static void printArray(int a[])

               {        / /把x当作数组中的元素值，（:）可以读作in,也就是for e ach in a

                  for(int x:a) {

                         if(x!=a[a.length-1])

                            system.out.print(x+",");

                             else

                               system.out.print(x);      

                        }       

               }

   　　总结：可以通过a.length属性获取数组的长度,记住数组只有length属性，字符串有length()方法

　２　获取数组中的最大值与最小值

          /*思路：

　　　１、定义一个变量来接收数组中两元素中最大值

　　　２、遍历数组中的每个元素与这个变量比较，再返回最大值给该变量

           3、既然是遍历，同上有两种方法

　　　返回值类型：int

          所需参数：int  a[]

              */

　　1public static void int(int a[])

        {

          　int temp=0;

　　　　for(int x:a)

               {

                     if(x>temp)

                       temp=x;

                          }

                      return temp;

                  }

        2   public static void int(int a[])

             {

                    int temp=0;

                   for(int x=0;x>a.length;x++)

                      {

                            if(a[x]>temp)

                               temp=a[x];             

                                  }

                                  return temp;

                            }

  　 最小值把符号改了就行了，这里就不用多写了

　３　数组元素排序

　　１）选择排序法

　　　  * 功能:对数组进行排序

  * 思路:

  * 1.将数组中的第一个元素与第二个元素相比,然后再与第三个比较;以此类推;循环第一个元素

  * 再循环第二个,所以会产生一个倒三角形,此时用到for循环

  * 2,定义判断条件,定义一个变量来临时储存最大值,

  * 3.通过变量来交换数组中元素的顺序

  * 步骤:

  * 返回值:没有

  * 未知参数:数组*/

 public static void sort(int[] a){

  for(int x=0;x<a.length-1;x++){//a.length-1:最后 一个不用比较

   for(int y=x+1;y<a.length;y++){//x+1:只比较相邻的元素

    if(a[x]>a[y]){

     swap(a, x, y);

    }

   }

  }

  

  }

 

    ２）冒泡排序法    

 * 功能:冒泡排序

     * 思路:

     * 1.将数组中第一元素与第二元素的值比较,得到的最大值又与第三个元素的比较;以此类推

     * 每完成一轮都会减少一个最大值,由些得知用for循环数组元素

     * 2.定义判断条件,定义一下变量来存储最大值

     * 3.通过变量来交换数组中元素的顺序

     * 返回值:没有

     * 未知参数:数组*/

 public static void selectSort(int[] a){

  for(int x=0;x<a.length-1;x++){

   for(int y=0;y<a.length-x-1;y++){//-x:让每次的比较的元素减少,-1:避免元素下标越界

    if(a[y]>a[y+1]){

    swap(a, y, y+1);

    }

   }

  }

  

 }

 /*功能:数组元素置换

  * 思路:

  * 1,定义一个变量

  * 2.将数组中的任意元素赋给该变量*/

 public static void swap(int[] a,int x,int y){

  int temp=a[x];

  a[x]=a[y];

  a[y]=temp;

 }

4 java类的定义

 1 ）类的定义

     格式如下：

           〈类声明〉

           {

             〈类主体〉

                   }

  2 ）类的声明

     格式如下：

         [〈修饰符〉] class〈类名〉[extends〈父类〉] [implenments〈接口名〉]

  3 ） 类的定义修饰符

    类的说明性修饰符说明了类的性质和权限，包括public、默认修饰符、abstract、final

  4 ）类主体

      格式如下：

           〈类声明〉

            {

              〈成员变量的声明〉

               〈成员方法的声明及实现〉

                }

  5 ）成员变量

       格式如下：

           [变量修饰符]〈变量类型〉〈变量名〉

       1)变量的修饰访问权限

        public：说明该变量是公有变量，允许任何程序包中的类的方法访问，其作用域最广。

        protected：说明该变量为保护变量，允许类自身，子类及同一包中的所有类的变量访问。

        private：说明该变量是私有变量，只能被定义在它类中的方法访问。

        默认修饰符：也称隐含修饰符，允许类自身及同一个包中的所有类的变量访问。

      2）用static修饰的变量是一个静态变量，称为类变量或者全局变量，无static说明的变量为实例变量(成员变量)

          静态变量与实例变量的区别：

        1)访问方法

            实例变量必须通过类的对象访问：

                        <类名>    〈对象名〉＝new  <类名>（）；

                         〈对象名〉.〈变量名〉

            静态变量可以通过类名访问：

                             〈类名〉.〈变量名〉

        2）存放位置：

                实例变量：随着对象的建立而存在于堆内存中。

                静态变量：随着类的加载而存在于方法区当中

        3）生命同期：

               实例变量：随着对象的消失而消失。

               静态变量：随着类的消失而消失，比实例变量长。

          局部变量与成员变量之间的区别:

        1)作用范围:

          局部变量：定义在方法内部的变量，或者语句中。

          成员变量：定义在整个类中。

        2）内存中的位置

           局部变量：存在于栈内存中。

          成员变量：在椎内存中，因为对象的存在而存在

        3 )作用范围:

          局部变量：使用之前必须被初始化。

          成员变量：默认的初始化值为null。

         常见面试题：

             final 是否可以配合static 使用？

            可以的，static final int age=10;

   6）成员方法

        格式如下：

                        [方法修饰符]〈方法返回值类型〉〈方法名〉（[〈参数列表〉]）

                                        {

                                                 方法体

                                                    }

    成员方法修饰方法有public,private,protected,final,static,abstract,synchronized

   final：此方法为最终方法,不能被其所在类的子类所重载.

   static：说明为静态方法,此方法不能被它的子类所重载.

  abstract：说明为抽象方法,只有方法说明,没有方法体;在其子类中被具体实现

  synchronized：此方法为同步方法,用于多线程程序设计,保证在同一时刻只有一个线程访问该方法,以实现线程之间的同步

7）返回值

无返回值：用void表示。

有返回值：用return+参数（必须与定义方法的参数类型一致）

8）构造方法

    0）作用：用于给对应对象进行初始化。

    1）语法：

        public      类名    （[参数列表]）{     [语句序列;]      }

   2) 特点：

       1.方法名与类名相同

       2. 不用定义返回值类型，只能由public ,private,protected.中的任一个修饰，如果用 private 修饰构造函数，该类将不能建立对象。

       3.不可以从父类继承，可以重载；一个类中可以有N多个构造方法

       4.不能直接通过方法名引用，必须通过new运算符。

       5.调用当前类或者是父类的另一个构造方法，使用当前的构造方法用this来引用，使用其父类的构造方法用super来引用，

          且是方法体的第一条语句。

      3）什么时候使用定义构造函数？

         当分析事物时，该事物存在具备一些特性或者行为；那么将这些内容定义在构造函数中。

      4）构造代码块：{.................}

      5）构造函数与构造代码块的别：

         构造函数：给对应的对象进行初始化。

        构造代码块：给所有对象统一进行初始化，对象一建立就运行；而且忧先于构造函数执行。

  5 类的使用

    1）对象创建：

         语法格式： type  对象名＝new type([参数列表])

    2）对象使用：

        1）引用对象中的变量：

                                <对象名>.<变量名>

       2）引用对象中的方法：

                                〈对象名〉. [方法名]（〈参数列表〉）

             

      3）继承：

                 java只支持单继承

           语法格式：

           class A  [extends 父类 B][ implements〈接口名〉]{

                                      〈成员变量的声明〉

                                            〈成员方法的声明及实现〉

                                   }

   4）super 与 this

            super：代表父类对象的引用。

        1) super有三种情况下可以使用：

              1.用来访问父类中被覆盖的方法。

              2.用来访问父类中的构造方法。

              3.用来访问父类中被隐藏的成员变量。

             this：体表子类对象的引用。

       2）this：代表它所在函数所属对象的引用.。

                  1)  可以用于区分局部变量和成员变量重名的情况。            

             例如：class Person{

                     private String name;

                     private String sex;

                     Person(String name){

                         this.name=name;           

                                   } 

                      Person(String name,String sex){

                         this(name);    //person(name) 必须定义在第一行，因为初始化要先执行。

                         this.sex=sex;

                                  }

                          }

   5）抽象类

               语法格式：

                 abstract class  类名{

                   声明数据成员；

                 返回值的数据类型       方法名称（参数列表）{   ........     }            //普通方法的定义

                 abstract  返回值的数据类型    方法名称（参数列表）；      //定义抽象方法                                                 }    

    6)  抽象类的特点:

       1.抽象方法一定在抽象类中。

       2.抽象方法、抽象类必须用abstract来修饰。

       3.抽象方法不可以用new产生对象，因为抽象方法没有方法体；是可以有构造函数的，一般私有化！

       4.抽象类中的方法要被使用，必须由子类覆盖父类所有的抽象方法后，建立子类对象调用。

          如果子类只覆盖了父类部分的抽象方法，那么子类也是抽象类。

       5.何时使用抽象类？

          当多个类中出现相同功能，但是功能主体不同，这是可以向上进行抽取，这是可以只抽取功能定义，而不抽取功能主体

          例如：普通班学习与高级班学员有共有的学习方法，但是学习的内容不一样。

   6）非访问控制符  static

             作用：用于修饰成员（成员变量，成员方法）。

              1）语法格式：

                   static   类型     变量名；

                   static  返回值类型    方法名（[参数列表]）{    ..........     } 

              2）调用方式：〈对象名〉.〈静态成员〉 或者    〈类名〉.〈静态成员〉

               特点：

                     1.随着类的加载而加载。

                     2.优先于对象存在。

                     3.被所有对象所共享。

                     4.可以直接被类名所调用。

               3）静态使用注意事项：

                     1.静态方法只能访问静态成员，非静态方既可以访问静态成员也可以访问非静态成员。

                     2.静态方法中不可以定义this,super 关键字，因为静态优先于对象存在。      

                4）静态的利与弊：

                    利处：对对象的共享数据进行单独空间存储，节省空间，没有必要为每个对象存一份，可以直接被类名所调用。

                   弊处：生命期过长，访问出现局限性（静态只能访问静态）。 

                5）使用方法：

                    1）什么时候使用静态变量（类变量）呢？

                        当对象中出现共享数据时，该数据就被定义成静态，对象中的特有数据被定义成非静态在于于堆内存中。  

                    2）什么时候使用静态函数？

                       当该方法功能内部没有访问到非静态数据（对象的特有数据），那么该方法就可以定义成静态的。

                       例如：

                                     class Person{

                                               private String name;

                                                static void show(){

                                                   system.out.println("hahaah......");                                                                                                                    }                     

                                                                     }

                       3）静态代码块：

                                1. 语法格式：

                                           static {

                                                           ............

                                                                             }    

 特点：随着类的加载而执行，只执行一次，并优先于主函数（main）；用于给类进行初始化。                      

  7）final ：最终。作为一个修饰符

             语法格式：  final 返回值类型 方法名（[参数列表]）{...........} 

            作用：

                 1.可以修饰类，方法，变量

                 2.被修饰的类，不能被继承；为了避免子类继承，覆盖（复写）该功能。

                 3.被修饰的方法，不能被覆盖（复写），

                 4.被修饰的变量是一个常量，只能赋值一次。

  7  接口

 1）接口的声明，是一种特殊的抽象类

      语法格式：

             [接口修饰符] interface〈接口名〉[extends〈父类接口列表〉]{

               .....  //接口体         

                 }

 2)接口修饰符

   接口修饰符有public和默认两种状态。

   1.public:任意类均可以使用这个接口。

   2.默认状态：同一包的类才能使用该接口，其他包的类无法访问。   

 3)接口格式的特点：

  1.接口中常见的定义：常量，抽象方法。

  2.接口的成员都有固定的修饰符。

     常量：public static final 

     抽象方法：public abstract

  3.接口与接口可以实现多继承

  4.接口不能创建对象，因为有抽象方法。

 4）接口的实现

  1.语法格式：

     [修饰符] class 类名 implements 接口列表（）{

              ..........//实现接口中所有的抽象方法

                    }

 

8  多态

   1）含义：可以理解为事物存在的多种体现形态。

         面向对象的多态性主要指两方面；

      

        1.方法重载(override):在同一个类中定义多个同名不同参数的方法

               特点:参数个数或者参数类型,顺序必须不同，与返回值没有关系。

        2.方法覆盖(overload):子类应与父类具有完全相同的方法名,返回值,参数列表

        

   2）多态的体现 ：  动物  x=new 猫（）；

         父类的引用指向了自己的子类对象。

        父类的引用也可以接收自己的子类对象。

   3）多态的前提：   

        必须是与类有关系，要么继承，要么实现。

        通常还有一个前提：覆盖。

   4）多态的好处

         多态的出现大大的提高了程序的拓展性。

   5）多态的弊端

        提高了拓展性，但是只能使用父类的引用访问父类中的成员。

   6) 多态的应用

   7）多态中成员方法的特点：

       1.编译时期：参阅引用变量所属的类是否有调用的方法，如果有，编译通过，如果没有，编译失败。

        2.运行时期：参阅对象所属的类中是否有调用的方法。

        简单总结：成员方法在多态调用时，编译看左边，运行看右边。

   8）在多态中，成员变量的特点：无论编译或运行，都参考左边

    9  封装（encapsulation）

       1 封装的基本原则：将你的成员变量标记为private,并入入提供public的getter与setter来控制存取动作。

   

   10 内部类

        含义：将一个类定义在另一个类里面，里面的类称为内部类（内置类，嵌套类）。

   1）访问的特点：

      内部类可以直接访问外部类的成员，包括私有成员。

      之所以能够访问外部类成员，因为内部类持有一个外部类的引用：外部类.this

      外部类要访问内部类的成员，必有建立内部类的对象。

   2）访问格式：

       外部类名.内部类名   对象名＝new 外部类对象.new 内部类（）对象；

   3）当内部类定义在局部时

      1.不可以被成员修饰符修饰，除了final修饰。

      2.可以直接访问外部类的成员，因为还有外部类中的引用。

      3.但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量或者在内部类中用“类名.this.局部变量名”

   4）匿名内部类

      1.匿名内部类其实就是内部类的简写形式。

      2.定义匿名内部类的前提：内部类必有是继承或者是实现一个接口。

      3.匿名内部类的格式；new 父类或者是接口（）{定义子类的内容（局部变量，局部方法）}.子类的方法

      4.其实匿名内部类就是一个匿名子类对象。

  **  思维拓展：单例设计模式：解决一个类在内存只存在一个对象。

    如何保证对象的唯一

    思路：

    1. 为了避免其他程序过多的建立该类的对象，先禁止其他程序建立该类的对象（将构造函数私有化）。

    2.为了其他程序访问到该类的对象，在本类中自定义一个类的对象（在类中建立一个本类对象）。

    3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式（提供一个方法可以获取到该对象）。

    第一方法：先初始化对象－－饿汉式(定义单例，优先使用)

         class Singleton{

               private Singleton(){};

               private  static Singleton  single=new Singleton();

               private static Singleton getSingleton(){

                                 return single;

                                   }

                       }

      第二方法：对象被调用后才初始化－－懒汉式

            class Singleton{

                 private Singleton(){}

                 private static  Singleton single=null;

                 prviate static synchronized Singleton getSingleton(){

                  if(single==null){

                            if(single==null)

                                       single=new Singleton();

                                                             }

                                       }

                               return single;

                              }

--------- android培训、java培训、期待与您交流！ ----------