第二章 Java语言基础

已于 2024-04-16 16:52:14 修改
阅读量339 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： java 开发语言
于 2022-11-07 22:14:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53222084/article/details/127740589
版权

文章目录

2.1 标识符和关键字、保留字

2.1.1 标识符

  • 定义：程序员自己规定的具有特定含义的字符序列。java语言中标识符即类、接口、变量、方法、包的名字。

  • 命名规则：由数字、字母、下划线、和“$"组成。不能为关键字、保留字，区分大小写。首字符不能为数字。

  • java对标识符命名时通常遵循如下规定(命名规范)。

    类型规则
    类和接口名通常是名词，每个词的首字母大写，其余小写。如HelloWorld,MyClass。（驼峰式命名）
    常量名基本数据类型的常量类型的常量使用全部大写字母，词与词之间用_分隔。如STUDENT_NUM。
    方法名通常是动词，首字母小写，其余词首字母大写，尽量少用_。如setTime。（小驼峰式命名）
    变量名首字母小写，其余词首字母大写，不用_，少用"$"。给变量命名尽量做到见名知意。如minSalary。（小驼峰式命名）

  • 字符 Java字符采用Unicode字符集的编码方案，每个字符占内存空间16位，因此有216(65536)个字符，字符编码最大值65535。字母和汉字都占俩个字节。占内存16位。

2.1.2 关键字

  • 定义：被Java语言赋予特定含义的单词，不能作为标识符使用。
  • 关键字的字母全部小写。
  • 常见的代码编辑器针对关键字有特殊颜色标记。
  • 在这里插入图片描述

2.1.3 保留字

  • 定义：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留

    字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const 。

2.2 基本数据类型与变量、常量

2.2.1 基本数据类型

  • bit：计算机中最小的存储单位。byte：计算机中的基本存储单位，1字节(byte) = 8 bit。
数据类型常见、[]表示所占字节数
基本数据类型（数值型）整数(byte[1]、short[2]、int[4]、long[8]) 浮点数(float[4]、double[8])
基本数据类型（非数值型）布尔(boolean)[1]、字符(char)[2]
引用数据类型类(class) 接口(interface) 数组([])
  • 在Java中，所有的数值类型所占据的字节数量与平台无关,以保证java的可移植性。

2.2.1.1 整型与浮点类型

  • 使用细节：

    1. Java的整形常量有固定的范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。
    2. 整数的默认类型是int，小数的默认类型是double。
    3. long类型的变量定义时防止整数过大后面要加L，float类型的变量定义时为了防止类型不兼容后面要加F。
    4. 关于浮点数在机器中存放形式的简单说明,浮点数 = 符号位 + 指数位 + 尾数位。
    5. 尾数部分可能丢失，造成精度损失(小数都是近似值)。
    6. 科学计数法：5.12e2 等价于 512.0 5.12E-2 等价于 0.0512.
    7. 当我们对运算结果是小数的进行相等判断时，应该是以俩个数的差值绝对值，在某个精度范围内判断。
    public class variable {
    public static void main(String[] args) {
        double a = 2.7;
        double b = 8.1/3;
        System.out.println(a);
        System.out.println(b);
        if(a == b)
            System.out.println("a=b");
        else
            System.out.println("两个数不相等");
    }
}
/* 
2.7
2.6999999999999997
两个数不相等
*/
2.2.1.2 字符型与布尔型

  • 使用细节：

    1. 在java中，char的本质是一个整数，所以char类型是可以进行运算的，在输出时，是unicode码对应的字符。其中，‘A’=65 A到Z连续 ‘a’=97 a到z连续 ‘0’=48 0到9连续。

    2. 布尔类型也叫Boolean类型，取值只允许true、false，无null。

    3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转。

      char c1 = 'a';
char c2 = 'a' + 'b';
System.out.println(c1); //a
System.out.println((int) c1); //97
System.out.println(c2); //Ã
System.out.println((int) c2); //195
char c3 = 97;
System.out.println(c3); //a
System.out.println((int)c3); //97

int m = 100;
char c4 = m; //false
char c5 = (char)m  //d

