【Java】基础语法

已于 2022-04-15 22:42:37 修改
阅读量958 收藏 12
点赞数 5
分类专栏： Java零基础指南 文章标签： java 开发语言 后端
于 2021-11-29 22:44:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24980365/article/details/121610631
版权

🌟个人博客：www.hellocode.top🌟
⭐所有文章均在上方博客首发，其他平台同步更新
🔥本文专栏：Java零基础指南
🌞更多相关内容请点击前往 Java零基础指南 查看
⚡如有问题，欢迎指正，一起学习~~

文章目录

前期准备

环境搭建

常用DOS命令

在这里插入图片描述

第一个Java程序
在这里插入图片描述

public class Hello{									//定义一个名为Hello的类（
	public static void main(String[] args){			//main入口
		System.out.println("Hello World");			//打印输出Hello World
    }
}

数据类型

常量

在程序的执行过程中，其值不会发生改变的量（数据）。

在这里插入图片描述

变量

就是内存中的存储空间，空间中存储着经常发生改变的值。

在这里插入图片描述

基本数据类型

在这里插入图片描述

引用数据类型

这部分后面会有专门的讲解，这里就不做过多说明了

键盘录入

目的

为了让数据更加灵活

步骤

  • 导包：import java.util.Scanner; (需要写在class上面)
  • 创建对象：Scanner sc = new Scanner(System.in); (只有sc可以改变，其他属于固定格式)
  • 使用变量接收数据:int i = sc.nextInt(); (只有i和sc变量可以改变，其他属于固定格式)

实例

import java.util.Scanner;	//导包
public class input{		//创建input类
	public static void main(String[] args){		//主入口
		Scanner scan = new Scanner(System.in);	//创建对象
        int a = scan.nextInt();		//使用变量接收数据
        System.out.println(a);		//打印输出数据
    }
}

标识符

就是给类、方法、变量等起名字的符号

定义规则

  • 由数字、字母、下划线(_)和美元符($)组成。
  • 不能以数字开头
  • 不能是关键字
  • 严格区分大小写

常见命名约定

  • 小驼峰命名法：常用于方法、变量
    约定1：标识符是一个单词的时候，首字母小写
    范例1：name
    约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
    范例2：firstName
  • 大驼峰命名法：常用于类
    约定1：标识符是一个单词的时候，首字母大写
    范例1：Student
    约定2：标识符由多个单词组成的时候，每个单词首字母都大写
    范例2：GoodStudent

类型转换

隐式转换

将数据类型中，取值范围小的数据，给取值范围大的类型赋值，可以直接赋值

int a = 10;		//int占4字节
double b = a;	//double占8字节

简单记：小的给大的，可以直接给
4升的油，倒入8升的桶，可以直接倒入
小的数据和大的数据类型运算，小的会先提升为大的数据类型再进行运算
byte short char 这三种数据在运算的时候，无论是否有更高的数据类型，都会提升为int，然后再进行运算

在这里插入图片描述

强制转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

  • 格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
int a = 10;		//int 4字节
byte b = (byte)a;		//byte 1字节
int c = (int)88.88;

强制类型转换，有可能会发生精度损失

精度损失：简单理解，将容积为8升的水倒入容积为4升的桶中，多出的水会洒掉

案例

  • 请判断下列代码是否存在问题，如果有，请指出并改正12
public class Test{
	public static void main(String[] args){
		byte a = 3;			//①
		byte b = 4;			//②
		byte c = a + b;		//③
		byte d = 3 + 4;		//④
	}
}

运算符

对常量或者变量进行操作的符号

表达式

用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。

不同运算符连接的表达式体现的是不同类型的表达式。

int a = 10;
int b = 20;
int c = a + b;

算术运算符

加（+）、减（-）、乘（*）、除（/）、取余（%）

加、减、乘都和小学一样，在用除法时，两整数相除只能得到整数，想要得到小数必须有浮点数参与运算
取余即指取结果的余数

