JAVA笔记一：FUNDAMENTAL

FUNDAMENTAL

---

一、概述

• Linux操作系统
  
  • 开源的操作系统、免费，主要作为服务器操作系统，
    而Java主要是服务器端开发，所以部署环境都是Linux
  • Linux与Windows目录结构的区别:
  • 文件系统不同:
    Linux:目录 Windows:盘符
  • 外部设备映射不同:
    Linux:挂载点 Windows:盘符
  • 安全级别不同:
    Linux:高 Windows:低
  • Linux常用命令:
    
    • pwd:显示当前工作目录
    • ls:查看当前工作目录的内容
    • cd:改变当前工作目录
    • 相对路径:相对于当前目录的位置
      
      • .:当前目录
      • ..:上一级目录
    • 绝对路径:相对于根目录的位置
      以/开头
• .Java开发环境:
  
  • 编译运行过程:———常见面试题
    
    • 编译期:.java源文件，经过编译，生成.class字节码文件,只检查语法
    • 运行期:JVM加载.class并运行.class
      跨平台、一次编程到处使用
• 名词解释:
  
  • JVM:java虚拟机
    
    • 加载.class并运行.class
  • JRE:java运行环境
    
    • 除了包含JVM以外还包含运行java程序所必须的环境
    • JRE=JVM+java系统类库
  • JDK:java开发工具包
    
    • 除了包含JRE以外还包含开发java程序所必须的命令工具
    • JDK=JRE+编译、运行等命令工具
    • 运行java程序的最小环境JRE
    • 开发java程序的最小环境JDK
  • 配置环境变量:——————了解
    
    • JAVA_HOME:指向jdk的安装路径
    • CLASSPATH:表示类的搜索路径，一般简写为.
    • PATH:指向jdk下的bin目录

二、变量

• 定义
  
  • 就是指代在内存中开辟的 用于存储运算过程中所需数据的 存储空间
• 声明:
  
  • int b,c,d; //声明三个整型的变量，名为b,c,d
• 命名:
  
  • 只能包含字母、数字、_和$符，并且不能以数字开头
  • 严格区分大小写
  • 不能使用关键字
  • 可以中文命名，但不建议
    建议”英文的见名知意”，”驼峰命名法”
• 初始化:第一次赋值
  
  • 声明的同时初始化:
  • 先声明后初始化:
    访问
    变量的操作必须与类型匹配

• 使用:

  • 对变量的使用就是对它所存的那个数的使用
    
    • int a = 5; //声明整型变量a并赋值为5
    • int b = a+10; //取出a的值5，加10后，再赋值给b
    • System.out.println(b); //输出变量b的值15
  • 变量的使用必须与数据类型匹配
    
    • int a = 3.14; //编译错误，数据类型不匹配
  • 变量在用之前必须声明并初始化
    
    • System.out.println(m); //编译错误，m未声明

• 基本数据类型:

  • int:整型，4个字节，-21个多亿到21个多亿
    
    • 整数直接量默认为int型，但不能超出范围，超范围则编译错误
    • 两个整数相除，结果还是整数，小数位无条件舍弃
    • 整数运算时超出范围，则发生溢出，溢出是需要避免的
  • long:长整型，8个字节，很大很大很大
    
    • 长整型直接量需在数字后加L或l
    • 运算时或有可能发生溢出，建议在第1个数字后加L
    • System.currentTimeMillis()用于获取自
      1970.1.1零时到此时此刻的毫秒数
  • double:浮点型，8个字节，很大很大很大
    
    • 浮点数直接量默认为double型，表示float需在数字后加F或f
    • double型数据参与运算时，有可能会出现舍入误差
  • boolean:布尔型，1个字节
    
    • 只能取值为true和false
  • char:字符型，2个字节
    
    • 采用Unicode编码格式，一个字符对应一个码(0到65535)
      表现形式的是char字符，但实质上存储的是int码
      ASCII码(‘a’–97 ‘A’–65 ‘0’–48)
    • 字符必须放在单引号中，有且仅有一个
    • Unicode是通用的定长字符集，所有字符都是16位
  • byte：1字节（8位）
  • short：2字节（16位）
  • float：4字节（32位）
