Java学习笔记3 Java基础

目录

1.1 书写方式

1.1.1 关键字

1.1.2 标识符

1.1.3 变量

1.1.4 常量

1.1.5 数据类型

1.1.6 注释

1.1.7 输入输出

1.2 运算符和表达式

1.2.1 算术运算符

1.2.2 比较运算符

1.2.3 逻辑运算符

1.2.4 位运算符

1.2.5 赋值运算符

1.2.6  三目运算符

1.2.7 运算符的优先级

1.3 流程控制

1.3.1 顺序结构

1.3.2 选择分支

1.3.3 循环结构

1.4 数组

1.4.1 数组的定义   

1.4.2 数组的初始化

1.4.3 元素访问

1.4.4 数组的遍历

1.4.5 数组的查找 (二分法）

1.4.6 数组的排序 (十大排序算法)

1.4.7 二维和多维数组(了解)

1.5 方法

1.5.1 定义语法

1.5.2 方法的组成

1.5.3 方法的调用

1.5.4 方法的重载

1.5.5 递归调用

---

1.1 书写方式

1.1.1 关键字

在Java语言中, 已经定义好的, 具有一定的功能或作用的单词, 全部是小写的.

Java中总共有51个关键字+2个保留字

byte short int long float double char boolean

public private protected (default)

final finally

if else for while do switch case default break continue return

class interface enum …

goto const

 

1.1.2 标识符

编写Java代码时, 定义的一些东西(方法, 变量, 常量, 类, 接口…)的名称

规则:

1. 字母, 数字, _ , $组成
2. 不能以数字开头
3. 不能使用关键字和保留字
4. 严格区分大小写

 

1.1.3 变量

在程序运行中, 值可以改变的内存空间.

语法: 数据类型 变量名;

 

赋值/初始化

(1)数据类型 变量名 = 值;

(2)数据类型 变量名;

变量名 = 值1;

变量名 = 值2;

 

注意事项:

(1)变量/常量, 必须先定义才能使用

(2)变量/常量, 必须先赋值才能访问.

(3)在同一作用域下, 变量/常量不能重复定义.

 

1.1.4 常量

在程序运行中, 值不可以改变的内存空间

语法: final 数据类型 常量名;

 

赋值/初始化

(1)final 数据类型 常量名 = 值;

(2)final 数据类型 常量名;

常量名 = 值1;

常量名 = 值2; // 不允许的

 

1.1.5 数据类型

(1) 8种基本数据类型

四种整型: byte  short  int  long

两种浮点型: float  double

字符型: char

布尔型: boolean

(2) 3种引用类型

数组

类

接口

 

1.1.6 注释

(1)单选注释 // 

(2)多行注释 /*  */

(3)文档注释 /**  */          -------注释允许你在程序中嵌入关于程序的信息

 

1.1.7 输入输出

(1)输入 Scanner

Scanner sc = new Scanner(System.in);

sc.next(), nextXX();

(2)输出 System.out.print(), println(), printf(“我今年%d岁”, 18);

 

1.2 运算符和表达式

1.2.1 算术运算符

+: 加法, 正号, 拼接字符串

-: 减法, 负号

*: 乘法

/: 除法,   整数的除法(两个整数相除, 结果还是整数), 非整数的除法

10 / 3 = 3; 整除, 地板除

10 / 3.0 = 3.3333333335;

%: 求余, 求模, 取余.. 可以对整数, 也可以对小数进行求余

10 % 3.3 = 10 – 9.9 = 0.1

++

--

int a = 10;

前置: ++a , --a    先进行自增/自减运算, 再计算表达式.

后置: a++, a-- 先计算表达式, 再进行自增,自减

 

1.2.2 比较运算符

(1)   >    >=     <      <=

只能对数值型进行运算, 比较数值大小关系, 结果是布尔型的.

(2)   ==    !=

可以针对任何类型的数据进行运算

如果运算数据是引用类型的, 比较两个引用是不是指向同一块内存

比如两个字符串:

a == b; // a和b 是不是指向同一个对象.

a.equals(b); // a 和 b 这两个变量中的字符序列是不是相同.

 

1.2.3 逻辑运算符

逻辑与: &&  &, 对布尔型进行与运算, 

如果两个数据都是true, 结果为true, 否则为false

A && B

逻辑或: || | , 对布尔型进行或运算

如果两个数据都是false, 结果为false, 否则为true;

A || B

逻辑非: !   对布尔型进行求反

非true 即 false, 非false 即true

 

短路运算: && || 这时逻辑运算执行短路操作, 当第一个表达式, 已经可以确定运算结果, 第二个表达式, 不会再执行.

A && B   如果 A的值是false, 无论B的值如何, 结果必然是false, 此时, B不运行

A || B 如果A的值是true, 无论B的值如何, 结果必须是true, 此时B也不运行.

 

1.2.4 位运算符

了解一下即可, 以二进制的形式进行位运算

& 按位与 对应位都是1, 结果的对应位也是1, 否则是0

1010 & 1100 = 1000

10 & 12 = 8

| 按位或 对应位都是0, 结果的对应位也是0, 否则是1

1010 | 1100 = 1110

^ 按位异或 对应位不相同, 结果为1, 否则是0

1010 | 1100 = 0110

~ 按位取反 对应位由1变成0, 从0变成1

~1010 = 0101

>> 右移位 所有的数字向右移n位, 前n位与第一位相同

1010 >>1 = 1101

1010 >> 2 = 1110

<< 左移位 所有的数字向左移n位, 后n 位补0

1010<<1 = 0100

>>> 无符号右移位 所有的数字向右移n位, 前n位补0

 

如何以最快的速度完成:  *2  *4  *8    /2  /4  /8

a*2   =>  a<<1

a*4 => a<<2

 

a/2 => a>>1

a/8 => a>>3

 

1.2.5 赋值运算符

= 为变量/常量赋值

a= 10;

int a, b;

a = b = 10;

 

二目运算符还可以与=进行组合, 结成复合赋值运算符

例如 + 与 = 可以组合成 +=

a += b;  相当于 a = a + b;

 

 

 

1.2.6  三目运算符

A ? B : C

A必须是一个布尔型的值

当A为true, 整个表达式的值取B的值

当A为false,整个表达式的值取C的值.

三目运算符是可以转换成if else 结构.

 

1.2.7 运算符的优先级

 

1.3 流程控制

1.3.1 顺序结构

程序按照从上往下的顺序, 一行一行地执行.

Java程序在执行时, 都是从main方法开始的.

 

1.3.2 选择分支

根据条件, 选择执行一部分代码.

1.3.2.1 if … else…

语法:

执行过程: 

（1）计算条件表达式的值, 

（2）值是true, 执行if 后的代码块

（3）值是false, 执行else后的代码块

变形: 

（1）else 可以省略

（2）if的嵌套

（3）如果代码块, 只有一行/是独立的块, 这时{}可以省略

 

1.3.2.2 switch case

语法：

 

执行过程:

1. 计算条件表达式的值, 值是byte, short, int, char, JDK后期版本中添加String
2. 依次与后面的case进行对比.比较表达式的值与常量值是否相等
3. 如果不相等, 跳过当前case, 与下一个case进行对比.
4. 如果所有的常量值与表达式都不相等, 进入default后的代码块执行.
5. 如果表达式的值与case后的常量值相等, 进入case后的代码块执行.直到遇到break.才会结束switch的执行.

public class Test {
   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';
 
      switch(grade)
      {
         case 'A' :
            System.out.println("优秀"); 
            break;
         case 'B' :
         case 'C' :
            System.out.println("良好");
            break;
         case 'D' :
            System.out.println("及格");
            break;
         case 'F' :
            System.out.println("你需要再努力努力");
            break;
         default :
            System.out.println("未知等级");
      }
      System.out.println("你的等级是 " + grade);
   }
}