字符之间相加时，字符会根据ASCII码值提升为int类型进行运算 （0–48 a–97 A–65）

int a = 1;
char b = 'a';
System.out.println(a + b);		//输出98

字符串之间相加时，可以使用+和（任意数据类型）拼接
当‘+’操作中出现字符串时，这个‘+’是字符串连接符，而不是算术运算符
在‘+’操作中，如果出现了字符串，就是连接运算符，否则就是算术运算符，当连续进行‘+’操作时，从左到右逐个执行

System.out.println("java" + 666);		//java666
System.out.println(1 + 99 +"java");		//100java
System.out.println("5+5=" + 5 + 5);		//5+5=55
System.out.println("5+5=" + (5 + 5));	//5+5=10

自增自减运算符

自增（++）、自减（–）

  • 单独使用时，++和–在前或者在后时结果都一样
  • 当参与其他操作时，在前则先自增（自减）后进行操作；在后则表示先进行相应操作后进行自增（自减）
  • 只能操作变量，不能操作常量

赋值运算符

赋值(=)、加后赋值(+=)、减后赋值(-=)、乘后赋值(*=)、除后赋值(/=)、取余后赋值(%=)

int a = 10;
a += 20;	//a = a + 20
System.out.println(a);		//30

注意：扩展运算符底层会自带强制类型转换的功能

关系（比较）运算符

等于(==)、不等(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)

注意：返回结果只有true或者false

逻辑运算符

  • &（与）：并且，全真则真，一假则假
  • |（或）：或者，全假则假，一真则真
  • !（非）：取反，真假假真
  • ^（异或）：两同为假，不同为真
  • 短路逻辑运算符
    • &&(短路与)：作用和&相同，但有短路效果
    • ||(短路或)：作用和|相同，但有短路效果

    逻辑短路：&&遇到false直接为false,不执行后面代码;||遇到true则直接为true，不执行后续代码

三元运算符

  • 格式：关系表达式 ? 表达式1 : 表达式2;
  • 执行流程
    • 首先计算关系表达式的值
    • 若为true则取表达式1的值
    • 若为false则取表达式2的值

流程控制

通过一些语句，来控制程序的执行流程

顺序结构语句

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

分支结构语句

if语句

  • 格式1：
if(关系表达式){
	语句体1；
}else{
	语句体2;
}
  • 执行流程：
    • 首先计算关系表达式的值
    • 如果关系表达式的值为true则执行语句体1
    • 如果关系表达式为false就执行语句体2
    • 继续执行后续代码
import java.util.Scanner;
public class A{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您的年龄：");
		int age = sc.nextInt();
		if(age >= 18){
			System.out.println("您已成年，可以进入");
		}else{
			System.out.println("对不起，您未成年，不能进入");
			}
     	}
	}

如果if语句中的语句体只有一条，那么大括号{}可以省略不写，但是不建议，容易混淆
if语句小括号后面不要写分号;

  • 格式2(多条件判断)：
if(判断条件){
	语句体1;
}else if(判断条件2){
	语句体2;
}
	...
else{
	语句体n+1;
}

import java.util.Scanner;
     
public class A{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入您的成绩：");
		int score = sc.nextInt();
		if(score >= 90 && score <= 100){
			System.out.println("优秀");
		}else if(score >= 80 && score < 90){
			System.out.println("良好");
		}else if(score >=60 && score < 80){
			System.out.println("及格");
		}else if(score <60 && score >= 0){
			System.out.println("不及格");
		}else{
			System.out.println("请输入正确的成绩！");
		}
	}
}

switch语句

  • 格式
