Java入门学习时的笔记

面向对象之前

1、windows常用的dos命令：

• exit 退出DOS命令窗口
• cls 清屏
• 标记复制法
• dir 列出当前目录下所有的子文件/子目录
• cd 命令
  • cd 命令表示：change directory【改变目录】
  • 用法：cd 目录路径
  • 路径包括相对路径和绝对路径
    • 绝对路径：从某个盘符下作为出发点的路径
    • 相对路径：从当前路径下作为出发点的路径
  • cd … 回到上级目录
  • cd \ 直接回到根路径
    如何切换盘符：
    d: 回车
    e: 回车
    .
    .
    .

2、什么是JDK？

• java开发工具包（需要去oracle下载。http://www.oracle.com）
• java包括三大块：
  • JavaSE（Java标准版）
  • JavaaEE（Java企业版）
  • JavaME（Java微型版）
    JavaSE是基础，以后主攻方向是JavaEE

3、什么是JVM?

• java虚拟机

4、java的加载与执行

• 编译阶段
  • 该阶段主要任务是检查java源程序是否符合java语法，符合则能生成字节码文件（xxx.class），否则反之
  • 字节码文件非二进制文件，无法在操作系统中直接执行
  • java程序员需要使用jdk当中自带的javac.exe命令进行java程序的编译（javac是一个java编译器工具）。javac如何用？在哪儿用？
    • javac的使用规则：
      javac java源文件路径
    • 在DOS命令窗口中使用
  • 一个java源程序可以编译生成多个.class文件
  • .class文件生成之后，java源文件即使删除也并不会影响java程序的执行。
  • 编译结束后可将.class文件拷贝到其他操作系统中运行
• 运行阶段
  • JDK安装之后除了自带一个javac.exe之外，还有另一个工具java.exe，其主要负责运行阶段
  • java.exe在哪里用？怎么用？
    • 在DOS命令窗口中只用
    • java.exe使用规则：
      java 类名
      例如：
      硬盘上有一个A.class,就这样用：java A
    • 运行阶段的过程：
      • 打开DOS命令窗口
  • 输入：java A
  • java.exe命令会启动java虚拟机（JVM），JVM会启动类加载器ClassLoader
  • ClassLoader会去硬盘上搜索A.class文件，找到该文件则将该字节码文件装载到JVM当中
  • JVM将A.class字节码文件解释成二进制10010101001010这样的数据
  • 然后操作系统执行二进制和底层硬件平台交互

5、java注释

• 单行注释
  //xxx
• 多行注释
  /*
  xxx
  xxx
  xxx
  .
  .
  .
  */
• javadoc注释
  /**
  *xxx
  *xxx
  *xxx
  *xxx
  *xxx
  */
• 类体中不允许直接编写java语句【声明变量除外】

6、class与public class的区别：

• 一个Java源文件中可以定义多个class
• 一个Java源文件中不一定有public的class
• 一个class会生成一个.class字节码文件
• 当一个Java源文件有public的类时，只能有一个该类，并且该类的名字必须与Java源文件名字一致
• 每一个class中都可以编写main方法，都可以设置程序的入口
• 任何一个class中必须要有main方法，不然会出运行错误

7、标识符

• 什么是标识符？
  • 在Java源程序中，凡是程序员有权利自己命名的单词都是标识符
  • 标识符在EditPlus中以黑色字体高亮显示（比如类名、方法名、变量名、接口名、常量名。。。）
• 标识符的命名规则：
  • 一个合法的标识符只能以数字、字母、下划线_、美元符号$组成，不能含有其他符号
  • 不能以数字开头
  • 严格区分大小写
  • 关键字不能做标识符
  • 理论上无长度限制，但最好不要太长
• 标识符的命名规范：
  • 最好见名知义
    例如：
    public class UserService{
    public void login(String username,String password){
    }
    }
    而不是
    public class A{
    public void login(String b,String c){
    }
    }
  • 遵守驼峰命名方式
    SystemService
    UserService
    CustomerService
    以上是驼峰式命名
    以下就不是驼峰式命名
    Systemservice
    userservice
  • 类名、接口名首字母大写，后面每个单词首字母大写
  • 变量名、方法名首字母小写，后面每个单词首字母大写
  • 常量名 ：全部大写
  • 合法与不合法的标识符：
    合法 不合法

******************************
_123Test          123Test
HelloWorld        HelloWorld！
$_B_C             Hello World
class1            class
public0           public

