Java学习笔记_系列02

1.数组：
   声明数组：  
      数组能以下列形式声明：
         类型[] array;
         类型 array[]; 
      注：
         JAVA中推荐用：类型[] array;
         一个数组是一个对象
         声明一个数组没有创建一个对象
         声明时不用指定长度
        
   创建数组：
      创建基本数据类型数组：int[] i = new int[2];
      创建引用数据类型数组：Student[] s = new Student[100];
      数组创建后其中的元素有初始值
         类型                     黙认值
         byte                        0
         short                       0
         int                         0
         long                        0l
         float                       0.0f
         double                   0.0d
         char                        \u0000
         boolean                   false
         reference types       null
      注：
         创建时一定要指定长度
         int[] i2=new int[];              //error
        
   初始化数组：
      声明、创建、初始化分开：
         int[] i;   //定义数组
         i = new int[2];    //分配空间
         i[0] = 0;      //初始化
         i[1] = 1;
        
      声明、创建、初始化在同一时间 ：
         int[] i = {0,1};     //显示初始化  {}中有几个值,则数组长度为几
         Student[] s = {new Student(),new Student()};
        
      注：   int[] i=new int[]{1,2,3};        //后面[]中不可以写数值
         int[] i1=new int[3]{1,2,3};      //error
         
   二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组)
      int[][] i1 = new int[2][3];
      int[][] i4 = {{1,1,1},{2,2,2},{3,3,3}};
      int[][] i3 = new int[][3];      //不允许高维没分配空间而先给低维分配空间
      int[][] i2 = new int[2][];
      i2[0] = new int[2];
      i2[1] = new int[3];    
     
   数组长度：
      数组的属性length
      数组长度一旦确定,不可改变    
      int[] i = new int[5]; 则i.length= 5
     
   数组拷贝：
      系统类System提供的
      static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
         src： 源数组     
         srcPos： 从源数组哪个位置开始拷贝(位置指的是元素的下标)
         dest： 目标数组
         destPos： 拷贝的元素放到目标数组的起始位置
         length： 拷贝多少个
        
   数组排序：
      自己实现一个排序方法来进行排序
      或者调用java.util.Arrays.sort(Object o)
2.类和对象：
   类：主观抽象，是对象的模板，可以实例化对象
      习惯上类的定义格式：
         package xxx;     
         import xxx;     
         public class Xxxx{
            属性 ······;
           
            构造器 ······;
           
            方法 ······;
         }

      定义属性：实例变量
         格式：[ 修饰符 ]  类型 变量名  [ = ? ]
         实例变量定义在类中但在任何方法之外。
         实例变量有默认值：各种各样的0。(同数组)
         实例变量的作用域至少在本类内部，受访问控制符的限制。
         在重合作用域，实例变量和局部变量允许有命名冲突，“局部优先”。
        
      定义方法：
         格式： [ 修饰符 ]  返回类型 方法名( 参数列表 ) [ throws  异常 ] { ······ }
         java中所有参数都是值传递。
            当没有值返回时，返回类型必须被定义为void。
         返回类型必须与方法名相邻，其他修饰符可以调换位置。
        
      构造器：
         在创建对象的过程中调用的方法。
         构造器没有返回类型。
         构造器的名字与类名相同。
         格式为：[ 修饰符 ]  类名( 参数列表 ){  }，修饰符可以是private、 protected、 default、private
         在一个对象的生成周期中构造器只用一次，由系统自动调用，不允许手工调用。
         程序员没有提供一个构造器，系统会自动提供一个无参的构造器。
         获得对象的方式：
            通过new（在堆空间中申请分配空间），new 类名()，可以通过这种形式或的一个对象，这时的对象是无法使用，必须把他的地址存放进一个对象变量才能够使用。
            例如 ：
               Car c=new Car();
         注意：
            最好在写类时提供一个无参的构造器。
                 
      this关键字：
         this是个隐式参数，代表当前对象;
            publie class Student{
               private String name;
               public void setName(String name){
                  this.name=name;      //this.name为当前对象的成员变量
               }
            }
           
         如果某个构造方法的第一个语句具有形式this( ··· )，那么这个构造方法将调用同一类中的其他构造方法。
        
              注意：
                 在构造器中this(...)必须放在该构造器的第一行。
            this不能出现在静态方法里面     
  
   类、对象、实例三者的关系：
      类：是对象的模板，可以实例化对象
      对象：类的个体
      实例：实现的对象
      student s;  
      s=new student();
         其中 Student为类，s为对象，new Student()为实例，s赋值后也是实例了。