switch(表达式){
	case 值1:
		语句体1；
		break;
	case 值2;
		语句体2;
		break;
		....
	default:
		语句体n+1;
		break;
}
  • 格式说明：
    • 表达式（将要被匹配的值）取值为byte、short、int、char、JDK5、以后还可以是枚举，JDK7以后可以是String
    • case:后面跟的是要和表达式比较的值（被匹配的值）
    • break：表示中断，结束的意思，用来结束switch语句
    • default：表示所有的情况都不匹配的时候，就执行该处的内容，和if语句的else相似
  • case穿透：
    • 现象：当开始case穿透，后续的case就不会具有匹配的效果，内部的语句都会执行
      直到看见break，或者将整体switch语句执行完毕，才会结束
    • 应用场景：当多个case语句出现重复现象，就可以考虑使用case穿透来优化代码
循环结构语句

for循环

推荐明确循环次数时使用

  • 格式
for(初始化语句;条件判断语句;条件控制语句){
	循环体语句;
}
  • 执行流程
    • 执行初始化语句
    • 执行条件判断语句，看其结果是true还是false
      如果是false，循环结束
      如果是true，循环继续
    • 执行循环体语句
    • 执行条件控制语句
    • 回到第2步继续循环
  • 案例
//在控制台输出1-5
for(int i = 1;i <= 5;i++){
	System.out.println(i);
}

//求1-5的数据和
int sum = 0;
for(int i = 1;i <= 5;i++){
	sum += i;
}
System.out.println(sum);

//求1-100的偶数和
int sum = 0;
for(int i = 1;i <= 100;i++){
	if(i % 2 == 0){
		sum += i;
	}
}
System.out.println(sum);

//输出所有的水仙花数
//水仙花数：是一个三位数，个位、十位、百位的数字立方和等于原数
for(int i = 100;i <= 999;i++){
	int sum;
	int a = i % 10;
	int b = i / 10 % 10;
	int c = i / 100;
	sum = a * a * a + b * b * b + c * c * c;
	if(sum == i){
		System.out.println(i);
	}
}

System.out.print()为同行打印，不换行
System.out.println()自带换行效果，类似于html中的块级元素，独占一行。括号内无内容时可以当作换行符来使用

while循环

不明确循环次数时推荐while

  • 格式：
while(条件判断语句){
	循环体语句;
	条件控制语句;
}

int i = 1;
while(int i <= 100){
	System.out.println(i);
	i++;
}

do…while循环

使用较少，了解即可

  • 格式：
do{
	循环体语句;
	条件控制语句;
}while(条件判断语句);
  • 三种循环的区别
    • for循环和while循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
    • do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
    • 条件控制语句中所控制的自增变量，因为归属于for循环的语法结构中，在for循环结束后，就不能再次被访问到了
    • 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

死循环

//for
for(;;){
	循环体语句;
}
//while
while(true){
	循环体语句;
}
//do...while
do{
	循环体语句;
}while(true);
  • 应用场景：
    例如：键盘录入一个1-100之间的整数（用户可能出现误操作现象）
while(true){
	Scanner sc = new Scanner(System.in);
	int a = sc.nextInt();
	if(a >= 1 && a <= 100){
           
	}
}
continue与break关键字
  • continue：跳过某次循环内容，继续开始下一层循环，只能在循环中使用
  • break：跳出整个循环，终止循环体内容的执行，只能在循环和switch中使用
  • 标号：可以给语句块加标号赋予它们名称，标号位于语句之前。标号只能被continue和break引用。
public class Test{
	public static void main(String[] args){
		int n = 1;
		lo:				//标号
		while(true){
		switch(n){
			case 1:
				System.out.println("1");
				break lo;			//通过标号，这里的break将结束外层while循环
			}
		}
	}
}
// 语句前只允许加一个标号，标号后面不能跟大括号。通过用break后加标号对处于标号中的语句进行控制。往往标号后是for.while.do-while等循环。

Random

作用

用于产生一个随机数

使用步骤

  1. 导包
import java.util.Random;
  1. 创建对象
Random r = new Random();
  1. 获取随机数
int number = r.nextInt(10);		//获取数据的范围:[0,10)，包括0，不包括10
int number = r.nextInt(10) + 1;		//获取数据的范围:[1,10]，包括1，也包括10