8、关键字（没啥好说的，编程练习记忆）
9、字面值

• 0、10、100 整数数据类型的字面值
• 3.14、1.876 浮点数据类型的字面值
• “abc”、“人” 字符串数据类型的字面值
• true、false 布尔数据类型的字面值
• ‘A’ 字符数据类型的字面值

• 注意：
  Java语言中所有的字符串型字面值必须使用双引号括起来，双引号是半角（英文双引号）
  Java语言中所有的字符型字面值必须使用单引号括起来，单引号是半角（英文单引号）

10、变量

• 什么是变量？
  • 变量是内存中的一块空间，这块空间有“数据类型”、“名字”、“字面值”
  • 变量是内存中存储数据的最基本的单元
• 数据类型的作用？
  • 不同的数据类型，底层会分配不同大小的内存空间
  • 数据类型是指导程序运行阶段，应该分配多大的内存空间
• 变量要求：变量中存储的具体“数据”必须与“数据类型”一致
• 声明和赋值可以一起完成，并且赋值之后还可以再重新赋值，并且一行中还能声明多个变量
• 通常访问一个变量包括两种访问形式：
  • 第一种：读取变量中保存的具体数据（字面值） get/获取
  • 第二种：修改变量中保存的具体数据（字面值） set/修改
• Java中变量必须先声明再赋值，才能访问。例如：int i;//编译报错：变量i并没有初始化；int i = 1;编译通过
• 方法体（没有说类体）中的Java代码，是遵循自上而下的顺序依次逐行执行的
• 在同一个作用域中，变量名不能重名（言外之意，在不同的作用域中，变量名可以重名）
• 变量的作用域只需要记住一句：出了大括号就谁也不认识谁
• 变量的分类：
  • 局部变量：在方法体中声明的变量，没有默认初始值，需要我们赋值
  • 成员变量：在方法体外（类体之内）声明的变量，有默认初始值

11、数据类型

• Java中的数据类型包括2种：

  • 基本数据类型
  • 引用数据类型
    • 类
    • 接口
    • 数组
      …

• 基本数据类型包括4大类8小种：

  • 第一类：整型
    byte,short,int,long
  • 第二类：浮点型
    float,double
  • 第三类: 布尔型
    boolean
  • 第四类：字符型
    char

• 字符串"你好啊"、"abc"不属于基本数据类型，属于引用数据类型

• 八种基本数据类型各自占用空间大小：
  基本数据类型 占用空间大小【单位：字节（Byte）】

  ---

   byte                              1
   short                             2
   int                               4
   long                              8
   float                             4
   double                            8
   boolean                           1
   char                              2
  

  1Byte=8bit(1bit代表一个二进制位0/1)

• 字符编码：一本人为编写的现实世界文字与二进制对应的字典。最早的字符编码是ASCII码

  • ASCII码表只记住以下三个：
    ‘a’–> 97 【01100001】
    ‘A’–> 65
    ‘0’–> 48
  • java语言采用unicode编码方式，所以“标识符”可以用中文
  • unicode编码有多种具体的实现：
    • UTF-8
    • UTF-16
    • UTF-32
      …
      在实际开发中，一般使用UTF-8编码方式比较多【统一编码方式】

• 八种基本数据类型的取值范围：

   类型                  取值范围
  

  ---

       byte                  [-128 ~ 127]
       short                 [-32768 ~ 32767]
  	 int		
  	 long
    	   float
   		double
       boolean               [true,false]
       char                  [0 ~ 65535]
  

• 八种基本数据类型的默认值

  数据类型 默认值

  ---

   byte,short,int,long        0
   float,double               0.0
   boolean                    false【在C语言中true是1，false是0】
   char                       \u0000
  

  八种基本数据类型的默认值是一切向0看齐

• 进制数：

  • 十进制：0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
  • 二进制：0 1 10 11 100 101 110 111
  • 十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f
  • 八进制：0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17

• java语言中整数型字面值的三种表示方式：

  • 十进制【是一种缺省默认的方式】
  • 八进制【需要以0开始】
  • 十六进制【需要以0x开始】
  • 示例程序：
    public class DataTypeTest04
    {
    public static void main(String[] args){
    int a = 10;
    int b = 010;
    int c = 0x10;
    System.out.println(a);//得到的结果是10
    System.out.println(b);//得到的结果是8
    System.out.println©;//得到的结果是16
    }
    }

