栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

02-Java编程基础

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

02-Java编程基础

Java编程基础
  • 标识符和关键字
    • 标识符
    • Java 关键字
  • Java 数据类型
    • 基本数据类型
    • 基本类型转换
  • 运算符
  • 流程控制
    • 分支结构
    • 循环结构
    • 控制循环结构

标识符和关键字 标识符

  标识符 就是用于给程序中变量、类、方法命名的符号。Java 语言是 区分大小写的 ,使用标识符的时候,需要注意如下规则:

  • 标识符可以由字母、数字、下划线和美元符组成,其中数字不能打头(此处的字母并不局限于 26 个英文字母,而且可以包含中文字符、日文字符等)
  • 标识符不能是 Java 关键字和保留字
  • 标识符不能包含空格
  • 标识符只能包含美元符,不能包含 @ 、 # 等其它特殊字符

  关于标识符,还有一些规范(可以不遵守):

  • 包名:多单词组成时所有字母都小写(xxxyyyzzz)
  • 类名、接口名:多单词组成时,所有单词的首字母大写(XxxYyyZzz)
  • 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写(xxxYyyZzz)
  • 常量名:所有字母都大写,多单词时候每个单词用下划线连接(XXX_YYY_ZZZ)
  • 为了提高阅读性,起名字时应该尽量 “见名知意”
Java 关键字

  Java 语言中有一些具有特殊用途的单词被称为 关键字,当定义标识符的时候,不要让标识符和关键字相同,否则引起错误。

  Java 的所有关键字都是小写的,也就是说 TRUE 并不是 Java的关键字。

Java 数据类型

  Java 语言是 强类型语言(所有的变量必须先声明、后使用;指定类型的变量只能接受类型与之匹配的值),这意味着每个变量和每个表达式都有一个在编译时就确定的类型,类型限制了一个变量能被赋的值,限制了一个表达式可以产生的值,限制了在这些值上可以进行的操作,并确定这些操作的含义。声明变量的语法如下:

type varName [= 初始值];

  定义变量的时候既可以指定初始值,也可以不指定初始值,但至少需要指定变量类型和变量名两个部分。定义变量时的变量类型可以是 Java 语言支持的所有类型,Java 语言支持的类型分为:基本类型和引用类型 。

  空类型就是 null 值的类型,因为 null 类型没有名称,所以不能声明一个 null 类型的变量或者转换到 null 类型。空引用(null)是 null 类型变量唯一的值,空引用可以转换为任何引用类型(不能转换为基本类型)。

基本数据类型

(一)整型

  整型通常有如下 4 种类型:

类型名称内存大小表数范围
byte8位-128(-2^7) ~ 127(2^7 - 1)
short16位-32768(-2^15) ~ 32767(2^15 - 1)
int32位-2147483648(-2^31) ~ 2147483647(2^31 - 1)
long64位-2^63 ~ 2^ 63 - 1

  int 是最常见的整数类型,通常情况下直接给出一个整数值默认就是 int 类型,需要注意下面两种情形:

  • 如果直接将一个较小的整数值(在 byte 或 short 类型的表数范围内)赋给一个 byte 或 short 变量,系统会自动把这个整数值当成 byte 或 short 类型来处理
  • 如果使用一个巨大的整数值(超出了 int 类型的范围),Java 不会自动把这个整数值当成 long 类型来处理。如果希望系统把一个整数值当成 long 类型来处理,应在这个整数值后面增加 l 或者 L 作为后缀

  Java 中整数值有 4 种表示方式:

  • 十进制:0 ~ 9,满 10 进 1
  • 二进制:0 和 1,以 0b 或者 0B 开头
  • 八进制: 0 ~ 7,满 8 进 1,以数字 0 开头表示
  • 十六进制:0 ~ 9 以及 A ~ F,满 16 进 1,以 0x 或者 0X开头

  所有数字在计算机底层都以二进制形式存在,并且不管正负,都是以补码的方式存储:

  • 正数:三码合一
  • 负数:
    • 原码:直接将一个数值转换成二进制,最高位是符号位
    • 负数的反码:是对原码按位取反,只是最高位(符号位)确定为 1
    • 十进制:反码加 1

(二)字符型

  字符型通常用于表示单个字符,字符型值必须使用单引号括起来。Java 语言使用 16 位的 Unicode 字符集作为编码方式。字符型值有如下三种表示方法:

  • 直接通过单个字符来指定字符型值,如 ‘A’、‘9’ 和 ‘0’ 等
  • 通过转义字符表示特殊字符型值,如 ‘n’、‘t’ 等
  • 字节使用 Unicode 值来表示字符型值,格式是 ‘uXXXX’,其中 XXXX 代表一个十六进制的整数

  由于计算机底层保存字符时,实际是保存该字符对应的编号,因此 char 类型的值也可以作为整数值来使用,完全可以参与加、减、乘、除以及比较大小的运算。

