05. core java note.txt

在达内培训java笔记

    if(...){...}else{...}
    if(...){...}else if(...){...}
    if(...){... if(...){...}}
    
    三重以上的选择，建议使用 switch
    switch(char c){
        case c1: ...; break;
        case c2: ...; break;
        ...
        default :...;
    } /*switch的括号里只能用 int 和 枚举类型
        能隐式转换为 int 的也可以：byte,short,char,Integer,Short,Character,Byte等。
        不能用 long、小数类型(float,double) 和 String。
        case后的值必须是常量。而包装类变量(Integer,Character)不会被视作常量。*/


循环：
   for(初始表达式;  布尔表达式 ;  步进 ) 循环语句;
     跟C的 for 一样，for 的初始化条件、结束条件、增量都可以不写。
    但条件判断部分只能是boolean值，所以只能是一条条件判断语句。
     for 循环一般用在循环次数已知的情况。
   while (<boolean expr>)...;
   do...; while (<condition>);   注意：do 后最好用“{}”，while 后的分号不可忘。

break 和 continue
   break 退出当前的循环体，在嵌套循环中，只退出当前的一层循环。
   continue 结束当前本次循环，继续进行下一轮的循环。可以说，只是本次忽略循环内后面的语句。
   continue 只能在循环体内用。break 可以用在任意代码块中，表示退出当前程序块(配合标签使用，很好用)
这两个相当于JAVA里的 goto 语句。

注意：(个人归结的)
    循环体内申明的变量，在循环体结束后立即释放，循环体外无法使用。
    但在另外一个循环体内可以再次申明一个跟前面同名的变量，互相不影响。
        如for内定义的 i：  for(int i=0;i<10;i++){...}
        则在上式 for 循环结束后无法再调用 i 值，还会报错。
      for(int i=0;i<10;i++){...} 和后面的 for(int i=0;i<3;i++){...} 互不影响
    若想循环体外还可以调用 for 循环体内的值，应先在体外定义。
        如：  int i;   for (i=0; i<10; i++){...}   则for 循环后再调用 i 值，其值为10 


关键字列表：
   abstract  boolean   break   byte     case    catch       char    class
   continue  default   do      double   else    extends     enum    false
   final     finally   float   for      if      implements  import  instanceof
   int       interface long    native   new     null        package private
   protected public    return  short    static  super       switch  synchronized
   this      throw     throws  transient true   try         void    volatile  while 
Java 中 true、false不是关键字,而是boolean类型的字面量。但也不能当作变量用。
所有的关键字都是小写，friendly，sizeof不是java的关键字 
保留字：const，goto ：这两个已经削去意义，但同样不能用作变量名。


 第三章   对象
名词
    对象：
    类：  一类属性相同的对象
    属性：是什么样
    方法：能做什么(C 中叫作函数)

对象:
    声明：Student s ;
        这时我们只是说明s是一个能够指向Student类型的引用(相当于C++中的指针),并没有创建一个对象。
        所以我们此时不能对s做任何操作。
    初始化：s = new Student();
        向系统申请一块存储空间(地址空间)，该地址空间保存的是一个Student类型的数据。
        而s中保存的就是该地址空间的首地址。
    变量：内存空间中一块具有固定长度的，用来保存数据的地址空间。(s也是一个变量)
    一个对象可以有多个引用指向。
      Student[] s = new Student[3]  只是相当于声明一个长度为 3 的Student类型的数组。 
        
实例变量和局部变量
实例变量：
    1、在一个类中，任何方法之外定义的变量；
    2、从面向对象的思想来说我们又把实例变量看成一个类的属性。
    3、实例变量在没有符初值时系统会自动帮我们做初始化：
          整型数据初始化为 0，布尔型数据初始化为 false，对象类型初始化为 null。
    实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。
局部变量：
    1、在方法内定义的变量叫局部变量。
    2、局部变量使用前必须初始化，系统不会自动给局部变量做初始化。
    3、局部变量的生命范围在他所在的代码块，在重合的作用域范围内不允许两个局部变量命名冲突。
注：局部变量与实例变量允许同名，在局部变量的作用域内，其优先级高于实例变量。
     我们可以用  this.实例变量名  以区分局部变量。


    第四章  数组
数组：
    数组也是对象
    数组中保存着多个相同类型的元素
    数组中的每一个元素都是变量
        可以创建数组对象，但数组里只能放对象的引用，不能直接放对象进去

数组的创建：
    1. 声明一个int数组变量，数组变量是数组对象的遥控器
       int[] nums;
    2. 创建大小为7的数组，并将它赋值给变量nums
       nums = new int[7];
    3. 赋于int数组每一个元素一个int值
       nums[0] = 6;  nums[1] = 34;  nums[2] = 23;  nums[3] = 4;  
多维数组：
    1.  定义方式：type 维数　arrayName；
        如：  int[][]  b = new int [2] [1];
    2.  分配内存空间,有两种方法：
        直接为每一维分配空间:   int[][] a = new int[2][3]；
        分别为每一维分配空间    int[][] a = new int[2][ ]； //列数可以没有，行数则一定要有
            a[0] = new int[3];   a[1] = new int[5];    //a[][]  看成一维数组
         可以为每行设置为空间大小不同的数组。
    3. 初始化,有两种方式：
        先定义数组，分配空间，然后直接对每个元素进行赋值(一个个写，或用for函数)
        在定义数组的同时进行初始化。
              如：int a[][] = {{2,3}, {1,5}, {3,4}};
    java实质上把多维数组看作一维数组，但数组里的元素也是一个数组，即数组的数组
    多维数组的长度 ＝ 行数；  (a.length=行数； a[0].length=列数)