• java中整数字面值，都会默认被当作int数据类型处理
  例如：long x = 456;

  • 456整数型字面值被当作int类型，占用4个字节
  • x变量在声明的时候是long类型，占用8个字节
  • int类型的字面值456赋值给long类型的变量x,存在类型转换
  • int类型转换为long类型；int类型是小容量，long类型是大容量
  • 小容量可以自动转换成大容量，成为自动类型转换机制
    例如：long x = 2147483648;//编译报错
  • 2147483648字面值默认当作int类型4个字节处理，而int类型取值范围【-2147483647～2147483647】，超出了int类型最大值编译报错
    解决方法：long x =2147483648L;
  • 2147483648一上来就被当作long类型处理，不存在类型转换

• 大容量不能自动转换成小容量，必须要强制数据类型转换符，并且强制转换可能存在精度损失

  • 例如：long x = 105L;
    int y = x;//编译报错
    应改为：
    long x = 105L；
    int y = (int)x;
  • 计算机底层存储数据都是采用的二进制补码存储的，真实数据值为原码
  • 正数的原码和补码相同；负数的补码是负数的绝对值的二进制码所有位（包括符号位）取反再加1
  • byte m = (byte)198;
    System.out.println(m);//-58
    计算过程
    原始数据：00000000 00000000 00000000 11000110
    强制类型转换之后：11000110
    11000110现在在计算机中存储，因此它是一个补码，将其转换成源码就是该数字
    11000110 - 1 --> 11000101
    取反：00111010【2+8+16+32】–> 58
    由于是负数，所以-58
  • 如果一个整数字面值没有超出byte、short、char类型取值范围，该字面值（虽然默认是int类型数据）可以直接赋值给byte、short、char类型变量,而不需要强制类型转换
    byte a = 127;//编译通过
    short a1 = 32767;//编译通过
    char a2 = 65536;//编译通过

• 浮点数据类型的字面值的默认数据类型是double，若浮点小数后面加F/f则浮点数据类型为float

  • double a = 3.14;//3.14的默认数据类型是double，变量a的数据类型是double，因此不存在数据类型转换
  • float b = 3.15;//编译报错，3.15字面值的数据类型是double，而变量b的数据类型是float
  • float b = (float) 3.15;//编译通过，强制数据类型转换
  • float b = 3.15f;//编译通过，3.15f表示3.15是一个float数据类型的字面值

• 关于基本数据类型之间的互相转换规则：

  • 八种基本数据类型除布尔类型之外剩下7中数据类型之间都可以互相转换
  • 小容量向大容量转换为自动转换，容量从小到大排序：
    byte < short < int < long < float < double
    < char <
    注意：
    任何浮点类型不管占多少字节都比整数类型容量大
    char和short可表示种类数量相同（容量一样大）但char可以取更大的正整数
  • 大容量转换成小容量加强制转换符叫强制类型转换，编译能通过，但运行阶段可能会损失精度，谨慎使用
  • byte、short、char混合运算的时候，各自先转换成int类型再做运算
  • 多种数据类型混合运算，先转换成容量最大的那种类型再做运算

12、运算符

• 算术运算符
  + 求和
  - 相减
  * 乘积
  / 商
  % 求余数【取模】
  ++ 自加1（i++ ++i两种写法都对，都等价于i=i+1）
  – 自减1

• 关系运算符（两侧只能写整型或浮点型数据）
  > 大于
  < 小于
  >= 大于等于
  <= 小于等于
  == 等于
  != 不等于

  • equals();用于判断字符串的内容是否相同
  • 关系运算符的运算结果一定是布尔类型：true/false

• 逻辑运算符
  & 逻辑与（两边的算子都为true，结果才是true）
  | 逻辑或（两边的算子只要有一个是true，结果就是true）
  ! 逻辑非（取反，!false就是true，!true就是false，这是一个单目运算符）
  ^ 逻辑异或（两边的算子只要结果不一样，最后的结果就是true）

  && 短路与
  || 短路或

  • 逻辑运算符要求两边算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
  • 短路和逻辑的区别在于以下例子：
    //逻辑与
    int x = 10;
    int y = 8;
    System.out.println(x < y & ++x > y);//x<y为false，但仍然继续执行++x
    System.out.println(x);//控制台上输出结果为11
    //短路与
    int x = 10;
    int y = 8;
    System.out.println(x < y && ++x > y);//x<y为false，因此整个结果已经是false了，没有继续执行++x,++x被“短路”了
    System.out.println(x);//控制台上输出结果为10
    从一定角度上来看，短路与较为智能，执行效率较高