猜数字案例

import java.util.Random;
import java.util.Scanner;
public class a{
	public static void main(String[] args){
		Random r = new Random();
		int ran = r.nextInt(100) + 1;
		while(true){
			System.out.print("请输入您猜的数字：");
			Scanner sc = new Scanner(System.in);
			int n = sc.nextInt();
			if(n > ran){
				System.out.println("猜大了~~");
			}else if(n < ran){
				System.out.println("猜小了~~");
			}else {
				System.out.println("猜恭喜你，猜对了，答案就是" + ran);
				break;
			}
		}
	}
}

开发神器-IDEA

概述

IDEA全称IntelliJ IDEA，是用于Java语言开发的集成环境，它是业界公认的目前用于Java程序开发最好的工具

集成环境

就是把代码编写、编译、执行、调试等多种功能综合到一起的开发工具

下载和安装
IDEA项目结构

project-module-package-class
这些结构的划分，是为了方便管理文件

  • IDEA中的第一个代码
    1. 创建Project项目
    2. 创建Module模块
    3. 创建Package包
    4. 创建Class类
    5. 在类中编写代码
    6. 完成编译运行

注意：最后代码一定要存放到src目录下，包名类似于com.baidu.demo1这样的格式

常用快捷键
  1. psvm + 回车：快速生成main方法
  2. sout + 回车：快速生成输出语句
  3. alt + 1 ：快速打开\隐藏工程目录结构
  4. alt + 4：打开\隐藏控制台
  5. Ctrl + alt + l：格式化代码
  6. alt + 回车：代码修正提示
  7. ctrl + D：向下复制一行
  8. ctrl + X：剪切当前行
  9. Ctrl + /：批量加入单行注释，再按一次就是取消注释
  10. Ctrl + shift + /：批量加入多行注释，再按一次就是取消
  11. ctrl + shift + ↑：上移当前行
  12. ctrl + shift + ↓：下移当前行
  13. Ctrl + alt + m : 将选中代码封装为一个方法
  14. 数组名.fori + 回车：快速遍历指定数组
  15. 集合.fori + 回车：快速遍历指定集合

数组

是一种容器，用来存储同种数据类型（或者比它所占字节小的）的多个值

格式

//1.数据类型[] 变量名	【最常用】
int[] array;
   
//2.数据类型 变量名[]		
int array[];
初始化

Java中的数组必须先初始化，才能使用

所谓初始化，就是在内存中，为数组容器开辟空间，并将数据存入容器的过程

  • 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值（只明确元素个数，不明确具体数值，推荐使用）
    • 格式：数据类型[] 变量名 = new 数据类型[数组长度];
    • 范例：int[] arr = new int[3];
    • 注意：打印数组变量名，输出的是数组在内存中的地址值

数组元素访问

  • 数组内存地址的访问：数组名
  • 数组内部保存的数据的访问：数组名[索引]
  • 索引从0开始，连续的，逐一增加
  • 数组在创建完毕后，没有赋值也能取出，取出的值为0
  • 默认值：
    整数——0
    浮点数——0.0
    布尔——false
    字符——空字符
    引用数据类型——null
内存分配

Java程序在运行时，需要在内存中分配空间

为了提高效率，就对空间进行了不同区域的划分
每一片区域都有特定的处理数据的方式和内存管理方式

  • 栈内存：方法运行时，进入的内存，局部变量都存放于这块内存当中
  • 堆内存：new出来的内容就会进入堆内存，并且会存在地址值
  • 方法区：字节码文件加载时进入的内存
  • 本地方法栈：调用操作系统相关资源
  • 寄存器：交给CPU去使用

静态初始化

初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组的长度（需求中明确了具体数据，直接静态初始化即可）

  • 格式：数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,....};
  • 范例：int[] arr = new int[]{1,2,3};
  • 简化格式：int[] arr = {1,2,3};

