Day1
进制转换
-
十进制转二进制:除2取余，倒叙取值
-
二进制转十进制：1的位置上从右往左依次加上2对应的几次方，从2的0次方开始
-
负整数转换二进制：先算出绝对值的二进制值，反码+1（补码）
-
小数：乘二正序
-
计算机最小的单位bit (位) 8位是一个字节(byte) 1024B = 1KB …
Java发展史
-
sun公司1995年发布
-
Java之父：James Gosling 詹姆斯·高斯林
-
版本：96年开始发布JDK1.0 ，1.1…
-
官方网站最新版本17,目前我们使用JDK1.8 免费，稳定，企业大多数使用的版本
Java语言的特点
1, 面向对象的编程语言
2, 跨平台的编程语言
Java的虚拟机 (负责解释java class文件)
3, 是一门解释型编程语言 (JVM解释)
4，简单性
5，健壮性(垃圾回收机制)和安全性
6, 多线程 (同一时刻可以执行多个任务)
JDK,JRE,JVM
JDK
Java开发工具包（ Java Development Kit），可以将java源代码编译成class文件,里面包含了常用的类库,同时包含JRE和JVM
JRE
Java运行环境（Java Runtime Environment )，如果没有jre,是不能执行class文件,JRE是包含了JVM的
JVM
Java虚拟机（Java Virtual Machine ），负责解释class文件给操作系统
编写Java的HelloWorld
编写源文件时的注意事项
- 文件命名：首字母大写，使用驼峰命名法
- 所有的符号要在英文半角的状态下输入
- 基础格式
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello World!");
}
}
（args可以变，println为换行输出）
（自动补全设置：window→preference→Java→Editor→Content Assist→Auto activation triggers for Java）
环境变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IelHV2Oq-1652941771723)(C:\Users\Zhangxy\AppData\Roaming\Typora\typora-user-images\1648517499990.png)]
Java关键字
public class viod static int float byte...
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YPjMr5L1-1652941771724)(C:\Users\Zhangxy\AppData\Roaming\Typora\typora-user-images\1648521355424.png)]
Java标识符
计算机语言中的各种符号，表示某个特定含义，需要自定义名字的标识
标识符命名规则：
- 不能使用关键字
- 由字母，数字，下划线，$，组成
- 不能以数字开头
行业内的一些命名习惯
- 顾名思义
- 类的名字首字母大写，变量名和方法名首字母小写，常量名全部大写
- 使用驼峰命名法
Day2
数据类型
为了把数据分成所需内存大小不同的数据，可以更好管理内存空间的分配
Java中的数据类型
八大基本数据类型
整数
byte ：1个字节 取值范围：-128~127
short ：2个字节 取值范围：
int ：4个字节 取值范围：
long ：8个字节 取值范围：
常用默认int
小数（浮点型）
float ：4个字节
double ：8个字节
字符
char ：采用Unicode编码，每个字符占两个字节
布尔
boolean ：只允许取值true或false
引用数据类型
String（字符串）、数组、类、接口、枚举…
Java的注释
注释是不被编译和运行的，是用我们最熟悉的语言对代码进行解释
一般在开发过程中，10行代码至少 由3行注释
三种注释
1,单行注释 //注释内容
//以下HelloWorld的输出
2,多行注释 /* 注释内容 */
/*
System.out.println("hello world");
System.out.println("my name is qiaqia");
*/
3,doc文档注释
/**
* 这是一个Hello World类
* @author rachel
*
*
*/
可以使用javadoc.exe生成开发文档
变量
是内存中分配的地址的名字，用来存储数据的
变量的三要素：变量类型、变量名字和变量值
//变量的三要素：变量类型、变量名字和变量值
int number;
//给变量赋值
number = 10;
number = 20;
int n = 0xf7;
System.out.println(n);
声明不同类型的变量并赋值
byte b = 127;
short s = 128;
long l = 10L;
float f = 0.5f;
double d = 10.5f;
char c = 65;
int i = '1';
System.out.println(i);
boolean flag = false;
String str = "dsfsdf";
同时声明多个变量
int num1=10,num2;
变量在使用之前必须初始化,否则编译报错
常量
不可变的量
//常量 (命名规则:建议全部大写)
//常量的声明
final double PI = 3.14;
//声明一个字符串类型的常量，并赋值为"hello"
final String STR = "hello";
System.out.println(PI);
在同一个作用域下，不能出现相同的变量或常量名, 不能重复
运算符
用于操作数据值
赋值运算符
long num1 = num; //= 是一个简单的赋值运算符 运算的优先级最低
+= -= *= /= %=
int number3 = 10;
number3 += 5;// number3 = number3 + 5;
System.out.println(number3);
算术运算符
+ - * / %
连接运算符 +
用于字符串拼接
//+ 连接运算符 :用于字符串的拼接
String str1 = "hello",str2 = "world";
String str3 = str1 +str2;
System.out.println(str3);
System.out.println("number3的值:"+number3);
System.out.println(str3+(number1+number2));
自增，自减
++ –
++在后面：先赋值，后加1
++在前面: 先加1，再赋值
– 同理
int i = 1;
// i++;
// ++i;
// int j = i++; //先赋值，后加1 j = i; i = i+1;
int j = ++i; //先加1， 再赋值 i = i+ 1; j = i;
System.out.println("j是:"+j);
System.out.println("i是:"+i);
int a = 10;
a=a++; //a=10
int b = a + a++ + a;//31
位运算符
将十进制转换成二进制进行按位运算
//位运算符 & | ^ << >>
int num1 = 8; //0000 1000
int num2 = 13; //0000 1101
num1 & num2; //0000 1000
num1 | num2; //0000 1101
num1 ^ num2; //0000 0101
num1 << 2; //0010 0000
num1 >> 2; //0000 0010
比较运算符
< >= <= == != 得到布尔类型的结果
System.out.println(10 > 6);//true
逻辑运算符
//逻辑运算符 & | && || !
boolean b1 = true,b2 = false;
System.out.println(!b1);//flase
//& 和 && 符号的区别 | 和 || 区别
//&& 具有短路运算,可以提高运行效率
int i = 5;
System.out.println( i>0 && i++ > 5); //i=6
System.out.println( i>0 && i++ > 5); //i=5
三元运算符 (三目运算符)
age >= 18 ? “成年” : “未成年”;
语法为：条件表达式？表达式1：表达式2
条件表达式 (boolean类型的结果) ? true : false
//用于等号右边，用作赋值
int age = 17;
String result = age >= 18 ? "成年" : "未成年";
System.out.println(result);
练习题:
声明一个整型变量，赋值为一个三位数的整数,分别求出个位，十位，百位的值
并计算个十百位的立方和
使用三目运算符判断这个数是不是水仙花数
public class Practise_Shuixianhua {
public static void main(String[] args) {
int num = 153;
int one, ten, hun;
int sum;
// 计算个位数
one = num % 10;
// 计算十位数
ten = num % 100 / 10;
// 计算百位数
hun = num / 100;
// 计算个位，十位，百位的立方和
sum = +one * one * one + ten * ten * ten + hun * hun * hun;
System.out.println(num == sum ? num + "是水仙花数" : num + "该数不是水仙花数");
}
}
运算符的优先级
1.逻辑非运算符“!”优先级最高，
2.其次是算术运算符
3.然后是关系运算符
4.再次是逻辑与运算符“&&”和逻辑或运算符“||”
5.最低的是赋值运算符。
基本数据类型转换
//将范围小的数据类型转为范围大的数据类型，可以实现自动转换
byte b = 10;
short sh = 10;
int c = b;
float f = c;
char ch = 65; // A-Z 65-90 a-z 97-122
int chint = ch;
System.out.println(chint);
//byte 和 short在运算时类型会自动提升为int类型
byte b1=127,b2=20;
short s1 =10,s2=20;
int b3 = b1+b2;
int s3 = s1+s2;
//强制转换，将大范围的转换为能兼容的小范围
int i1 = 30;
byte b4 = (byte)i1;
double d1 = 10.1;
int i2 = (int)d1;
System.out.println(i2);
面试题:
& 和 && 符号的区别?
&：用于数字之间是位运算符，用于条件之间是逻辑运算符
&&:逻辑运算符，具有短路运算功能，能提高程序运行的效率
Day3
Debug断点调试
F5:
F6: 执行下一句代码
F7:
F8:结束当前断点
条件结构
如果…就…
否则就…
单分支if语句
语法结构
if(条件表达式){
语句块
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ehsM0ZZz-1652941771725)(D:\课堂笔记及视频\一阶段\day03\images\单分支流程图.png)]
条件表达式为真，才执行里面的语句块
//成绩
double score = 55;
if(score >= 60) {
//语句块
System.out.println("及格了");
System.out.println("并且很优秀");
}
练习:
声明三个整型变量并赋值，找出三个数中的最大值
//声明三个整型变量并赋值，找出三个数中的最大值
int a=22,b=66,c=56;
//假设a就是最大值
int max = a;
//先比较a和b,找出a和b中较大的数
if( a < b) {
max = b;
}
//用max和c去比
if(max < c) {
max = c;
}
System.out.println(max);
双分支if语句
格式：
if(条件表达式){
语句块1
}else{
语句块2
}
如果条件表达式为真，则执行语句块1；否则，执行语句块2
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vAfNGQ49-1652941771726)(D:\课堂笔记及视频\一阶段\day03\images\双分支流程图.png)]
//判断一个数是奇数还是偶数
int num = 9;
if(num % 2 == 0) {
System.out.println(num+"是偶数");
}else {
System.out.println(num+"是奇数");
}
System.out.println("over");
else不能单独使用,else必须和if配套使用,if可以单独使用
嵌套if
在if或者else里面再写if
if（）{
if(){
}else{
}
}else{
if(){
}
}
//嵌套if
double score = -10;
//先判断是否是一个合法的分数
if(score >=0 && score <=100) {
System.out.println("合法的分数");
if(score >= 60) {
System.out.println("及格");
if(score >= 90) {
System.out.println("成绩优秀");
}else {
// if() {
//
// }
}
}else {
System.out.println("不及格");
}
}else {
System.out.println("无效分数");
}
练习:
声明一个变量year年,判断是否是闰年
4年一闰，百年不闰，400年再闰
1800年
2000年
//声明一个变量year年,判断是否是闰年
//4年一闰，百年不闰，400年再闰
// 1800 不是 能被4整除，能被100整除，又不能被400整除
// 1996 是 原因是能被4整除
// 2000 是 能被400整除
int year = 1996;
if((year % 4 == 0 && year %100 != 0) || year%400==0) {
System.out.println("是闰年");
}else {
System.out.println("不是闰年");
}
练习题:
1，声明两个变量i和num,判断i是不是num的约数
2，声明一个变量score,取值范围要在0<100之间,90以上为优秀,80-90之间为良好,60-80之间为及格，60以下为不及格,输出对应的结果
多分支if语句
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yhPcvXsK-1652941771727)(D:\课堂笔记及视频\一阶段\day03\images\多分支流程图.png)]
语法:
if(条件表达式1){语句块1}
else if(条件表达式2){语句块2}
else if(条件表达式3){语句块3}
…
else if(条件表达式m-1){语句块m-1}
else{语句块m}
//声明一个变量score，90-100为优秀，
// 80-90之间为良好，60-80之间为及格，60以下为不及格，输出对应的结果，要求用多重if完成
int score = 110;
if(score<=100 && score>=0) {
if(score>=90) {
System.out.println("优秀");
}else if(score>=80){
System.out.println("良好");
}else if(score>=60) {
System.out.println("及格");
}else{
System.out.println("不及格");
}
}else {
System.out.println("无效分数");
}
switch结构
语法结构:
算术表达式:变量名称
//算数表达式1支持数据类型：byte,short,int,char,String,枚举
switch(算术表达式){
case 常量表达式1 ：
语句块1
break;
case 常量表达式2 ：
语句块2
break;
…
default ：
语句块m
break;
}
会用算术表达式和case里面的常量值进行等值的比较，如果值相等，则执行对应的语句块,直到遇到break为止，break可以跳出整个swith,如果所有值都不等，则执行default语句块，通常把default放在最后(default是可以省略的)
break
表示跳出switch,如果没有break,会从满足条件的case开始一直往下执行，直到break为止
default
当所有case等不满足时，执行default,通常把default放在最后(default是可以省略的)
算术表达式支持的数据类型
byte short int char String 枚举(了解)
应用场景:
3个及以上在比较等值且满足数据类型的时候使用switch
输入
Scanner
//1、导包
import java.util.Scanner;
//导包的动作必须出现在类定义之前
//2、创建对象
Scannner in = new Scanner(System.in);
//上面这个格式里，只有in是变量名，其他的都不可变
//3、接收数据
int i = in.nextInt();
//上面这个格式里，只有i是变量名，其他的都不可变
//关闭输入
in.close();
//输入
Scanner in = new Scanner(System.in);
//需要接收用户输入的数据
//接收控制台输入的下一个整数
//in可更改
System.out.println("请输入第一个数字:");
int num1 = in.nextInt();
System.out.println("请输入第二个数字:");
int num2 = in.nextInt();
in = new Scanner(System.in);
System.out.println("请输入一个字符串");
//下一个字符串
String str = in.nextLine();
System.out.println(str);
char 变量名 = myScanner.next().charAt(0);//接收第一个字符
随机数
//1、导包
import java.util.Random;
//导包的动作必须出现在类定义之前
//2、创建对象
Random r = new Random();
//上面这个格式里，只有r是变量名，其他的都不可变
//3、获取随机数
int number = r.nextInt(10);
//上面这个格式里，只有number是变量名，其他的都不可变
//取值为0到10，包含0，不包含10
//生成随机数
Random random = new Random();
int num1 = random.nextInt(6)+1;
int num2 = random.nextInt(6)+1;//random取值为0到6，包含0，不包含6
System.out.println(num1);
System.out.println(num2);
字符串的一些知识
- 字符串的比较
JVM的内存中有栈内存，堆内存，方法区，方法区中有常量池
String str1 =new String("hellow");//当输入hellow时，此地址存放在堆内存中
String str2 ="hello";//此hellow地址存放在方法区中的常量池中
str1==str2//此结果为false
//Java中==比较的是地址
//使用equals比较字符串
System.out.println("请输入大或者小");
Scanner in = new Scanner(System.in);
String str = in.next();
if(str.equals("大")) {
System.out.println("等");
}else {
System.out.println("不等");
}
- 字符串大小写转换
转小
str.toLowerCace();
System.out.println(str);
转大
str.toUpperCace();
System.out.println(str);
- 字符串转为字符数组
char[] chs=str.toCharArray();
作业（分支结构）：
第一题:
玩骰子游戏
请押注：输入大或者小
随机生成两个1-6的随机数，组合在一起，大于6就是大，反之是小
输出你押注的结果，输了还是赢了
第二题:
请输入一个数，判断这个数是不是水仙花数
步骤：
1，必须是一个三位数，否则是无效输入
2, 算出个位，十位，百位的值
3 计算个，十，百位的立方和
4, 判断立方和是否等于这个数，并给出最终结果
第三题:
1，输出
System.out.println(“欢迎来到Java世界,遇到问题你会怎么办?”);
System.out.println(“请选择:1,看上课视频 2，看笔记 3，寻求同学帮助 4，问老师 5，放任不管”);
2,请输入你的选项
3,对应每个选项，给出一句鼓励的话
第四题(选做)
计算小红的工资：
小红暑假去打工，所在的公司上班时间是周一至周五，周末双休，每一天200元，请输入小红入职的星期数n(周一至周五), 请输入一个天数day，计算day天后，小红能拿多少工资
Day4
循环结构
作用：为了解决代码中重复性的问题，可以提高代码的可维护性，在Java中循环由三种方式，while，do while，for
while循环
先验循环,先验证条件是否成立，如果成立，则执行循环体
- 语法结构
while（布尔表达式）{
循环体
}
- while循环的使用
int i = 0; //控制循环的次数 (迭代变量)
while(i<10) { //i<10 循环条件 必须要事其为假的时候，否则一直为真，会出现死循环
//循环体 (需要被重复执行的代码)
System.out.println("hello"+i);
i++; //修改迭代变量的值
}
System.out.println("over");
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EJsXg8U2-1652941771728)(D:/课堂笔记及视频/一阶段/day04/while.png)]
- 案例 猜数字
//案例 猜数字
System.out.println("请输入一个数字:");
Scanner in = new Scanner(System.in);
boolean flag = true;//用来控制循环是否继续
int number = 9;
while(flag) {
int guessNum = in.nextInt();
if(guessNum == number) {
System.out.println("猜对了");
flag = false;
}else {
System.out.println("猜错了");
System.out.println("请重新输入一个数字:");
}
}
// System.out.println(guessNum);
- 练习:
使用while循环打印出1-100之间的所有偶数
//使用while循环打印出1-100之间的所有偶数
//计算出1-100的偶数和
int i = 1;
int sum = 0;
while(i<=100) {
//判断一个数是不是偶数
int num = i;
if(num % 2 == 0) {
System.out.println(num+"是偶数");
sum += num;
//2 + 4 + 6 + 8....+100
}
i++;
}
- 练习:
//请输入一个数字,提示用户是否继续输入 y/n? y 最后算出所有输入数字的总和
do while循环
后验循环 : 做…事情直到条件不满足为止
先做，再判断条件,始终会执行一次
语法结构
do{
//循环体
}while(条件表达式);
//猜数字
int num = 9;
boolean isContinue = true;
do {
System.out.println("请猜一个数字");
Scanner in = new Scanner(System.in);
int number = in.nextInt();
if(num == number) {
System.out.println("猜对了");
isContinue = false;
}else {
System.out.println("猜错了，再猜");
}
}while(isContinue);
//已知循环次数，用迭代变量控制
//未知循环次数，用布尔类型的变量来控制
- 练习
//请输入一个数，判断这个数是不是质数 (只能被1和自己整除的数 7 11 13)
//如果是7 用7从2-6进行整除判断
// int i = 2;
System.out.println("请输入一个数:");
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int i = 2;
boolean falg = true;//默认是质数
while(i<num && falg) {
//判断这个数和i是否能整除
if(num % i == 0) {
falg = false;
}
i++;
}
if(falg) {
System.out.println("是质数");
}else {
System.out.println("不是质数");
}
for循环
- 语法结构
for(表达式1；表达式2；表达式3){
表达式4
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2bXXFKea-1652941771730)(D:/课堂笔记及视频/一阶段/day04/for.png)]
表达式1,2,3可以省略,但不推荐省略
增强for foreach (后续讲)
已知循环次数，用for循环
未知循环次数，用while循环或者do-while循环
continue
用于循环中,表示结束本次循环,继续下一次循环
//计算1=100的偶数和
int sum = 0;
for(int i = 1;i<=100;i++) {
if(i%2 == 0) {
System.out.println("是偶数");
continue;
}
sum+=i;
}
break
结束当前所在的循环
//请输入一个数，判断这个数是不是质数 (只能被1和自己整除的数 7 11 13)
//如果是7 用7从2-6进行整除判断
// int i = 2;
System.out.println("请输入一个数:");
Scanner in = new Scanner(System.in);
int num = in.nextInt();
int i = 2;
boolean falg = true;//默认是质数
while(i<num) {
//判断这个数和i是否能整除
if(num % i == 0) {
falg = false;
System.out.println("不是质数");
break;
}
i++;
}
if(falg) {
System.out.println("是质数");
}
return
有结束循环的作用（直接结束方法）
数组
数组：是一种用于存储多个相同类型数据的存储模型
数组是一种引用数据类型
数组是一种基本的数据结构，是一种线性表结构
- 定义格式：
1、（推荐）
数据类型[] 数组名；
int[] arr;
2、
数据类型 数组名[];
int arr[];
数组初始化：
A：所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组元素赋值
B：数组初始化：动态初始化，静态初始化
静态初始化
初始化时指定每个数组元素的初始值，由系统决定数组长度
格式：
数据类型[] 变量名=new 数据类型[] {数据1，数据2，数据3，…}
简化格式：
数据类型[] 变量名= {数据1，数据2，数据3，…}
int arr =new int[] {1,2,3};
int arr ={1,2,3};
动态初始化
初始化时只指定数组长度，由系统为数组分配初始值
格式：
数据类型[] 变量名 = new 数据类型[数组长度]；
int[] arr=new int[10];
/*
左边：
int：说明数组中的元素类型是int类型
[]:说明这是一个数组
arr：数组的名字
右边：
new：为数组申请内存空间
int：说明数组中的元素类型是int型
[]: 这是一个数组
10：数组长度，表明数组中的元素个数
*/
数组在初始化时，会为存储空间添加默认值
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vevMtLPn-1652941771731)(C:\Users\Zhangxy\AppData\Roaming\Typora\typora-user-images\1649312409444.png)]
数组元素访问
- 数组变量的访问方式：
格式：数组名
- 数组内部保存的数据的访问方式：
格式：数组名[索引]；
- 索引：
数组中数据的编号方式，用于访问数组中的数据使用，数组名[索引]等同于变量名，是一种特殊的变量名
- 从0开始
- 连续的
- 逐一增加，每次加1
int[] arr = new int[3];
System.out.println(arr);//[I@15db9742 申请数组内存空间时，空间的地址
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0
数组常见的问题
- 索引越界：访问了数组中不存在的的索引对应元素，造成索引越界问题
- 空指针异常：访问的数组已经不再指向堆内存的数据，造成空指针异常
- null：空值，引用数据类型的默认值，表示不指向任何有效对象
数组常见操作
- 获取数组元素数量
数组名.length
arr.length
- 遍历
//方法1
for (int x=0;x<arr.length;x++){
arr[x];
}
//方法2 Foreach遍历
for(int i: arr){
System.out.println(i);
}
练习
//输入10个数字，分别存入数组中，使用循环打印数据并计算出它的平均值
double[] nums = new double[10];
//循环输入10个数字,存入数组
Scanner input = new Scanner(System.in);
for(int i = 0;i<nums.length;i++) {
System.out.println("请输入第"+(i+1)+"个数字:");
nums[i] = input.nextInt();
}
double sum = 0;
//遍历数组
for(double num:nums) {
sum+=sum;
System.out.print(num+" ");
}
double avg = sum / nums.length;
System.out.println("平均值:"+avg);
- 获取最值
int[] arr = {12,45,32,54,60};
int max=arr[0];
for (int x=1;x<arr.length;x++){
if(arr[x]>max){
max=arr[x];
}
}
- 数组扩容
1:手动扩容\缩容
int[] nums = new int[] {2,3,4};
System.out.println(nums);
//插入一个新元素
//创建一个新数组
int[] newNums = new int[nums.length+1];
newNums[i] = nums[i];
}
// System.out.println("输入要添加的数据:");
//
// Scanner in = new Scanner(System.in);
//
// //将输入的数据赋值给新数组的最后一个元素
// newNums[newNums.length-1] = in.nextInt();
//遍历整个新数组
for(int n : newNums) {
System.out.print(n+" ");
}
//将原数组的数据拷贝到新数组中
for(int i = 0;i<nums.length;i++) {
2：工具类扩容
新数组=Arrays.copyOf(原数组，新数组长度);
String[] names={"zhangsan","lisi","wangwu"};//原数组
names=Arrays.copyOf(names,names.length+1);//数组的地址将会发生变化，新扩充为最后一位
3：工具类缩容
String[] names={"zhangsan","lisi","wangwu"};
names=Arrays.copyOf(names,names.length-1);//缩容的元素，默认为最后一位
数组拷贝
System.arraycopy(src原数组，srcPos原数组起始下标，dest目标数组，destPos目标数组起始下标，length拷贝长度)；
int[] srcNums = {2,4,6};
int[] destNums = new int[srcNums.length+1];
System.arraycopy(srcNums, 1, destNums, 0, srcNums.length-1);
数组内存分配
Java程序运行时，需要在内存中分配空间。
为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
java中是将所有数据存放在JVM虚拟机内存中
1，栈，
- 方法是在栈中运行的，
- 局部变量：在方法中声明，当方法结束后，变量就被释放
2，堆
- 凡是使用了new关键字创建对象，数据都存放在堆中
- 没有用的数据，将会被垃圾回收系统回收。
3，方法区
4，本地方法区
5，寄存器
- 栈内存：存储局部变量
定义在方法中的变量，例如：arr。使用完毕，立即消失
- 堆内存：存储new出来的内容（实体，对象）
数组在初始化时，会为存储空间添加默认值，每一个new出来的东西都有一个地址值，使用完毕，会在垃圾回收器空闲时回收。
多个数组指向相同时，栈内存中的地址相同，共用一个堆内存数据，修改其中一个数组堆堆内存的数据时，其他数组的元素也相应改变
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
int[] arr2 = arr;
System.out.println(arr); //[I@15db9742
System.out.println(arr2); //[I@15db9742
System.out.println(arr[0]); //100
System.out.println(arr2[0]);//100
arr2[0] = 111;
System.out.println(arr[0]); //111
System.out.println(arr2[0]);//111
//final 定义数组，仅该数组的地址不可修改，其内部元素可以改变
final int[] arr=new int[] {1,2,3};
arr= new int[] {4,5,6};//报错
arr[0]= 4;//可执行
排序
- 选择排序
for (int i = 0; i < arr.length-1; i++) {
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < arr[i]) {
min = arr[j];
arr[j] = arr[i];
arr[i] = min;
}
}
}
- 冒泡排序
for(int i =0 ; i<arr.length-1 ; i++) {
for(int j=0 ; j<arr.length-1-i ; j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
- 练习
有一个英文字符串，按字母顺序实现排序
//字符串相关的几个方法
String str = "aohdyyrqwWQ";
//将其全部转为小写
str = str.toLowerCase();
//str.toUpperCase() 转大写
//把字符串转换为字符数组
char[] chs = str.toCharArray();
System.out.println(chs[chs.length-1]);
二维数组
二位数组中的每一个元素再是一个一位数组
多维数组同理
int[][] num={{1,2},{3}};
int[][] num=new in[][]{{1,2},{3}};
int[][] num=new int[3][];//3个一维数组，初始值为null
int[][] num=new int[3][2];//3个一维数组，每个数组长度为2，初始值为0
//使用二维存放用户名和密码
String[] user1 = {"zhangsan","123"};
String[] user2 = {"lisi","456"};
// String[] user3 = {"wangmazi","789"};
//访问二维数组的方式
String[][] users = new String[3][];
users[0] = user1;
users[1] = user2;
users[2] = new String[] {"wangmazi","789"};
// users[2][1] 2代表的是一维数组所在的位置
// users[2][1] 1一维数组中元素的位置
System.out.println(users[2][1]);
方法
- 方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊的功能的代码集
- 方法必须先创建才可以使用，该过程称为方法定义
- 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用
方法定义和调用
- 方法定义（方法的签名）
//格式public static :修饰符
public static void 方法名（）{
//方法体
}
//public static :修饰符
当重定义一个数组时，等于修改了该数组的地址，里面的所有元素值都要重置。
- 方法调用
//格式
方法名（）；
需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
package Day06;
import java.util.Scanner;
public class Demo_fangfa {
public static void main(String[] args) {
even();
}
public static void even() {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个数,偶数为true，奇数为false");
int num = in.nextInt();
if (num % 2 == 0) {
System.out.println("true");
} else {
System.out.println("false");
}
in.close();
}
}
debug
F5进入方法
F6下一步
F7跳出方法
F8结束当前断点
带参数方法的定义和调用
- 定义格式
public static void 方法名(参数){......}
//单个参数
public static void 方法名(数据类型 变量名){......}
public static void max(int number){......}
//多个参数
public static void 方法名(数据类型 变量名1，数据类型 变量名2，...){......}
public static void max(int number1,int number2,...){......}
1. 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
2. 方法定义时，多个参数之间使用逗号分隔
- 调用格式
方法名（参数）
方法名（变量名/常量值);//单个参数
even（5);
方法名（变量名1/常量值1,变量名2/常量值2);//多个参数
max（5,6);
方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
//输入一个数，判断是否为偶数
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个数,偶数为true，奇数为false");
int num = in.nextInt();
even(num);
in.close();
}
public static void even(int num) {
if (num % 2 == 0) {
System.out.println("true");
} else {
System.out.println("false");
}
}
形参和实参
- 形参：方法定义中的参数，由数据类型和变量名组成，本身不具备值，用来接收实际参数的值，作用域只在方法中
public static void even(int num) int num 为形参
- 实参：方法调用中的参数，是一个常量值或一个变量名，方法调用时传递的参数，具有实际值的数据
even(num); num 为实参
带返回值方法的定义和调用
- 定义格式
public static 数据类型 方法名（参数）{
//方法体
return 数据；
}
public static :修饰符
数据类型：返回值类型，如果五返回值可以写void，一般省略return
方法名：调用方法时使用的标识
参数：由数据类型和变量名组成，多个参数之间用逗号隔开
public static boolean even(int num) {
if (num % 2 == 0) {
return true;
} else {
return false;
}
}
- 调用
数据类型 变量名=方法名（参数）；
boolean flag=even(5);
方法的返回值通常会使用变量接收，否则返回值将无意义
方法的注意事项
-
方法不能嵌套定义(方法不能在方法中定义，而是在类中)
-
void表示无返回值，可以省略return，也可以单独的书写return，此时return后面不加数据
public static void even(int num) {
//代码段
}
public static void even(int num) {
//代码段
return;
}
-
明确返回值类型，如果没有就写void
-
明确参数的类型和数量
-
调用时，void类型方法直接调用即可，非void类型方法，推荐用变量接收调用
方法重载
指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
- 条件
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不同（类型不同或数量不同）
- 特点
- 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
- 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
public class Demo_fangfa {
public static int sum(int a, int b) {
return a + b;
}
public static double sum(double a, double b) {
return a + b;
}
}
- 在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法
方法的参数传递
对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
public static void main(String[] args) {
int number = 10;
System.out.println(number); //10
change(number); //20
System.out.println(number); //10
}
public static void change(int number) {
number = 20;
System.out.println(number);
}
对于引用数据类型的参数，形参的改变，有可能影响实参的值
public static void main(String[] args) {
int[] number = {10};
System.out.println(number[0]); //10
change(number); //20
System.out.println(number[0]); //20
}
public static void change(int[] number) {
number[0] = 20;
System.out.println(number[0]);
}//堆内存中的数据被改变
public static void main(String[] args) {
int[] number = {10};
System.out.println(number); //[I@15db9742
change(number); //[I@6d06d69c
System.out.println(number); //[I@15db9742
}
public static void change(int[] number) {
number = new int[] {20};
System.out.println(number);
}//栈内存中的数据未改变
可变参数类型 （不定参数类型）
在调用方法时传入不定长度的参数
- 定义
在定义方法时，在最后一个形参后加上三点 …，就表示该形参可以接受多个参数值，多个参数值被当成数组传入。
- 调用
public class Varargs {
public static void test(String... args) {
for(String arg : args) { //args实则为一个数组
System.out.println(arg);
}
}
public static void main(String[] args) {
test();//0个参数
test("a");//1个参数
test("a","b");//多个参数
test(new String[] {"a", "b", "c"});//直接传递数组
}
}
- 注意事项
-
可变参数只能作为函数的最后一个参数（但其前面可以有也可以没有其他参数）
-
一个函数最多只能有一个可变参数
-
Java的可变参数，会被编译器转型为一个数组
-
变长参数在编译为字节码后，在方法签名中就是以数组形态出现的。（这两个方法的签名是一致的，不能作为方法的重载。如果同时出现，是不能编译通过的）。
-
优先匹配固定参数
-
可变参数可以兼容数组，反之不成立
public class Test_01 { public void sort(int... i) { //形参为可变参数 for(int j :i) { System.out.println(j); } } }public class Deno_test { public static void main(String[] args) { int[] n1=new int[] {1,2,3}; int[] n2=new int[] {4,5,6}; Test_01 t=new Test_01(); t.sort(n1); //实参为数组，结果正确 } }
1830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