• 赋值类运算符（+=、-=、*=、/=、%=、=）

  • 需注意：
    byte i = 10;
    i += 5;等同于i = (byte) (i + 5);

    int k = 2147483647;
    k += 5;等同于k = (int) (k + 5);

    long x = 10L;
    int y = 5;
    y += x;等同于y = (int) (y + x);
    结论：扩展类赋值运算符不改变运算结果类型，它与 i = i + 5;不一样

• 三目运算符/条件运算符/三元运算符
  布尔表达式 ? 表达式1 : 表达式2
  规则：如果布尔表达式的结果为true，则表达式1的结果作为整个表达式的结果
  如果布尔表达式的结果为false，则表达式2的结果作为整个表达式的结果

13、选择（分支）结构

• if语句（一共四种）
  • 接收用户键盘输入：
    import java.util.Scanner;//导入Scanner类
    Scanner s = new Scanner(Syste.in);//创建键盘扫描器对象s
    //Scanner类对象s调用next()方法，等待用户键盘输入文本信息【以字符串的形式】
    //将信息赋值给变量userInput
    String userInput = s.next();
    //Scanner类对象s调用nextInt()方法，等待用户键盘输入数字信息【以整数型的形式】
    //将信息赋值给变量num
    int num = s.nextInt();
    //Scanner类对象s调用nextDouble()方法，等待用户键盘输入数字信息【以浮点型的形式】
    //将信息赋值给变量num2
    double num2 = s.nextDouble();
• switch语句
  switch(int类型/String类型的字面值或变量){
  case int类型/String类型的字面值或变量 :
  java语句;
  …
  break;
  case int类型/String类型的字面值或变量 :
  java语句;
  …
  break;
  …
  default :
  java语句
  }
  注意：case穿透和case合并

14、循环结构

• for循环
  for(初始化表达式;布尔表达式;更新表达式){
  循环体语句
  }
  • 初始化表达式;布尔表达式;更新表达式都不是必须的【但是两个分号是必须的】
  • 初始化表达式再整个循环中最先执行，且只执行一次
• while循环
  • 语法结构：
    while(布尔表达式){
    循环体;
    }
    循环体可能执行次数为0次
• do…while循环
  • 语法结构
    do{
    循环体;
    }while(布尔表达式);
  • 执行原理：
    先执行循环体，再判断布尔表达式是否为真，为真执行循环体，为假结束，循环体执行次数至少1次
  • 注意：最后有一个分号别丢了！
  • 与while循环的区别就是：do…while();是先斩后奏

15、控制循环的语句

• break;
  • break;语句在for,while,do…while循环语句中用来跳出循环，终止循环的执行
  • break;语句在switch语句中用来终止switch语句的执行，不终止就穿透
  • break;语句在默认情况下终止的是离他最近的循环【就近原则】，也可以指定终止某个循环，需要给循环起名
    例如：
    //给for循环起名为for1
    for1:for (int j = 1;j <= 3 ;j ++)
    {
    System.out.println(“for1执行了”+j+“次”);
    //给for循环起名为for2
    for2:for (int i = 1;i <= 5;i ++)
    {
    if (i == 4)
    {
    //终止了for1循环
    break for1;
    }
    System.out.println(“i–>”+i);
    }
    }
• continue;
  • continue;与break;的区别：
    • break;表示直接结束循环
  • continue;表示本次循环continue;后面的java语句不执行了，直接跳到下一次循环“继续”执行
  • continue 循环名称;（和break 循环名称;一样）

16、方法

• 某个功能代码只需要写一遍
  要使用这个功能，只需要给这个功能传递具体数据
  这个功能完成之后返回一个具体的结果，这样代码就能重复利用了，提高代码复用性【这就是“方法”】
• 使用这个方法，我们称为：“调用/invoke”
• 方法定义在类体当中，方法体之外，一个类中可以定义多个方法，并且编写位置没有顺序，方法体中的代码有顺序
• 方法的语法结构：
  [修饰符列表] 返回值类型 方法名(形式参数列表){
  方法体;
  }
  • 修饰符列表【可选项，不是必须的】，目前统一写成：public static【以后细说】
  • 方法的修饰符列表有static关键字的话，如何调用该方法？
    • 类名.方法名(实际参数列表);//可以调用其他类中的方法
  • 方法名(实际参数列表);//调用的是当前类中的方法，可以省略“类名.”