3.方法重载：
   方法名相同，参数表不同，不考虑返回值类型(但最好还是使返回类型一致)。
   编译器根据参数，选择一个方法，如果没有完全匹配的，对于参数表采用“向上就近匹配原则”，但不允许模棱两可。
   方法重载屏蔽了一个对象的同一类方法由于参数不同所造成的差异。
4.封装：
   类的属性加private修饰符，来限制只能够在类的内部进行访问，有效的保护数据。
   对于类中的私有属性，要对其给出一对方法getXxx()，setXxx()访问私有属性，保证对私有属性的操作的安全性。
   方法公开的是方法的声明，即只须知道参数和返回值就可以调用该方法，隐藏方法的实现的细节。
   一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。
5.继承：
   父类到子类是从一般到特殊的关系。
      泛化：将不同子类中的共性抽象成父类的过程。
      特化：在原有父类的基础上加入一些个性的过程。
      原则：父类放共性，子类放个性。
   继承的关键字：extends
   Java只支持单继承：一个类最多只有一个直接的父类。

        方法覆盖：
      方法名：相同
      参数表：相同
      访问限制符：相同或者更宽
      返回值类型：相同或者子类返回的类型是父类返回的类型的子类（在JDK5.0以后）
      抛出的异常：不能比父类更宽。
    
        super关键字：
      super()表示调用父类的构造器
      super()也和this()一样必须放在方法的第一句
      super()和this()不能同时出现        
      super可以屏蔽子类属性和父类属性重名时带来的属性遮盖，super. 表示调用父类的方法或属性
      在子类的构造器中如果没有指定调用父类的哪一个构造器，那么就会调用父类的无参构造器，即super()
     
   注意：
      父类的构造器不能被子类继承
      方法和属性可以被继承，权限不限制能否继承过来，限制的是能否直接访问
      先构造父类，后构造子类，先this后super
6.多态：
   多态分为两种：编译时多态和运行时多态。
      编译时类型：主观概念，把它看作什么。
      运行时类型：客观概念，实际它是什么。
        例：Animal a=new Dog();
               指着狗问，这个动物是什么？
              
        运行时多态的三原则：
      对象类型不变。
      只能对对象调用编译时类型中定义的方法。
      在程序的运行时，根据对象的运行时类型，找覆盖后的方法来调用。（运行时动态类型绑定）
     
        强制类型转换： 一定没有新对象生成。(父类的引用赋值给子类的引用需要进行强制类型转换)
        关键字：instanceof
             用法：引用  instanceof  类名    判断这个引用所指向的对象是否属于这个类。
        用在强制转换之前，避免类型转换异常。
         if(a instanceof Dog){
            Dog d=(Dog)a;
         }
        
   多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。
