Java基础-语法

一、关键字和保留字

定义：被Java语言赋予了特殊含义，用做专门用途的字符串

特点：关键字中所有的字母都为小写

官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

类别 关键字
访问控制 private、protected、public、default
类、方法和变量修饰符 abstract、class、extends、final、implements、interface、native、new、static、strictfp、synchronized、transient、volatile
程序控制语句 break、case、continue、default、do、else、for、if、instanceof、return、switch、while
错误处理 assert、catch、finally、throw、throws、try
包相关 import、package
基本类型 boolean、byte、char、double、float、int、long、short
变量引用 super、this、void
定义数据类型值得字面量 true、false、null
保留字（现有版本未使用） goto，const

二、标识符

1. 概念

Java对各种变量，方法和类等要素命名时使用的字符序列称为标识符。凡是可以自己起名字的地方都叫标识符，比如：类名、变量名、方法名、接口名、包名...

2. 规则

  1. 由26个英文字母大小写、0-9、_或$组成
  2. 不能以数字开头
  3. 不能使用关键字和保留字，但是可以包含关键字和保留字
  4. 大小写敏感，长度无限制
  5. 标识符不能包含空格

3. 命名规范

  1. 包名：多单词组成时所有字母都小写
  2. 类名、接口名：多单词组成时，所有单词的首字母大写
  3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写
  4. 常量名，所有字母都大写，多单词时每个单词用下划线连接

三、变量

1. 概念

  1. 内存中的一个存储区域
  2. 该区域的数据可以再同一类型范围内不断变化
  3. 变量是程序中最基本的存储单元。包含变量类型、变量名的存储的值

2. 作用

用于在内存中保存数据

3. 使用注意

  1. 每个变量必须先声明后使用
  2. 使用变量名来访问这块区域的数据
  3. 变量的作用域：其定义所在的一对{}内
  4. 变量只有在其作用域内才有效
  5. 同一个作用域内，不能定义重名的变量

4. 定义变量的格式

数据类型 变量名 = 变量值;

5. 变量的分类

5.1 按照数据类型分类

  1. 基本数据类型（8种）
    1. 数值型
      1. 整数类型（byte、short、int、long）
      2. 浮点类型（float、double）
    2. 字符型（char）
    3. 布尔型（boolean）
  2. 引用数据类型
    1. 类（class）
    2. 接口（interface）
    3. 数组（[]）

5.2 按声明的位置分类

  1. 成员变量
    1. 实例变量（不以static修饰）局部变量
    2. 类变量（以static修饰）
  2. 局部变量
    1. 形参
    2. 方法局部变量
    3. 代码块局部变量
类型 占用空间 范围 默认值
byte 1字节 -128（-2^7）~ 127（2^7-1） 0
short 2字节 -32768(-2^15)~32767(2^15 - 1) 0
int 4字节 -2,147,483,648(-2^31)~2,147,483,647(2^31-1) 0
long 8字节 -9,223,372,036,854,775,808(-2^63)~9,223,372,036,854,775,807(2^63 -1) 0L
float 4字节 1.4E-45~3.4028235E38 0.0f
double 8字节 4.9E-324~1.7976931348623157E308 0.0d
boolean 1位 true 或false false
char 2字节 \u0000(0)~\uffff(65535)

6. 基本数据类型之间的运算规则

6.1 自动类型提升

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

特别的，当byte、char、short三种类型的变量做运算时，结果为int型。

// 低  ------------------------------------>  高
// byte,short,char—> int —> long—> float —> double

6.2 强制类型转换

  1. 自动类型提升的逆运算
  2. 需要使用强转符()
  3. 可能导致精度损失

7. String类型

  1. String属于引用数据类型
  2. 声明String类型变量时，使用一对""
  3. String可以和8种基本数据类型变量做运算，且运算只能使连接运算。
public class HelloWorld {
    public static void main(String[] args) {
        String str = "Hello World!";
        System.out.println(str);
    }
}

四、运算符

1. 算数运算符

public class OperatorTest {

  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) ); // a + b = 30
     System.out.println("a - b = " + (a - b) ); // a - b = -10
     System.out.println("a * b = " + (a * b) ); // a * b = 200
     System.out.println("b / a = " + (b / a) ); // b / a = 2
     System.out.println("b % a = " + (b % a) ); // b % a = 0
     System.out.println("c % a = " + (c % a) ); // c % a = 5
     System.out.println("a++   = " +  (a++) ); // a++   = 10
     System.out.println("a--   = " +  (a--) ); // a--   = 11
     System.out.println("b++   = " +  (b++) ); // b++   = 20
     System.out.println("++b   = " +  (++b) ); // ++b   = 22
  }
}