• 转义字符
  
  • ’\n’ 表示回车符
  • ‘\r’表示换行符
  • ‘\\’表示反斜杠（\）
    
    • 由于反斜杠（\）是转义符，其意义已不再是其本身作为一个字符的意义，当它出现时即代表此处是需要转义的。如果想使用其作为字符的意义，即输出反斜杠，则需要对其转义
  • ‘\”表示单引号（’）
  • ‘\”’表示双引号（“）
  • 需要转义的情况
    
    • 有些字符在Java语言中有特殊的含义，需输出该字符本身时，则需转义。如单、双引号及反斜杠
    • 有些字符本身没有特殊含义，即是普通字符，但是需要在特定情况下，代表不同的意义，则需转义。如n、r
• 字符集编码
  
  • UTF16-BE
    
    • 将16位的char数据一分为2
    • 优点：定长2个字节；缺点：英文浪费一半空间，支持的字符少
  • UTF-8
    
    • 变长编码：1~4字节
    • 1字节：英文和符号；2字节：128-2000多点，其他语言
    • 3字节：2000多~65535， 涵盖全部中文；4字节：65536~10万+
    • 优点：支持10万+文字，英文编码最短，国际化最优
    • 缺点：中文编码浪费少量空间
  • GBK（国标扩展：guo biao kuo=gbk）
    
    • 变长编码：1~2字节
    • 英文1字节，128个；中文2字节
    • 支持字符范围：中+英文 20000+
    • 缺点：范围小，只支持中（日韩）文
    • 优点：中英文混合编码最优。中国本地化最优
• 基本数据类型的转换:
  
  • 类型从小到大依次为:
    byte-short-int-long-float-double
    　　　char-
  • 两种方式:
    
    • 自动类型转换:小类型到大类型
    • 强制类型转换:大类型到小类型
      
      • 语法:(要转换成为的数据类型)变量
      • 强转有可能会发生溢出或精度的丢失
  • 两点规则:
    
    • 整数直接量可以直接赋值给byte,short,char,
      但不能超范围
    • byte,short,char型数据参与运算时，
      先一律转换为int再运算。

三、运算符与程序的逻辑结构

• 任何复杂的程序逻辑都可以通过三种结构来实现:
  
  • 顺序结构:从上往下逐行执行，每句必走
  • 分支结构:有条件的执行某语句，并非每句必走
  • 循环结构
• 运算符:
  
  • 算术运算符:+-*/%,++,–
  • 自增++，自减–
    
    • 如果写在变量前表示在使用这个变量之前加1或减1
    • 如果写在变量后表示在使用这个变量之后加1或减1
  • 关系运算符:>,<,>=,<=,==,!= boolean
  • 逻辑运算符:&&,||,! boolean
    
    • Java逻辑运算遵循“短路逻辑”原则
    • &称为不短路与，|称为不短路或
  • 赋值运算符:=,+=,-=,*=,/=,%=
  • 字符串连接运算符:+
  • 三目/条件运算符:boolean?数1:数2
    
    • 可以嵌套，即表达式1，表达式2也是三目表达式

• 分支结构:

  • if结构:1条路
  • if…else结构:2条路
  • if…else if结构:多条路
  • switch…case结构:多条路
    
    • case1，case2,…是入口，进入以后则不再判断，运行直到switch语句结束
    • 因此，由于case块中往往是不同的操作，每次只需执行某个块，需与break配合使用
    • 相比if else语句，switch结构的效率更高，结构更清晰
    • JDK7.0开始，switch case开始支持字符串表达式

• 循环:反复执行一段相同或相似的代码

  • 循环的三要素:
    
    • 循环变量的初始化
    • 循环的条件(以循环变量为基础)
    • 循环变量的改变(向着循环的结束变)
      循环变量:在整个循环过程中所反复改变的那个数
  • 循环结构:
    
    • while:先判断后执行，有可能一次都不执行
    • do…while:先执行后判断，至少执行一次
      要素1与要素3相同时，首选do…while
    • for:应用率最高，固定次数循环

  • 循环中关键字

    • break：跳出循环，常常与条件语句一起使用，只能跳出一层循环
    • continue：跳过循环体中剩余语句而进入下一次循环

  • 三种循环结构的更佳适用情况:

    • while:”当…”
    • do…while:”直到…”
      要素1与要素3相同时首选do…while
    • for:固定次数循环
  • 嵌套循环:
    
    • 循环中套循环，一般多行多列时使用，外层控制行，内存控制列
    • 执行规则:外层循环走一次，内层循环走所有次
    • 建议:嵌套的层数越少越好，能一层就不用两层，能两层就不用三层，若业务必须要通过三层以上的循环才能解决，说明设计有问题。