注意: 如果进入case后的代码执行, 而这块代码中没有break, 就会进入下一个case后的代码执行.

 

1.3.3 循环结构

根据条件重复执行同一块代码

1.3.3.1 while

语法:

执行过程

1. 计算条件表达式的值
2. 值是false, 结束循环
3. 值是true, 进入循环体执行.循环体执行完后, 回到第1)步

 

1.3.3.2 do…while

语法:

执行过程

1. 进入循环体执行
2. 循环体执行完成, 计算条件表达式的值
3. 如果条件表达式值是false, 结束循环
4. 如果条件表达式值是true, 回到第1步

 

区别

1. 写法不一样: while是条件在前, 循环体在后, do while是条件在后, 循环体在前
2. 执行顺序不一样: while 先判断条件, 再执行循环, do while是先执行循环, 再进行条件判断
3. 极端条件下, 执行结果不同: while的循环体可能一次也不执行, do while的循环体至少会执行一次.

1.3.3.3 for

语法:

初始化表达式: 对for进行初始化操作. 通常定义迭代变量并设置初始值, int i=0;

迭代表达式: 对迭代变量进行迭代操作. 通常会写i++  i—

 

执行过程:

1. 执行初始化表达式
2. 计算条件表达式的值, 
3. 如果条件表达式的值是false, 结束循环
4. 如果条件表达式的值是true, 进入循环体执行
5. 循环体执行完成后, 执行迭代表达式, 再回到第2步

 