2.2.2 常量

  • 定义：常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。

  • 声明：Java中必须用final关键字声明符号常量，其声明格式为final 数据类型 常量名 = 缺省值; 如final int STUDENT_NUM = 10;

    final表示这个常量只能被赋值一次，一但赋值后就不能再更改。

  • 命名规则：基本数据类型的常量类型的常量使用全部大写字母，词与词之间用_分隔。如STUDENT_NUM。

  • 常量有三种类型：

    1. 静态常量：希望某个常量可以在一个类中的多个方法中使用，可以使用关键字static final设置一个类常量，类常量的定义在main方法的外部。不需要创建对象就可以访问它，在类外部访问形式为 Constants.CM_PER_INCH 。这种常量在编程中使用很多。

    2. 成员常量：作用域类似于成员变量，但不能修改。

    3. 局部常量：作用域类似于局部变量，但不能修改。

      public class Constants {
	public static final double CM_PER_INCH = 2.54; //静态常量
    final int AA = 10; //成员常量
	public static void main(String[] args) {
        final int BB = 20; //局部常量
		double paperWidth = 8.5;
		double paperHeight = 11;
		System.out.println("Paper size in centimeters: " + paperWidth * CMJERJNCH + by " + paperHeight * CM_PER_INCH) ; 
	} 
}

2.2.3 变量

  • 定义：在程序运行中其值可以发生改变的量，从本质上讲变量是内存中的一小块区域，不同的变量，类型不同，占用的空间大小不同。

  • 命名规则：首字母小写，其余词首字母大写，不用_，少用"$"。给变量命名尽量做到见名知意。如minSalary。（小驼峰式命名）

  • 变量使用的注意事项：

    • 变量在同一个作用域内不能重名。

    • 变量未赋值不能使用，即变量必须先声明，后使用。

    • long类型的变量定义时防止整数过大后面要加L，float类型的变量定义时为了防止类型不兼容后面要加F。

    • 逐一声明每一个变量可以提高程序的可读性。

    • 在 Java 中， 变量的声明尽可能地靠近变量第一次使用的地方， 这是一种良好的程序编写风格。

  • 变量的分类：

    1. 局部变量（在类方法中定义的变量）

    ​ 属于方法，在方法栈中分配空间，分配后没有初始值，即不会自动初始化，必须在使用之前显示初始化。

    1. 成员变量（全局变量）（在类中定义的变量）

    ​ 属于对象或类，在堆中分配空间，分配空间后具有默认初始值，即自动初始化。

2.3 运算符

2.3.1 算术运算符

  • 加+ 减- 乘* 除/ 取余%

  • 取余的本质 a % b = a - (a / b) * b

  • System.out.println(10 / 4); //2
System.out.println(10 / 4.0); //2.
System.out.println(10 % 4); //2
System.out.println(10 % 4.0); //2.0

int l = 1;
l = l++; //temp=i l=l+1 l=temp l=1
System.out.println(l); //1

int b = 1;
b = ++b; //b=b+1 temp=b b=temp 
System.out.println(b); //2

  • 在默认情况下， 虚拟机设计者允许对中间计算结果采用扩展的精度。

    但是， 对于使用 strictfj 关键字标记的方法必须使用严格的浮点计算来生成可再生的结果。

  1. 字符的+操作

​ 拓展的+= 隐含了强制类型转换。
​ 算术表达式中包含多个基本数据类型的值时，整个算术表达式的类型会自动提升。

  • byte、short、char都会被提升到int型。

  • 整个表达式的类型会自动升级到表达式中最高等级操作数相同的类型。

  • byte、short、char——int——long——float——double

  1. 字符串的+操作

    +左右有一边出现字符串，则其功能为字符串的连接运算。

2.3.2 关系运算符(比较运算符)

  • 定义：关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false 。

    ​ 关系表达式 经常用在 if 结构的条件中或循环结构的条件中。

  • 常见：

    运算符运算范例结果
    ==相等于1==2false
    ！=不等于1!=2true
    <小于1<2true
    >大于1>2false
    <=小于等于1<=2true
    >=大于等于1>=2false
    instanceof测试 左边的对象 是否是 右边的类 的实例“irving” instanceof Stringtrue
  • int a = 9;
int b = 8;
System.out.println(a > b); //T
System.out.println(a < b); //F
System.out.println(a >= b); //T
System.out.println(a == b); //F
System.out.println(a != b); //T
System.out.println("irving" instanceof String); //T

2.3.3 逻辑运算符

  • 定义：用于连接多个条件（多个关系表达式），最终的结果也是一个 boolean 值。
  • 常见：
逻辑运算符号作用说明
&逻辑与a&b 一假则假
|逻辑或a|b一真则真
^逻辑异或a^b ab真假性不同才为true
!逻辑非!a 真假性与a相反
&&短路与一假则假、左假则停
||短路或一真则真、左真则停
  • int a = 10;
int b = 20;

// 逻辑与
boolean flag = a > 100 & ++b < 20;
System.out.println(flag); //F
System.out.println(b); //21

// 短路与
boolean flag = a > 100 && ++b < 20;
System.out.println(flag); //F
System.out.println(b); //20

// 逻辑或
boolean flag = a > 5 | ++b < 20;
System.out.println(flag); //T
System.out.println(b); //21

// 短路或
boolean flag = a > 5 || ++b < 20;
System.out.println(flag); //T
System.out.println(b); //20

// 非与异或
boolean flag1 = true;
boolean flag2 = false;
boolean flag3 = true;
System.out.println(flag1);  //T
System.out.println(flag2);  //F
System.out.println(!flag1);  // F
System.out.println(!flag2); // T
System.out.println(flag1 ^ flag2); //T
System.out.println(flag1 ^ flag3); //F

2.3.4 三元运算符

  • 格式：关系表达式? 表达式1 : 表达式2

  • 范例：a>b? a : b true执行a false执行b

  • int a = 10;
int b = 20;
int result = a > b ? a++ : b--;
System.out.println(result); //20
System.out.println(a); //10
System.out.println(b); //19

int c = 10;
int d = 20;
int resultTwo = c < d ? c++ : d--;
System.out.println(resultTwo); //10
System.out.println(c); //11
System.out.println(d); //20

// 找出三个数中的最大数
int n1 = 10;
int n2 = 20;
int n3 = 30;
int max1 = n1 > n2 ? n1 : n2;
int max2 = max1 > n3 ? max1 : n3;
System.out.println("result is " + max2);

  • 使用细节：

    1. 表达式 1 和表达式 2 要为可以赋给接收变量的类型(或可以自动转换）。

    2. 三元运算符可以转成 if–else 语句。

2.4 表达式的类型转换

2.4.1 自动类型转换

  • 定义：在java程序进行赋值或者运算时，把一个数值范围小的数值或变量赋值给数据范围大的变量。

  • 规则：

    char–int–long–float–double

    byte–short–int–long–float–double

  • 使用细节：

    1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据，然后进行计算,自然，表达式的结果的类型自动提升为操作数中最大的类型。

    2. 当我们把精度(容量)大的数据类型赋值给精度(容量)小的数据类型时，就会报错，反之就会进行自动类型转换。

    3. (byte、short)和char之间不会相互自动转换。

    4. byte、short、char他们三者可以计算，在计算时首先转换为int类型。

    5. boolean不参与转换。

      byte b1 = 1;
byte b2 = 2;
int b3 = b1 + b2;
System.out.println(b3); //3
System.out.println(2.12e2 + "," + 2.12e-2); //212.0,0.0212

2.4.2 强制类型转换

  • 定义：把一个数值范围大的数值或变量赋值给数据范围小的变量。由多储存字节到少储存字节的转换会丢失一些信息。

  • 使用细节：

    1. 7种数值型可以混合运算，布尔型不能与7种数值型混合运算。

    2. char类型可以保存int的常量值，但不能保存int的变量值，需要强转。

      char c1 = 100; //true
int m = 100 // true 
char c2 = m // false
char c3 = (char)m  //true
System.out.println(c3) //100对应的字符

    3. byte、short、char在进行运算时，当做int类型处理。

2.4.3 基本数据类型和String类型转换

2.4.3.1 基本类型转为String类型

  1. 将基本类型后加” “即可。

    int n1 = 100;
float n2 = 1.1f;
double n3 = 1.3;
boolean n4 = true;
String str1 = n1 + "";
String str2 = n2 + "";
String str3 = n3 + "";
String str4 = n4 + "";
System.out.println(str1); //100
System.out.println(str2); //1.1
System.out.println(str3); //1.3
System.out.println(str4); //true
2.4.3.2 String类型转为基本数据类型
String str5 = "123";
byte num1 = Byte.parseByte(str5);
short num2 = Short.parseShort(str5);
int num3 = Integer.parseInt(str5);
long num4 = Long.parseLong(str5);
float num5 = Float.parseFloat(str5);
double num6 = Double.parseDouble(str5);
boolean b4 = Boolean.parseBoolean("true");
System.out.println(num1); //123
System.out.println(num2); //123
System.out.println(num3); //123
System.out.println(num4); //123
System.out.println(num5); //123.0
System.out.println(num6); //123.0
System.out.println(b4); //true

  • 注意事项：

    在将 String 类型转成 基本数据类型时， 要确保String类型能够转成有效的数据，比如我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数。

2.5 键盘输入

  • 定义：在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。Input.java , 需要一个 扫描器(对象), 就是Scanner 。

  • 示例：

    Scanner sc = new Scanner(System.in);
System.out.println("请输入球员年龄："); //请输入球员年龄：
int age = sc.nextInt();  // 20

System.out.println("请输入球员薪水："); //请输入球员薪水：
double salary = sc.nextDouble(); //100.56

System.out.println("请输入球员能力值："); //请输入球员能力值
int ability = sc.nextInt(); //91

System.out.println("球员年龄:" + age + " 球员薪水:" + salary + " 球员能力值:" + ability); //球员年龄:20 球员薪水:100.56 球员能力值:91

  • next() 与 nextLine() 区别：

    • next()：

      1. 一定要读取到有效字符后才可以结束输入。

      2. 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

      3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

      4. next() 不能得到带有空格的字符串。

      在这里插入图片描述

    • nextLine()：

      1. 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。

      2. 可以获得空白。

      在这里插入图片描述

2.5.1 输入单个字符

  • // 输入单个字母
Scanner sc = new Scanner(System.in);
System.out.println("请输入："); //请输入：
char c = sc.next().charAt(0); //afsdfdsfsd
System.out.println("首字母是:" + c); //首字母是:a

2.5.2 循环输入

  • double sum = 0;
double average;
int t = 0;
System.out.print("请输入整数：");
while (sc.hasNextInt()) {
	int a = sc.nextInt();
	sum += a;
	t++;
	average = sum / t;
	System.out.println("当前已输入：" + t + "次" + "," + " 总数是：" + sum + " 平均数是：" + average);
    System.out.print("请输入整数：");
}
sc.close();
System.out.println("你输入的不是整数，程序结束");

2.5.3 Random

  • 作用：Random 类提供的所有方法生成的随机数字都是均匀分布的，也就是说区间内部的数字生成的概率是均等的，在表 1 中列出了 Random 类中常用的方法。

  • 方法说明
    boolean nextBoolean()生成一个随机的 boolean 值，生成 true 和 false 的值概率相等
    double nextDouble()生成一个随机的 double 值，数值介于 [0,1.0)，含 0 而不包含 1.0
    int nextlnt()生成一个随机的 int 值，该值介于 int 的区间，也就是 -231~231-1。如果需要生成指定区间的 int 值，则需要进行一定的数学变换
    int nextlnt(int n)生成一个随机的 int 值，该值介于 [0,n)，包含 0 而不包含 n。如果想生成指定区间的 int 值，也需要进行一定的数学变换
    void setSeed(long seed)重新设置 Random 对象中的种子数。设置完种子数以后的 Random 对象和相同种子数使用 new 关键字创建出的 Random 对象相同
    long nextLong()返回一个随机长整型数字
    boolean nextBoolean()返回一个随机布尔型值
    float nextFloat()返回一个随机浮点型数字
    double nextDouble()返回一个随机双精度值

  • 使用步骤

    1. 导包 import java.util.Random
    2. 创建对象 Random r = new Random ();
    3. 获取随机数 int number = r.nextInt(10);获取数据范围[0,10)的数,前闭后开。

2.6 字符串（String）

  • 定义：字符串就是Unicode字符序列。
  • 不论使用哪种形式创建字符串，字符串对象一旦被创建，其值是不能改变的，但可以使用其他变量重新赋值的方式进行更改。

2.6.1 字串

  • 定义：String类的substring方法可以从一个较大的字符串中提取出一个字串。

  • // 字串
String s1 = "hello";
String s2 = s1.substring(0,3); //前闭后开
System.out.println(s2); //“hel”

2.6.2 拼接

  • 定义：与绝大多数的程序设计语言一样，Java语言允许使用 + 号连接（拼接）两个字符串。

  • String s3 = "hello";
String s4 = "kyrie";
String s5 = s3 + " " + s4;
System.out.println(s5); //"hello kyrie"

2.6.3 不可变字符串

  • 定义：String 类没有提供用于修改字符串的方法，如果想要修改字符串， 只能通过字串的方法提取，然后再拼接上替换的字符串。

  • // 不可变字符串
String s6 = "hello";
String s7 = s6.substring(0,3) + "p";
System.out.println(s7); //"help"

  • 优点：编译器可以让字符串共享，可以想象各种字符串存放在公共的存储池中。字符串变量指向存储池中相应的位置，如果复制一个字符串变量，原始字符串与复制的字符串共享相同的字符。总而言之，java的设计者任务共享带来的高效率远胜过提取、拼接字符串带来的低效率。

2.6.4 检测字符串是否相等

  • 定义：可以使用 equals 方法检测两个字符串是否相等。

  • // 不可变字符串
String s8 = "hello";
String s9 = "kyrie";
String s10 = "hello";
System.out.println(s8.equals(s9)); //false
System.out.println(s8 == s9); //false
System.out.println(s8.equals(s10)); //true
System.out.println(s8 == s10); //true

  • 细节：一定不要使用==运算符检测两个字符串是否相等！ 这个运算符只能够确定两个字串是否放置在同一个位置上。当然， 如果字符串放置在同一个位置上， 它们必然相等。但是，完全有可能将内容相同的多个字符串的拷贝放置在不同的位置上。

2.6.5 空串和Null串

  1. 空串定义：空串 “” 是长度为 0 的字符串，空串是一个 Java 对象， 有自己的串长度（ 0 ) 和内容（空）。

    • // 检测是否为空串
String s11 = "";
Boolean b1 = s11.length() == 0; //长度检测
Boolean b2 = s11.equals(""); //内容检测
System.out.println("s11 is 空串？：" + b1 ); //s11 is 空串？：true
System.out.println("s11 is 空串？：" + b2 ); //s11 is 空串？：true

  2. Null串定义：String 变量还可以存放一个特殊的值， 名为 null, 这表示目前没有任何对象与该变量关联。

    • // 检测是否为Null串    
String s12 = null;
Boolean b3 = s12 == null; //== 检测
System.out.println("s12 is null? ：" + b3); //s12 is null? : true
System.out.println(s12.equals(null)); //报错

2.6.6 码点与代码单元

  • 定义：Java 字符串由 char 值序列组成。

  • 常见方法：

    1. str.length() 方法将返回采用 UTF-16 编码表示的给定字符串所需要的代码单元数量。

      String s13 = "hello kyrie";
System.out.println("字符串长度是：" + s13.length()); //11

    2. str.codePointCount(0, greeting.length)，得到码点数量，即实际长度。

      String s13 = "hello kyrie";
System.out.println("码点数量是：" + s13.codePointCount(0,s13.length())); //11

    3. str.charAt(n) 将返回位置 n 的代码单元，n 介于 0 ~ str.length()-1之间。

      String s13 = "hello kyrie";
System.out.println("第一个字母是：" + s13.charAt(0)); //h
System.out.println("最后一个字母是：" + s13.charAt(s13.length() - 1)); //e

    4. 遍历字符串

      for (int i = 0;i < s13.length();i++) {
	System.out.println(s13.charAt(i));
}

2.6.7 String API

2.6.8 构建字符串

  • 定义：有些时候， 需要由较短的字符串构建字符串,采用字符串连接的方式达到此目的效率比较低。每次连接字符串， 都会构建一个新的 String 对象，既耗时， 又浪费空间。使用 StringBuildei类就可以避免这个问题的发生。

  • StringBuilder builder = new StringBuilder();
// 当每次需要添加一部分内容时， 就调用 append 方法。
builder.append("hello");
builder.append(' ');
builder.append("kyrie");
String completedString = builder.toString();
System.out.println(completedString); //hello kyrie

2.7 进制(程序员的基本功)

  • 定义：对于整数，有四种表示方式：

    二进制：0,1 ，满 2 进 1.以 0b 或 0B 开头。

    十进制：0-9 ，满 10 进 1。

    八进制：0-7 ，满 8 进 1. 以数字 0 开头表示。

    十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

  • // 1.输出示例
//n1 二进制
int n1 = 0b1010;
// n2 10 进制
int n2 = 1010;
// n3 8 进制
int n3 = 01010;
// n4 16 进制
int n4 = 0X10101;
System.out.println("n1=" + n1); //n1=10
System.out.println("n2=" + n2); //n2=1010
System.out.println("n3=" + n3); //n3=520
System.out.println("n4=" + n4); //n4=65793
System.out.println(0x23A); //570

2.7.1 进制转换

2.7.1.1 二、八、十六进制转换为十进制

  • 规则：从最低位(右边)开始，将每个位上的数提取出来，乘以2、8、16的（位数-1）次方，然后求和。

  • // 2.二、八、十六进制转换为十进制
System.out.println(0b110001100); //396
System.out.println(02456); //1326
System.out.println(0xA45); //2629
2.7.1.2 十进制转换为二、八、十六进制

  • 规则：将该数不断除以 2、8、16，直到商为 0 为止，然后将每步得到的余数倒过来，就是对应的二、八、十六进制。

  • // 3.十进制转换为二、八、十六进制
System.out.println("123转换为二进制为：0b01111011");
System.out.println("678转换为八进制为：01246");
System.out.println("8912转换为十六进制为：0X22D0");
2.7.1.3 二进制转换为八进制、十六进制

  • 规则：从低位开始,将二进制数每（3、4）位一组，转成对应的八、十六进制数即可。

  • // 4.二进制转换为八进制、十六进制
System.out.println("0b11 100 101转换位八进制为：0345");
System.out.println("0b11 1001 0110转换为十六进制为：0x396");
2.7.1.4 八进制、十六进制转换为二进制

  • 规则：：将八、十六进制数每 1 位，转成对应的一个 3 、4位的二进制数即可。

  • // 5. 八进制、十六进制转换为二进制
System.out.println("01230转换为二进制为：001 010 011 000");
System.out.println("0xAB29转换为二进制为：1010 1011 0010 1001");

2.7.2 位运算

  • 相关内容：
    1. 二进制是奉2进位的进位制，0、1是基本算符。
    2. 现代的电子计算机技术全部采用的是二进制，因为它只使用0、1俩个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制(Binary)数用0和1两个数字及其组合来表示任何数。进位规则是“逢2进1”，数字在不同的位上代表不同的值，按从右至左的次数，这个值以二倍递增。
2.7.2.1 原码、反码、补码
  1. 二进制的最高位是符号位：0表示正数、1表示负数。
  2. 正数的原码、反码、补码都一样（三码合一）。
  3. 负数的反码=它的原码符号位不变，其他位取反（0 -> 1,1 -> 0 ）
  4. 负数的补码=它的反码+1。
  5. 0的反码，补码都是0。
  6. java没有无符号数，换言之，java中的数都是有符号的。
  7. 在计算机运算时，都是以补码的方式来运算的。
  8. 当我们看运算结果的时候。要看它的源码。
2.7.2.2 位运算符

  • java中有7个位运算符，如下

    符号作用
    按位与 &两位全为1，结果为1，否则为0
    按位或 |两位有一个为1，结果为1，否则为0
    按位异或 ^两位有一个为0，一个为1，结果为1，否则为0
    按位取反 ~0 ->1，1->0
    算术右移 >>低位溢出，符号位不变，并用符号位补溢出的高位
    算术左移 <<符号位不变，低位补0
    逻辑右移 >>>逻辑右移也叫无符号右移，运算规则是：低位溢出，高位补0

  • 示例

    System.out.println(2&3); //2
System.out.println(~-2); //1
System.out.println(~2); //-3
System.out.println(2|3); //3
System.out.println(2^3); //1

System.out.println(1 >> 2); //0
System.out.println(1 << 2); //4 
System.out.println(4 << 3); //32
System.out.println(15 >> 2); //3
    • 特别说明，没有<<<符号。

2.8 流程控制

2.8.1 顺序结构

  • 定义：顺序结构是程序中最简单、最基本的结构。没有特定的语法结构，按照代码的先后顺序依次执行。程序中大多数代码都是这样执行。

  • public class Test {
    int n1 = 1;
    int n2 = n1 + 1 ; //right
   
    int n2 = n1 + 1
    int n1 = 1 //false    
}

2.8.2 分支结构(if else,switch case)

2.8.2.1 if else

  • 定义：Java 中的条件语句允许程序根据条件的不同执行不同的代码块。

  • 练习：

    1. // if分支控制 练习1
boolean b1 = true;
if (b1 == false) {
    System.out.println("a");
} else if (b1) {
    System.out.println("b");
} else if (!b1) {
    System.out.println("c");
} else {
    System.out.println("d");
} //b

boolean b2 = true;
if (b2 = false) {
    System.out.println("a");
} else if (b2) {
    System.out.println("b");
} else if (!b2) {
    System.out.println("c");
} else {
    System.out.println("d");
}  // c

    2. // if分支控制 练习2
Random r = new Random();
int number = r.nextInt(101);
while (true) {
    System.out.print("请输入你要猜的数字：");
    Scanner sc = new Scanner(System.in);
    int guessNumber = sc.nextInt();
    if (guessNumber > number) {
        System.out.println("你猜的数字偏大");
    } else if (guessNumber < number) {
        System.out.println("你猜的数字偏小");
    } else {
        System.out.println("终于猜中了随机数");
        break;
    }
}

    3. // if分支控制 练习3
Scanner sc = new Scanner(System.in);
System.out.print("请输入月份：");
int month = sc.nextInt();
if (month >= 4 && month <= 10) {
    System.out.print("请输入客户年龄：");
    int year = sc.nextInt();
    if (year >= 18) {
        System.out.println("成人衣服100元");
    } else {
        System.out.println("童装50元");
    }
} else if ((month >= 1 && month <= 3) || (month >= 11 && month <= 12)) {
    System.out.println("淡季通通10元");
} else {
    System.out.println("月份不对请重新输入月份...");
}
2.8.2.2 switch case

  • 定义：switch 语句是Java的多路分支语句。它提供了一种基于一个表达式的值来使程序执行不同部分的简单方法。因此，它提供了一个比一系列 if-else-if 语句更好的选择。

  • switch注意事项和细节讨论：

    1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型。

      // switch 分支控制练习1
Scanner sc = new Scanner(System.in);
System.out.print("请输入一个字符：");
char c = sc.next().charAt(0);
switch (c) {
	case 'a':
		System.out.println("星期一");
		break;
	case 'b':
		System.out.println("星期二");
		break;
	case 65:
		System.out.println("星期三");
		break;
	default:
		System.out.println("过年了...");
}
//输出示例
//请输入一个字符：A
//星期三

    2. switch(表达式)中表达式的返回值必须是：(byte,short,int,enum[枚举]，String)

      double c = 1.1;
switch(c) {
	case 1.1:  // 报错
    System.out.println("过年了...);
    break;
}

    3. case字句中的值必须是常量，而不能是变量。

    4. default字句是可选的，当没有匹配的case时，执行default。

    5. break语句用在执行完一个case分支后使程序跳出switch语句块，如果没有写break，程序会顺序执行到switch结尾，除非遇到break。（穿透现象）

  • 练习：

    1. // switch 分支控制练习2
Scanner sc = new Scanner(System.in);
System.out.print("请输入学生考试成绩：");
int grade = sc.nextInt();
if (grade < 0 || grade > 100) {
    System.out.println("输入的学生成绩有误，请重新输入成绩...");
} else {
    switch ((int) grade / 60) {
        case 1:
            System.out.println("学生成绩合格");
            break;
        case 2:
            System.out.println("学生成绩不合格");
            break;
        default:
            System.out.println("数据有误");
    }
}

    2. // switch 分支控制练习3
Scanner sc = new Scanner(System.in);
System.out.print("请输入月份：");
int month = sc.nextInt();
switch (month) {
    case 3:
    case 4:
    case 5:
        System.out.println("春季");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋季");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
    default:
        System.out.println("输入的数据有误");
}
2.8.2.3 if和switch比较
  1. 如果判断的具体数值不多，而且符合byte、short、int、char、enum[枚举]、String这六种类型。虽然俩个语句都可以使用，建议使用switch语句，switch 语句将比与之等效的 if-else 语句快得多。
  2. 其他情况，对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

2.8.3 循环结构(for,while,do…while)

2.8.3.1 for

  • 定义：for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。for 语句通常使用在知道循环次数的循环中。

  • 基本语法：

    for (循环变量初始化;循环条件;循环变量迭代) {
	循环操作(可以多条语句)；
}

// for死循环 
for(;;) {
    
}

  • 注意事项和细节说明：

    1. 循环条件是返回一个布尔值的表达式。

    2. for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。

    3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代 语句，中间用逗号隔开。

      // for循环练习1
int count = 3;
for (int i = 0, j = 0; i < count; i++, j += 2) {
    System.out.println("i = " + i + " j = " + j);
}
/* 输出结果
i = 0 j = 0
i = 1 j = 2
i = 2 j = 4 */

  • 练习：

    1. // for循环练习2 公鸡、母鸡、小鸡分别值5、3、1/3元。现在用100元买一百只鸡
for (int cock = 0; cock < 20; cock++) {
    for (int hen = 0; hen < 33; hen++) {
        int chicken = 100 - cock - hen;
        if ((double) 1 / 3 * chicken + 5 * cock + 3 * hen == 100) {
            System.out.println("公鸡有：" + cock);
            System.out.println("母鸡有：" + hen);
            System.out.println("小鸡有：" + chicken);
        }
    }
}

    2. // for循环练习3 水仙花数
int count = 0;
for (int i = 100; i <= 999; i++) {
    int a = i / 100;  // 百位
    int b = i / 10 % 10;  // 十位
    int c = i % 10;  // 个位
    if (Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3) == i) {
        System.out.println(i);
        count++;
    }
}
System.out.println("水仙花的个数是：" + count);
2.8.3.2 while

  • 定义：while 语句是 Java 最基本的循环语句，是一种先判断的循环结构，可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。

  • 基本语法：

    循环变量初始化;
while (循环条件) {
    循环体(语句);
    循环变量迭代;
}

// while 死循环
while(true) {
    
}

  • 练习：

    1. // while循环练习1
double paper = 0.1;
int height = 8844430;
int count = 0;
while (paper <= height) {
	paper *= 2;
	count++;
}
System.out.println("折叠的次数是：" + count);

    2. // while循环练习2
int i = 0;
while (i <= 100) {
	if (i % 17 == 0) {
		System.out.println(i);
	}
	i++;
}
2.8.3.3 do…while

  • 定义：do-while 循环语句也是 Java 中运用广泛的循环语句，它由循环条件和循环体组成，但它与 while 语句略有不同。do-while 循环语句的特点是先执行循环体，然后判断循环条件是否成立，因此do…while 循环至少会执行一次。

  • 基本语法：

    循环变量初始化;
do {
    循环体(语句);
    循环变量迭代;    
} while(循环条件);

  • 练习：

    1. Scanner sc = new Scanner(System.in);
char answer = ' ';
do {
    System.out.println("坤坤向你发起了篮球邀请");
    System.out.print("接受坤坤的篮球邀请吗？y/n：");
    answer = sc.next().charAt(0);
    System.out.println("你的回答是：" + answer);
} while (answer != 'y');

System.out.println("你干嘛啊，哎哟！");
2.8.3.4 多重循环控制

  • 介绍：

    1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环.【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
    2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环.

  • 练习：

    1. // 多重循环练习1 九九乘法表
for (int i = 0; i <= 9; i++) {
	for (int j = 1; j <= i; j++) {
		System.out.print(j + " * " + i + " = " + (j * i) + "\t");
	}
	System.out.println();
}

    2. // 多重循环练习2 空心金字塔
Scanner sc = new Scanner(System.in);
System.out.print("请输入要打印的空心金字塔的行数：");
int totalLevel = sc.nextInt();
for (int i = 1; i <= totalLevel; i++) { //i表示当前层数
    for (int j = 1; j <= totalLevel - i; j++) { //打印内容前的空格
        System.out.print(" ");
    }
    for (int j = 1; j <= 2 * i - 1; j++) { //打印内容
        if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
            System.out.print("*");
        } else {
            System.out.print(" ");
        }
    }
    System.out.println();
}