(三)浮点型

  Java 的浮点型有两种:float 和 double ,浮点型也有固定的表数范围和字段长度(与机器无关):

  • float 类型:单精度浮点数,占有 4 个字节 32 位,其中第 1 位是符号位,接下来 8 位表示指数,再接下来的 23 位表示尾数
  • double 类型:双精度浮点数,占有 8 个字节 64 位,其中第 1 位是符号位,接下来 11 位表示指数,再接下来的 52 位表示尾数

  Java 中的浮点数有两种表示形式:

  • 十进制数形式:例如 5.12
  • 科学计数法形式:例如5.12e2

  Java 中的浮点数默认是 double 类型,如果希望 Java 把一个浮点类型当成 float 类型处理,应该在这个浮点类型值后紧跟 f 或 F。

  Java 还提供了三个特殊的浮点数值:正无穷大、负无穷大和非数,用于表示溢出和出错。正无穷大通过 Double 或 Float 类的 POSITIVE_INFINITY 表示;负无穷大通过 Double 或 Float 类的 NEGATIVE_INFINITY 表示;非数通过 NaN 表示。所有正无穷大的数都是相等的,所有负无穷大的数也是相等的,而非数不与任何数值相等,甚至和非数本身都不相等。

  当程序中用到的数值位数特别多地时候,可以在数值中使用下画线,不管是整型数值,还是浮点型数值,都可以自由地使用下画线:

double pi = 3.14_15_92_65_36;

(四)布尔型

  布尔型只有一个 boolean 类型,用于表示逻辑上的 “真” 或 “假”,数值只能是 true 或 false,不能用 0 或者 非 0 来代表。boolean 类型的值或者变量主要用于流程控制。

基本类型转换

(一)自动类型转换

  系统支持把某种基本类型的值直接赋给另一种基本类型的变量,这种方式被称为自动类型转换。当把一个 表数范围小的数值或变量直接赋给另一个表数范围大的变量时 ,系统将可以进行自动类型转换:

  上图中左边的数值类型可以自动转换为右边的数值类型。不仅如此,当把任何基本类型的值和字符串值进行连接运算的时候,基本类型的值将自动转换为字符串类型:

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        String str = "Hello";
        System.out.println( a + b + str); // 30Hello
        System.out.println(str + a + b); // Hello1020
    }
}

(二)强制类型转换

  强制类型转换的语法格式是:(targetType)value,当进行强制类型转换的时候,可能造成精度降低或溢出:

public class Test {
    public static void main(String[] args) {
        int iValue = 233;
        byte bValue = (byte)iValue;
        System.out.println(bValue); // -23
    }
}

  通常字符串不能直接转换为基本类型,但可以通过基本类型对应的包装类把字符串转换为基本类型:

public class Test {
    public static void main(String[] args) {
        String a = "45";
        int aValue = Integer.parseInt(a);
        System.out.println(aValue);
    }
}

  Java 为 8 种基本类型都提供了对应的包装类:

数据类型包装类
booleanBoolean
byteByte
shortShort
intInteger
longLong
charCharacter
floatFloat
doubleDouble

  Java 为这 8 个包装类都提供了 parseXxx(String str) 的静态方法用于将字符串转换为基本类型。

(三)表达式类型的自动提升

  当一个算术表达式中包含多个基本类型的值时,整个算术表达式的数据类型将发生自动提升,Java 定义的自动提升规则如下:

  • 所有的 byte、short、char 类型将被提升到 int 类型
  • 整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型
public class Test {
    public static void main(String[] args) {
        short sValue = 5;
        // 编译错误,因为算术表达式被提升到int型,将
        // int型赋值给short型报错
        sValue = sValue + 5;
    }
}
运算符

  Java 使用运算符将一个或多个操作数连缀成执行语句。

(一)算术运算符

  Java 没有提供其它复杂的运算符,如果需要完成乘方、开方等运算,可借助 java.lang.Math 类的工具方法完成复杂的数学运算。

(二)赋值运算符

  赋值运算符(=)用于为变量指定变量值:

public class Test {
    public static void main(String[] args) {
        short sValue = 5;
    }
}