1.3.3.4 关键字

break

用在switch, 结束switch语句

用在循环中, 结束整个循环, 进入循环后的代码执行.

continue

结束本次循环, 进入下一次循环执行.

 

return

结束方法, 提供返回值.

 

1.4 数组

1.4.1 数组的定义   

(引用类型的数组)

可以存放多个相同数据类型的元素的集合.

数组通常是一块连续的内存空间. 一旦分配了内存, 数组的大小就不能再改变了.

 

语法:

数据类型[] 数组名;

数据类型 数组名[];

定义数组, 就是在定义一个变量, 只是变量的类型是数组.

 

1.4.2 数组的初始化

因为数组在定义后, 只是一个变量, 没有任何的值, 需要对数组进行初始化.

初始化要分配内存空间.

方法一:

数据类型[] 数组名 = new 数据类型[长度];

1. 在堆内存中申请出 数据类型的长度*数组长度
2. 每个元素都会先初始一个值

基本数据类型, 会初始成类0的值

引用类型, 会初始成null;

方法二:

数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3, ….};

1. 在堆内存中申请出 数据类型的长度*数组长度
2. 根据{}中的元素, 为数组元素赋值

方法三:

数据类型[] 数组名 = {元素1, 元素2, 元素3, ….};

1. 在堆内存中申请出 数据类型的长度*数组长度
2. 根据{}中的元素, 为数组元素赋值

前两种可以拆开写, 第三种不能拆开.

 

1.4.3 元素访问

因为数组是一个有序的集合, 因此可以使用下标访问数组中的元素

数组名[下标]

下标, 元素在数据中的位置, 从0开始到（长度-1）

 

1.4.4 数组的遍历

从头到尾把数组中的元素逐个取出来.

    （1）采用循环生成下标

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (int i=0; i<myList.Length; i++) {
         System.out.println(myList[i]);
      }
   }
}

    （2）使用增强for循环 foreach

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
 
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

 

1.4.5 数组的查找 (二分法）

查找元素的下标、求最大、最小值、求和、求平均值、二分法

 

1.4.6 数组的排序 (十大排序算法)

冒泡排序

快速排序

插入排序

选择排序

归并排序

堆排序

桶排序

基数排序

计数排序

希尔排序

 

1.4.7 二维和多维数组(了解)

定义二维和多维

二维数组可以看作是每个元素都是数组的一维数组

遍历

二维需要使用双层循环, 三维数组需要使用三层循环.

 

 

1.5 方法

1.5.1 定义语法

方法都是定义在类中的

 

1.5.2 方法的组成

1.5.2.1 修饰符-----限制方法的使用场景

权限修饰符: public   protected   private (默认)

static: 静态的

final:最终的

abstract: 抽象的

 

1.5.2.2 返回值类型

void ----没有返回值

基本数据类型

引用类型

当方法指定了返回值 类型, 方法结束时, 必须使用return 提供一个相应类型的返回值

 

1.5.2.3 参数列表

方法执行时, 可以通过参数列表向方法传递数据

定义(数据类型 参数名, 数据类型 参数名…..)

 

形参: 形式参数, 方法定义时的参数

实参: 实际参数, 方法调用时, 传递的具体值就是实际参数

 

1.5.3 方法的调用

变量 = 方法名(实参);

 

1.5.4 方法的重载

在一个类中, 出现了方法名相同, 但是参数列表不同的方法. 这就叫做方法的重载.

参数列表的不同:

    参数的数量不同

    参数的类型不同

    参数的顺序不同

public static int max (int a, long b);

public static int max (long a, int b);

构成重载

不构成重载的情况:

参数名不同

返回值类型不同

 

1.5.5 递归调用

一个方法的内部, 又调用了这个方法本身. 这就叫递归调用.

递归层数过多, 可能会导致JVM栈内存溢出