2.8.4 跳转控制语句(break,continue,return)

2.8.4.1 break

  • 定义：break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说提前结束当前的整个循环。一般用在switch或者循环(for,while,do…while)中。

  • 基本语法：

    {	
    ......
    break;
    ......
}

  • 注意事项：

    1. 用标签（label）可以指定一个代码块，标签可以是任何合法有效的 Java 标识符，后跟一个冒号。

    2. break语句可以出现在多层嵌套的语句块中，可以通过标签指明要终止的是那一层语句块。

    3. 如果没有指定break，默认退出最近的循环体。

    4. 在实际开发中，尽量不适用标签。

      // break练习1 
lable1:
for (int j = 0; j < 3; j++) {
    lable2:
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            break;
        }
        System.out.println("i = " + i);
    }
}
// 输出结果
i = 0
i = 1
i = 0
i = 1
i = 0
i = 1
    
lable3:
for (int j = 0; j < 3; j++) {
    lable4:
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            break lable3;
        }
        System.out.println("i = " + i);
    }
}
// 输出结果
// i = 0
// i = 1

  • 练习：

    1. // break练习2 
int i;
int sum = 0;
for (i = 0; i <= 100; i++) {
    sum += i;
    if (sum > 20) {
        System.out.println("当前的和是：" + sum + " 当前是第" + i + "次");
        break;
    }
}

    2. // break练习3 登录案例