四、方法

• 程序=算法+数据结构
  
  • 算法:解决问题的流程/步骤(顺序、分支、循环)
  • 数据结构:将数据按照某种特定的结构来保存
    数怎么存
  • 设计良好的/合理的数据结构会导致好的算法
• 方法:
  
  • 封装一段特定的业务逻辑功能
  • 方法尽可能的独立，一个方法只干一件事
  • 方法可以被反复调用多次
  • 优点：结构清晰，便于维护，便于合作开发
• 方法的定义:
  
  • 修饰词 返回值类型 方法名(参数列表){
    方法体
    }
• 方法的调用:
  
  • 无返回值: 方法名(有参传参);
  • 有返回值: 数据类型 变量 = 方法名(有参传参);
• return的用法:
  
  • return 值; //1.1)结束方法的执行 1.2)返回结果给调用方
  • return; //2.1)结束方法的执行(只能用在无返回值的方法中)

五、数组中常用的方法

• System.arraycopy方法用于数组复制

  若想实现数组的复制，可以使用System.arraycopy( )方法，其结构如下：

     -  public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

• 如上代码的，每一个参数的意义见下列表：
  src：源数组
  srcPos：源数组中的起始位置
  dest：目标数组
  destPos : 目标数组中的起始位置
  length：要复制的数组元素的数量
  通过下面的代码，可实现数组的复制：

int[ ] a = { 10 ,20 ,30 ,40 ,50 };int[ ] a1 = new int[ 6 ] ;System.arraycopy( a , 1 , a1 , 0 , 4 );    结果：20,30,40,50

• Arrays.copyOf方法用于数组复制
  使用java.util.Arrays类的copyOf方法可实现数组的复制，其结构如下所示：

类型[ ]  newArray = Arrays.copyOf ( 类型[ ]  original , int  newLength )

　　Arrays.copyOf（）方法示例代码如下所示：

int [ ]  a = { 10,20,30,40,50 } ;int [ ]  a1 = Arrays . copyOf ( a, 6 ); 

　　上段代码执行后，a1的结果为：10 20 30 40 50 0，分析其执行过程　为：　声明 一个整型数组，数组变量名称为a，赋初始值为10 20 30 40 50，声明整型数组a1，将a数组数据复制到a1数组，设置其为6个长度，因a数组只有5个元素，所以最后一位补0。故而输出结果为10 20 30 40 50 0。总结出 Arrays.copyOf（）方法的特点如下列表所示：
生成的新数组是原始数组的副本；
newLength小于源数组，则进行截取；（自己通过代码演示效果）；
newLength大于源数组，则用0或 null进行填充；

• 数组的“扩容”
  Java语法规定，数组的长度在创建后是不可改变的，这点需要明确。而所谓的扩容实际上是指创建一个更大的新数组并将原有数组的内容复制到其中。可以通过Arrays.copyOf()方法，简便的实现数组的扩展，代码如下：

int [ ]  a = { 10,20,30,40,50 } ;a = Arrays . copyOf (  a, a.length+1 );

　　上段代码执行后，输出a数组的数据为：10,20,30,40,50,0。此时a数组的长度为6，实现了所谓的“扩容”。

• Arrays.sort方法用于数组排序
  JDK提供的Arrays.sort（）方法封装了数组的排序算法，如下述代码所示：

int[ ] arr = { 49, 81, 1, 64, 77, 50, 0, 54, 77, 18 };Arrays.sort( arr ) ;for(int i=0; i<arr.length; i++) {    System.out.println(arr[i] );}

　　分析上面的代码，输出结果为：0 1 18 49 50 54 64 77 77 81。可以看到，借助于Arrays.sort()方法实现了升序排列。