2. 赋值运算符

赋值（=）支持连续赋值

public class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 15;
        int c = 20;
        c = a + b;
        System.out.println("c = a + b c = " + c ); // c = a + b c = 25 简单赋值
        c += a ;
        System.out.println("c += a c = " + c ); // c += a c = 35
        c -= a ;
        System.out.println("c -= a c = " + c ); // c -= a c = 25
        c *= a ;
        System.out.println("c *= a c = " + c ); // c *= a c = 250
        c /= a ;
        System.out.println("c /= a c = " + c ); // c /= a c = 25
        c %= a ;
        System.out.println("c %= a c = " + c ); // c %= a c = 5
        c <<= 2 ;
        System.out.println("c <<= 2 c = " + c ); // c <<= 2 c = 20
        c >>= 2 ;
        System.out.println("c >>= 2 c = " + c ); // c >>= 2 c = 5
        c >>= 2 ;
        System.out.println("c >>= 2 c = " + c ); // c >>= 2 c = 1
        c &= a ;
        System.out.println("c &= a c = " + c ); // c &= a c = 0
        c ^= a ;
        System.out.println("c ^= a c = " + c ); // c ^= a c = 10
        c |= a ;
        System.out.println("c |= a c = " + c ); // c |= a c = 10
    }
}

3. 比较运算符（关系运算符）

比较运算符的结果是Boolean类型

public class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b = " + (a == b) );  // a == b = false
        System.out.println("a != b = " + (a != b) );  // a != b = true
        System.out.println("a > b = " + (a > b) );  // a > b = false
        System.out.println("a < b = " + (a < b) );  // a < b = true
        System.out.println("b >= a = " + (b >= a) );  // b >= a = true
        System.out.println("b <= a = " + (b <= a) );  // b <= a = false
    }
}

4. 逻辑运算符

&：逻辑与 |：逻辑或 !：逻辑非

&&：短路与 ||：短路与 ^：逻辑异或

a b a&b a&&b a|b a||b !a a^b
true true true true true true false false
true false false false true true false true
false true false false true true true true
false false false false false false true false

5. 位运算符

public class OperatorTest {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c ); // a & b = 12
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c ); // a | b = 61
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c ); // a ^ b = 49
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );  // ~a = -61
 
     c = a << 2;     /* 240 = 1111 0000 */
     System.out.println("a << 2 = " + c ); // a << 2 = 240
 
     c = a >> 2;     /* 15 = 1111 */
     System.out.println("a >> 2  = " + c ); // a >> 2  = 15
  
     c = a >>> 2;     /* 15 = 0000 1111 */
     System.out.println("a >>> 2 = " + c ); // a >>> 2 = 15 无符号右移
  }
}

6. 三元运算符

格式：(条件表达式)?表达式1:表达式2;

说明：

  1. 条件表达式的结果为boolbean类型
  2. 根据条件表达式真或假，决定执行表达式1还是表达式2
  3. 凡是可以使用三元运算符的地方都可以改写为if...else

五、流程控制

1. if-else

1.1 if

public class IfTest {
    public static void main(String[] args) {
        int heartBeats = 79;
        if (heartBeats > 60 || heartBeats < 100) {
            System.out.println("心率正常！");
        }
    }
}

1.2 if...else...

public class IfTest {
    public static void main(String[] args) {
        int age = 21;
        if (age < 18) {
            System.out.println("未成年人");
        }else {
            System.out.println("成年人");
	    }
    }
}

1.3 if...else if...else...

public class IfTest {
    public static void main(String[] args) {
        int score = 61;
        if (score >= 0 && score < 60) {
            System.out.println("不及格");
        }else if (score > 60 && score <= 80) {
            System.out.println("及格");
	}else if (score > 80 && score <= 100) {
	    System.out.println("优秀");
        }else
            System.out.println("错误");
	}
}

2. switch-case

语法：

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}
  1. 根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
  2. break可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
  3. switch结构中的表达式只能是如下的6中数据类型之一：byte、short、char、int、String（JDK7.0新增）、枚举（JDK5.0新增）。
  4. case之后只能声明常量，不能声明范围。
  5. break关键字是可选的。
  6. default:相对于if-else结构中的else，default结构是可选的。

3. for

格式：

for(①初始化; ②循环条件（布尔表达式）; ④迭代条件) {
    ③循环体
}

执行过程：①--> ②-->③-->④-->②-->③-->④-->②-->③-->④...-->②

例1：输出20以内的偶数：

