Java学习笔记之数据类型和流程控制

2.数据类型和流程控制

java 源文件

======================================

  1. 公共类名与文件名一致

        《HelloWorld.java》

        -------------------------------

          public class HelloWorld {

          }

  2. package 包

        本质是目录，

        分门别类存放不同的类

  3. import 导包

        指明一个类的路径，

        在代码中可以简写类名

数据类型

======================================

  * 基本类型

  * 引用类型

基本类型

======================================

  byte      1字节，-128到127，-2^7到2^7-1

  short     2字节，-2^15到2^15-1

  int       4字节，-2^31到2^31-1

  long      8字节，-2^63到2^63-1

  float     4字节，单精度

  double    8字节，双精度

            美国工业电气协会浮点数表示规范

  char      2字节，0到65535

            表示字符，或字符的整数编码

            char c = 'a';

            char c = 97;

            char c = '中';

            char c = 20013;

  boolean   1字节

            true   false

             真     假

基本类型的字面值

=====================================

  1.整数字面值，是 int 类型

      int a = 45345;

      long b = 9999999999;//错，右侧字面值是 int，但超出范围

  2.byte,short,char，三种范围比 int 小的整数

    允许用范围内的值直接赋值

      byte a = 127;//右侧是 byte 类型

      byte a = 128;//错，右侧是 int 类型

  3.浮点数字面值是 double 类型

      double a = 3.14;

      float a = 3.14;//错，右侧是double

  4.字面值后缀

      L   - long

            long b = 9999999999L;

      F   - float

            float a = 3.14F;

      D   - double

            double a = 3d;

  5. 字面值前缀

      0x    - 16进制前缀

              0xff      255

      0     - 8进制前缀

              0377      255

      \u    - char类型16进制前缀

              '\u0061'    a

              '\u4e2d'    中

基本类型运算规则

==========================================

  1.计算结果的数据类型，

    与运算项中范围最大的类型一致

        3 / 2     得 1

        3d / 2    得 1.5

  2.byte,short,char 三种比 int 范围小的整数,

    运算时，会先自动转为 int

        byte a = 2;

        byte b = 3;

        byte c = a + b;//错，int+int，结果是int

  3.整数运算溢出

        int a = Integer.MAX_VALUE;

        a = a + 1;//得负数最小值

          01111111111111111111111111111111  +   1

          -----------------------------------------

          10000000000000000000000000000000

        300000000L * 60 * 60 * 24 * 365

  4.浮点数运算不精确

        2-1.9       得：0.100000000000009

        4.35*100    得：434.99999999999994

  5.浮点数的特殊值

        Infinity    无穷大

        ------------------------------

            3.14 / 0

            Double.MAX_VALUE * 2

        NaN         Not a Number

        ------------------------------

            负数开平方：Math.sqrt(-2)

类型转换

==========================================

  * 范围小的类型 --> 范围大的类型

    自动转换

        byte a = 127;

        int b = a;

            01111111

            00000000 00000000 00000000 01111111

        byte a = -1;

        int b = a;

            11111111

            11111111 11111111 11111111 11111111

  * 范围大的类型 --> 范围小的类型

    强制转型

        int a = 257;

        byte b = (byte) a;

          00000000 00000000 00000001 00000001

          00000001

运算符