数组遍历

将数组中所有的元素取出来

动态获取数组元素个数：数组名.length

int arr = {1,2,3,4,5,6,7,8,9};
for(int i = 0; i <= arr.length; i++){
	System.out.println(arr[i]);
}

注意：遍历是指取出数据的过程，不要局限的理解为：遍历就是打印

数据常见操作

  • 获取最值
    思路：定义一个变量，用于保存最大值（或最小值）
    取数组中的第一个值作为变量的初始值（假设第一个值就是最大（小）值）与数组中的剩余数据逐个对比
int[] arr = {1, 2, 3, 4, 5, 6, 7000, 8, 919};
int max = arr[0];
for(int i = 0; i < arr.length; i++){
	if(arr[i] > max) max = arr[i];
}
System.out.println("最大值为：" + max);
  • 数组元素求和
import java.util.Scanner;
public class test{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[];
		int sum = 0;
		for(int i = 0; i < arr.length; i++){
			System.out.print("请输入第" + (i+1) + "个数值：");
			int n = sc.nextInt();
			sum += n;
		}
		System.out.println("数组内的元素的和为：" + sum);
	}
}
  • 数组基本查找
int[] arr = {19, 28, 37, 46, 50};
Scanner sc = new Scanner(System.in);
System.out.print("请输入您要查找的数据：");
int n = sc.nextInt();
for(int i = 0; i < arr.length; i++){
	if(arr[i] == n){
		System.out.println("您要查找的数据索引为：" + i);
		break;
	}
}

方法

概念

方法就是一段具有独立功能 的代码块，不调用就不执行

使用前提

方法必须先创建才可以使用，该过程称为方法的定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用

方法定义

public static void 方法名(){
	//方法体
}

方法调用
方法名();

注意：方法必须先定义后调用，否则程序将会报错
方法与方法之间是平级关系，不能嵌套定义
在方法没有被调用的时候，都在方法区中的字节码文件（.class）中存储
方法被调用的时候，需要进入到栈内存中运行

带参方法的定义和调用

public static void 方法名(参数){
	//方法体
}
  • 单个参数：数据类型 变量名
  • 多个参数：数据类型 变量名1 , 数据类型 变量名2 , .....
  • 调用：方法名(参数);
    方法名(变量名/常量值);
    方法名(变量名1/常量值1 , 变量名2/常量值2 , ...);

方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将会报错

形参和实参

  • 形参：全称形式参数，是指方法定义中的参数
  • 实参：全称实际参数，是指方法调用中的参数

带参数方法练习

// 需求：设计一个方法（print）用于打印n到m之间的所有的奇数
public class a{
	public static void main(String[] args){
		print(10, 20);
	}
	public static void print(int n, int m){
		for(int i = n; i <= m; i++){
			if(i % 2 != 0) System.out.println(i);
		}
	}
}

带返回值方法的定义和调用

public static 数据类型 方法名(参数){
	return 数据;
}

方法定义时，return后面的返回值与方法定义上的数据类型要匹配，否则就会报错
在执行代码时，return语句后面的语句都不会执行，属于无效代码
return;可以用于结束方法，也就是方法从栈内存中弹出去，该过程称为方法的弹栈

调用：数据类型 变量名 = 方法名(参数);

方法通用格式

public static 返回值类型 方法名(参数){
	方法体;
	return 数据;
}
方法重载

方法名相同，参数也完全相同，称为方法的重复定义，是一种冲突性的错误
在调用方法的时候，Java虚拟机会通过参数的不同来区分同名的方法

在同一个类中，定义了多个同名的方法，但每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
注意：识别方法之间是否是重载关系，只看方法名和参数，和返回值无关

好处：不用记忆过多繁琐的方法名字

方法重载练习