7.修饰符static： 把对象相关的变成类相关的，它可以修饰属性、方法、代码块和内部类
   static修饰属性（类变量）：
      那么这个属性就可以用" 类名.属性名 "来访问，也就是使这个属性成为本类的类变量，为本类对象所共享。
      类加载的过程，类本身也是保存在文件中（字节码文件保存着类的信息）的，java会通过I/O流把类的文件读入JVM（java虚拟机），这个过程称为类的加载。JVM会通过类路径（CLASSPATH）来找字节码文件。需要的时候才会进行类加载，生成对象时是先加载后构造
      类变量，会在加载时自动初始化，初始化规则和实例变量相同。
      注意：
         类中的实例变量是在创建对象时被初始化的
         static修饰的属性，是在类加载时被创建并进行初始化，类加载的过程只进行一次，也就是类变量只会被创建一次。
        
   static修饰方法（静态方法）：
      会使这个方法成为整个类所公有的方法，可以用" 类名.方法名 "访问。
      static修饰的方法，不能直接访问本类中的非静态成员，但本类的非静态方法可以访问本类的静态成员。
      在静态方法中不能出现this关键字。
      父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可以被子类中的静态方法覆盖，但是没有多态。（在使用对象调用静态方法时其实是调用编译时类型的静态方法）
      java中的main方法必须写成static的原因：在类加载时无法创建对象，而静态方法可以不通过对象调用，所以在类加载时就可以通过main方法入口来运行程序。
     
   static修饰初始代码块：
      这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。
      可以用静态初始代码块初始化一个类。
      动态初始代码块，写在类体中的“{}”，这个代码块是在生成对象时运行，这种代码块叫动态初始代码块。
8.单例设计模式：
   一个类只允许有一个对象，保证所有引用的对象都是同一个对象。
   因为只允许存在一个对象，则不允许在外面直接new出新的对象，所以应该把构造器设为private，。
   在类内定义一个公开的静态方法，让使用者进行调用，通过该方法去获得一个实例。
   例：
      public calss Singleton{
         private static Singleton s;
         private Singleton(){}
         public static Singleton newInstance(){
            if ( s == null)
               s = new Singleton();
            return s;
         }
      }
9.修饰符final：不允许改变，可以修饰变量、方法、类
   final修饰变量：
      被fianl修饰的变量就会变成常量，一旦赋值不能改变
      常量可以在初始化时直接赋值，也可以在构造方法里赋值，只能在这两种方法里二选一，不能不为常量赋值
      常量不会有默认初始值
      锁定栈，使栈中的数据不可以改变
      静态常量只能在初始化时直接赋值
     
   final修饰方法：
      被final修饰的方法将不能被其子类覆盖，保持方法的稳定不能被覆盖
  
   final修饰类：
      被final修饰的类将不能被继承
      final类中的方法也都是final的
  
   注意：
      final不能用来修饰构造方法
10.访问权限控制：  
   private：
      本类内部可以访问
      不能继承到子类
   default：
      本类内部可以访问，同包其他类也可以访问。
      同包可继承
   protected：
      本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问。
      能继承到子类
   public：
      任何地方都可以访问 
      能继承到子类
11.修饰符abstract：抽象的，定义框架不去实现，可以修饰类和方法
   abstract修饰类：
      会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型
      抽象类就相当于一个类的半成品，需要子类继承并覆盖其中的抽象方法，这时子类才又创建实例的能力，如果子类没有实现父类的抽象方法，那么子类也要为抽象类。
  
   abstract修饰方法：
      会使这个方法变成抽象方法，也就是只有声明而没有实现，实现部分以";"代替，需要子类继承实现。
      抽象方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承的抽象方法的实现）。
      方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。
  
   注意：
      有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
12.接口(interface)：
   接口的定义：接口从本质上说是一种特殊的抽象类。
      关键字interface。
      在接口中，所有的方法为公开、抽象的方法：public abstract
      在接口中，所有的属性都是公开、静态的常量：public static final
      接口与接口之间可以多继承，用extends，多个之间用逗号隔开。
      接口中没有构造方法，不能用“new 接口名”来实例化一个接口，但可以声明一个接口。
  
   接口的实现：
      关键字implements
      一个类实现一个接口必须实现接口中所有的方法，否则其为抽象类，并且在实现类中的方法要加上public(不能省略)。
         类中的默认修饰符：default。
         接口中的默认修饰符：public。
      一个类除了继承另一个类外（只能继承一个类），还可以实现多个接口(接口之间用逗号分隔)。

   接口的作用：
      间接实现多继承：用接口来实现多继承并不会增加类关系的复杂度。因为接口不是类，与类不在一个层次上，是在类的基础上进行再次抽象。
      接口可以抽象出次要类型，分出主、次关系类型，符合看世界的一般方法。
      接口隔离，与封装性有关。一个对象都有多个方面，可以只展示其中几个方面，其他的都隐藏。因此可以看为“更高层次的封装”，把          一个大接口做成若干个小接口。
      通过接口制定标准（最重要的作用）
         接口：制定标准。
         接口的调用者：使用标准。
         接口的实现类：实现标准。
             解耦合作用：把使用标准和实现标准分开，使得标准的制定者和实现者解除偶合关系，具有极强的可移植性
            例：sun公司提供一套访问数据库的接口（标准），java程序员访问数据库时针对数据库接口编程。接口由各个数据库厂商负责实现。
          
   接口编程的原则
      尽量针对接口编程（能用接口就尽量用接口）
      接口隔离原则（用若干个小接口取代一个大接口）
     
   注意：
      接口中没有构造器，也没有main方法