=========================================

  +-*/

      + 数学运算、字符串连接运算

  %   取余

     0 % 3  0

     1 % 3  1

     2 % 3  2

     3 % 3  0

     4 % 3  1

     5 % 3  2

     6 % 3  0

     7 % 3  1

     8 % 3  2

     9 % 3  0

     x 能否被 4 整除: x % 4 == 0

  > >= < <= == !=

    &&    逻辑与，两侧同时是真，结果是真；

          任意一侧是假，结果是假。

          短路与，左侧是假，右侧被忽略。

    ||    逻辑或，两侧同时是假，结果是假；

          任意一侧是真，结果是真。

          短路或，左侧是真，右侧被忽略。

    !     非，真变假，假变真。

          做相反的条件判断，

          判断“非b”是真，

          即，判断 b 是假。

          if(!b) {

          }

    &   位与，两位同时是1结果是1

    |   位或，两位同时是0结果是0

    ^   异或，相同是0不同是1

        对同一个值异或两次得到原值

    ~   求反，0变1,1变0

    >>  带符号右移位

        符号位是0左侧补0

        符号位是1左侧补1

    >>> 不带符号右移位

        不管符号位是1还是0，

        左侧都补0

    <<  左移位，右侧补0

        *) 右移一位，相当于除2

        *) 左移一位，相当于乘2

  ++

  --

      自增、自减

      int a = 10;

      //a变成11，打印a的原值10

      System.out.println(a++);

      int a = 10;

      //a变成11，打印a的新值11

      System.out.println(++a);

      int a = 10;

      //a变成11，给b赋a的原值10

      int b = a++;

      int a = 10;

      //a先变成11，再将原值10重新赋给a

      a = a++;

  ? : 三项运算

      1 ? 2 : 3

      1是true，执行2；

      1是false，执行3。

  = 赋值运算

  +=

      int a = 10;

      a += 3;// a = a + 3;

  /=

  >>=

  ^=

  &=

      与赋值运算符联用，会自动转型

      byte a = 2;

      a = (byte) (a + 3);

      a += 3;

      a += 3.14;

流程控制语句

============================================

  if-else if-else

      if(条件) {

      } else if(条件) {

      } else if(条件) {

      } else {

      }

  switch-case-default

      *)只能判断byte,short,char,int,       enum

      *)当满足一个case，从这个case

        向后无条件执行每个case，直到结束

        或者遇到 break 中断(跳出switch)

        switch(变量或表达式) {

          case 5:

          case 10:

              ...

              break;//中断

          case 1:

          case 100:

          default:

        }

  for

      for(定义变量; 条件; 变量修改) {

      }

      //1到10打印

      for(int i=1; i<=10; i++) {

        System.out.println(i);

      }

  while

      先判断再执行

      while(条件) {

      }

  do-while

      先执行再判断，

      至少执行一次

      do {

      } while(条件);

  循环嵌套

  ------------------------------------

    for(int i=1; i<=3; i++) {

        for(int j=1; j<=2; j++) {

            i, j

        }

    }

    i  j

    ------

    1, 1

    1, 2

    2, 1

    2, 2

    3, 1

    3, 2

  break

  -------------------------

    中断(跳出循环)

  continue

  -------------------------

    继续下一轮循环

数组

======================================

  * 用来存放一组数据的数据结构

  * 创建数组

  ------------------------------

    1. int[] a = new int[5];

          新建5个长度的数组，

          5个位置都有默认值

            默认值：

              数字：    0 0.0

              boolean： false

              引用：    null

    2. int[] a = {2,6,2,3,76,3};

    3. a = new int[]{56,34,7,324};

  * 数组访问

  ----------------------------------

    a[0] = 34434;

    print(a[3])

    int i = a[2]

    a[2]++

  * 数组长度属性

  ----------------------------------

    a.length

    *) 数组一旦创建，长度不可变

    *) 数组最大下标是 a.length-1

    *) 数组长度可以是0

  * 数组遍历

  ----------------------------------

    从头到尾依次访问每个位置

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

      a[i]

    }

  * java.util.Arrays 数组工具类

  --------------------------------------

    Arrays.toString(数组)

      数组中的值连接成字符串，

      格式："[值1, 值2, 值3]"

    Arrays.copyOf(数组, 长度)

      将原数组，复制成指定长度的新数组，

      长度更长，后面多出几个位置；

      长度更短，截断

    Arrays.sort(数组)

      优化的快速排序算法

    Arrays.binarySearch(有序数组，目标值)

      在有序数组中查找目标值的位置，

      如果找不到，返回一个负数无意义值

    Arrays.fill(数组, 值)

      在数组中填满指定的值

  * 数组复制

  -------------------------------------

    *) Arrays.copyOf(数组， 长度)

         直接新建数组

    *) System.arraycopy(

                原数组,

                原数组起始位置,

                目标数组,

                目标数组起始位置,

                复制的数据数量)

          不会新建数组，

          如果需要新数组，要自己事先创建

  * 二维数组

      *) 存放数组的数组

      *) 创建二维数组

      ---------------------------------

        1. int[][] a = new int[3][2];

            *)创建外围数组长度是3

            *)在三个位置各创建一个数组长度是2

            *)共创建了4个数组

        2. int[][] a = new int[3][];

            *)创建外围数组长度是3

            *)三个位置都是 null 值（空）

            *)可以之后再创建数组，放入二维数组

              a[0] = new int[5];

              a[1] = new int[3];

              a[2] = new int[4];

        3. int[][] a = {

              {2,5,3},

              {1,7,4,9,5},

              {3,2,7,8}

           };

     *) 二维数组遍历

     -------------------------------------

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

            for(int j=0;j<a[i].length;j++) {

                a[i][j]

            }

        }