// 需求：使用方法重载思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,int,long)
public static void main(String[] args){
	System.out.println(compare(20, 30));
}
public static boolean compare(byte a, byte b){
	return a == b;
}
public static boolean compare(short a, short b){
	return a == b;
}
public static boolean compare(int a, int b){
	return a == b;
}
public static boolean compare(long a, long b){
	return a == b;
}
方法的参数传递
  1. 当传入基本数据类型时，传入的是具体的数值，且方法中的变量和main中的变量并无联系
  2. 当传入引用类型时，传入的是具体的内存地址，这种情况可以在方法中改变引用类型变量的值

案例

// 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11,22,33,44,55]
public static void main(String[] args) {
	int[] arr = {11, 22, 33, 44, 55};
	printArray(arr);
}
public static void printArray(int[] arr) {
	System.out.print("[");
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i]);
		if (i == arr.length - 1) System.out.print("]");
		else {
			System.out.print(", ");
		}
	}
}

// 需求：设计一个方法用于获取数组元素中的最大值
public static void main(String[] args){
	int[] arr = {11,33,44,88,22};
	System.out.println("数组中的最大值为：" + max(arr));
}
public static int max(int[] arr){
	int max = arr[0];
	for(int i = 0; i < arr.length; i++){
		if(arr[i] > max) max = arr[i];
	}
	return max;
}

// 需求：设计一个方法，该方法中能够同时获取最大值和最小值
public static void main(String[] args){
	int[] arr = {11,22,33,44,2,2393,55};
	int[] res = get(arr);
	System.out.println("最大值为：" + res[0]);
	System.out.println("最小值为：" + res[1]);
}
public static int[] get(int[] arr){
	int max = arr[0];
	int min = arr[0];
	for(int i = 0; i < arr.length; i++){
		if(arr[i] > max) max = arr[i];
		if(arr[i] < min) min = arr[i];
	}
	int[] arrMaxAndMin = {max, min};
	return arrMaxAndMin;
}

注意：return语句只能同时返回一个值，需要返回多个值的话可以使用数组

Debug

概述

是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序

操作流程

Debug调试，又称为断点调试，断点其实是一个标记，告诉Debug从标记的地方开始查看

添加断点 -> Debug运行 -> 根据Debug窗口调试(Step into向下进行；Stop停止) -> 删除断点

进制

指进位制：是人们规定的一种进位方式

常见进制

二进制、八进制、十进制、十六进制

计算机数据在底层运算的时候，都是以二进制进行的，了解不同的进制，便于我们对数据的运算过程理解的更加深刻

  • 十进制：逢十进一，借一当十
  • 二进制：逢二进一，借一当二（只有0和1）
  • 八进制：逢八进一，借一当八（0，1，2，3，4，5，6，7）
  • 十六进制：0~9，a~f（其中a~f表示10~15）

在Java中，数值默认都是十进制，不需要加任何修饰
二进制：数值前面以0b开头，b大小写都可
八进制：数值前面以0开头
十六进制：数值前面以0x开头，x大小写都可
注意：书写的时候，虽然加入了进制的标识，但打印在控制台展示的时候都是十进制数据

进制转换
  • 任意进制到十进制公式：系数*基数的权次幂 相加
    系数：每一【位】上的数
    基数：几进制，就是几
    权：从数值的右侧，以0开始，逐个+1增加
  • 十进制到任意进制的转换公式：除基取余
    使用源数据，不断地除以基数（几进制就是除几）得到余数，直到商为0，再将余数倒序拼起来即可
  • 快速进制转换法：8421码
    8421码又称BCD码，是BCD代码中最常用的一种
    BCD：（Binary-Coded Decimal）二进制码十进制数
  • 在这种编码方式中，每一位二进制值的1都是代表一个固定数值，把每一位的1代表的十进制数加起来得到的结果就是他所代表的十进制数
原码反码补码