public class ForTest {
    public static void main(String[] args) {
        for (int i = 0; i <= 20; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
		}
    } 
}

例2：求两个数的最大公约数和最小公倍数

public class CommonDivisorAndCommonMultiple {
    public static void main(String[] args) {
        int n = 12;
        int m = 20;

        // 获取最大公约数
        // 1.获取两个数中的较小值
        int min = (m <= n)? m : n;
        // 2.遍历
        for(int i = min; i >= 1; i--){
            if(m % i == 0 && n % i == 0){
                System.out.println("最大公约数为：" + i);
                break;
            }
        }

        // 获取最大公倍数
        // 1.获取两个数中的最大是
        int max = (m >= n)? m : n;
        // 2.遍历
        for (int i = max; i <= m*n; i++){
            if(i % m == 0 && i % n == 0){
                System.out.println("最小公倍数：" + i);
                break;
            }
        }
    }
}

嵌套循环：

技巧：内层循环控制行数，外层循环控制列数

例1：九九乘法表

public class NineNineMultiplicationTable {
    public static void main(String[] args) {
        for(int i = 1; i <= 9; i++){
            for(int j = 1; j <= i; j++){
                System.out.print(i + "*" + j + " = " + i*j + " ");
            }
            System.out.println("");
		}    
    }
}

例2：打印100以内的质数（素数，只能被1和他本身整除的自然数）：

方法一：

// 从2开始，到这个数-1结束为止，都不能被这个数本身整除。
class PrimeNumberTest {
    public static void main(String[] args){
		boolean isFlag = true;
        for(int i = 2; i <= 100; i++){
            for( int j = 2; j < i; j++){
                if (i % j == 0){
                isFlag = false;
                }
            }
            if (isFlag == true){
                System.out.println(i);
            }
            isFlag = true;
		}
    }
}

方法二：

class PrimeNumberTest {
    public static void main(String[] args){
		boolean isFlag = true;
        for(int i = 2; i <= 100; i++){
	    // 优化二：对本身是质数的自然数是有效的
            for( int j = 2; j <= Math.sqrt(i); j++){
                if (i % j == 0){
                isFlag = false;
                break; // 优化一 : 只对本身非质数的自然数是有效的
                }
            }
            if (isFlag == true){
                System.out.println(i);
            }
            isFlag = true;
        }
    }
}

4.while

格式：

①初始化条件
while(②循环条件) {
    ③循环体;
    ④迭代条件;
}

执行过程：①--> ②-->③-->④-->②-->③-->④-->②-->③-->④...-->②

例1：输出20以内的偶数：

public class WhileTest {
     public static void main(String[] args) {
         int i = 1;
         while(i <= 20){
             if(i % 2 == 0){
                 System.out.println(i);
             }
             i++;
	 	 }	 
     } 
}

5.do-while

格式：

①初始化条件
do{
    ③循环体;
    ④迭代条件;    
}while(②循环条件);

执行过程：①-->③-->④-->②-->③-->④-->②...-->②

例1：输出20以内的偶数：

public class DoWhileTest {
     public static void main(String[] args) {
         int i = 1;
	 do{
	     if(i % 2 == 0){
	         System.out.println(i);
	     }
	     i++;
	  }while(i <= 20);
     } 
}

6.break和continue

使用范围 循环中的作用（不同点） 相同点
break switch-case、循环结构 结束当前循环 关键字后面不能声明执行语句
continue 循环结构 结束当次循环 关键字后面不能声明执行语句 
public class BreakTest {
    public static void main(String[] args){
        for(int i = 1; i <= 4; i++){
            for(int j = 1; j <= 10; j++){
                if(j % 4 == 0){
                	break; // 默认跳出包裹此关键字最近的一层循环
            	}
            	System.out.print(j);
            }
            System.out.println();
		}
    }
}

结束指定标签的for循环

public class BreakTest {
    public static void main(String[] args){
    label:for(int i = 1; i <= 4; i++){
            for(int j = 1; j <= 10; j++){
                if(j % 4 == 0){
                    break label; //结束指定标识的一层循环结构
                    // continue label; // 结束指定标识的一层循环结构当次循环
                }
                System.out.print(j);
            }
	    System.out.println();
		}
    }
}

例：打印100以内的质数

class PrimeNumberTest {
    public static void main(String[] args){
    label:for(int i = 2; i <= 100; i++){
            for( int j = 2; j <= Math.sqrt(i); j++){
                if (i % j == 0){
                	continue label;
            	}
            }
            System.out.println(i);
		}
    }
}
posted @ 2021-08-08 22:23  苏方木  阅读(62)  评论(0)  编辑  收藏  举报