提问

------------------------------------

请简述你对数组的理解

【数组的基本概念】

1. 数组是一组相同类型的数据的集合

2. 每个数组都有长度，这个长度是在初始化数组的时候就已经确定的

3. 数组的长度是不可以被改变

4. 数组的每个元素都有“下标”(index)，可以用于引用数组的元素，下标是从0开始顺序编号的

【数组的初始化】

1. 静态的初始化：在创建数组时就确定数组的各个元素的值：

  int[] arr = { 9, 5, 2, 7 };

2. 动态的初始化：创建数组时，需要确定数组的长度，但是可以不确定数组的各元素的值

  int[] arr = new int[8];

  int[] arr; arr = new int[8];

  int[] arr; arr = new int[] { 9, 5, 2, 7 };

变量

============================================

  * 局部变量

      定义在方法中，或局部代码块中

      *) 必须手动初始化

            初始化：第一次赋值，在内存中分配内存空间

            int a;

            a = 12;

            print(a);

      *) 局部变量的作用域，

         在它定义的代码块中有效

      *) 作用域内，不能重复定义

            void a() {

                int i=10;

                if(...) {

                    i++;

                    int j = 100;

                }

                int j = 1000;

            }

  * 成员变量

      定义在类中，方法之外

方法

============================================

  * 命名的代码块

  * 返回类型

        *) void 表示“空”，没有返回值

        *) 有返回值要定义返回值类型

  * 参数

        *) 空参，不接收参数

              void f() {

              }

              f()

        *) 有参数，要定义每个参数的类型，

           调用时，要按顺序传递参数数据

              void f(int a, double b, String c) {

              }

              f(56, 3.14, "abc")

  * return

        *) 有返回值的方法，向调用位置返回数据

              return xxxx;

        *) void 方法中，返回到调用位置继续执行，

           当前方法，到 return 位置结束

              return;

  * 递归

        *) 在方法中调用自身

        *) 一步一步地简化问题，

           简化成最简问题，

           再倒推求出结果

        *) 一般不同时做多次递归调用，

           否则运算量会急剧增加

提问：请简述内存的作用

-------------------------------------

【什么是内存】

内存即内部存储器，与外部存储器是不同的硬件，内部存储器通常有：RAM、ROM、Cache。

RAM：Random Access Memory：PC机的内存条

ROM：Read Only Memory：固件

Cache：高速缓存，内置在CPU里

在描述手机的存储设备时，“运行内存”即RAM，相当于PC机的“内存条”，而“存储内存”相当于PC机的“硬盘”。

【内存的特性】

可读可写，断电以后数据消失。

【内存的作用】

内存(RAM)用于存储正在执行的程序与数据。

内存是CPU可以直接交换数据的唯一硬件。

内存是CPU与其它所有外部设备交换数据的桥梁。

问题：请详细描述JAVA程序运行过程中堆与栈的特性。

栈：基本数据类型的数据，对象的引用，参数的副本

堆：对象的数据

所有的赋值操作，都在栈内存中进行，赋值操作与堆内存无关。

所有的对比(==)操作，都是在栈内存中进行的。