创建数组对象的另外几种方式：
   Int[] nums = {6,34,23,4,15,0, 57}; (java 形式) 
          这方法只能在初始化定义的时候可以，以后再想定义nums={...}就不行了
   Int[] nums = new int[] {6,34,23,4,15,0, 57};  
           这句的后一个 int[] 内不能填数字，怕人弄错数目；
           这句可以先 int[] nums;以后再另外定义 nums = new int[]{...} 
    []可以换换位置，如：
      Int nums[]; (C 和 C++ 形式) 
   注意： short  [] z [] []; //这是合法的，定义一个三维数组
         声明数组时，不能定义其大小；只有 new 数组时可以定大小。

数组元素的默认值:
   byte  short   int   long  为 0
   float  double 为 0.0
   char  为 ‘\0’
   boolean  为 false
    引用类型为null

数组的 length 属性:
    表示数组的长度，是指这个数组最多能保存的元素个数
     length属性只能被读取，不能被修改
     java.lang.ArrayIndexOutOfBoundsException:  (这是数组下标越界的报错)

随机数：
   Math.random(); //可以产生随机的0~1 的小数,不需导包
   java.util.Random;  //可以产生更加多种的随机数
0~100的一个随机整数(包括0，但不包括100)：
   Double d = 100*Math.random(); int r = d.intValue();  //方法一
   Random r = new Random();   int num = r.nextInt(100); //方法二；需要 import java.util.Random;
   可以直接在程序中写这句，而临时导入  int i = new java.util.Random().nextInt(100);

Arrays.sort(数组名)
    排序算法。需导入 impor java.util.Arrays;

数组的拷贝:
    1. 用 for 语句，将数组的元素逐个赋值。直接如果直接将数组 a = 数组b;则是将b的指针赋给a
    2. 用System.arraycopy();
     arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
       src - 源数组。 
       srcPos - 源数组中的起始位置。 
       dest - 目标数组。 
       destPos - 目标数据中的起始位置。 
       length - 要复制的数组元素的数量。
    如：System.arraycopy(a, 0, b, 0, a.length);  //把数组 a 全部复制到数组 b 中


在java中对面向对象(OO)的要求
    1．对象是客观存在的，万物皆对象。
        (注：看不见的对象并不表示该对象不存在，比如说事件)；
    2．简单性：采用面向对象方法可以使系统各部分各司其职各尽所能。
    3．复用性：对象的功能越简单其可重用性越高。
    4．弱耦合性：各司其职各尽所能。
    5．高内聚性：一个对象独立完成一个功能的能力
    6．类是一类事务的共性，是人类主观认识的一种抽象，是对象的模板。

面向过程与面向对象的对比
    面向过程：先有算法，后有数据结构。先考虑怎么做。
    面向对象：先有数据结构，后有算法。先考虑用什么做。



 第六章  构造方法
方法的声明(分为五个部分)
    1．方法的修饰符(可以有多个，且顺序无关)
    2．方法的返回值类型
    3．方法名
    4．方法的参数列表
       如果方法有参数,一定要以正确的数量、类型、和顺序传递参数;可以将变量当作参数传入,但要类型相符
    5．方法允许抛出的例外(异常)
注：编译器只能做语法上的检查，而不能进行逻辑上的检查。
     Java中不允许有废话，永远不会执行的语句不允许写。
    1. 声明格式:
       <modifiers><return_type><name>([argument_list>])[throws <exception>]{<block>}
       例如：public String getName(){return name;} 
    2. 当没有返回值时，返回类型必须被定义为 void。
    3. 构造方法没有返回类型。
    4. 返回类型必须与方法名相邻，其他修饰符号可以调换位置。


参数传递 
    在java方法传参过程中简单类型是按值传递，对象类型是按引用传递。
    按值传递传递的是数据的副本。
        按引用传递 传递的是保存该数据的地址
      Java语言总是使用传值调用,这意味着方法得到的只是所有参数值的拷贝。
        因此，方法不能修改传递给它的任何参数变量的内容。
    对象类型的参数传递的也是该对象的引用值
    方法中并不能改变对象变量，但能通过该变量调用对象的方法或修改对象的成员。

    方法的参数基本上与局部变量相同，但你不需要直接初始化它
    编译器会确保方法调用时会有与声明相符的参数传进来，且参数会自动被赋值

形参 VS 实参：
    形参(形式参数)：相当于函数(Java中也把函数称之为方法)中的局部变量
         在函数被调用时创建，并以传入的实参作为起始值，函数调用结束时被释放
         不会影响主程序中其他的变量(即使有变量跟他们同名),因为他们是不同作用域的变量，互不干扰。
    实参：调用函数时，实际传给函数形式参数的数据。


重载(Overload) 
    在同一个类中，允许同时存在一个以上的同名函数，只要他们的参数列表不同即可。
    参数列表不同，可以是参数的类型或个数不同，也可以是不同类型参数的顺序不同。
    1、相同方法名，不同参数表。
    2、方法重载时，对于参数的匹配有个向上就近原则。(这样可以节省栈空间资源)；
    3、为什么面向对象中要有方法重载？
       方法的重载使同一类方法由于参数造成的差异对于对象的使用者是透明的。
       对象的使用者只负责把参数交给对象，而具体怎么实现由对象内部决定。