• 返回值类型
  • 返回值类型可以指定所有的基本数据类型和引用数据类型
  • void关键字表示，没有返回值
  • 返回值语句：return 字面值;（注意，该语句一旦执行，方法立即结束，和return;一样）
  • 返回值类型是void的时候，方法体中不能编写“return 字面值;”这样的语句
    但是可以编写“return;”这样的语句。为什么呢？
    因为“return;”和“break;”功能类似。
    “return;”的功能是：“return;”语句所在的方法立即结束
  • 一个有返回值的方法，调用它时，它的返回值可以选择接收或者不接收，接收则采用变量接收
    • 类名.方法名(实参列表);//调用了该方法，但没有接收它的返回值
• 数据类型 变量名 = 类名.方法名(实参列表);//调用了还方法，并且接收了它的返回值;
• 还可以这样接收返回值：
  System.out.println(类名.方法名(实参列表));//直接在控制台打印输出返回值
  • 在同一个作用域中，return语句下面不能编写代码
• 方法在执行过程中，在jvm中如何分配内存？内存如何变化？
  • 方法只定义，不调用，是不会执行的，并且JVM中也不会给该方法分配“运行所属”的内存空间
  • 在JVM内存划分上有这样三块主要的内存空间（当然，除了这三块之外还有其他的内存空间）
    • 方法区内存//最先有数据，方法代码片段属于.class的一部分.class 生成时，将方法代码片段的字节码文件存放在方法区内存
  • 栈内存//调用(运行)方法时，在栈内存中给该方法分配栈内存，此时发生压栈动作；方法执行结束后，分配的栈内存空间全部释放，发生弹栈动作
    //局部变量在方法体中声明，局部变量运行阶段内存在栈内存中分配
  • 堆内存
  • 在Editplus中，字体颜色为红色表示一个类的名字，并且这个类是JavaSE类库中自带的
• 方法的重载（又叫overload）
  • 构成方法重载的条件
    • 在同一个类中
• 方法名相同
• 参数列表不同
  • 数量不同
  • 顺序不同
  • 类型不同
  • 方法重载和返回值类型无关！
• 方法递归
  • 方法自己调用自己就叫方法递归，形如：

    	a(){
		a();
	}

  * 递归必须要有终止条件，不然会有栈溢出错误
  * 递归很耗费栈内存，能不用尽量不用，即使递归有终止条件，
  	并且终止条件是正确的，
   	也可能发生栈溢出因为递归得太深了。

17、数组

• 声明数组
  语法： 数据类型[ ] 数组名；
  或者： 数据类型 数组名[ ]；
• 分配空间
  简单地说，就是指定数组中最多可存储多少个元素
  语法： 数组名 = new 数据类型 [ 数组长度 ];
  其中，数组长度就是数组中能存放元素的个数。我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间
  int[] scores = new int[5];//长度为5的整数型数组，名为scores
• 赋值
  分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向 scores 数组中存放学生成绩
  score[0] = 87;
  在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如
  int[] scores = {87,90,65,34};
  以上也等价于：
  int[] scores = new int[] {87,90,65,34};
  数组名.length用于获取数组的长度
• 使用Arrays类操作Java中的数组(要先导入java.util包)

* 排序：语法：  Arrays.sort(数组名);可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列），如：
	int[] a = new int[] {9,12,6,48};
	Arrays.sort(a);
	for(i=0;i<a.length;i++){
		System.out.print(a[i]+" ");
	}//6 9 12 47
* 将数组转化为字符串：语法：  Arrays.toString(数组名);可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开，如：
	int[] a = new int[] {9,12,6,48};
	System.out.println("输出数组中的元素：" + Arrays.toString(a));//输出数组中的元素：[9, 12, 6, 48]

• 使用foreach操作数组

* 语法：
	for(元素数据类型 元素变量名 ：遍历对象){
		执行代码;
	}
	例如：
	// 定义一个整型数组，保存成绩信息
	int[] scores = { 89, 72, 64, 58, 93 };
	// 使用foreach遍历输出数组中的元素
	for (int a    : scores            ) {
		System.out.print(a+" ");
	}//89 72 64 58 93