注释
注释概念
- 注释是在程序指定位置添加的说明性信息。
- 注释内容不会参与编译和运行。
注释分类
- 单行注释 格式：// 注释信息
添加 注释 Ctrl+Shift+/
去除注释的快捷键是Ctrl+Shift+\ - 多行注释 格式：/* 注释信息 */
- 文档注释 格式：/** 注释信息 */
添加注释 alt+shift+J
关键字
概念
被java赋予了特定含义的英文单词。
- class:用于创建一个类。
- public:限制类名需要和文件名保持一致。
特点
- 关键字的字母全部小写。
- 常用代码编辑器，针对关键字有特殊的颜色标记。
main不是关键字。
常量
概念
在程序的执行过程中，其值不会发生改变的量（数据）。
分类
- 字符串常量：被双引号包裹的内容
- 整数常量：所有整数
- 小数常量：所有小数
- 字符常量：被单引号包裹的内容，里面只能存放单个字符
- 布尔常量：true false
- 空常量：null 空常量不能输出打印
变量
概念
变量就是内存中的存储空间，空间中存储着经常发生改变的量（数据）。
定义变量
- 格式: 数据类型 变量名=数据值;
数据类型：为空间中存储的数据，加入类型限制 整数or小数or…
变量名：为空间起的名字
数据值：空间中要存储的数值
数据类型
计算机存储单元
无论是内存还是硬盘，计算机存储设备的最小信息单元叫位(bit)，又称为比特位，通常用b表示。
计算机中最小的存储单元叫字节(byte)，通常用B表示，字节是有连续的8个位组成。
数据类型
不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。
- 常量【没有手动指定数据类型】但只要是数据，就会存在数据类型，整数默认为int，浮点数默认为double
变量的定义和使用
变量的定义
数据类型 变量名=数据值;
变量的使用
变量就是内存中的空间，内部存储着不断发生变化的数据。
变量的注意事项
- 变量名不允许重复定义
- 一条语句可以定义多个变量，但需要使用逗号分割
- 变量在使用之前一定要进行赋值
- 定义float和long变量 float类型变量后面加入F的标识 long类型变量后面加入L的标识
- 变量的作用域范围，只在它所在的大括号中有效，当大括号中的代码执行完毕后，内部所[定义]的变量就会从内存中消失
键盘录入
import java.util.Scanner;
public class DemoScanner{
public static void mian(String[] args){
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println(a);
}
}
标识符
概述
给类、方法、变量等起名字的符号。
定义规则
- 由数字、字母、下划线(_)、和美元符($)组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
命名
- 小驼峰命名法：方法、变量 firstName
- 大驼峰命名法：类 GoodStudents
类型转换
- 隐式转换
- 将数据类型取值范围小的数据给取值范围大的类型赋值，可以直接赋值
例:
int a = 10;
double b = a;
数据范围小到大：
byte->short/char->int->long->float->double - 小的数据类型和大的数据类型计算，小的会提升为大的之后，再进行运算
public class test{
public static void main(String[] args){
int a = 10;
double b = 12.3;
double c = a + b; //a和b在运算过程中，先将a提升为double类型，在进行运算，所以结果用double接收
}
}
- byte short char三种数据在运算的时候，不管是否有更高的数据类型，都会提升为int，再进行运算
public class test{
public static void main(String[] args){
byte a = 10;
byte b = 20;
int c = a + b;
}
}
- 强制转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
目标数据类型 变量名 = (目标数据类型)值或者变量;
强制转换有可能发生精度损失
public class test{
public static void main(String[] args){
byte a = 10;
byte b = 20;
byte c = a + b; //错误 byte相加先转为int 纠正byte c = (byte)(a + b);
byte d = 3 + 4 ;//正确 java存在常量优化机制：在编译时(javac)，会先计算出结果并自动判断该结果是否在byte取值范围内 在通过 不在失败
}
}
运算符
算数运算符
运算符和表达式
- 运算符：对常量或者变量进行操作的符号
- 表达式：用运损福把常量或者变量连接起来符合java语法的式子
例：
int a = 10;
int b = 20;
int c = a + b;
+是运算符并且是算数运算符
a+b是表达式，由于+是算数运算符，所以这个表达式叫算数表达式
算数运算符
+*-
/ 整数相除，结果只能是整数，如果想要得到带有小数的结构，必须加入小数(浮点类型)的运算
%(取模)：取余数
字符的"+"操作
- ASCII码 字节到字符的对应关系
a：97 A：65 0:48
字符串的"+"操作
字符串可以用+号跟[任意数据类型]拼接
System.out.println(1+99+“年”); //100年
System.out.println(“5+5=”+5+5); //5+5=55
System.out.println(“5+5=”+(5+5)); //5+5=10
案例：数值拆分
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
import java.util.Scanner;
public static void mian(String[] args){
//录入一个三位数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数：");
int num = sc.nextInt();
//个位计算
int ge = num % 10；
//十位
int shi = num/10%10;
//百位
int bai = num/100;
System.out.println("整数"+num+“个位为：”+ge+“ 十位为：”+shi+“ 百位为”+bai);
}
自增自减运算符
- ++ 自增
- – 自减
只能操作变量不能操作常量
单独使用：
++和–无论放在变量前面还是后面，结果是一样的。
++a;
b–;
参与操作：
在前：先对该变量做自增(++)或自减(–),然后再拿变量参与操作。
在后：先将该变量原本的值取出来参与操作，随后再进行自增(++)，自减(–)
public static void main(String[] args){
int a = 10;
int b = ++a;
System.out.println(a); //11
System.out.println(b); //11
int aa = 10;
int bb = aa++;
System.out.println(aa); //11
System.out.println(bb); //10
int num = 123;
System.out.println(num++); //123
System.out.println(num); //124
}
赋值运算符
扩展赋值运算符底层会自带强转功能
关系运算符
关系运算符(比较运算符)
关系运算符的结果都是boolean类型
逻辑运算符
整合多个比较表达式的条件
- &(与)：并且，遇false则flase，只有符号左右两边同时为true，结果才为true
- |(或)：或者，遇true则true，只有符号左右两边同时为false，结果才为false
- !(非)：取反，
- ^(异或)： 相同为false，不同为true
###应用场景
- 键盘录入学生成绩按，如果是90-100之前，则输出优秀
score>=90&score<100 - 键盘录入工人工号，只要3号5号7号
id == 3 |id ==5 |id ==7
短路逻辑运算符
三元运算符
三元运算符
- 格式：关系表达式?表达式1:表达式2;
执行流程：
首先计算关系表达式的值
如果值为true，取表达式1的值
如果值为false，取表达式2的值
public static void main(String[] args){
int a = 10;
int b = 20;
int max = a >b?a:b;
System.out.println(max);
}
案例
已知三个和尚身高为150cm 210cm 165cm 获取这三个和尚的最高身高。
public static void main(String[] args){
int a=150;
int b=210;
int c=165;
int tempMax = a>b?a:b;
int max=tempMax>c?tempMax:c;
System.out.println(max);
int result = a>b?a:b> c ? a>b?a:b: c;
}
分支语句
流程控制
通过一些语句，来控制程序的【执行流程】
- 顺序结构
- 分支结构(if,switch)
- 循环结构(for,while,do…while)
顺序结构语句
java程序默认的执行流程，按照代码先后顺序依次执行。
if语句
格式1
格式2
格式3
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相似。
案例
键盘输入星期数，显示今天的减肥活动。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五：拳击
周六：爬山
周日：好好吃一顿
import java.util.Scanner;
public class TestSwitch{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入");
int week = sc.nextInt();
switch(week){
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("输入有误");
break;
}
}
}
switch语句的case穿透现象
如果switch语句中，case省略了break语句，就会case穿透，当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行直到看见break，或者将整体switch语句执行完毕，才会结束。当switch语句中，多个case给出的语句体出现了重复的，就可以考虑使用case穿透来优化。
案例：
1-5工作日 6-7休息日
import java.util.Scanner;
public class TestSwitch{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入");
int week = sc.nextInt();
switch(week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
default:
System.out.println("输入有误");
break;
}
}
}
循环语句
for循环
格式：
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
案例：输出数据
在控制台输出1-5和5-1的数据
public static void main(String[] args){
for(int i=1;i<=5;i++){
System.out.println(i);
}
for(int i=5;i>0;i--){
System.out.println(i);
}
}
案例：求和
求1-5的数据和
public static void main(String[] args){
int sum = 0;
for(int i=1;i<=5;i++){
sum + =i;
}
System.out.println(sum);
}
案例：求偶数和
求1-100的偶数和
public static void main(String[] args){
int sum = 0;
for(int i=1;i<=100;i++){
if(i%2 == 0){
sum + = i;
}
}
System.out.println(sum);
}
案例：逢7过(包含7或者7的倍数)
求1-100间满足逢7过的数
public static void main(String[] args){
for(int i=1;i<=100;i++){
int ge = i%10;
int shi = i /10 % 10;
if(ge==7||shi==7||i%7==0{
System.out.println(i);
}
}
}
案例：水仙花
水仙花是3位数，水仙花的个位、十位、百位数字立方和等于原数
public static void main(String[] args){
for(int i=100;i<1000;i++){
int ge = i%10;
int shi = i/10%10;
int bai = i/100;
int count = 0;
if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
//Sytem.out.println(i);
Sytem.out.print(i+" ");
count++;
if(count%2==0){
System.out.prinln(); //每行打印两个
}
}
}
}
while循环
格式:
while(条件判断语句){
循环体语句;
条件控制语句;
}
输出1-100的数
public static void main(String[] args){
int i = 1;
while(i<=100){
System.out.println(i);
i++;
}
}
案例：珠穆朗玛峰
珠穆朗玛峰高8844.43米=8844430毫米，一张足够大的纸，厚度是0.1毫米，折叠多少次可以折成珠穆朗玛峰的高度？
public static void main(String[] args){
double paper = 0,1;
int zf = 8844430;
int count = 0;
while(paper <= zf){
paper*=2;
count++;
}
System.out.println(count);
}
do…while循环
格式：
初始化语句;
do{
循环体语句；
条件控制语句；
}while(条件判断语句);
无论循环条件是否满足，都至少会执行一次循环体
do…while循环是从上到下依次执行的
打印10次垃圾
public static void main(String[] args){
int i = 1;
do{
System.out.println("垃圾");
i++;
}while(i<-10);
}
三种循环的区别
三种循环的区别
- for循环和while循环先判断条件是否成立，然后决定是否执行循环体(先判断后执行)
- do…whiile循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体(先执行后判断)
for和while的区别
- 条件控制语句所控制的自增变量，因为归属for循环的语句结构中，在for循环结束后，就不能再次被访问了
- 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
三种循环使用场景
- 明确循环次数，推荐使用for循环
- 不明确循环次数，推荐使用while循环
- do…while循环，很少使用
死循环
无限循环
- for( ; ; ){}
- while(true){}
- do{}while(true);
应用场景
录入一个1-100的整数
用户可能会出现误操作
死循环之后的语句无法执行到，会报错。
跳转控制语句
- continue：跳过某次循环体内容的执行
注意：使用是基于条件控制，在循环体内部使用
模拟电梯上行过程1-24层，4层不停。
public static void main(Strng[] args){
for(int i=1 ; i<=24 ; i++){
if(i==4){
continue;
}
System.out.println(i);
}
}
- break:终止循环体内容的执行
注意：使用是基于条件控制的，break语句只能在循环和switch中进行使用
模拟20岁工作到80岁，60岁退休。
public static void main(Strng[] args){
for(int i=20 ; i<=80 ; i++){
if(i==60){
break;
}
System.out.println(i);
}
}
案例：用户可多次查询星期对应的减肥计划，直至输入0，程序结束。
import java.util.Scanner;
public class Test{
public static void main(String[] args){
lo:while(true){
System.out.println("请输入您要查看的星期数");
System.out.println("(如无需继续查询，请输入0退出程序)");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch(week){
case 0:
System.out.println("感谢您的使用");
break lo;
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("慢走");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("全集");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("吃一顿");
break;
default:
System.out.println("您输入有误");
break;
}
}
}
}
break和continue只能跳出、跳过自己所在的那一层关系，如果想要跳出、跳过指定的一层就可以加入标号。
如：
标号名:while(true){
switch(表达式){
case 1:
break 标号名;
}
}
Random
产生一个随机数
import java.util.Random;
public class TestRandom{
public static void main(String[] args){
Random r = new Random();
int num = r.nextInt(10); //[0,10)
System.out.println(num);
}
}
案例：猜数字
自动生成一个1-100的数字，实现猜出这个数字是多少
当猜错的时候根据不同情况给出相应的提示
- 如果猜的数字比真实数字大，提示你猜的数据大了
- 如果猜的数字比真实数字小，提示你猜的数据小了
- 如果猜的数字与真实数字相等，提示恭喜你猜中了
import java.util.Random;
import java.util.Scanner;
public class TestRandom{
public static void main(String[] args){
Random r = new Random();
int randomNum = r.nextInt(100) + 1; //[1,100]
Scanner sc =new Scanner(System.in);
while(true){
System.out.println("猜的数据大了");
int num = sc.nextInt();
if(num > randomNum ){
System.out.println("猜的数据大了");
}else if(num < randomNum ){
System.out.println("猜的数据小了");
}else {
System.out.println("猜中了");
break;
}
System.out.println("感谢您的使用");
}
}
}
数组
- 概念
数组是一种容器，用来存储同种数据类型的多个值。
如果今后要操作的数据，是同一组数据，就可以使用数组容器进行存储。
int类型的数组容器可存byte short，不可存boolean double - 格式
数据类型[] 变量名
数据类型 变量名[]
数组初始化之动态初始化
概述
Java中的数组必须先初始化，然后才能使用
所谓初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
注意：打印数组变量的时候，会打印出数组的内存地址。
[I@10f87f48
@：分隔符
[：当前空间是一个数组类型
I：当前数组让其中所存储的数据类型
10f87f48：十六进制内存地址
- 格式：数据类型[] 变量名 = new 数据类型[数组长度];
int arr[] = new int[5];
数组元素访问
-
数组内存地址的访问方式
-
格式：数组名
-
数组内部保存的数据的访问方式
-
格式：数组名[索引]
-
索引是数组容器中空间的编号，从0开始、连续的、逐一增加1
-
作用：访问数组容器中的空间位置
注意：数组在创建完毕后，即使没有赋值，也可以取出，但取出的元素都是默认初始化值。
内存分配
- 栈内存：方法运行时，进入的内存，局部变量都存放在这块内存中
- 堆内存：new出来的内存都会进入堆内存，并且会存在地址值
- 方法区：字节码文件(.class文件)加载时进入的内存
- 本地方法栈：调用操作系统相关资源
- 寄存器：交给CPU取使用
数组内存图
默认值
两个数组内存图
注意：每new一次，在堆内存中，都是一块新的空间，堆内存中的空间地址不会出现重复的现象
多个数组指向相同的内存图
数组初始化之静态初始化
初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组长度。
- 格式：数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,…};
int[] arr = new int[]{1,2,3}; - 数据类型[] 变量名 = {数据1,数据2,数据3,…};
int[] arr = {1,2,3};
动态初始化：手动指定数组长度，由系统给出默认的初始化值。
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。
数组操作的两个小问题
- 索引越界：访问了数组中不存在的索引，造成索引越界问题
- 空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常
null：空值，引用数据类型的默认值，表示不指向任何有效对象
数组常见操作
遍历
将数组中所有的数据取出来
获取数组元素数量
格式：数组名.length
arr.length
案例、
获取最值
public static void main(String[] args){
int[] arr = {12 ,45, 98, 73, 60};
int max = arr[0];
for(int i = 1; i<arr.length; i++){
//max=max>arr[i]?max:arr[i];
if(arr[i]>max){
max = arr[i];
}
}
System.out.println(max);
}
数组元素求和
键盘录入5个整数，存储到数组中，并对数组求和
import java.util.Scanner
public class test{
public static void main(String[] args){
Scannern sc = new Scanner(Syystem.in);
int sum = 0;
int[] arr = new int[5];
for(int i=0;i<arr.lenth;i++){
System.out.println("请输入第"+(i+1)+"个整数：");
arr[i]=sc.nextInt();
}
for(int i=0;i<arr.lenth;i++){
sum+=arr[i];
}
System.out.println(sum);
}
}
查找
import java.util.Scanner
public class test{
public static void main(String[] args){
int[] arr = {19, 28,37,46, 50};
Scannern sc = new Scanner(Syystem.in);
System.out.println("请输入您要查找的元素：");
int num = sc.nextInt();
int index = -1;
for(int i=0;i<arr.lenth;i++){
if(num==arr[i]){
index = i;
break;
}
}
System.out.println(index);
}
}
评委打分
import java.util.Scanner
public class test{
public static void main(String[] args){
Scannern sc = new Scanner(Syystem.in);
int[] arr = new int[6];
for(int i=0;i<arr.lenth;i++){
System.out.println("请输入第"+(i+1)+"个评委的打分：");
int score= sc.nextInt();
if(score>=0&&score<=100){
arr[i]=score;
}else{
System.out.println("您的输入有误！");
i--;
}
}
int max = arr[0];
for(int i=0;i<arr.lenth;i++){
if(max<arr[i]){
max=arr[i];
}
}
int min= arr[0];
for(int i=0;i<arr.lenth;i++){
if(min>arr[i]){
min=arr[i];
}
}
int sum = 0;
for(int i=0;i<arr.lenth;i++){
sum+=arr[i];
}
int avg = (sum - min - max)/4;
System.out.println(avg);
}
}
方法
概述
方法(method)就是一段具有独立功能的代码块，不调用就不执行，可以提高代码的复用性。
前提：
- 方法必须先创建才可以使用，该过程称为方法定义
- 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
定义和调用
定义
- 格式：
public static void 方法名(){
//方法体
}
调用 - 格式：
方法名();
注意： - 方法必须先定义后调用，否则程序将报错
- 方法与方法之间是平级关系，不能嵌套定义
public class DemoMethod{
public static void main(String[] args){
eat();
}
pulic static void eat(){
study();
System.out.println("吃饭");
}
pulic static void study(){
System.out.println("学习");
}
}
调用过程
- 方法没有被调用的时候，都在方法区中的字节码文件(.class)中存储
- 方法被调用的时候，需要进入到栈内存中运行
带参数方法的定义和调用
定义
- 格式：
public static void 方法名(参数){…} - 注意：
- 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
- 方法定义时，多个参数之间使用逗号(,)分割
调用
- 格式：
方法名(参数); - 注意：
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
public class DemoMethod{
public static void main(String[] args){
isEvenNumber(10);
}
pulic static void isEvenNumber(int num){
if(num%2==0){
System.out.println("偶数");
}else{
System.out.println("奇数");
}
}
}
形参和实参
形参：形式参数，是指方法定义中的参数。
实参：实际参数，方法调用中的参数。
打印n到m之间所有的奇数
public class DemoMethod{
public static void main(String[] args){
print(10, 20);
}
pulic static void print(int n, int m){
for(int i= n;i<=m;i++){
if(i%2==1){
System.out.println(i);
}
}
}
}
带返回值方法的定义和调用
根据一个方法产生的结果，来去组织另外一段代码逻辑，为了拿到这个方法产生的结果，就需要定义带有返回值的方法
定义
格式：
public static 数据类型 方法名(参数){
return 数据;
}
注意：
方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
调用
数据类型 变量名 = 方法名(参数);
定义一个方法，计算两个整数相加的和
public class DemoMethod{
public static void main(String[] args){
int num = add(10, 20);
System.out.println(num);
}
pulic static int add(int n, int m){
int c = n + m;
return c;
}
}
方法的通用格式
- 格式：
public static 返回值类型 方法名(参数){
方法体;
return 数据;
} - 定义方法时：
明确参数：主要是明确参数的类型和数量
明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型 - 调用方法时：
void类型的方法，直接调用即可
非void类型的方法，推荐用变量接收调用
方法的注意事项
- 方法不能嵌套定义
- 方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写，如果要编写return，后面不能跟具体的数据。
- return语句下面，不能编写代码
public class DemoMethod{
public static void main(String[] args){
print(10, 20);
}
pulic static void print(int n, int m){
if(m<n){
System.out.println("输入有误");
//return; 可以用于结束方法，也就是将方法从栈内存中弹出去，该过程称之为方法的弹栈
return;
//System.out.println(); 无效代码，无法执行
}
System.out.println(n+"到"+m+"之间的奇数为：");
for(int i= n;i<=m;i++){
if(i%2==1){
System.out.println(i);
}
}
}
}
方法重载
方法名相同，参数也完全相同，称为方法的重复定义，是一种冲突性的错误
调用方法的时候，JVM会通过参数的不同来区分同名的方法
概念
在同一类中，定义了多个同名的方法，但每个方法具有不同的参数类型或者参数个数，这些同名的方法，就构成了重载关系
好处：不用记忆繁琐的方法名
设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,int,long)
public class DemoOverload{
public static void main(String[] args){
int a= 10;
int b = 20;
System.out.println(compare(a,b));
}
pulic static boolean compare(int n, int m){
return n == m;
}
pulic static boolean compare(byte n, byte m){
return n == m;
}
pulic static boolean compare(short n, short m){
return n == m;
}
pulic static boolean compare(long n, long m){
return n == m;
}
}
方法的参数传递
方法参数传递(基本类型)
方法参数传递为基本类型，传入方法中的是具体的数值
方法参数传递(引用类型)
方法参数传递为引用类型，传入方法中，是内存地址
案例
- 设计一个方法用于数组遍历，要求遍历的结果在一行上的。如：[11,22,33,44,55]
public class DemoMethod{
public static void main(String[] args){
int[] arr = [11,22,33,44,55];
printArray(arr);
}
pulic static void printArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i==arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+",");
}
}
}
}
- 获取数组最大值
public class DemoMethod{
public static void main(String[] args){
int[] arr = [11,22,33,44,55];
int max = maxArray(arr);
System.out.print(max);
}
pulic static int maxtArray(int[] arr){
int max = arr[0];
for(int i=1;i<arr.length;i++){
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
}
- 同时获取数组最大值最小值
return语句 只能带回一个结果
public class DemoMethod{
public static void main(String[] args){
int[] arr = [11,22,33,44,55];
int[] maxAndMin = maxmintArray(arr);
System.out.print(maxAndMin[0]);
System.out.print(maxAndMin[1]);
}
pulic static int[] maxmintArray(int[] arr){
int max = arr[0];
for(int i=1;i<arr.length;i++){
if(max<arr[i]){
max = arr[i];
}
}
int min = arr[0];
for(int i=1;i<arr.length;i++){
if(min>arr[i]){
min = arr[i];
}
}
int[] maxAndMin = {min, max};
return maxAndMin;
}
}
进制
进位制
- 十进制
- 二进制
逢二进一 - 八进制
采用0-7八个数字，逢八进一 - 十六进制
用数字0-9和字母A-F(a-f)表示，其中A-F表示10-15
书写格式
- 十进制
java中数值默认都是10进制，不需要加任何修饰 - 二进制
数值前面以0b开头，b大小写都可以 - 八进制
数值前面以0开头 - 十六进制
数值前面以0x开头，x大小写都可以
注意：
以上内容是jdk7版本后才被支持
打印在控制台的都是十进制数据
进制转换
任意进制到十进制
公式：系数*基数的权次幂 相加
系数:每一【位】上的数
基数：几进制就是几
权：从数值的右侧，以0开始，逐个+1增加
- 二进制到十进制
- 十六进制到十进制
十进制到任意进制
公式：除基取余
使用源数据，不断的除以基数(几进制，基数就是几)得到余数，直到商为0，再将余数倒着拼起来即可。
- 十进制到二进制
- 十进制到十六进制
快速进制转换法
- 8421码
BCD码 二进制码十进制数
原码反码补码
注意：计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的。
-
原码(直观看出数据大小)：看数据
-
反码：转数据
正数的反码与其原码相同，负数的反码是对其原码逐位取反，但符号位除外 -
补码(数据以该状态进行运算)：运算数据
正数的补码与其原码相同，负数的补码是在其反码的末位加1
位运算
基本位运算
- 位运算符是二进制位的运算，先将十进制数转成二级智能会数再进行运算
- 在二进制位运算中，1表示true，0表示false。
6&2
~6
位移运算符
异或运算
一个数，被另外一个数，异或两次，该数本身不变
10^ 5 ^ 5 ->10
10 ^ 5 ^ 10 ->5
案例
- 数据交换
两个整数变量a=10, b=20 实现这两个变量的数据交换，最终输出a=20, b=10;
使用三方变量
public static void main(String[] args){
int a = 10;
int b = 20;
int temp = a;
a = b;
b = temp;
System.out.print("a="+a);
System.out.print("b="+b);
}
不允许使用三方变量
public static void main(String[] args){
int a = 10;
int b = 20;
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.print("a="+a);
System.out.print("b="+b);
}
- 反转
public static void main(String[] args){
int[] arr = {11, 22, 33, 44, 55};
for(int start = 0, end=arr.length-1;start < end;start++,end--){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
二维数组
二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器
动态初始化
定义格式
- 格式1：数据类型[][]变量名
int[][] arr; - 格式2：数据类型 变量名[][];
int arr[][]; - 格式3：数据类型[] 变量名[];
int[] arr[];
动态初始化
- 格式：数据类型[][] 变量名 = new 数据类型[m] [n];
m表示这个二维数组可以存放多少个一维数组
n表示每一个一维数组可以存放多少个元素
int[][] arr = new int[2][3];
二维数组地址
[[I@10f87f48
@：分隔符
I：当前数组让其中所存储的数据类型
10f87f48：十六进制内存地址
[[：几个中括号就代表的是几维数组
二维数组存储一维数组的时候，存储的是一维数组的内存地址
细节问题
先定义数组存入二维数组的是一维数组的地址
静态初始化
定义格式
- 格式：数据类型[][]变量名 = new 数据类型[][] {元素1, 元素2, …};
int[][] arr = new int[][] {{11, 22}, {33, 44}}; - 简化：数据类型[][]变量名 = {元素1, 元素2, …};
int[][] arr = {{11, 22}, {33, 44}};
常见操作
遍历
已知一个二维数组arr= { {11, 22,33}, {33, 44,55}}; 遍历该数组，取出所有元素并打印
public static void main(){
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]);
}
}
}
销售额求和
public static void main(){
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);
}
608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
