Java
1. java入门
1.1 常用的dos命令
dir命令显示盘符下的文件
cd..返回上一级
运用javac工具
清除命令cls,清屏指令
返回根目录即cd/
退出exit
1.2 path环境变量
作用：能够在任意一个文件都可以访问到javac和java工具
校验
到其他盘符编写javac，看是否可以运行javac
1.3 hello world 案例编写和执行
java程序开发运行流程：编写代码，编译代码，运行代码
public class helloworld{
public static void main(String[] args){
System.out.println("helloworld");
}
}
其中String和System要大写，不然会直接报错。
2. 基础语法
2.1 注释
-
单行注释
格式：//注释信息
-
多行注释
格式：/注释信息/ /* */
-
文档注释
格式：/注释信息/ /** **/
2.2 关键字
public:限制类名需要和文件名保持一致
class：用于创建一个类
-
关键字的特点：
全是小写
编辑器显示特殊的颜色
2.3 常量
常量：在程序的执行中，其值不会发生改变的量（数据）
public class DemoConstant{
/*
常量的分类: .
字符串常量:被双引号 所包裹的内容
整数常量: 所有整数
小数常量: 所有小数
字符常量:被单引号包裹的内容,里面只能存放单个字符
布尔常量:只有两值，true(真)， false (假)
布尔常量单独打印没有意义，为了后面要学习的运算符，打基础
空常量:null,数組部分详细讲解
注意: nu11空常量不能输出打印
*/
public static void main(String[] args){
System.out.println("你好，猪头");
}
}
2.4 变量介绍
变量就是内存中的存储空间，空间中存储着经常发生改变的量（数据）。
-
定义变量格式
数据类型 变量名=数据值；
2.5 数据类型
| 数据类型 | 关键字 | 内存占用（字节） | 取值范围 |
|---|---|---|---|
| 整数 | byte | 1 | -128~127 |
| short | 2 | -32768~32767 | |
| int （默认） | 4 | -2的31次方到2的31次方-1 | |
| long | 8 | -2的62次方到2的62次方-1 | |
| 浮点数 | float | 4 | 1.401298e-45到3.402823e+38(e-45=10的负4次方) |
| double（默认） | 8 | 4.9000000e到1.797693e+308 | |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | ture,false |
2.6 变量的定义和使用
public class a{
public static void main(String[] arag){
//整数类型变量
int a=10;
//小数类型变量
double b=12.3;
//字符串类型变量
char c='a';
//布尔类型变量
boolean d=true;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
注意：
-
变量名不能重复定义
-
一条语句可以定义多个变量，但需要使用逗号进行分割
-
变量使用之前一定要进行赋值
-
定义float变量的时候，需要在数值后面加入F的标识，F可以大写也可以小写
定义long变量的时候，需要在数值后面加入L的标识，L可以大写也可以小写
public class ab{ public static void main(String[] arag) { long a=1000L; System.out.println(a); float b=12.3F; System.out.println(b); } } -
变量的作用域：只有在它所在的大括号中有效
2.7 键盘录入
import java.util.Scanner;
//步骤1：导包
public class demo{
public static void main(String[] arag){
//步骤2：创建对象
Scanner sc = new Scanner(System.in);
//步骤3：使用变量接收数据
int i = sc.nextInt();
System.out.println(i);
}
}
2.8 标识符
标识符：就是给类，方法，变量等起名字
定义规则：
-
由数字，字母，下划线和美元符（$）组成
-
不能以数字开头
-
区分大小写
-
不能是关键字
命名约定：
小驼峰命名法：方法，变量
-
标识符是一个单词，首字母小写
-
标识符是多个单词，首字母小写，其他单词首字母大写
大驼峰命名法：
-
标识符是一个单词，首字母大写
-
标识符是多个单词，每个单词首字母大写
2.9 类型转换
-
隐式转换:将数据类型中，取值范围小的数据，给取值范围大的类型赋值，可以直接赋值。
public class demo1{ public static void main(String[] arga){ int a=10; //int 4个字节 double b=a; //double 8个字节 System.out.println(b); } }
注意：
-
小的数据类型,和大的数据类型运算,小的会提升为大的之后,再进行运算
-
byte short char三种数据在运算的时候,不管是否有更高的数据类型,都会提升为int ,然后再进行运算
-
强制转换：把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名= (目标数据类型)值或者变量;
public class demo2{ public static void main(String[] arag){ int a=10; byte b=(byte)a; System.out.println(b); } } -
案例
public class test{ public static void main(String[] arag){ byte a= 3; byte b= 4; /* 前置知识点：1. 小的数据类型,和大的数据类型运算,小的 会提升为大的之后,再进行运算 2. byte short char三种数据在运算的时 候,不管是否有更高的数据类型,都会提升为 int ,然后再进行运算 错误原因： byte c= a+b,byte上升到int类型，然后结果就是 int类型，赋值给byte，就是小赋大 */ // byte c= a+b; //解决方法 byte c= (byte)(a+b); System.out.println(c); /* 这里的3和4是两个常量，Java存在常量优化机制，会在编译 的时候就会让3和4进行相加，然后会自动判断7是否在byte的 取值范園内 不在范围内:编译出错 在范围内:通过编译 */ byte d= 3+4; System.out.println(d); long num=127873923L; } }
3 . 运算符
3.1 算数运算符
运算符：对常量或者变量进行操作的符号
表达式：用运算符把常量或者变量连接起来符合Java语法的式子
public class demo3{
public static void main(String[] args){
System.out.println(10+30);
System.out.println("-------------");
System.out.println(10/2);
System.out.println(10/3);
System.out.println(10.0/3);
System.out.println(10/3.0);
System.out.println("-------------");
System.out.println(5%2); //取余数
System.out.println("-------------");
int a=1;
char b='a';
System.out.println(a+b);
}
}
3.2 字符串的加操作
public class demo4{
public static void main(String[] args){
int a=1;
char b='a';
System.out.println(a+b);
System.out.println("-------------");
//当字符串加运算中加号就是字符串连接符，而不是算术运算符
System.out.println("大帅比"+666);
System.out.println("大帅比"+true);
}
}
字符加运算：a + b的运算中, a为int类型, b为char类型当( byte short char int )在-起运算的时候,都会提升为int之后,再进行运算char提升为int的过程,就是直找码表中,字符所对应的数值表示形式字符'a’查找到数值的97之后,在跟数值1进行运算,结果就是98,所以，最终输出在控制台的结果就是98
3.3 算术运算符
需求:键盘录入一个三位数,将其拆分为个位、十位、百位后,打印在控制台 分析: ①:使用Scanner键盘录入一个三位数 ②:个位的计算:数值%10 123除以10 (商12 ,余数为3) ③: 十位的计算:数值/ 10% 10 123除以10 ( 商12 ,余数为3 ,整数相除只能得到整数) 12除以10 (商1 ,余数为2 ) ④:百位的计算:数值/ 100 123除以100 (商1 ,余数为23) ⑤:将个位，十位百位拼接上正确的字符串,打印即可
import java.util.Scanner;
//步骤1：导包
public class demo5{
public static void main(String[] arag){
//使用Scanner键盘录入一个三位数
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个三位数：");
int num = sc.nextInt();
//个位的计算:数值%10
int ge = num%10; //123%10=3
//十位的计算:数值/ 10% 10
int shi = num/10 %10; //123/10=12 12%10=2
//百位的计算:数值/ 100
int bai = num/100; //123/100=1
//将个位，十位百位拼接上正确的字符串,打印即可
System.out.println("整数"+num+"个位数为"+ge);
System.out.println("整数"+num+"十位数为"+shi);
System.out.println("整数"+num+"百位数为"+bai);
}
}
数值拆分公式
个位：数值%10
十位：数值/10%10
百位：数值/10/10%10
千位：数值/10/10/10%10
3.4 自增自减运算符
public class demo6{
/*
单独使用的时候，++，——，无论是放前面还是放后面，结果都一样。
*/
public static void main{
int a=10;
++a;
System.out.println(a);
int b=10;
--b;
System.out.println(b);
}
}
public class demo7{
public static void main(String[] args){
//++在前：先对该变量做自增（++）或者自减（--）,然后再拿变量参与操作。
int a=10;
int b=++a;
System.out.println(a);
System.out.println(b);
//++在后，先将该变量原来的值，取出来参与操作，随后再进行自增，自减。
int aa=10;
//bb=10
int bb=aa++;//aa=11
System.out.println(aa);
System.out.println(bb);
int num=123;
System.out.println(num++); //123,先打印num，然后再自增
System.out.println(num); //这里就是124，自增增加完成
//System.out.println(10++);
//10++ -->10=10+1；错误
}
}
3.5 赋值运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | a=10 ,将10赋值给变量a |
| += | 加后赋值 | a+=b，将a+b的值赋值给a |
| -= | 减后赋值 | a-=b，将a-b的值赋值给a |
| *= | 乘后赋值 | a*=b，将axb的值赋值给a |
| /= | 除后赋值 | a/=b，将a/b的值赋值给a |
| %= | 取余后赋值 | a%=b,将a/b的余数给a |
public class demo8{
public static void main{
int a=10;
a+=10;
System.out.println(a);
short s=10;
//s=s+1;
s=(short)(s+1);
System.out.println(s);
short ss=10;
ss+=1;
System.out.println(ss);
//赋值运算符自带强制类型转换
}
}
3.6 逻辑运算符
&（与）：并且
|（或）：或者
！（非）：取反
^（异或）：
public class demo9{
public static void main(String[] args){
System.out.println(true&false);
System.out.println(true&true);
System.out.println(false&false);
System.out.println(false&true);
System.out.println("-------------------------------");
System.out.println(true|false);
System.out.println(true|true);
System.out.println(false|false);
System.out.println(false|true);
System.out.println("-------------------------------");
System.out.println(true^false); //true
System.out.println(true^true); //false
System.out.println(false^false); //false
System.out.println(false^true); //true
System.out.println("-------------------------------");
System.out.println(!true);
System.out.println(!!true);
}
}
-
短路逻辑运算符
符号 作用 说明 && 短路与 作用和&相同，但是有短路的效果 || 短路或 作用和|相同，但是有短路的效果 public class note1 { /* &&符号这边为false时，右边就不执行了 &无论左边是true还是false，右边都要执行 */ public static void main(String[] args){ int x=3; int y=4; System.out.println(++x>4&y--<5);//false System.out.println("x="+x); //4 System.out.println("y="+x); //4 y--<5没有执行 } }
3.7 三元运算符
-
格式：关系表达式？表达式1：表达式2
执行流程：
首先计算关系表达式的值
如果值为true，取表达式1的值
如果值为false，取表达式2的值
public class note1 {
public static void main(String[] args){
int x=3;
int y=4;
int max = x>y ?x:y;
System.out.println(max);
}
}
案例：三个和尚
public class note2{
public static void main{
int height1=150;
int height2=210;
int height3=165;
//比较获取较大值
int tempmax=a>c?a:b;
int max=tempmax>c?tempmax:c;
System.out.println(max);
}
}
4. 条件控制语句
4.1 顺序结构语句
public class note2 {
public static void main(String[] args){
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
}
}
按照代码先后顺序，依次执行
4.2 IF语句
-
if语句格式
格式：
if (关系表达式){语句体；
}
public class note3{ public static void main(String[] args){ System.out.println("开始") int age=19; if (age>=18){ System.out.println("可以上网吧"); } System.out.println("结束") } }注意：
-
if语句所控制的的语句体，如果是一条语句，大括号可以省略不写
-
if语句小括号后面，没有分号
-
-
if语句格式2
if (关系表达式){
语句体；
}
else{
语句体2；
}
public class note3{ System.out.println("开始") public static void main{ int num=19; if (num%2==0){ System.out.println("偶数"); } else{ System.out.println("奇数"); System.out.println("结束") } } -
if语句格式3
if (关系表达式){
语句体；
}
else if{
语句体2；
}
else{
语句体3；
}
import java.util.Scanner; public class note4{ public static void main(String[] args){ //1.使用Scanner录入考试成绩 System.out.println("请输入您的成绩"); Scanner sc =new Scanner(System.in); int score = cs.nextInt(); //2.判断是否在合法范围之内 if (score>=0 && score<=100){ //合法成绩 if (score>=95 & score<=100){ System.out.println("自行车一辆"); } else if (score>=90 & score<=94){ System.out.println("游乐场"); } else if (score>=80 & score<=89){ System.out.println("变形金刚"); } else{ System.out.println("挨顿打"); } } else{ System.out.println("你的成绩输入有误"); } } }
4.3 switch语句
-
格式：
switch (表达式){
case 值1：
语句体1；
break；
case 值1：
语句体1；
break；
……
default:
语句体n+1；
break；
}
public class note5 { public static void main(String[] args){ int week=100; 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; } } } 注意：
-
case给出的值不允许重复
-
case后面的值只能是常量，不能是变量
-
-
case穿透现象
import java.util.Scanner; public class note6 { /* case穿透现象如何产生 switch语句中，case省略break语句，就会开始case穿透 现象： 当开始case穿透，后续case就不会具有匹配效果，内部的语句就会执行 直到科技break，或者switch语句执行完后，才会结束 */ public static void main(String[] args){ System.out.println("请输入星期数："); Scanner sc =new Scanner(System.in); 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; } } } //优化： import java.util.Scanner; public class note6 { /* case穿透现象如何产生 switch语句中，case省略break语句，就会开始case穿透 现象： 当开始case穿透，后续case就不会具有匹配效果，内部的语句就会执行 直到科技break，或者switch语句执行完后，才会结束 */ public static void main(String[] args){ System.out.println("请输入星期数："); Scanner sc =new Scanner(System.in); 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; } } }
5. 循环
5.1 FOR循环
格式：
for (初始化语句；条件判断语句；条件控制语句){
循环体语句；
}
public class note7 {
public static void main(String[] args){
for(int i=1;i<=3;i++){
/*
int i=1 初始化
i<=3 条件判断
i++ 条件控制语句
*/
System.out.println("折返跑");
}
}
}
-
案例
public class note8 { public static void main(String[] args){ for(int i=1;i<=5;i++){ System.out.println(i); } System.out.println("--------------打印1-5，5-1"); for(int i=5;i>=1;i--){ System.out.println(i); } System.out.println("--------------求和"); int sum=0; for(int i=1;i<=5;i++){ sum=i+sum;//sum+=i } System.out.println(sum); System.out.println("--------------偶数求和"); int sum1=0; for(int i=1;i<=100;i++){ if (i%2==0){ sum1+=i; } } System.out.println(sum1); System.out.println("----------水仙花数"); /* 水仙花数即：个位，十位，百位数字的立方等于原数 例如371=3^3+7^3+1^3=27+343+1=371 */ for(int i=100;i<=999;i++){ int ge=i%10; int shi=i/10%10; int bai=i/100; if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){ System.out.println(i); } } System.out.println("----------统计，水仙花数优化"); int count=0; for(int i=100;i<=999;i++){ int ge=i%10; int shi=i/10%10; int bai=i/100; if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){ //判断打印水仙花数过程中拼接空格，但不换行，当一行有两个时换行 System.out.print(i+" "); count++; if(count%2==0){ System.out.println(); } } } } }
5.2 while循环
格式：
初始化语句：
while （条件判断语句）{
循环体；
条件控制语句；
}
public class note9 {
public static void main(String[] args){
int i=1;
while (i<=100){
System.out.println(i);
i++;
}
while (i<=520) {
System.out.println("i love you");
i++;
}
}
}
-
案例
public class note9 { public static void main(String[] args){ /* 需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫 米) ,假如我有一张足够大的纸,它的厚度是0.1毫米。 请问,我折叠多少次,可以折成珠穆朗玛峰的高度? */ int count=0; double paper=0.1; int zf=8844430; while (paper <=zf){ paper *=2; count++; System.out.println(paper); } System.out.println(count); } } -
do……while循环语句
格式：
初始化语句
do{
循环体语句；
条件控制语句；
}while（条件判断语句）；
执行流程：
-
执行初始化语句
-
执行循环体语句
-
执行条件控制语句
-
执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
-
回到2步骤继续
public class par1 { /* 特点： do…while循环，无论循环条件是否满足，都至少会执行一次循环体。 原因：do…while循环是从上到下依次执行 */ public static void main(String[] args){ int i=11; do{ System.out.println("大帅哥，帅小伙"); i++; }while (i<=10); System.out.println(i); } } -
三种循环的区别
for循环和whie循环先判断条件是否成立,然后决定是否执行循环体(先判断后执行) do..while循环先执行一次循环体 , 然后判断条件是否成立,是否继续执行循环体(先执行后判断)
for和while的区别:
-
条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了
-
条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用
public class part2 { public static void main(String[] args){ for (int i =1;i<=5;i++){ //for循环内部[定义]的变量，在循环后，就会从内存中消失 System.out.println(i); } //System.out.println(i);错误:找不到符号i System.out.println("-----------------"); //while循环 int a=1; while (a<=5){ System.out.println(a); a++; } System.out.println(a+"..."); } }
三种循环的场景:
-
明确循环次数 ,推荐使用for循环
-
不明确循环次数 ,推荐使用while循环
-
do..while循环 ,很少使用
死循环
public class par3 {
public static void main(String[] args){
for(;;){
System.out.println("停不下来了");
}
while(true){
System.out.println("停不下来了");
}
}
}
5.3 跳转控制语句
public class par4 {
public static void main(String[] args){
for(int i=1;i<=24;i++){
if (i==4){
continue;
}
System.out.println(i+"层到了");
}
for(int t=20;t<=80;t++){
if(t==60){
break;
}
System.out.println(t+"岁正在上班");
}
}
}
5.4 Random
作用：随机产生一个随机数
步骤
-
导包
import java.util.Random;
-
创建对象
Random r=new Random();
-
获取随机数
int number = r.nextInt(10);
获取数据范围：[0,10]包括0，不包括10
import java.util.Random;
public class par5 {
public static void main(String[] args){
Random r=new Random();
for(int i=1;i<=10;i++) {
int num = r.nextInt(10)+1;//随机数1-10
System.out.println(num);
}
}
}
6.快捷键
| psvm+回车 | 快速生成main方法 |
|---|---|
| sout +回车 | 快速生成输出话句 |
| alt+1 | 打开\隐藏工程目录結构 |
| alt+4 | 打开\隐藏控制台 |
| Ctrl + alt+ L | 格式化代码 |
| Alt + enter | 代码修正提示 |
| CtrL + D | 向下复制一行 |
| CtrL + X | 剪切当前行 |
| CtrL + / | 批量加入单行注释，再按一次就是取消 |
| Ctrl + shift + / | 批量加入多行注释，再按一次就是取消 |
| Alt+shift+↑ | 上移当前行 |
| Alt+shift+↓ | 下移当前行 |
7.数组
数组是一种容器，用来存储（同种数据类型）的多个值
-
格式一
-
数组类型[] 变量名
-
范例：int[] array
-
格式二
-
数组类型 变量名[]
-
范例：int array[]
package array;
public class marray1 {
/*
数组类型[] 变量名
数组类型 变量名[]
*/
public static void main(String[] args) {
//数据类型的[变量]，变量没有进行初始化，就直接使用了，这就是错误原因
//int[] arr=创建数组容器;
char[] carr;
System.out.println(carr);
int a=10;
System.out.println(a);
}
}
7.1初始化
-
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值
-
格式：数据类型[]变量名=new 数据类型[数组长度]；
-
范例：int[] arr=new int[3];
package array;
import jdk.management.resource.internal.inst.SocketOutputStreamRMHooks;
public class array2 {
public static void main(String[] args) {
/*通过new关键字创建一个int类型的数组容器，
该容器可以存储5个int类型的整数，
该容器被arr数组变量所记录
打印数组变量的时候1，会打印出数组的内存地址
*/
int [] arr=new int[5];
System.out.println(arr);
//[I@4554617c数组的内存地址
/*
@:分隔符
[：当前的空间的是一个数组类型
I：当前数组容器中所存储的数据类型
4554617c：十六进制内存地址
*/
byte[] barr=new byte[3];
System.out.println(barr);
//[B@74a14482
}
}
7.2 数组元素访问
数组元素访问格式
数组名[索引]
访问数组容器中的空间位置
package array;
public class array3 {
public static void main(String[] args) {
int[] arr =new int[3];
System.out.println(arr);
System.out.println(arr[0]);//默认的初始化值为0
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("----------------------");
arr[0]=11;
arr[1]=13;
arr[2]=15;
System.out.println(arr[0]);//默认的初始化值为0
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
Java内存分配
Java程序在运行时,需要在内存中分配空间。
为了提高运算效率，就对空间进行了不同区域的划分
每一片区域都有特定的处理数据方式和内存管理方式。
-
栈内存:方法运行时，进入的内存，局部变量都存放于这块内存当中
-
堆内存: new出来的内容都会进入堆内存，并且会存在地址值
-
方法区:字节码文件(.class文件)加载时进入的内存
-
本地方法栈:调用操作系统相关资源
-
寄存器:交给CPU去使用
| 数据类型 | 默认值 |
|---|---|
| 整数 | 0 |
| 浮点数 | 0.0 |
| 布尔 | false |
| 字符 | 空字符 |
| 引用数据类型 | null() |
package array;
public class array4 {
public static void main(String[] args) {
int[] arr1=new int[2];
arr1[0]=11;
arr1[1]=19;
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println("-------------------");
int[ ] arr2=new int[3];
System.out.println(arr2);
arr2[0]=33;
arr2[1]=31;
arr2[2]=34;
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
package array;
public class array5 {
/*
两个数组指向相同
*/
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]);
}
}
7.3 数组初始化
1. 静态初始化
静态初始化：初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组的长度。
-
格式：数据类型 [] 变量名 = new 数据类型[] {数据1，数据2，数据3，......}；
-
简化格式：数据类型[]变量名={数据1，数据2，.....}；
package array;
public class arr6 {
public static void main(String[] args) {
/*
静态初始化：初始化时，就可以指定数组要存储的元素，系统还会自动计算出该数组的长度。
- 格式：数据类型 [] 变量名 = new 数据类型[] {数据1，数据2，数据3，......}；
- 简化格式：数据类型[]变量名={数据1，数据2，.....}；
*/
int[]arr=new int[]{11,34,66};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("----------");
int[]arr1={11,34,66};
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
}
}
-
两种初始化的区别
-
动态初始化:手动指定数组长度,由系统给出默认初始化值。
-
静态初始化:手动指定数组元素,系统会根据元素个数，计算出数组的长度
应用场景
-
动态初始化:只明确元素个数，不明确具体数值，推荐使用动态初始化
例:使用数组容器来存储键盘录入的5个整数
-
静态初始化:需求中已经明确了要操作的具体数据,直接静态初始化即可
7.4 数组操作的两个常见小问题
-
索引越界：访问不存在的（ArrayIndexOutOfBounds Exception ）
public class array4 {
public static void main(String[] args) {
int[] arr1=new int[2];
System.out.println(arr1[0]);
}
}
-
空指针:访问的数组已经不再指向堆内存的数据，造成空指针异常
public class array4 {
public static void main(String[] args) {
int[] arr1=new int[2];
System.out.println(arr1[0]);
arr=null;
System.out.println(arr1[0]);
}
}
-
null :空值,引用数据类型的默认值,表示不指向任何有效对象
7.5 数组常见操作
-
遍历
package array;
public class arr7 {
/*
数组的遍历
动态获取数组元素的个数：数组名.length
*/
public static void main(String[] args) {
int[] arr ={12352,3,1,34,4};
System.out.println("arr数组元素的个数"+arr.length);
for(int i=0;i<5;i++){
System.out.println(arr[i]);
}
}
}
-
获取最值
package array; public class arr7 { public static void main(String[] args) { int[] arr ={12352,3,1,34,4}; int max=arr[0]; System.out.println("arr数组元素的个数"+arr.length); for(int i=1;i<arr.length;i++){ if(arr[i]>max){ max=arr[i]; } } System.out.println(max); } } -
求和
package array; import java.util.Scanner; public class arr7 { public static void main(String[] args) { //键盘录入对象，准备键盘录入 Scanner sc =new Scanner(System.in); //定义求和变量，准备记录累加后的结果 int sum=0; //动态初始化一个长度为5的int数组，准备存储键盘录入的数值 int[] arr =new int[5]; //将键盘录入的数组存储到数组中 for(int i =0;i<arr.length;i++){ System.out.println("请输入第"+(i+1)+"个整数"); //arr[i]=10; arr[i]=sc.nextInt(); } //遍历数组 for (int i = 0; i < arr.length; i++) { sum+=arr[i]; } System.out.println(sum); } } -
评委打分
package array; import java.util.Scanner; public class arr8 { public static void main(String[] args) { //定义一个数组，用动态初始化完成数组元素的的初始化 int[] arr = new int[6]; //键盘录入 Scanner sc = new Scanner(System.in); for (int i = 0; i < arr.length; i++) { System.out.println("请输入第" + (i + 1) + "值："); int score = sc.nextInt(); if (score >= 0 && score <= 100) { //合法分值 arr[i] = score; } else { //非法分值 System.out.println("输入有误"); i--; } } for (int i= 0; i < arr.length; i++) { System.out.println(arr[i]); } //最值 int max = arr[0]; //System.out.println("arr数组元素的个数" + arr.length); for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } System.out.println("最大值为："+max); int min = arr[0]; //System.out.println("arr数组元素的个数" + arr.length); for (int i = 1; i < arr.length; i++) { if (arr[i] < min) { min = arr[i]; } } System.out.println("最小值为："+min); int sum =0; for (int i = 0; i < arr.length; i++) { sum+=arr[i]; } //计算平均分 int avg=(sum-min-max)/(arr.length-2); System.out.println("平均值为："+avg); } }
8. 方法与debug
8.1 方法定义与调用
方法（method）：就是一段具有独立功能的代码块，不调用就不执行
-
格式：public static viod 方法名(){
//方法体
}
方法调用
格式：方法名（）；
注意：方法与方法之间是平级关系，不能嵌套定义
package DemoMethod;
public class DeMe {
/*
格式：public static viod 方法名(){
//方法体
}
方法调用
格式：方法名（）；
注意：方法与方法之间是平级关系，不能嵌套定义
*/
public static void main(String[] args) {
eat();
}
public static void eat(){
study();
System.out.println("吃饭");
}
public static void study(){
System.out.println("学习");
}
}
方法练习
需求:设计个方法method ,方法中定义-个变量(数值随意） 判断这个变量是奇数还是偶数，并在main方法中调用method. 思路:
1:定义方法，名称为method
2:方法中定义变量，使用i语句判断是奇数还是偶数
3.main方法中调用method方法
package DemoMethod;
import java.util.Scanner;
public class deme1 {
public static void main(String[] args) {
method();
}
//1:定义方法，名称为method
public static void method() {
System.out.println("请输入一个数：");
Scanner sc =new Scanner(System.in);
int num=sc.nextInt();
if(num%2==0){
System.out.println("偶数");
}else {
System.out.println("奇数");
}
}
}
8.2 带参数方法的定义和调用
格式：public static viod 方法名(参数){.....}
public static viod 方法名(数据类型 变量名){.....}
public static viod 方法名(数据类型 变量名1,数据类型 变量名2,...){.....}
调用格式： 方法名(参数);
方法名(变量名/常数值);
方法名(变量名1/常数值1，变量名2/常数值2，.....);
package DemoMethod;
import com.sun.xml.internal.messaging.saaj.soap.SOAPVersionMismatchException;
public class deme2 {
public static void main(String[] args) {
method(78097876);
}
public static void method(int num) {
if (num % 2 == 0) {
System.out.println("偶数");
} else {
System.out.println("奇数");
}
}
}
-
形参和实参
形参：全称形式参数，是指方法定义中的参数
实参：全称实际参数，方法调用中的参数
练习：
需求：设计一个方法（print）用于打印到n到m之间所有奇数
-
定义方法,名称为print
-
为方法添加两个int类型的形参，准备接受调用者传递过来的实参
-
方法中设计for循环，循环从n开始，到m结束
-
循环中加入if判断，是奇数，则打印
-
main方法中调用print方法，传入两个实际参数
package DemoMethod;
public class deme3 {
public static void main(String[] args) {
print(10,85);
}
//1. 定义方法,名称为print
//2. 为方法添加两个int类型的形参，准备接受调用者传递过来的实参
public static void print(int n,int m){
System.out.println(n+"到"+m+"之间的奇数");
//方法中设计for循环，循环从n开始，到m结束
for(int i=n;i<=m;i++){
//循环中加入if判断，是奇数，则打印
if(i%2==1){
System.out.println(i);
}
}
}
}
8.3 带返回值方法的定义和调用
意义：我们经常会根据一个方法产出的结果,来去组织另外一段代码逻辑
为了拿到这个方法产生的结果,就需要定义带有返回值的方法
带返回值方法定义
格式：public static 数据类型 方法名（参数）{
return数据；
}
调用格式：数据类型 变量名=方法名（参数）；
package DemoMethod;
public class deme4 {
/*
格式：public static 数据类型 方法名（参数）{
return数据；
}
调用格式：数据类型 变量名=方法名（参数）；
*/
public static void main(String[] args) {
int num=add(21,3234);
System.out.println(num);
}
public static int add(int a,int b){
int c=a+b;
return c;
}
}
练习
需求：设计一个方法可以获取两个数较大值，数据来源于参数
-
定义一个方法,声明两个形参接收计算的数值，求出结果并返回
-
使用if语句得出a和b之间的最大值,根据情况retum具体结果
-
在main0方法中调用定义好的方法并使用变量保存
package DemoMethod;
public class deme5 {
/*
1. 定义一个方法,声明两个形参接收计算的数值，求出结果并返回
2. 使用if语句得出a和b之间的最大值,根据情况retum具体结果
3. 在main0方法中调用定义好的方法并使用变量保存
*/
public static void main(String[] args) {
// 3. 在main0方法中调用定义好的方法并使用变量保存
int result=getmax(129,322);
System.out.println(result);
}
//1. 定义一个方法,声明两个形参接收计算的数值，求出结果并返回
public static int getmax(int a,int b){
//2. 使用if语句得出a和b之间的最大值,根据情况retum具体结果
if(a>b){
return a;
}else{
return b;
}
}
}
8.4 方法通用格式
格式：public static 返回值类型 方法名（参数）{
方法体；
return 数据；
}
-
public static 修饰符
-
返回值类型 方法操作完毕之后返回的结果数据，所对应的数据类型 如果方法操作完毕，没有数据返回，这里写void，而且
方法体中-般不写return
-
方法名 调用方法时候使用的标识
-
参数 由数据类型和变量名组成,多个参数之间用逗号隔开
-
方法体 完成功能的代码块
-
return 如果方法操作完毕,有数据返回,用于把数据返回给调用
者
public static 盘子 炒菜(米，菜，油){
盘子p=米+油+菜
return p;
}
盘子p=炒菜（大米，地沟油，烂白菜）;
定义方法时,要做到两个明确
明确参数:主要是明确参数的类型和数量
明确返回值类型:主要是明确方法操作完毕之后是否有数据返回,如果没
有，写void ;如果有，写对应的数据类型
8.5 注意事项
-
方法不能嵌套定义
-
方法的返回值类型为void ,表示该方法没有返回值，没有返回值的方法可以省略return语句不写如果要编写return ,后面不能跟具体的数据。
-
return语句下面,不能编写代码,因为永远执行不到，属于无效的代码
package DemoMethod;
public class deme3 {
public static void main(String[] args) {
print(10,85);
}
//1. 定义方法,名称为print
//2. 为方法添加两个int类型的形参，准备接受调用者传递过来的实参
public static void print(int n,int m){
if(m<n){
System.out.println("输入有误");
return;
//return;可以用于结束方法，也就是将方法从栈内存中弹出去， 该过程称之为方法的弹栈
}
System.out.println(n+"到"+m+"之间的奇数");
//方法中设计for循环，循环从n开始，到m结束
for(int i=n;i<=m;i++){
//循环中加入if判断，是奇数，则打印
if(i%2==1){
System.out.println(i);
}
}
}
}
8.6 方法重载
方法重载：方法名相同，参数也完全相同，称为方法的重复定义是一种冲突性
的错误
在同一个类中，定义了多个同名的方法,但每个方法具有不同的参数类型或参数
个数,这些同名的方法，就构成了重载关系。
方法重载好处
-
不用记忆过多的繁多的方法名字
练习：
需求:使用方法重载的思想，设计比较两个整数是否相同的方法,兼容全整数类型( byte,short,intlong)
-
定义一个比较的方法compare( ,参数选择两个int型参数
-
定义对应的重载方法，变更对应的参数类型,参数变更为两个long型参数
-
定义所有的重载方法，两个byte类型与两个short类型参数
-
完成方法的调用，测试运行结果
package Overload;
public class overload {
/*
1. 定义一个比较的方法compare( ,参数选择两个int型参数
2. 定义对应的重载方法，变更对应的参数类型,参数变更为两个long型参数
3. 定义所有的重载方法，两个byte类型与两个short类型参数
4. 完成方法的调用，测试运行结果
*/
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(Byte a,byte b){
return a==b;
}
public static boolean compare(short a,short b){
return a==b;
}
public static boolean compare(long a,long b){
return a==b;
}
}
8.7 方法的参数传递
8.7.1 方法参数传递（基本类型）
8.7.2 方法参数传递（引用类型）
练习
需求:设计一个方法,该方法能够同时获取数组的最大值，和最小值
-
方法中定义-一个数组，将最大值和最小值存入数组中,并将整个数组返回
-
调用该方法,将数组中的最大值和最小值取出进行打印
package Overload;
public class demo {
/*
注意：return只能带回一个结果
*/
public static void main(String[] args) {
int[] arr={11,22,33,44,55};
int[] maxmin=getmaxmin(arr);
System.out.println(maxmin[0]);
System.out.println(maxmin[1]);
}
public static int[] getmaxmin(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[] maxmin={min,max};
return maxmin;
}
}
8.8 debug
Debug :是供程序员使用的程序调试工具,它可以用于查看程序的执行流程,也可
以用于追踪程序执行过程来调试程序。
-
操作流程
Debug调试，又被称为断点调试,断点其实是一个标记，告诉Debug从标记的地方开始查看
-
选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可。
-
在代码区域右键Debug执行
-
看Debugger窗口
-
点Step Into (F7)这个箭头，也可以直接按F7
-
点Stop结束
-
如果是多个断点,可以每一个再点击次。也可以一次性全部删除。
-
debug使用
通过点击下一个查看哪段代码出现问题。
package Overload;
public class demo2 {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<=5;i++){
if(i%2==0){
//i+=sum;
sum+=i;
}
}
System.out.println(sum);
}
}
9. 进制
-
进制介绍
进制:指进位制,是人们规定的一种进位方式表示某位置上的数，运算时是逢X进一位。十进制是逢十进一，进制就是逢二 进-，八进制是逄八进一 ...
-
原因：原因:计算机数据在底层运算的时候，都是以二进制形式也有数据是以八进制、十进制、或者十六进制进行存储或运算,了解不同的进制便于我们对数据的运算过程理解的更加深刻。
-
十进制: Java中，数值斯认都是10进制，不需要加任何修饰。
-
二进制:数值前面以0b开头，大小写都可以。
-
八进制:数值前面以0开头。
-
十大进制:数值前面以0x开头, x大小写都可以。
-
控制台打印出来都是十进制
目录
同理八进制转换十进制
9.2 快速进制转换
-
8421码:
-
8421码又称BCD码,是BCD代码中最常用的一种
-
BCD : (Binary-Coded Decimal)二进制码十进制数在这种编码方式中,每一位二进制值的1都是代表一个固定数值 ，把每一位的1代表的十进制数加起来得到的结果就是它所代表的十进制数。
-
9.3 原码反码补码
原码：看数据
反码：转数据
补码：运算数据
-
正数的原反补都是相同的 负数的[反码] , 是根据[原码]取反(0变1 , 1变0)得到的(符号位不变) 负数的[补码] , 是根据[反码]的末尾+1，得到的
9.4 位运算
| 符号 | 计算公式 |
|---|---|
| &位与 | 遇false则false,遇0则0 |
| |位或 | 通true刚true, 遇1则1 |
| ^位异或 | 相同为false,不同为true |
| ~取反 | 全部取反，0变1, 1变0 (也包括符号位) |
| << | 有符号左移运算，二进制位向左移动，左边符号位丢弃， 右边补齐 运算规律:向左移动几位，就是乘以2的几次幂 |
| >> | 有符号右移运算，二进制位向右移动，使用符号位进行补位 运算规律:向右移动几位，就是除以2的几次幂 |
| >>> | 无符号右移运算符，无论符号位是0还是1 ，都0 |
练习
需求:已知两个整数变量a= 10，b= 20，使用程序实现这两个变量的数据交换
最终输出a=20，b=10;
-
定义一个三方变量temp ,将a原本记录的值，交给temp记录( a的值,不会丢了）
-
使用a变量记录b的值，( 第一步交换完毕，b的值也丢不了了)
-
使用b变量记录temp的值，也就是a原本的值(交换完毕)
-
输出a和b变量即可
package Overload;
public class demo2 {
/*
1. 定义一个三方变量temp ,将a原本记录的值，交给temp记录( a的值,不会丢了）
2. 使用a变量记录b的值，( 第一步交换完毕，b的值也丢不了了)
3. 使用b变量记录temp的值，也就是a原本的值(交换完毕)
4. 输出a和b变量即可
*/
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);
//利用异或完成两个数据交换
a=a^b; //a=10^20
b=a^b; //a=10^20^20
a=a^b; //a=10^20^10
System.out.println(a);
System.out.println(b);
}
}
反转
需求:已知-个数组arr= {19, 28, 37. 46, 50};用程序实现把数组中的元素值交换, 交换后的数组arr= {50, 46, 37, 28, 19};并在控制台输出交换后的数组元素。
package Overload;
public class demo3 {
public static void main(String[] args) {
int[]arr={11,22,33,44,55};
int temp=arr[0];
arr[0]=arr[4];
arr[4]=temp;
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
10. 二维数组
二维数组也是一种容器,不同于维数组，该容器存储的都是一维数组容器
10.1 二维数组初始化
格式1：数据类型[ ][ ]变量名; 格式2：数据类型[ ]变量名[ ]; 格式3：数据类型变量名[ ][ ];
-
动态初始化
格式: 数据类型[][]变量名= new数据类型[m][n]; m表示这个二维数组，可以存放多少个一维数组 n表示每一个维数组，可以存放多少个元素 package Overload; import com.sun.xml.internal.messaging.saaj.soap.SOAPVersionMismatchException; public class demo5 { public static void main(String[] args) { int[][]arr=new int[3][3]; System.out.println(arr); //数据取出 /* 二维数组存储的一维数组，存储的都是他们的内存地址 */ System.out.println(arr[0][0]); System.out.println(arr[0][1]); //存储数组 arr[0][0]=11; arr[0][1]=22; arr[0][2]=33; arr[1][0]=44; System.out.println(arr[0][0]); System.out.println(arr[0][1]); System.out.println("-----------------"); /* 二维数组中存储的是一维数组， 存入 [提前创建好的一维数组] 内存地址的替换 */ int[]arr1={11,22,33}; int[]arr2={44,55,66}; int[]arr3={22,33,44}; int[][]arr4=new int[3][3]; arr[0]=arr1; arr[1]=arr2; arr[2]=arr3; System.out.println(arr4[1][2]); System.out.println(arr4[2][1]); } }
10.2 静态初始化
格式：数据类型[ ][ ]变量名=new数据类型[][]{{元素1，元素2……}，{元素1，元素2……}，……};
简化格式：数据类型[ ][ ]变量名={{元素1，元素2……}，{元素1，元素2……}，……};
public class demo6 {
public static void main(String[] args) {
int[]arr1={11,22,33};
int[]arr2={43,34,5,6};
int[][]arr={{11,22,33},{43,34,5,6}};
System.out.println(arr[0][2]);
int[][]array={arr1,arr2};
System.out.println(arr[0][2]);
}
}
10.3 常见操作
-
遍历
已知一个二维数组arr={ {11, 22, 33}, {33, 44, 55};遍历该数组，取出所有元素并打印
-
遍历二维数组,取出里面每一个维数组
-
在遍历的过程中，对每一个维数组继续完成遍历，获取内部存储的每一个元素
package Overload; public class arr7 { public static void main(String[] args) { int[][]arr={{11,22,33},{44,55,66}}; for (int i = 0; i < arr.length; i++) { for (int i1 = 0; i1 < arr[i].length; i1++) { System.out.println(arr[i][i1]); } } } } -
-
求和
-
定义求和变量，准备记录最终累加结果
-
使用二维数组来存储数据,每个季度是一个维数组，再将4个-维数组装起来
-
遍历维数组,获取所有元素，累加求和
-
输出最终结果
package Overload; public class arr8 { public static void main(String[] args) { int sum=0; int[][] arr={{22,33,44},{11,22,33},{44,55,66}}; for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr.length; j++) { sum+=arr[i][j]; } } System.out.println(sum); } } -
扫一扫
290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