注意：计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的

  • 原码：（可直观的看出数据大小）就是二进制定点表示法，最高位为符号位，0正1负，其余位表示数值的大小
    一个字节等于8个比特位，也就是8个二进制位

  • 反码：（将原码转换为补码）正数的反码与其原码相同，负数的反码是对其原码逐位取反，但符号位除外

  • 补码：（数据以该状态进行运算）正数的补码与其原码相同，负数的补码是在其反码的末位加1

    正数的原反补都是相同的
    负数的【反码】，是根据【原码】取反（0变1，1变0）得到的==（符号位不变）==
    负数的【补码】，是根据【反码】的末尾+1得到的

位运算

  • 位运算指的是二进制位的运算，先将十进制数转换成二进制后再进行运算

  • 在二进制位运算中，1表示true，0表示false
    & 位与：遇false则false，遇0则0
    | 位或：遇true则true，遇1则1
    ^ 位异或：相同为false，不同为true (a = a ^ b ^ b)
    ~ 取反：全部取反，0变1，1变0（也包括符号位）

  • 位移运算符：
    << 有符号左移运算，二进制位向左移动，左边符号位丢弃，右边补齐0
    运算规律：向左移动几位，就是乘以2的几次幂

    >> 有符号右移运算：二进制位向右移动，使用符号位进行补位
    运算规律：向右移动几位，就是除以2的几次幂

    >>> 无符号右移运算符，无论符号位是0还是1，都补0

  • 案例：

// 需求：在不使用第三方变量的情况下，实现两数据交换
public static void main(String[] args){
	int a = 10;
	int b = 20;
	a = a ^ b;
	b = a ^ b;
	a = a ^ b;
	System.out.println(a);
	System.out.println(b);
}

// 需求：实现数组元素的反转（交换数组中元素的值）
int[] arr = {11, 22, 33, 44, 55, 66, 77};
for(int start = 0, end = arr.length - 1; start < end; start++, end--){
	int temp = arr[start];
	arr[start] = arr[end];
	arr[end] = temp;
}
for(int i = 0 ; i < arr.length; i++){
	System.out.println(arr[i]);
}

二维数组

二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

定义格式

  • 格式1：数据类型[][] 变量名;
  • 格式2：数据类型 变量名[];
  • 格式3：数据类型[] 变量名[];

动态初始化：数据类型[][] 变量名 = new 数据类型[m][n];

  • m表示这个二维数组可以存放多少个一维数组==(行)==
  • n表示每一个一维数组，可以存放多少个元素==(列)==

拓展：将一个提前创建好的一维数组存储到二维数组中

int[] arr = {11, 22, 33};
int[][] arr2 = new int[1][3];
arr2[0] = arr;
System.out.println(arr2[0][2]);

静态初始化：

  • 格式：数据类型[][] 变量名 = new 数据类型[][]{{元素1, 元素2,...}, {元素1, 元素2,...}...};
  • 简化格式：数据类型[][] 变量名 = {{元素1, 元素2,...}, {元素1, 元素2,...}, ...};

二维数组遍历

// 需求：已知一个二维数组arr = {{11, 22, 33}, {33, 44, 55}};  遍历数组，取出所有元素并打印
int[][] arr = {{11, 22, 33}, {33, 44, 55}};
for(int i = 0; i < arr.length; i++){
	for(int j = 0; j < arr[i].length; j++){
		System.out.println(arr[i][j]);
	}
}

案例：

// 需求：二维数组求和
int sum = 0;
int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
	for(int i = 0; i < arr.length; i++){
		for(int j = 0; j < arr[i].length; j++){
			sum += arr[i][j];
		}
	}
System.out.println(sum);

推荐阅读：Java面向对象基础

  1. ③中错误，在byte short char运算时，会直接提升为int，然后再进行运算; ↩︎

  2. ④正确：Java存在常量优化机制，3和4是两个常量，会在编译的时候让3和4进行相加，然后判断7是否在byte的取值范围内 ↩︎

