目录
实操:设计一个方法(print) 用于打印n到m之间所有的奇数
java入门+环境搭建
java是什么？能干什么？
JAVA由美国SAN公司在1995年推出的计算机语言。
09年oracle公司收购sun公司
JAVA语言的三个版本？
Java SE：标准版本，是其他两个版本的基础，用于桌面应用的开发。 目的是为EE打基础。（计算器，为后期java ee开发打基础）
Java ME： 小型版，用于嵌入式消费类电子设备。现在已经被安卓和ios取代了。
Java EE：（企业版）用于web方向的网站开发。
网页：通过浏览器将数据展示在用户面前
网站=网页+后台服务器
JAVA跨平台原理
java语言在不同操作系统平台上，需要相应的“翻译”，此翻译也就是虚拟机（软件）（虚拟机本身不允许跨平台），允许跨平台的是java程序。
JRE和JDK之间的关系和作用？（从开发步骤进行解答）
开发java程序的步骤：
编写代码：就是创建一个文件，将代码写到结尾是.java 的文件才可以被编译和执行
JRE=java runtime environment 缩写，指java运行环境，包含JVM虚拟机及java核心类库。
类：Java文件在代码中的集合体现（类=Java文件，一个文件一个1类）
类库：存放多个java文件的仓库。
核心类库：Java已经写好的，非常核心的，代码仓库。
重点理解：我们在编写代码的过程中，需要采用到java存放在JRE中，已经写好的java文件。
编译代码： .java文件是属于源文件，无法被JVM所识别执行的。
解决方案：将其翻译为JVM虚拟机可以直接识别的并执行
翻译方式：使用java提供在JDK中翻译的工具
JDK=java development kit java语言的软件开发工具包，内部包含了代码的编译工具和运行工具。
翻译成为.class文件（字节码文件），即可被JVM直接识别执行。
运行代码：也要使用JDK的运行工具去运行，将.class文件运行在JVM虚拟机上，代码运行在虚拟机中
JDK下载和安装？
地址：http://www.oracle.com
JDK里面各个目录的作用？
常用DOS命令提示符
dos命令提示符
目的为了能够使用JDK，bin目录里面的编译（javac.exe）和运行(java.exe)工具。
不是双击去使用（黑色窗口DOS命令提示符一闪而过）
到底怎么使用：指令！ cmd
盘符切换D:
查看详情dir
切换目录cd
退出 cd .. 退到上一级
cd.
在bin目录下输入 javac 跳出有显示用法（则验证jdk安装成功）
PATH环境变量配置
为什么要配置：目的是为了在任意目录（文件夹路径）下，都能访问到bin目录中的javac和java工具。
怎么配置？
Win+E---->找到计算机---->右击找到属性----->高级系统设置选择高级选择环境变量选择新建---> （控制面板里面的系统里面的高级设置 ）
在找到path
Hello World 案例的编写执行
1，新建文本文档，修改名字为HelloWorld.java
2，编写代码，
3，进入cmd 编译（javac 文件名.java） , 执行 （java 类名）
hello world 案例详解
class{} 此时建立了一个框架，编译会报错。 class就是一个类，也就是一个java程序
public class HelloWorld{ //public的作用是限制 类名称和 文件名 一致的。
//class是定义一个类，后面加上类明名称，也就是一个java程序（建立一个框架）
public static void main (String[] args){ //程序入口点，main方法称之为主方法
System.out.println("HelloWorld"); //程序输出
}
}notepad的使用
要执行的话，右键文件，找到打开所在文件夹（命令行）
注释：解释代码
关键字:被java赋予了特殊含义的英文单词
关键字特点
1，全部小写
2，有颜色标记
数据类型+类型转换
常量是什么？
程序执行过程中，值不会发生改变的量。
例子，使用语句输出的helloworld就是常量。
分类：
字符串常量：被双引号所包裹的内容。 "HelloWorld" "帅哥学java!"
整数常量：所有整数 666, -888
小数常量：所有小数 13.14,-5.21
字符常量：被单引号包裹的内容。 'A' , '0' ,'我'
布尔常量：just only ，true and false，单独打印没意义，为后面学运算符打基础
空常量：一个特殊的值，值为null ，数组部分详解 注意空常量不能输出打印。
变量是什么？
为什么需要变量？
浏览器里面的后台登录界面里面有用户名和密码，浏览器会将二者提交到后台的java程序里面，而后台java程序运行在内存里面，浏览器提交过来的数据也存放在内存里面，后台java程序会为用户名lisha开辟一个为userName的空间，同理密码为111222的开辟一个为passWord的空间。
如果有多个用户登录，那么userName和passWord这两块空间，所记录的值，经常发生变化，对于这种经常发生变化的数据，称之为变量。
结论：变量就是内存中的存储空间，空间中存储着经常发生变化的量（数据）。
变量的定义格式
数据类型 变量名 = 数据值;
数据类型有哪些？
不同的数据类型也分配了不同的内存空间，所以他们表示的数据大小是不一致的。
1字节（byte）=1B =8bit bit（比特位）=小b表示
数据类型分类
public class DemoVariable {
/*
基本数据类型
整数：
byte 1字节
short 2字节
int 4字节
long 8字节
小数：
float 4字节
double 8字节
字符：
char 2字节
布尔:
boolean 1字节
*/
public static void main(String[] args) {
//格式 ：数据类型 变量名=数据值；
//整数类型变量
int ab = 10;
System.out.println(ab); //在内存中划分出一个空间名字为ab，将值为10填入
//小数类型变量
double cd = 12.3;
System.out.println(cd);
//字符类型变量
char ef='z';
System.out.println(ef);
//布尔类型变量
boolean gh = true ;
System.out.println(gh);
}
}
变量注意事项
1，变量名不允许重复定义。
2，一条语句可以定义多个变量，但是需要逗号分割，注意逗号后面就不要加类型了啊！
3，变量使用以前一定要进行赋值，否者会报错为初始化变量。
4，定义float时候，需要在数值后面加入f的标识可大写可小写
和long时候，需要在数值后面加入l的标识可大写可小写，建议大写。 使用时不会显示出来。
5，变量的一个作用域范围：只在他所在的大括号里面管用。
注意，当大括号里面的代码执行完毕后，内部所定义的变量就会从内存中释放。
键盘录入
目的：是让我们操作数据变得灵活，即键盘输入什么，变量a就记录什么。
import java.util.Scanner;
public class DemoScanner {
/*
步骤1；导包，需要写在class上面
import java.util.Scanner;
步骤2：创建对象
Scanner sc = new Scanner(System.in);
只有sc可以改变，其他属于固定格式
步骤3：使用变量接收数据
int i = sc.nextInt();
只有i变量可以改变，其他属于固定格式
*/
public static void main (String[] args){
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.print(i);
}
}标识符
就是给类，方法，变量等起名字的符号。
组成：数字，字母，下划线和美元组成
不能是数字开头
不能是关键字
区分大小写
常见命名规定
小驼峰命名法：方法、变量
•约定1：标识符是一个单词的时候，首字母小写
范例1：name
约定2：标识符由多个单词组成的时候，第一个单河首字母小写，其他单词首字母大写
• 范例2：firstName
大驼峰命名法：类
•约定1：标识符是一个单词的时候，首字母大写
范例1：Student
约定2：标识符由多个单词组成的时候，每个单词的首字母大写
•范例2：GoodStudent
类型转换
为什么要学习类型转换？
int a = 10 ;
double b = 12.3 ;
数据类型 c = a + b; // a会先提升为大的后，也就是double类型后，再进行运算。 两个double运算还是double ，结果使用double接收。
类型转换分类：
隐式转换：将数据类型中取值范围小的数据，给取值范围大的类型赋值，可以直接赋值
eg：
int a = 10 ；
double b = a；//int 4字节，double8字节，就会输出10.0。简单记忆，小的给大的可以直接给。
注意：byte short chart 无论什么情况，都会先提升为int 类型后再参与运算。（用int接收）
强制转换：大给小
把一个表示数据范国大的数值或者变量赋值给另一个表示数据范国小的变量
格式：目标数据类型 变量名=(目标数据类型)值或者变量;
范例：int k = (int) 88.88 ; // k为88
注意：强制类型转换，有可能会发生精度损失
精度损失：简单理解，将容积为8升的容器中的水，倒入容积为4升的容器中，如果水超出了4升，就酒了。是暴力的把小数点后面的直接丢掉，不是四舍五入哦！
public class 类型转换案例 {
/*
找出下面代码错误，并指出原因并解决。
*/
public static void main(String[] args) {
byte a = 3 ;
byte b = 4 ;
byte c = a + b ; // 此处要进行强制转换 byte c = (byte) ( a + b ) ,,还要用()来提升算数优先级。
System.out.println(c);
byte d = 3 + 4 ;
System.out.println(d); // 这里的3和4是两个常量，Java存在常量优化机制，会在编译的时候就会让3和4进行相加，然后会自动判断7是否在byte的取值范国內。
// 不在范围内：编译出错
// 在范国肉：通过编译
//如果将3改为300就会报错，因为超过了byte的取值范围
long num = 1234567891011L ; //加L是强转
}
}运算符
算数运算符
运算符：对常量和变量进行操作的符号。
表达式：用运算符将常量和变量连接起来的符合jiava语法的式子就可以称
为表达式。
eg ：
int a = 10 ；
int b = 20 ；
int c = a + b ；
+ ： 运算符，算数运算符。
a + b ： 表达式 ，因为 + 是算术运算符，所以这个就是算数表达式。
算术运算符 符号 ： + - *
/ ：整数相除得整数，若要得小数，必须加入小数（浮点类型）的运算
%（取余）： 取余数。
public class suanshuyunsuan {
public static void main (String [] args){
System.out.println(10+20); //30
System.out.println(10-20); //-10
System.out.println(10*20); //200
System.out.println("----------------------");
System.out.println(10/2); //5
System.out.println(10/3); //3
System.out.println(10.0/3); //3.3333333333335
System.out.println(10/3.0); //3.3333333333335
System.out.println("----------------------");
System.out.println(10%3); //1
}
}
字符+的操作
public class suanshuyunsuan {
public static void main (String [] args){
int a = 1 ;
char b = 'a' ;
System.out.println(a+b); /* 解释： byte short char int 都会提升为int 之后，
在进行运算。但是char属于字符，字符是如何提升为int数值类型呢？char的提升过程就是，
查码表中字符对应的数值形式。用的ASCII码表：字节到字符的对应关系。目的是便于计算机以字
节方式进行存储。 */
}
}
注意只用记忆0，a，A三个位置即可。
字符串的+操作
public class suanshuyunsuan {
public static void main (String [] args){
/*作用：就是可以跟任意数据类型或者字符串去进行拼接。
字符串中出现+，那么此时他就是连接符了。*/
System.out.println("woshidashuaige"+66666); //woshidashuaige66666
System.out.println("woshidashuaige"+"lixinaki"); //woshidashuaigelixinaki
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 class suanshuyunsuan {
public static void main (String [] args){
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println("请输入一个三位数");
int ge=i%10; //个位
int shi=i/10%10; //十位
int bai=i/100; //百位
System.out.println("整数"+i+"个位为："+ge); //整数876个位为：6
System.out.println("整数"+i+"十位为："+shi); //整数876十位为：7
System.out.println("整数"+i+"百位为："+bai); //整数876百位为：8
/*总结：
个位：数值%10
十位：数值/10%10
百位：数值/10/10%10
千位：数值/10/10/10%10 。。。。。。等等*/
}
}
自增自减运算符：
/*
++ 自增 变量值加1
-- 自减 变量值减1
a++ a = a + 1 ；
b-- b = b - 1；
单独使用无论放前面或后面都先运算。
++ 和 -- 只能操作变量不能操作常量。会报错。
*/
public class suanshuyunsuan {
public static void main (String [] args){
int a = 20 ;
a++;
System.out.println(a); //像这种单独的自增自减，就直接运算。输出为21
int b = a++ ;
System.out.println(a); //a ++ 和 a --都是先运算在自增。
System.out.println(b); // 输出结果a=22 ， b = 21 。
int c = ++a ;
System.out.println(a); // 输出结果a=23 ，b = 23。
System.out.println(c); // --a 和++ a 都是先自增在运算。输出结果为c=21
System.out.println(10++); //这种情况下是会报错的，常量不能进行自增自减。
}
}赋值运算符
| 符号 | 作用 | 说明 |
| = | 赋值 | a=10,将10的值给变量a。 |
| += | 加后赋值 | a+=b , 将a+b的值给a。 |
| -= | 减后赋值 | ，将a-b的值给a。 |
| *= | ，将a*b的值给a。 | |
| /= | ，将a/b的商给a。 | |
| %= | ， 将a/b的余数给a |
//扩展：赋值运算符会自带强转功能。
public class suanshuyunsuan {
public static void main (String [] args){
/*找出下面的程序错误，并加以改正*/
short s = 1;
s = (short)(s+1); //错误的是s = s + 1 ；
System.out.println(s);
short ss = 1 ;
ss += 1;
System.out.println(ss); //下面是对的。原因是+=可以制动进行强制转换！
}
}关系运算符（比较运算符）
| 符号 | 说明 |
| == | a==b,判断a和b的值是否相等，成立为true ，不成立为false |
| ！= | a！=b,判断a和b的值是否不相等，成立为true ，不成立为false |
| > | a>b,判断a是否大于b，成立为true ，不成立为false |
| >= | 同理 |
| < | 同理 |
| <= | 同理 |
public class suanshuyunsuan {
public static void main (String [] args){
System.out.println(10>20); // false
}
逻辑运算符
/*
实际中我们是 5< x < 15 这样表示的。
java里面
拆解后：x > 5和x < 15
java表示： x>5 & x<15
*/
public class suanshuyunsuan {
public static void main (String [] args){
/*
逻辑运算符 的作用，【整合多个表达式的运算符】
1.连接多个比较表达式
2.连接true 或 false ，直接连接布尔常量类型或变量。
最终得到的结果是boolean类型的true 或 false
*/
/*
逻辑运算符的分类
&与 他与他 成功就成功
|或 有一个 成功就是成功
!非 取反，!true
^异或 相同就是false，不同就是true
*/
int x = 30;
//true & true
System.out.println(x>5 & x<35); //结果是true
}
}短路逻辑运算符
| 符号 | 作用 | 说明 |
| && | 短路与 | 和&作用一样，但是有短路的作用 |
| || | 短路或 | 和 | 作用一样，但是有短路的作用 |
public class suanshuyunsuan {
/*
&和&&的区别 ：
&:无论符号左边是否是true，右边都要继续执行。
&&：具有短路效果，符号左边为false，右边就不再执行了，如果为true ，右边继续执行
|：无论符号左边是否是true，右边都要继续执行。
||：具有短路效果，符号左边为false，继续执行，如果为左边为真，右边不执行
*/
public static void main (String [] args){
int x = 3 ;
int y = 4 ;
System.out.println(++x > 4 & y-- < 5);
//System.out.println(++x > 4 && y-- < 5);
System.out.println("x="+x);
System.out.println("y="+y);
/*输出结果
&
D:\java代码>java suanshuyunsuan.java
false
x=4
y=3
&&
D:\java代码>java suanshuyunsuan.java
false
x=4
y=4*/
}
}
三元运算符
/*
格式： 关系表达式？表达式1：表达式2 ；
先运算关系表达式，true的话就运算表达式1的值，否者就是2的值。
使用场景：求两个变量的最大值。
*/
public class suanshuyunsuan {
public static void main (String [] args){
int x = 3 ;
int y = 4 ;
int max = x > y ? x : y ;
System.out.println("max="+max);
/*
结果：
D:\java代码>java suanshuyunsuan.java
max=4
*/
}
}实操案例：三个和尚
需求：一座寺庙里面有三个和尚，身高分别为150cm，210cm，165cm，求最高升高。
分析：
1.定义三个变量
int man1=150；
int man2=210；
int man3=165；
2.int maxman = （man1>man2）？ Man1:man2;
3.int caojiman= (maxman>man3)?maxman:man3;
4打印出来
程序流程控制
作用：用于控制程序的执行流程。
流程控制语句分类（三类）
顺序结构
作用：java默认的执行流程，从上到下依次顺序执行。
分支结构(if.switch)
if语句（三种类型）
if语句格式1：
if（关系表达式）{
语句体；
} //如果关系表达式为true，就继续执行语句体，false就不执行语句体，执行后面的其他语句
public class fenzhiyuju {
public static void main (String[] args){
System.out.println("开始");
int age = 17;
if (age >= 18){
System.out.println("可以上网吧");
}
System.out.println("结束");
}
}if语句格式2：
if（关系表达式）{
语句体1；
}
else {
语句体2；
}
语句体3； //如果，否者的关系，二者只能选其一，然后执行语句3
public class fenzhiyuju {
public static void main (String[] args){
int num = 10;
if (num%2 == 0){
System.out.println("它是偶数");
}
else{
System.out.println("它是奇数");
}
}
}if语句格式3：目的是想用上多个判断条件
if (判断条件1){
语句体1；
}else if（判断条件2）{
语句体2；
}……..
else {
语句体 n+1；
}
public class fenzhiyuju {
public static void main (String[] args){
int score = 70;
if (score >= 90 && score <= 100){
System.out.println("成绩为优秀");
}
else if (score >= 70 && score <= 89) {
System.out.println("成绩为一般");
}
else if (score >= 60 && score <= 69){
System.out.println("成绩为及格");
}
else if (score >= 0 && score <= 60){
System.out.println("请继续加油");
}
else{
System.out.println("您的成绩有误");
}
}
} //D:\java代码>javac fenzhiyuju.java
//fenzhiyuju.java:19: 错误: 需要 class、interface、enum 或 record
//进行删除多余的大括号。if 语句 案例 ：
需求，键盘录入学生考试成绩，根据成绩，程序给出不同奖励 ，，同上一样，加入了键盘录入。
switch语句
格式 ： switch （表达式）{
case 值1 ：
语句体1；
break；
case 值2 ：
语句体2；
break ； //中断，用于结束switch语句
…
default : //都不匹配就匹配default
语句体 n+1；
break ；
} //顺序匹配语句体，
注意 ：case 后面的值不允许重复，且只能是常量不能是变量！
import java.util.Scanner;
public class fenzhiyuju {
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("您输入有误!");
}
}
}switch 语句的穿透现象：
需求：键盘录入星期数，输出工作日，休息日。
（1-5）工作日，（6-7）休息日。
穿透是如何产生的？
如果switch语句中，省略了break语句，就会开始穿透。
现象：
当开始穿透的时候，后续会继续匹配不会再有匹配效果，直到break ，或者switch语句执行完毕，才会结束。
作用优化代码！
使用场景： 发现case给出的语句体中出现了重复的，可以考虑用case穿透进行优化代码。
import java.util.Scanner;
public class fenzhiyuju {
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. while,do..while）
for循环语句格式
for(初始化语句；条件判断语句；条件控制语句){
循环体语句；
}
案例1：1-5求和
public class xunhuan {
public static void main (String[] args){
int i = 1 ;
int sum = 0;
for(i=1;i<=5;i++){
sum += i;
System.out.println(sum);
}
System.out.println("数字1-5的和为"+sum);
}
}
/*
结果：
D:\java代码>java xunhuan.java
1
3
6
10
15
数字1-5的和为15
*/
案例2：求1-100的偶数和，并把结果打印到控制台输出。
public class xunhuan {
public static void main (String[] args){
int i = 1 ;
int sum = 0;
for(i=1;i<=100;i++){
if (i%2==0){
sum += i ;
}
}
System.out.println("数字1-100的偶数和为"+sum);
}
}
/*
数字1-100的偶数和为2550
*/案例3：水仙花数，输出所有水仙花数
什么是水仙花数？？
例如一个三位数，个加十加百位数字的立方和等于原数。
public class xunhuan {
public static void main (String[] args){
int i = 1 ;
for(i=1;i<=999;i++){
int ge = i %10 ;
int shi = i / 10 % 10 ;
int bai = i / 100 %10 ;
if ((ge*ge*ge+shi*shi*shi+bai*bai*bai)==i){
System.out.println(i);
}
}
}
/*
1
153
370
371
407
*/案例4：统计
需求：在控制台输出所欲水仙花数，要求每行打印2个水仙花数
System.out.println(i ); //打印后 换行
System.out.print(i+"_"); //打印后 不换行
public class xunhuan {
public static void main (String[] args){
int i = 1 ;
int sum = 0;
int count = 0 ; //判断一排有好多个。
for(i=1;i<=999;i++){
int ge = i %10 ;
int shi = i / 10 % 10 ;
int bai = i / 100 %10 ;
if ((ge*ge*ge+shi*shi*shi+bai*bai*bai)==i){
System.out.print(i+" ");
count++ ;
if (count %2 == 0 ){
System.out.println() ;
}
}
}
}
}
/*
1 153
370 371
407
*/
while循环语句
完整格式：
初始化语句；
while （条件判断语句）{
循环体语句；
条件控制语句；
}
基本格式 ：
while （条件判断语句）{
循环体语句；
}
案例1：珠穆朗玛峰
已知山峰高度为8844.43m=8844430mm，假如有一张0.1mm的纸，要对折多少次，可以折成珠穆朗玛峰的高度.
为啥要使用while ，场景 ： 不明确到底要折叠多少次的情况，反之明确知道次数，就使用for。
public class xunhuan {
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(paper) ;
}
System.out.println(count) ;
}
}do...while循环语句格式
基本格式：
do{
循环体语句;
}while(条件判断语句);
完整格式：
初始化语句；
do{
循环体语句;
条件控制语句；
}while(条件判断语句);
特点是无论如何都会去执行一遍循环体。
public class xunhuan {
public static void main (String[] args){
int i = 11 ;
do{
System.out.println("我是大帅哥！") ;
i++ ;
}while (i <= 10) ;
System.out.println(i) ;
}
}
/*
我是大帅哥！
12
*/三种循环的区别，以及各自的应用场景。
三种循环的区别 :
for循环和while循环先判断条件是否成立，然后决定是否执行循环体(先判断后执行)
do...while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体(先执行后判断)
for和while的区别:
条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
三种循环的场景:
明确循环次数，推荐使用for循环 例如:在控制台打印10次HelloWorld,求1-100之间的数据和不明确循环次数，推荐使用while循环 例如:珠穆朗玛峰案例
do..while循环，很少使用
public class xunhuan {
public static void main (String[] args){
for (int i=1;i<=5;i++){
System.out.println(i) ; //原因是for循环里面定义的变量，在执行完循环后会被内存释放。
}
// System.out.println(i) ; //xunhuan.java:6: 错误: 找不到符号
System.out.println("----------------") ;
//while 循环
int i = 1 ;
while (i <= 10){
System.out.println(i) ;
i++ ;
}
System.out.println(i) ; //区别就是此处的i不属于while循环语法结构。
}
}死循环
死循环:无限循环
举例1:不开心我就吃，吃了我就胖，胖了我就不开心
举例2:第一天上课没精神，晚上熬夜复习，第二天没精神，晚上熬夜复习，第三天没精神
死循环格式(三种)
for(;;){ }
while(true){ }
do{ }while(true);
while的死循环格式是最常用的命令提示符窗口中Ctrl+C可以结束死循环
public class xunhuan {
public static void main (String[] args){
//for (;;){
//System.out.println("停不下来了") ;
//}
//while (true) {
//System.out.println("停不下来了") ;
//}
do{
System.out.println("停不下来了") ;
}while(true) ;
System.out.println("看看我能被执行吗") ; // 错误: 无法访问的语句，因为执行不到它了！
}
}跳转控制语句
//作用：某个条件达成是跳过继续下一次执行或则结束某个循环。
public class xunhuan {
public static void main (String[] args){
/*需求：模拟电梯上行的过程1-24层，4楼不停.
注意：使用基于条件控制，循环内部使用。
*/
for (int i = 1 ; i <= 24 ;i++){
if(i == 4){
continue; //循环内部使用，跳过的作用。continue关键字。
}
System.out.println(i+"层到了");
}
/*需求：模拟20工作到80岁，60岁退休。
注意：break只能在循环和switch里面使用。*/
for (int s = 20 ; s <= 80 ; s++){
if (s == 60){
break ;
}
System.out.println(s+"岁正在上班");
}
}
}案例1：减肥计划改进版本
需求：用户可以多次查询对应星期的减肥计划，直到输入0，程序结束。
思路
1，业务功能是多次进行，此处需要循环
2，不明确循环次数，采用while循环
3，匹配到0的时候，使用break结束循环
/*
标号名:while(true){
switch(表达式){
case 1 ：
break 标号名 ;
}
}
*/
import java.util.Scanner ;
public class xunhuan {
/*步骤：
1.不明确用户操作几次，使用死循环包裹业务逻辑
2.匹配到0时，使用break结束循环死循环。*/
public static void main (String[] args){
lo:while (true){
System.out.println("请输入您要查看的星期数：") ;
System.out.println("如果无需继续查看，请输入0退出程序") ;
Scanner sc = new Scanner (System.in);
System.out.println("请输入周几？");
int week = sc.nextInt();
switch (week) {
case 0 :
System.out.println("感谢您的使用");
break lo ; //跳转出lo名字的while循环，不加上lo的话就是跳转出switch语句。
//小结：break 和continue 只能跳出，跳过自己所在的那一层关系，
//如果想要跳出，跳过指定的一层就可以加入标号。
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("您输入有误!");
}
}
}
}
RanDom：产生一个随机数
使用步骤:
1，导包
import java.util .Random;
导包的动作必须出现在类定义的上面
2,创建对象
Randon r = new Random() ;
上面这个格式里面，r是变量名，可以变，其他的都不允许变
3,获取随机数
int number = r.nextInt() ; //获取数据的范围:[0,10) 包括0,不包括10
上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变
import java.util.Random ; // 导包，产生随机数
public class xunhuan {
public static void main (String[] args){
Random r = new Random() ; //创建对象
int num = r.nextInt(10) ; //
System.out.println(num) ;
}
}import java.util.Random ; // 导包，产生随机数
public class xunhuan {
public static void main (String[] args){
Random r = new Random() ; //创建对象
for(int i=1;i<=10;i++){ //循环执行十次，得出十个随机数。
int num = r.nextInt(10) ; //r.nextInt(10) 还可以接+ - * / 的运算符，进行操作。
System.out.println(num) ;
}
}
}案例1:猜数字
需求:程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示
如果猜的数字比真实数字大，提示你猜的数据大了
如果猜的数字比真实数字小，提示你猜的数据小了
如果猜的数字与真实数字相等，提示恭喜你猜中了
分析:
A,要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
B,因为无法预知几次能够猜中，因此猜数字这个操作应该是反复进行的，需要使用循环，而while循环通常用于描述未知循环次数的循环
C,使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
D,比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else.if格式，根据不同情况进行猜测结果显示，当猜中后使用break结束循环即可
import java.util.Random ; // 导包，产生随机数
import java.util.Scanner ;
public class xunhuan {
public static void main (String[] args){
//1,准备Random和Scanner的对象，分别用于产生随机数和键盘录入
Random r = new Random() ;
Scanner sc = new Scanner(System.in) ;
//2,使用random产生一个1-100的随机数，作为要猜测的数字。
int randomnum = r.nextInt(100)+1 ;
System.out.println(randomnum) ; //走后门打印出来
//5以上内容需要进行多次，但是无法预估用户输入几次可以猜对，使用while （true）死循环，进行包裹。
while (true) {
//3，键盘录入用户猜测的数据。
int num = sc.nextInt() ;
//4,使用录入的数据和随机数对比，并给出提示。
if(num >randomnum){
System.out.println("猜大了") ;
}else if(num < randomnum) {
System.out.println("猜小了") ;
}else{
//6.猜对之后，break结束
System.out.println("猜中了") ;
break ;
}
}
}
}数组
数组是什么?为什么要使用？
数组(array)是一种容器，用来存储同种数据类型的多个值
总结:数组容器在存储数据的时候，需要结合数据类型考虑例如 : int类型的数组容器 (boolean byte short double ]
建议:容器的类型，和存储的数据类型保持一致
那么为什么要使用数组呢？
数组定义格式
格式一:
数据类型[ ] 变量名
范例:int[] array
格式二:
数据类型 变量名[]
范例:int array[ ]
publicclassshuzushiyan{
/*
数组的定义格式：
1.数据类型[] 数组名;定义了一个int类型的数组，数组名交arr
2.数据类型 数组名[];
*/
publicstaticvoidmain(String[]args){
int[]arr;
System.out.println(arr);//报错原因没有初始化或者赋值。
}
}数组初始化之动态初始化
Java中的数组必须先初始化然后才能使用
所谓初始化：:就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
public class shuzushiyan {
/*
数组的动态初始化：
在初始化的时候，需要手动指定数组长度，系统会为数组容器分配初始值。
动态初始化格式：
数据类型[] 数组名 = new 数据类型[数组长度] ;
注意：
[I@23fc625e
@：分隔符
[:当前的空间是一个数组类型
I：当前数组容器中所存储的数据类型
23fc625e：十六进制内存地址。
*/
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度] ;
//通过new关键字创建一个int类型的数组容器，该容器可以存储5个int类型的整数，该容器被arr数组变量所记录。
int [] arr = new int [5] ;
System.out.println(arr); //打印数组变量的时候会打印出数组的内存地址[I@23fc625e
byte [] bArr = new byte [3] ;
System.out.println(bArr);
}
}
数组元素访问
数组内存地址的访问方式
格式:数组名
数组内部保存的数据的访问方式
格式:数组名[索引]
索引是什么?干嘛用的?
假如数组容器中，已经存储了三个愿望(不错的生意，貌美如花的妻子，当官的兄弟)
现在让你选一个，该如何将你的选择告诉数组 ?
假如你选择了第二个！（这里就引出了数组中的元素位置需要编号！，计算机中习惯从0开始）
public class shuzushiyan2 {
public static void main(String[] args) {
int[] arr = new int[3] ;
System.out.println(arr); //[I@23fc625e 内存地址
System.out.println(arr[0]); //0 是系统自动分配的默认初始化值
System.out.println(arr[1]); //0
System.out.println(arr[2]); //0
System.out.println("---------------------") ;
//数组名[索引]
arr[0] = 9 ;
arr[1] =5 ;
arr[2] = 2 ;
System.out.println(arr[0]); //9
System.out.println(arr[1]); //5
System.out.println(arr[2]); //2
}
}内存分配
目的是更加了解数组在内存中的操作过程。
Java中内存分配
Java 程序在运行时，需要在内存中分配空间.为了提高运算效率，就对空间进行了不同区域的划分每一片区域都有特定的处理数据方式和内存管理方式。
栈内存:方法运行时，进入的内存，局部变量都存放于这块内存当中
堆内存:new出来的内容都会进入堆内存，并且会存在地址值
方法区:字节码文件(class文件)加载时进入的内存
本地方法栈:调用操作系统相关资源
寄存器:交给CPU去使用（重点是前三个）
每new一次就会在堆内存里面新产生一个空间。堆内存的地址空间绝对不会存在重叠现象
那么多个数组指向相同内存图呢？
public class Dem5Array {
/*两个数组指向相同*/
public static void main(String[] args) {
int[] arr1 = new int[2];
arr1[0] = 11;
arr1[1] = 22;
/*
数组类型的变量应该记录什么?
地址值
*/
int[] arr2 = arr1;
arr2[0] = 33;
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println("---------");
System.out.println(arr2[0]);
System.out.println(arr2[1]);
}
}
/*
D:\develop\jdk-13.0.2\bin\java.exe -Didea.launcher.port=52111 "-Didea.launcher.bin.path=D:\develop\IntelliJ IDEA 2018.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\java_project\java bases\out\production\java bases;D:\develop\IntelliJ IDEA 2018.3.3\lib\idea_rt.jar" com.intellij.rt.execution.application.AppMainV2 Dem5Array
33
22
---------
33
22
Process finished with exit code 0
*/
数据类型默认值
数组初始化之静态初始化
静态初始化:初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组长度
格式:数据类型[] 变量名 = new 数据类型[] {数据1,数据2，数据3,......};
范例 :int[] arr = new int[] {1 ,2 , 3 } ;
简化格式:数据类型[] 变量名= {数据1，数据2,数据3，....};
范例 :int []arr = {1 , 2 , 3};
/*
静态初始化:需求中已经明确了要操作的具体数据，直接静态初始化即可例:将一班的学生成绩存入数组中 11，22，33
intl arr = {11, 22, 33};
*/
public class Dem5Array;{
/*
数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度
完整格式:
数据类型[] 数组名 = new 数据类型{数据1，数据2，数据3...};
简化格式:
数据类型[] 数组名 ={数1,数据2,数3...};
*/
public static void main(String[]args){
// 数类型[] 数组名 = new 数据类型[]{数据1,数2,数据3...};
int[]arr=new int[]{11,22,33};
System.out.printIn(arr[0]);
System.out.printIn(arr[1]);
System.out.println(arr[2]);
// 数据类型[] 数组名 = {数据1,数据2，数据3...};
int[]arr2={44,55,66};
System.out.printIn(arr2);
System.out.printIn(arr2[0]);
System.out.printIn(arr2[1]);
System.out.printIn(arr2[2]);
}
}两种初始化的区别对比
动态初始化:手动指定数组长度，由系统给出默认初始化值。
静态初始化:手动指定数组元素，系统会根据元素个数，计算出数组的长度。
数组操作的常见小问题
索引越界:访问了数组中不存在的索引对应的元素，造成索引越界问题
空指针异常:访问的数组已经不再指向堆内存的数据，造成空指针异常
null:空值，引用数据类型的默认值，表示不指向任何有效对象
数组常见操作
遍历：取出数组中所有数据
public class shuzu {
/*
数组遍历：通过循环获取元素
动态获取数组元素个数：数组名.length
*/
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66};
//数组名.length
System.out.println("数组arr中元素个数为："+arr.length);
//for(int i = 0 ; i < 5 ;i++){ //手动写死了，不严谨，不推荐
for(int i = 0 ; i < arr.length ;i++)
//i:0,1,2,3,4
System.out.println(arr[i]);
}
//遍历：就是指取出数据的过程！！！
//遍历的通用格式
/*
int[] arr = {......}
for(int i = 0 ; i < arr.length ; i++){
对arr[i]进行操作
}*/
}
}
/*
数组arr中元素个数为：6
11
22
33
44
55
*/取出最值（最大）
public class shuzu {
/*
需求:从数组中查找最大值
int[] arr = (12,45,98, 73,60);
实现步骤:
1，假设数组中的第一个元表为最大值
2，遍历数组，获成每一个元表，准备进行比较
3，如果比较的过程中，出现了比max 更大的， max记录更大的值
4，循环结束后，打印最大值
*/
public static void main(String[] args) {
int[] arr = {12, 45, 98, 73, 68};
// 1， 假设数组中的第一个元表为最大值
int max = arr[0];
// 2.遍历数组，获成每一个元素，准备进行比教
for (int i = 1; i < arr.length; i++) {
// 3.如果比教的过程中，出现了比max更大的， max记录更大的值
if (arr[i] > max) {
max = arr[i];
}
}
// 4. 据环结束后，打印最大值
System.out.println("max:" + max);
}
}数组元素求和
import java.util.Scanner ;
public class shuzushiyan_arry1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int sum = 0;
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第" +(i + 1) + "个整数");
arr[i] = sc.nextInt();
}
for (int i = 0; i < arr.length; i++) { //一个for循环一个功能 ，数组名字.fori 快捷键生成for循环
sum += arr[i];
}
System.out.println("sum:" + sum);
}
}方法（method）
是什么？为什么要用？
1，就是一段具有独立功能的代码块，不调用就不执行。
2，例如豌豆射手，寒冰豌豆，大白菜射手等，共同点发射炮弹代码20行，也就是公共代码区域。
方法的定义和调用
a，方法必须先创建才可以使用，该过程称为方法定义
public static void 方法名(){ //eat
方法体
}
b，方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
方法名() ;
eat() ;
//注意：必须要先定义，才可以被调用！
//方法与方法间是平级关系，不能被嵌套定义！public class methodtest0 {
public static void main(String[] args) {
study() ;
eat() ;
}
public static void study () { //必须要定义void，java: 方法声明无效; 需要返回类型
System.out.println("学习");
}
public static void eat () {
study();
System.out.println("吃饭");
}
}方法的调用过程
方法没有被调用的时候，都在方法区中的字节码文件(class)中存储。
方法被调用的时候，需要进入到栈内存中运行
先进后出原则（例如子弹匣）
方法练习：奇偶数判断
/*
方法练习
需求:设计一个方法method，方法中定义一个变量(数值随意判断这个变量是奇数还是偶数，并在main方法中调用method.
思路:
一:定义方法，名称为method
二:方法中定义变量，使用i语句判断是奇数还是偶数
三:main方法中调用method方法
*/
public class methodtest1 {
public static void main(String[] args) {
method() ;
}
public static void method(){ //注意方法不能定义在主函数里面。
int num = 99 ;
if(num % 2 == 0){
System.out.println("是偶数") ;
}else{
System.out.println("是奇数");
}
}
}带参数方法的调用
如果定义方法里面的参数被写死了，那么可用性就降低，别人也要来使用的话，就要改方法里面的参数。
所以如上代码，要修改！改为如下：
public static void method(int num){
if(num % 2 == 0){
System.out.println("是偶数") ;
}else{
System.out.println("是奇数");
}
}
}带参数方法的定义格式
格式： public static void 方法名（参数）{... ...}
格式（单个参数）：public static void 方法名 (数据类型 变量名){... ...}
范例（单个参数）：public static void method （int number）{......}
格式（多个参数）：public static void 方法名 (数据类型 变量名,数据类型 变量名,... ...){... ...}
范例（多个参数）：public static void getmax （int number,int number）{......}
注意：
方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
方法定义时，多个参数之间使用逗号(,)分隔
带参数方法的调用格式
格式：方法名（参数） ；
格式（单个参数）：方法名（变量名/常量值） ；
范例（单个参数）：method （5） ；
格式（多个参数）：方法名(变量名1/常量值1，变量名2/常量值2);
范例（多个参数）：getmax（5，6）；
public class methodtest2 {
public static void main(String[] args) {
isjioushu(10);
}
public static void isjioushu(int num ){
if(num % 2 == 0){
System.out.println("是偶数") ;
}else {
System.out.println("是奇数");
}
}
} 形参和实参
形参:全称形式参数，是指方法定义中的参数（变量）
实参:全称实际参数，方法调用中的参数
实操:设计一个方法(print) 用于打印n到m之间所有的奇数
例如:
5-10之间所有的奇数为:
5
9
思路：
1:定义方法，名称为print
2:为方法添加两个int类型的形参，准备接受调用者传递过来的实参
3:方法中设计for循环，循环从n开始，到m结束
4:循环中加入if判断，是奇数，则打印
5:main方法中调用print方法，传入两个实际参数
public class methodtest2 {
public static void main(String[] args) {
isjioushu(10,20);
}
public static void isjioushu(int n , int m ){
System.out.println(n+"到"+m+"之间的奇数为：");
for(int i = n ; i <= m ; i++ ) {
if (i % 2 != 0) {
System.out.println(i) ;
}
}
}
} 带返回值方法的定义和调用
为什么要用？
我们经常会根据一个方法产出的结果，来去组织另外一段代码逻辑为了拿到这个方法产生的结果，就需要定义带有返回值的方法。
带返回值方法的定义格式
格式： public static 数据类型 方法名（参数）{
return数据 ；
}
范例1：public static boolean eat(int number){
return true ;
}
范例2：public static int getmax（int a, int b）{
return 100;
}
注意：方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。
带返回值方法的调用格式
格式1： 方法名（参数） ;
get(5) ;
格式2： 数据类型 变量名 = 方法名（参数） ；
boolean flag = get (5) ;
注意：方法的返回值通常会使用变量进行接收，否则返回的值无意义。
public class methodtest3 {
public static void main(String[] args) {
int sum = add(10, 30) ;
System.out.println(sum);
}
public static int add (int a , int b ){
int c = a + b ;
return c ;
}
}案例：设计一个方法可以获取到两个数的最大值，数据来自于参数
思路：
1，定义一个方法，声明两个形参接收计算的数值，求出结果并返回
2，使用if语句得出a和b之间的最大值，根据情况retum具体结果
3，在main0方法中调用定义好的方法并使用变量保存
4，在main0方法中调用定义好的方法并直接打印结果
public class methodtest3 {
public static void main(String[] args) {
int max = getmax (80, 30) ;
System.out.println(max);
}
public static int getmax (int a , int b ){
if(a > b){
return a ;
}else if (a < b) {
return b ;
}else {
return 0 ;
}
}
}
方法的通用格式
格式： public static 返回值类型 方法名（参数）{
方法体；
return；
}
//void 一般没有数据返回，方法体中也不写return定义方法时，要做到两个明确：
1，明确参数:主要是明确参数的类型和数量
2，明确返回值类型:主要是明确方法操作完毕之后是否有数据返回，如果没有，写void;如果有，写对应的数据类型。
调用方法时
1，void类型的方法，直接调用即可
2，非void类型的方法，推荐用变量接收调用
方法的注意事项？
1，方法不能嵌套定义
2，方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写如果要编写return，后面不能跟具体的数据。
3，return语句下面，不能编写代码，因为永远执行不到，属于无效的代码
方法重载
同一个类中可不可以存在同名的方法？
public class shuzu {
public static void method (int a , int b) {
//计算a+b的和
System.out.println(a+b);
}
public static void method (int a , int b){
System.out.println(a-b); //method(10,20)到底执行哪一个逻辑呢？
}}
//方法名相同，参数也完全相同，称为方法的重复定义，是一种冲突性错误。
//调用方法时，java虚拟机会通过参数的不同来区分同名的方法。
//例如method（10,20）和method（10，20,30）·在同一个类中，定义了多个同名的方法，但每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
·简单记:同一个类中，方法名相同，参数不同的方法
参数不同: 个数不同、类型不同、顺序不同（不建议使用）
注意:识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关
public class shuzu{
public static void main(String[] args) {
print(10,20);
}
public static void print(int n , int m){
if(m < n){
System.out.println("输入有误");
return ; //可以用于结束方法，也就是将方法从栈内存中弹出去，此过程为弹栈。
// return下面不是不能写代码吗？
}
System.out.println("n到m的奇数为："); // ctrl+鼠标右键，可以查看println的源代码，也就是重载的好处！直接调用各种类型的println！
for (int i = n; i<=m ; i++) {
if(i%2==1){
System.out.println(i);
}
}
}
}
//重载好处：不用记忆过多繁琐的方法名字。重载方法练习：
需求:使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型(byte,short,int，long)
思路:
一：定义一个比较的方法ompare()，参数选择两个int整形参数
二：定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
三：定所有的重载方法，两个byte类型与两个short类型参数
四：完成方法的调用，测试运行结果
public class shuzu{
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
System.out.println(compare(a,b));
}
public static boolean compare(int a , int b){
return a == b ;
}
public static boolean compare(short a , short b){
return a == b ;
}public static boolean compare(byte a , byte b){
return a == b ;
}public static boolean compare(long a , long b){
return a == b ;
}
}方法的参数传递
（基本类型）
public class shuzu{
/*
方法参数传递为基本数据类型 ：
传入方法中，是具体的数值。
*/
public static void main(String[] args) {
int number = 100 ;
System.out.println("调用change方法前：" + number);
change(number);
System.out.println("调后change方法前：" + number);
}
public static void change(int number){
number = 200 ; //只改change里面的number，不改主方法里面的，然后执行完后弹出栈内存，但是主方法里面的还是100！
}
}（引用类型）
public class shuzu{
/*
方法参数传递为引用数据类型 ：
传入方法中，是内存地址。
*/
public static void main(String[] args) {
int[] arr = {10,20,30} ;
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调后change方法前：" + arr[1]);
}
public static void change(int[] arr){
arr[1] = 200 ;
}
}
/*调用change方法前：20
调后change方法前：200*/
数组遍历
需求:设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如:[11,22,33,44,55]
思路:
一：定义一个数组，用静态初始化完成数组元素初始化
二：定义一个方法，对数组进行遍历
三：历打印的时候，数据不换行
System.out.print0;
四：用遍历方法
public class shuzu {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55};
printarr(arr);
System.out.println("另外一段逻辑代码");
}
public static void printarr(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length ; i++) {
if(i == arr.length - 1){
System.out.print(arr[i]+ "]");
}else{
System.out.print(arr[i]+",");
}
}
}
}获取数组最大值
需求:设计一个方法用于获取数组中元素的最大值
思路:
一：定义一个数组，用静态初始化完成数组元素初始化
二：定义一个方法，用来获取数组中的最大值
三：调用获取最大值方法，用变量接收返回结果
四：把结果输出在控制台
public class shuzu {
public static void main(String[] args) {
int[] arr ={11,22,33,44,55,44,33,22,11} ;
int max = getmax(arr) ;
System.out.println(max);
}
public static int getmax(int[] arr){
int max = arr[0] ;
for (int i = 0; i < arr.length ; i++) {
if(max < arr[i]){
max = arr[i] ;
}
}
return max ;
}
}求数组最大值和最小值
需求:设计一个方法，该方法能够同时获取数组的最大值，和最小值
思路:
一：方法中定义一个数组，将最大值和最小值存入数组中，并将整个数组返回
二：调用该方法，将数组中的最大值和最小值取出进行打印
return返回多个值，可以考虑数组
public class shuzu {
public static void main(String[] args) {
int[] arr = {11,55,33,22,66} ;
int[] getmaxandmin = getmaxandmin(arr) ;
System.out.println(getmaxandmin[0]);
System.out.println(getmaxandmin[1]);
}
public static int[] getmaxandmin(int[] arr){
int max = arr[0] ;
for (int i = 0; i < arr.length ; i++) {
if(max < arr[i]){
max = arr[i] ;
}
}
int min = arr[0] ;
for (int i = 0; i <arr.length ; i++) {
if (min > arr[i]) {
min = arr[i] ;
}
}
int[] getmaxandmin = {min,max};
return getmaxandmin ;
}
}二维数组
概述：二维数组存储的是一维数组容器
二维数组动态初始化
二维数组定义格式
格式1： 数据类型 [] [] 变量名;
范例： int [][] arr ;
格式2： 数据类型 变量名 [] [] ;
范例： int arr [][] ;
格式3： 数据类型 [] 变量名 [];
范例： int [] arr [] ;
初始化
格式：数据类型 [] []变量名 = new 数据类型 [m] [n] ;
m:表示可以存放多少个一维数组。
n:表示每一个一维数组可以存放多少个元素。
范例：int [] [] arr = new int [2] [3] ;
public class shuzu {
public static void main(String[] args) {
int[][] arr = new int[3][3] ;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][2]);
//向二维数组中存储元素
arr[0][2] = 999 ;
System.out.println(arr[0][2]);
}
}二维数组内存读写过程
二维数组之静态初始化
格式： 数据类型 [][] 变量名 = new 数据类型[][] {(元素1，元素2),(元素3，元素4),... ...} ;
范例 ：int [][] arr = new int[][] {(1,2),(3,4)};
public class shuzu {
public static void main(String[] args) {
int[] arr1 = {11,22,33} ;
int[] arr2 = {44,55,66} ;
int[][] arr = {{99,88,77},{66,55,44}} ;
//这是静态初始化的简化格式，上述的是完整格式。
System.out.println(arr[0][2]);
int[][] arry = {arr1,arr2} ;
System.out.println(arry[0][2]) ;
}
}二维数组常见操作
二维数组遍历
public class shuzu {
public static void main(String[] args) {
int[][] arr = {{11,22,33},{44,55,66}} ;
for (int i = 0; i < arr.length ; i++) {
System.out.println(arr[i]);
for (int j = 0; j < arr[i].length ; j++) {
System.out.println(arr[i][j]);
}
}
}
}
/*
[I@23fc625e
11
22
33
[I@3f99bd52
44
55
66
*/二维数组-求和
public class shuzu {
public static void main(String[] args) {
int sum = 0 ;
int[][] arr = {{11,22,33},{44,55,66},{77,88,99},{91,92,93}} ;
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);
}
}Debug
是提供程序员使用的程序调试工具，他可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序。
Debug调试，又被称为断点调试，断点其实是一个标记，告诉Debug从标记的地方开始查看
一·如何加断点
选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。
二·如何运行加了断点的程序
右键debug执行
三·看哪里
debugger窗口，可以看见程序执行到的位置，以及变量在执行过程中的变化。
四·点哪里
点step into（F7）这个箭头。
五·如何删除断点
单击鼠标左键即可。
进制
public class shuzu {
public static void main(String[] args) {
/*
十进制：java中，数值默认都是10进制，无需任何修饰。
二进制：数值前面以0b开头，b大小写均可。
八进制：数值前面以0开头。
十六进制：数值前面以0x开头，x大小写均可以。
注意：书写时，虽然加入了进制标识，但打印的时候控制台展示的都是十进制数据。
*/
System.out.println(10);
System.out.println("八进制数据010的十进制表示为："+ 010);
System.out.println("十六进制数据0x10的十进制表示为："+ 0x10);
}
}
任意进制转为十进制
例如：0x100
拆解：0x为十六进制标识
系数：1 0 0
基数：16（因为当前是16进制）
权：从右侧开始以0为编号，逐个加1
0 --- 0
0--- 1
1 --- 2
套入公式：系数*基数的权次冥相加
0*16^0 = 0
0*16^1 = 0
1*16^2 = 0
结果：0+0+256=256
十进制转换到任意进制
公式：除基取余
使用源数据，不断除以基数得到余数，直到商为0，再将余数倒起来拼接起即可
原码 反码 补码（二进制数据的三种状态）
为啥要学呢？
public class shuzu {
public static void main(String[] args) {
byte b = (byte)130 ;
System.out.println(b); //b为-126
}
}原码反码补码个绍
注意:计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的.
原码(可直观看出数据大小)（看数据）
就是二进制定点表示法，即最高位为符号位，[0]表示正，[1]表示负，其余位表示数值的大小通过一个字节表示+7和-7，代码:byteb1=7; byte b2=-7;一个字节等于8个比特位，也就是8个二进制位
0(符号位)0000111
1（符号位)0000111
反码（转数据）
正数的反码与其原码相同;负数的反码是对其原码逐位取反，但符号位除外
补码(数据以该状态进行运算 )（运算数据）
正数的补码与其原码相同;负数的补码是在其反码的末位加1。
正数的原反补都是相同的
负数的[反码]，是根据[原码] 取反(0变1，1变0)得到的(符号位不变）
负数的[补码]，是根据[反码]的末尾+1，得到的
求-7的补码？
原码 : 1(符号位) 0000111 符号位不变，0变1，1变0
反码 : 1(符号位) 1111000 反码的末尾+1，求补码
+1
补码 :1(符号位) 1111001
位运算（符）
连接的是数字的话就是位运算符，否则就是逻辑运算符。
位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算在二进制位运算中，
1表示true，0表示false
例如：6取反
例如12 << 1 (向左移动几位，就乘以2的几次冥)
同理向右就是除法。
注意：一个数被另外一个数，异或两次，该数本身不变。
案例：数据交换
需求:已知两个整数变a = 10，b20，使用程序实现这两个变量的数据交换最终输出a= 20，b=10；
思路:
定义一个三方变量temp，将a原本记录的值，交给temp记录 (a的值，不会丢了)
使用a 变量记录的值，(第一步交换完毕，b的值也丢不了了 )
使用b变量记录temp的值，也就是a原本的值 (交换完毕)
输出a和b变量即可
public class shuzu {
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
int temp = a ;
a = b ;
b = temp ;
System.out.println("a=" + a);
System.out.println("b=" + b);
}
}如果不允许使用三方变量呢？
public class shuzu {
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);
}
}案例：数组反转
需求:已知一个数组arr ={19,28,37,46,50};用程序实现把数组中的元素值交换
交换后的数组arr ={50，46，37,28，19}: 并在控制台输出交换后的数组元素
public class shuzu {
public static void main(String[] args) {
int[] arr = {19,28,37,46,50} ;
//定义两个变量，start和end来表示开始和结束的指针。
int start = 0 ;
int end = arr.length -1 ;
int temp = arr[start];
arr[start] = arr[end] ;
arr[end] = temp ;
for (int i = 0; i < arr.length ; i++) {
System.out.println(arr[i]);
}
}
}
480
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