13.封装类：
   Java为每一个简单数据类型提供了一个封装类。
   除int和char，其余类型首字母大写即成封装类。
      int                Integer
      char             Character
   最常用的两个封装类Integer和Double
   jdk1.4之前基本类型和封装类的转化是需要构造器去转化的，到了jdk1.5是自动进行转化的
   int、Integer和String之间的转化(最常用的)
      int i=1;
      Integer in = new Integer(i);            //int --> Integer
      int  i = in.intValue();               //Integer --> int
      String  str = String.valueOf(i);         //Int --> String
      int  ii = Integer.parseInt(str);         //String --> int
      String  s = in.toString();               //Integer --> String
      Integer inte = Integer.valueOf(str);      //String -->Integer 
14.Object类
   hashCode()：
      返回该对象的哈希码值
      hashCode 的常规协定是：
         在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。
         如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。
        
   toString()：
      返回该对象的字符串表示。
      通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂。建议所有子类都重写此方法。
     
   equals()
      指示某个其他对象是否与此对象“相等”。
      equals 方法在非空对象引用上实现相等关系：
         自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。
         对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。
         传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。
         一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y)始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。对于任何非空引用值 x，x.equals(null) 都应返回 false。
         注意：
            当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。
15.String、StringBuffer和StringBulder  
   String： 不可改变的Unicode字符序列
      池化思想，把需要共享的数据放在池中，用一个存储区域来存放一些公用资源以减少存储空间的开销。
      在String类中，以字面值创建时，会到Java方法空间的串池中去查找，如果没有则会在串池里创建一个字符串对象，并返回其地址赋给对象变量，如果有就返回串池中字符串的地址，并把这个地址赋给对象变量。
      如果是new，则会在堆空间中创建String类的对象，不会有上述的过程
      如：
         String s1 = "abc";            //新创建，字符串常量池中没有该串，则会在池中创建一个串"abc"
         String s2 = "abc";            //串池中已经存在"abc"，则s2会去指向"abc"而不会去创建一个新的
         String s3 = new String("abc");           //直接在堆中去开辟一个新的空间，而不会去池中查找
      类中的具体方法查看下Api文档。
      调用任何String中的方法，不会改变String自身，除非重新赋值。
        
   StringBuffer： 可改变的Unicode字符序列
      允许并发操作，是线程安全的
      String类在进行字符串连接时会显得效率很低，就是因为它所产生的对象的属性是不能够修改的，当连接字符串时也就只能创建新的对象。
      对于很多字符串连接时，应当使用StringBuffer类，使用这个类的对象来进行字符串连接时就不会有多余的中间对象生成，从而优化了效率。
      例：对于字符串连接String str = "A" + "B" + "C" + "D";
         产生："AB"、"ABC"、"ABCD"
         在串池中产生的"AB"、"ABC"明显是多余对象，浪费空间。
                       解决方案：
            String s = null;
            StringBuffer sb = new StringBuffer("A");
            sb.append("B");
            sb.append("C");
            sb.append("D");
            s = sb.toString();
              
   StringBulder： 可改变的Unicode字符序列
      操作同StringBuffer，只是不支持并发操作，非线程安全的