Scanner sc = new Scanner(System.in);
int chance = 3;
String name = "";
String password = "";
for (int i = 0; i < 3; i++) {
    System.out.print("请输入账号名称：");
    name = sc.next();
    System.out.print("请输入密码：");
    password = sc.next();
    if ("kyrie".equals(name) && "666".equals(password)) {
        System.out.println("恭喜你登录成功！");
        break;
    }
    chance--;
    System.out.println("登录失败，您当前还有" + chance + "次机会。。。");

}
2.8.4.2 continue

  • 定义：continue 用在循环中，基于条件控制，跳过某次循环体的执行，继续下一次执行。

  • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用的规则一样。

  • 基本语法：

    {
    ......
    continue;
    ......
        
}

  • 练习：

    1. label1:
for (int j = 0; j < 2; j++) {
    label2:
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            continue;
        }
        System.out.println("i = " + i);
    }
}

// 输出结果
// 俩组 i = [0,9] 
    

label3:
for (int j = 0; j < 2; j++) {
    label4:
    for (int i = 0; i < 10; i++) {
        if (i == 2) {
            continue label3;
        }
        System.out.println("i = " + i);
    }
}
// 输出结果
// i = 0
// i = 1
// i = 0
// i = 1
2.8.4.3 return
  • 定义：使用在方法，表示跳出所在的方法。特别的，如果return写在main方法，表示退出程序。

2.9 方法（Method）

2.9.1 方法的概述

  • 方法是具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。
  • 方法必须先创建再使用，该过程称为方法的定义。
  • 方法创建后并不是直接运行的，需要手动调用后才执行，该过程称为方法的调用。

2.9.2 方法的注意事项

  • 方法不能嵌套定义。
  • void表示无返回值，可以省略return，也可以单独书写return后面不加东西。

2.9.3 方法重载

  • 在同一个类中定义的多个方法之间的关系，满足下列多个条件的方法相互构成重载。

  • 方法名称相同。

  • 方法参数个数不同，或参数类型不同。

  • 与返回值无关。

2.9.4 方法的参数传递

  • 基本数据类型：形式参数改变，不影响实际参数的值。
  • 引用数据类型：形式参数改变，影响实际参数的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值