九思のJava之路
关注
专栏目录
Java基础语法.docx
05-13
### Java基础语法详解 #### 一、Java 开发环境(JDK) **JDK (Java Development Kit)** 是开发Java应用程序的基础工具包，包含了编译、调试和运行Java程序所需的所有工具。 - **JRE (Java Runtime Environment)**：...
java 每行打印10个数据
热门推荐
小蓝的博客
05-06 1万+
以后再补上。。以后再拆分。public class Test {     public static void main(String[] args)     {         printNEachLine();         printNEachLine1();         printNEachLine2();     }     static void printNEachLine()...
Java在同一行中把它打印三次,在java中以同一行打印
weixin_31812189的博客
02-25 432
I have a base class called Items and 3 derived classes, and within the Items base class i have a print function of the formpublic void print(){System.out.println("ID " + id + " Title " + title + " ")...
java在一行固定输出，比如在一行打印进度
软件开发随记
03-13 5780
    在java中要实现在控制台一行中定点输出，因为我想实现的一个功能是在一行中显示FTP上传和下载进度，比如在一行中输入上传进度为30％后，在新进度到来的时候，更新其中的30％为40％。而不是重新启动一行输出上传进度为40％。     在java的输出控制中\r是回到开头，\n是换行，在输出的过程中不用println，而是用\r\n这些控制符控制回车换行。具体代码为。 System.out.p...
Java实现打印功能
KK_gentleman的博客
09-12 5076
前段时间项目中刚好有遇到这个需求，具体是实现将上传到服务端的附件进行不下载在线打印，打印时要进行预览。 一开始是想直接使用Java API的打印方法，具体实现时发现在启用后可以调出打印对话框，但打印机没有反应，查看了网上的很多方法，试了下还是不行，就放弃了。看下Java实现的代码： import java.io.FileInputStream; import java.io.FileNotF...
java在输入的同一行中输出,JAVA输入输出总结
weixin_32534653的博客
03-15 2646
标准输入：Scanner cin = new Scanner(System.in);cin.nextLine();：输入一行，可能存在空格，功能特点类似于C中的gets()；cin.next();:输入一个单词，以空白字符为结束标志，类似于scanf(“%s”,str);cin.nextInt();:输入整形数据cin.nextDouble();输入浮点性数据以上4种输入方式这些输入都是可见的，不...
Java基础语法
10-12
### Java基础语法知识点详解 #### 一、Java语言基础 Java是一种广泛使用的面向对象的编程语言，具有简单性、安全性、高性能、可移植性和多线程支持等特点。本章节主要介绍Java的基础语法，包括数据类型、变量、...
Java基础语法)教案
04-05
### Java基础语法教案知识点解析 #### 一、Java开发环境搭建 **1.1 Java语言概述** - **视频摘要:** 引入Java语言的历史和发展，包括它的起源、发展历程及其广泛的应用场景。通过介绍Java的特点（如面向对象、跨...
java基础语法
12-19
java基本的数据类型，swing窗体的使用，java基本的循环语句
Java在同一行中把它打印三次_如何打印到同一行？
weixin_29162439的博客
02-25 1226
首先，我很抱歉提出这个问题，但我认为它可以使用另一个答案。德里克·舒尔茨(Derek Schultz)是对的。'\ b'字符将打印光标向后移动一个字符，使您可以覆盖在那里打印的字符(除非您在顶部打印新信息，否则它不会删除整行甚至是那里的字符)。以下是使用Java的进度条的示例，尽管它不遵循您的格式，但显示了如何解决覆盖字符的核心问题(仅在32位计算机上的Ubuntu 12.04中使用Oracle ...
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 845
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 434
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 535
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 795
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1262
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 330
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1111
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 883
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
Java基础语法详解与实战
"Java基础知识综合，包括Java开发环境的搭建，基础语法的讲解，如变量、运算符、流程控制语句等，旨在为初学者打下坚实的编程基础。" Java是一种广泛使用的高级编程语言，其跨平台的特性使得它在各种操作系统上都能...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

九思のJava之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值