(三)位运算符

  位运算符是直接对整数的二进制进行的运算,关于位运算符需要注意的细节如下:

  进行位运算的时候还要遵循如下规则:

  • 对于低于 int 类型的操作数总是先自动转换为 int 类型后再移位
  • 对于 int 型的整数移位 a >> b,当 b > 32 的时候,系统先用 b 对 32 求余(因为 int 类型只有 32 位),得到的结果才是真正移位的位数
  • 对于 long 类型的整数移位 a >> b,当 b > 64 的时候,总是先用 b 对 64 求余,得到的结果才是真正移位的位数

  赋值运算符可与算术运算符、位移运算符结合,扩展成功能更强大的运算符,如:x += y => x = x + y。只要能使用这种扩展后的赋值运算符,通常都推荐使用它们,因为这种运算符不仅具有更好的性能,而且程序会更加健壮。

(四)比较运算符

  比较运算符用于判断两个变量或常量的大小,比较运算的结果是一个布尔值:

(五)逻辑运算符

  逻辑运算符用于操作两个布尔型的变量或常量:

运算符说明
&&与,前后两个操作数必须都是true才返回true,否则返回false
&不短路与,作用与&&相同,但不会短路
||或,只要两个操作数中有一个是true,就可以返回true,否则返回false
|不短路或,作用与||相同,但不会短路
!非,只需要一个操作数,如果操作数为true,则返回false;否则返回true
^异或,当两个操作数不同时才返回true,如果两个操作数相同则返回false
public class Test {
    public static void main(String[] args) {
        int a = 10;
        // 因为 || 是短路或,所以判断到true以后,
        // 后面的表达式 a++ > 10 不会执行,此时a依然是10
        if (true || a++ > 10) {}
        System.out.println(a);  // 10
        // 因为 | 是非短路或,所以判断到true以后,
        // 后面的表达式 a++ > 10 还会执行,此时a依然是11
        if (true | a++ > 10){}
        System.out.println(a);  // 11
    }
}

(六)三目运算符

  三目运算符的语法格式如下:

(expression) ? if-true-statement : if-false-statement;

  先对逻辑表达式 expression 求值,如果逻辑表达式返回 true,则返回第二个操作数的值;如果逻辑表达式返回 false,则返回第三个操作数的值:

public class Test {
    public static void main(String[] args) {
        System.out.println(10 > 5 ? 10 : 5);
    }
}

(七)运算符的优先级

  运算符有不同的优先级,优先级就是表达式运算中的运算顺序:

流程控制

  流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。流程控制方式采用结构化程序设计中规定的三种基本流程结构:

  • 顺序结构:程序从上到下逐行地执行,中间没有任何判断和跳转
  • 分支结构:根据条件选择性地执行某段代码
  • 循环结构:根据循环条件重复性地执行某段代码
分支结构

  Java 提供了两种常见的分支控制结构:if 语句和 switch 语句。

(一)if 条件语句

  if 语句使用布尔表达式或布尔值作为分支条件来进行分支控制,有如下三种形式:

// 形式一
if (logic expression) {
    statement...
}

// 形式二
if (logic expression) {
	statement...
} else {
    statement...
}

// 形式三
if (logic expression) {
	statement...
} else if (logic expression) {
    statement...
} 
... // 可以有零个或者多个 else if 语句
else {
    statement...
}

  关于 if 条件语句的使用说明:

  • 条件表达式必须是布尔表达式(关系表达式或逻辑表达式)、布尔变量
  • 语句块只有一条执行语句时,一对 {} 可以省略,但是建议保留
  • 可以根据需要嵌套使用
  • 当多个条件是 “互斥” 关系的时候,条件判断语句及执行语句间顺序无所谓;当多个条件是 “包含” 关系的时候,需要遵循 “小上大下 / 子上父下”
public class Test {
    public static void main(String[] args) {
       int age = 45;
       if (age > 60) {
           System.out.println("老年人");
       } else if (age > 40) {
           System.out.println("中年人");
       } else if (age > 20) {
           System.out.println("青年人");
       }
    }
}

(二)switch 分支语句

  switch 语句由 一个控制表达式和多个 case 标签 组成,switch 语句后面的控制表达式的数据类型只能是 byte、short、char、int 四种整数类型,枚举类型和 java.lang.String 类型。switch 语句往往需要在 case 标签后紧跟一个代码块,case 标签作为这个代码块的标识。其语法格式如下:

switch (expression)
{
    case condition1: {
        statement(s);
        break;
    }
    case condition2: {
        statement(s);
        break;
    }
        ...
    case conditionN: {
        statement(s);
        break;
    }
    default: {
        statement(s)
    }
}

  Java 允许 case 语句后面没有 break 语句,此时 switch 语句会先求出 expression 表达式的值,然后拿这个表达式和 case 标签后的值进行比较,一旦遇到相等的值,程序就开始执行这个 case 标签后的代码,不再判断与后面的 case、default 标签的条件是否匹配,除非遇到 break。

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int score = Integer.parseInt(sc.nextLine());
       String degree = "";
       switch (score / 10) {
           case 10:
           case 9: degree = "A"; break;
           case 8:
           case 7: degree = "B"; break;
           case 6: degree = "C"; break;
           default:degree = "D";
       }

       System.out.println("考试成绩为:" + score + " - 等级为:" + degree);
    }
}

  Java7 虽然增强了 switch 语句的功能,允许 switch 语句的控制表达式是 String 类型的变量或表达式,但不能是 StringBuffer 或 StringBuilder 这两种字符串类型。

循环结构

  循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为 循环体。

(一)while循环语句

  while 循环的语法格式如下:

[init_statement]
while (test_expression)
{
    statement;
    [iteration_statement]
}

  while 循环每次执行循环体之前,先对 test_expression 循环条件求值,如果循环条件为 true,则运行循环体部分。使用 while 循环的时候,一定要保证循环条件有变成 false 的时候,否则这个循环将成为一个死循环,永远无法结束这个循环。

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        int number = 1;
        while (number <= 10) {
            sum += number++;
        }
        System.out.println("sum = " + sum);
    }
}

(二)do while循环语句

  do while 循环与 while 循环的区别在于 while 循环是先判断循环条件,如果条件为真则执行循环体;而 do while 循环则是先执行循环体,然后才判断循环条件,其语法格式如下:

[init_statement]
do {
    statement;
    [iteration_statement]
} while (test_expression);

  与 while 循环不同的是,do while 循环的循环条件后必须有一个分号。

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        int number = 1;
        do {
            sum += number++;
        } while (number <= 10);
        System.out.println("sum = " + sum);
    }
}

(三)for循环语句

  for 循环时更加简洁的循环语句,基本语法格式如下:

for ([init_statement]; [test_expression]; [iteration_statement]) {
    statement
}

  程序在执行 for 循环时,先执行循环的初始化语句 init_statement,初始化语句只在循环开始前执行一次。每次执行循环体之前,先计算 test_expression 循环条件的值,如果循环条件返回 true,则执行循环体,循环体执行结束后执行循环迭代语句。

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 0; i <= 10; i++) {
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}

  for 循环中的初始化语句、循环条件、迭代语句部分都是可以省略的:

public class Test {
    public static void main(String[] args) {
        int sum = 0;
        int i = 0;
        for (; i <= 10 ; ) {
            sum += i;
            i++;
        }
        System.out.println("sum = " + sum);
    }
}

(四)嵌套循环

  循环时可以嵌套使用的:

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + "*" + j + "=" + i * j + "tt");
            }
            System.out.println();
        }
    }
}
控制循环结构

(一)break 结束循环

  有些时候需要在某种条件出现时强行终止循环,而不是等到循环条件为 false 时才退出循环。可以使用 break 来实现这个功能,break 用于完全结束一个循环:

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

  break 不仅可以结束其所在的循环,还可以直接结束其外层循环。这时候需要在 break 后紧跟一个标签,这个标签用于标识一个外层循环:

public class Test {
    public static void main(String[] args) {
        outer:
        for (int i = 1; i < 10; i++) {
           for (int j = 1; j < 10; j++) {
               System.out.println("i = " + i + ", j = " + j);
               if ( j % 2 == 0) {
                    break outer;
               }
           }
        }
    }
}

(二)continue 结束本次循环

  continue 的功能和 break 有点类似,区别是 continue 只是忽略本次循环剩下的语句,接着开始下一次循环,并不是终止循环:

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

  continue 后面也可以紧跟一个标签,用于直接跳过标签所标识循环的当次循环的剩下语句:

public class Test {
    public static void main(String[] args) {
        outer:
        for (int i = 1; i < 10; i++) {
           for (int j = 1; j < 10; j++) {
               System.out.println("i = " + i + ", j = " + j);
               if ( j % 2 == 0) {
                    continue outer;
               }
           }
        }
    }
}

(三)return 语句结束方法

  return 关键字并不是专门用于结束循环的,return 的功能是结束一个方法。

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
           for (int j = 1; j < 10; j++) {
               System.out.println("i = " + i + ", j = " + j);
               if ( j % 2 == 0) {
                    return;
               }
           }
        }
    }
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939546.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号