2022/8/1
统计思想:
需求: 在控制台输出, 水仙花有多少个?
分析:
定义一个统计变量count:从0开始
水仙花:满足3位数,每一个位的数据的立方和相加是这个数据本身
100-999之间确定每各位的数据本身
int get = 当前这个数据 % 10 ;
int shi = 当期这个数据/10 %10;
int bai = 当期这个数据/10 /10 % 10 ;判断:x == (ge* ge* ge+shi* shi* shi+bai* bai* bai)
count ++ ;输出count
while循环
- 格式:
初始化语句; while(条件表达式){ 循环体语句 ; 控制体语句或者步长语句 ; }
执行流程:
首先,先初始化语句,对变量赋值;
执行条件表达式,是否成立;成立,则执行循环体语句,依次控制体语句进行变量控制--->再次判断条件表达式是否成立,成立,执行循环体语句--->控制体语句进行变量控制
当条件表达式不成立,while循环结束;
- 注意事项: 控制体语句不要忘了,否则死循环;
while循环和for循环的区别(重点)
- 共同点
能描述一种循环的思想, 将重复性冗余代码进行优化,提供程序阅读性; - 不同点
a) 格式不同
b) 场景不同
for循环----明确循环次数(开发中优先使用)
while循环----不明确循环次数
c) 是否节省内存资源
从格式来说
for循环---->循环结束之后, 变量被释放了
while循环--->循环结束,依然可以使用该变量, 相对于for循环格式来说,比较耗费内存资源
实际开发中, for更常使用
2022/8/2
do-while循环
格式:
初始化语句; do{ 循环体语句 ; 控制体语句 ; }while(条件表达式) ;
当条件不成立时, 循环体至少使用一次,
jdk源码里面会使用到do-while循环
死循环
两种格式
(一)
for(;;){ 循环体语句; }
(二)while格式的死循环----使用更多
while(true){ 循环体语句; break ; } //当达到某个条件, 结束while循环
Math.random() -----获取一个随机数
流程控制语句
break----结束中断, 在switch 或在循环中
continune----结束当前循环, 立即进入下一次循环
return---在方法中, 结束方法去使用; 一般携带返回的结果, 很少单独使用
方法
定义有具体返回值类型的方法的格式
固定写法:
public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...){
//完成业务逻辑
return 结果;
}
调用,使用的赋值调用
返回值类型 变量名= 方法名(实际参数1,实际参数.....) ;两个明确
- 明确返回值类型
- 明确参数类型以及参数个数
- 图解
2022/8/3
方法----没有具体返回值
- 应用场景
① 当某个业务逻辑里面比如完成的数据的直接输出,展示数据----System.out.println("xxx") ;
② 业务逻辑中可能数据某个数据在进行排序 数据交换
这种方法在定义的时候, 遵循有具体返回值类型的方法定义格式:
没有具体的结果是直接输出在控制台上,
关键字 void,代替返回值类型(Java定义方法语法的要求:需求没有具体返回结果,就是用void)
定义格式:
public static void 方法名(形式参数类型1 参数名称1, 形式参数类型2 参数名2,....){ }
- 经典例题:
键盘录入两个数据,比较两个数据是否相等,需要定义方法来实现,并在主方法中测试
方式1:
可以写一个方法,有返回值结果:true/false boolean类型
方式2:
可以写一个方法,没有返回值结果,方法里面直接输出
"两个数据相等" 或者"两个数据不相等"
方法重载 (overload)
方法名相同(完全一致,区分大小写), 参数列表不同(顺序/类型/个数)
方法重载: 为了某个功能扩展性,多个方法方法名可以相同(完全相同),参数列表不同,与返回值无关
- 参数列表不同
1)参数个数不同
2)参数类型不同
3)考虑参数类型的顺序
方法重载是概念性的东西,一般用在设计代码层面 ;
给一个需求,只需要定义某个功能实现即可!后期看jdk的api文档,学习它里面的常用类的一些功能(涉及方法重载)
举例:
公司让你开发针对某个模块的api文档---考虑某个功能,方法的形式参数可以传递任何类型包括引用类型
方法的三种调用形式：
①直接调用：
直接写方法名调用
②赋值调用：
调用方法，在方法前面定义变量，接受方法的返回值
③输出语句调用：
只能在有返回值类型的方法调用，直接在输出语句中调用方法
数组
数组是一种容器,只能存储同种类型的元素, 数组是存储数据的长度固定的容器,可以保存多个数据
特点: 保存的数据类型要一致
注意: 创建数组时, 不能动静结合----不能同时动态和静态初始化,只能有一种
定义格式
数据类型[] 数组名称 int[] arr
数据类型 数组名称[] int arr[]初始化:
①动态初始化
int[] arr = new int[3]
int arr[] = new int[3]
②静态初始化(2种)
int[] arr = new int[]{元素1,2.... };
int[] arr = {11,22,33}
长度属性
用数组名.length可以获取数组的长度。因为数组索引是由0开始的，所以数组最大的索引值为数组名.length-1
数组的初始值
数组在没有给其初始化赋值时比如：
int arr=new int[10]
暂且只知道数组长度为10，并没有说明各个索引位的数值是多少。
实际上不同数据类型的数值，在未给其赋值时，都会有一个默认值。
整数类型数组默认值是0
小数类型数组默认值是0.0
字符类型数组默认值是空
布尔类型数组默认值是false
引用数据类型数组默认值是null
数组原理内存图
1.内存的概念
内存是一个很常见的概念，电脑有电脑内存，手机也有手机内存。
内存是程序的临时存储区域，我们编写的程序是存放在硬盘中的，但是在硬盘中到的程序是不会运行的，必须要放进内存中才能运行，运行完毕后会清空内存。
JVM作为Java虚拟机，它要运行程序，自然要对内存进行划分和管理：
- 寄存器：给CPU使用
- 本地方法栈：JVM在使用操作系统功能的时候使用
- 堆内存：存储对象或者数组
- 方法栈：方法运行时使用的内存;存储局部变量使用该区域
- 方法区:
字节码文件区域----方法调用过程需要加载类
static区域----main方法就是static 修饰的
常量池----常量都是在常量池
数组的变量实际存储的就是堆内存中的地址。
只要有new操作就会在堆内存中开辟空间。
2022/8/4
面试题//数组int[ ] array = new int[3] ;
这句话完成哪些事情? --------内存干了什么事情
1)需要在栈内存中开辟空间, int[ ] array这个变量
2)new int[3] ; 需要在堆内存中申请空间
3)为这个堆内存中的这些数组的元素, 进行系统默认初始化, int类型的元素在数组中默认值0
4)系统初始化完毕, 为堆内存空间产生一个空间地址值,
5)将堆内存空间地址值赋值给栈内存的变量array
6)栈内存变量array指向堆内存地址;
数组中基本应用
①最值问题max/min
分析
假设思想
1.定义一个参照物, array[0] 就是最大值max
2.从array[1]开始遍历数组的其他元素
3.判断: 使用之后的元素一次和参照物进行比较;修改最大值
4.获取最大值
经典例题 int[] array = {65,45,76,87,13} ;
public class ArrayDemo {
public static void main(String[] args) {
//创建一个数组静态初始化
int[] array = {65,45,76,87,13} ;
//1)定义一个参照物 array[0]
int max = array[0] ;
//2)从角标1开始遍历数组的其他元素
for(int x =1 ;x < array.length ; x++){
if(array[x]> max){
//后面的元素比较大
max = array[x] ;
}
}
System.out.println("数组中的最大值是:"+max);
System.out.println("-----------------------------------------") ;
//学习了方法,上面代码进行改进
//赋值调用
int max2 = getArrayMax(array) ; //实际参数
System.out.println("max2:"+max2);
System.out.println("-----------------------------------------") ;
//获取数组最小值
int min = getArrayMin(array);
System.out.println("min:"+min);
}
②数组查表法
给定一个数据, 快速获取数组中的某个元素 :数组名称[索引值]
//字符串数组---存储字符串
- String[ ] strArray = { }
//创建数组的格式: 静态初始化
数据类型[ ] 数组名称 = {元素1,元素2,,,,,}
需求 :键盘录入一个数据 : 显示"星期"
public class ArrayDemo2 {
public static void main(String[] args) {
//键盘录入一个数据
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入一个数字(0-6):") ;
int num = sc.nextInt() ;
//已知字符串数组--->里面存储 了一些元素
String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
System.out.println("你查询的星期是:"+strArray[num]) ;
}
}
数组中的基本元素查找法:
查询元素 的第一次出现的索引值, 每次都需要从头查到尾
对于基本元素查找法的---数组的元素内容, 可以有序/可以无序
二分查找法(折半查找)----数组元素必须有序!
已知一个数组, 静态初始化了, 查询数组中某个元素的索引值:
int[] arr = {}69,57,13,24,87}
查询13这个元素第一次出此案的索引值
//分析
(1)定义一个方法
方法的返回值 int
方法的参数结合参数个数 int[ ] ,2个参数
(2)
遍历数组,获取所有元素
判断: 如果要查询的元素和数组的元素一致, 就找到了返回角标值//
public class ArrayDemo3 {
public static void main(String[] args) {
int[] arr = {69,57,13,24,87} ;
//调用方法
int index = getIndex(arr, 13); //找13
System.out.println("index:"+index);
System.out.println("----------------------------") ;
int index2 = getIndex(arr, 133); //找13
System.out.println("index2:"+index2);
}
public static int getIndex(int[] array,int target){
for(int x = 0 ; x < array.length; x++){
if(target == array[x]){
return x ;
}
}
return -1 ; //查询数组:找不到元素,返回负数 -1
}
}
冒泡排序---- bubbleSort(arr) ;
两两比较, 将较大的值往后排
规律:
两两比较---将较大值往后放
第一次,有0个不比较
第二次,有1个不比较
.....
比较次数: 数组长度-1----> int x<arr.length-1
bubbleSort(arr) ;
System.out.println("--------------");
public static void bubbleSort(int[] arr){
for(int x=0; x < arr.length-1 ; x++){
for(int y =0; y < arr.length-1-x ; y++){
if(arr[y]>arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ; //引入中间变量temp
}
}
}
}
2022/8/5
面向对象
2022/8/5
面向对象
创建一个对象的内存图解
/面试题/
- 形式参数分别为基本类型和引用类型(数组的情况)的不同情况？
基本类型----作为形式参数传递; 形式参数的改变不会影响实际参数
引用类型----作为形式参数传递; 形式参数的改变直接影响实际参数, 除了String类
引用类型String特殊类型: 是一个常量; String 作为形式参数(引用类型), 和基本类型作为形式参数是一样,形式参数的改变不会影响实际参数
(基本类型和引用类型做为形参传递的特点图)
/面试题/
- 局部变量和成员变量的区别?
①局部变量, 在方法定义和方法说明中存在的变量; 其生命周期会随着方法的调用结束
②成员变量, 说明对象的特征特点, 自身特质的变量, 属于程序的默认设置
封装
就是将现实世界事物的属性隐藏了(加入一个关键字private)-----测试类中不能直接使用;
私有的, 无法直接访问的
对外数据的安全性,对外提供了一个方法, 访问权限最小的.
访问方法: setXXX( ) / getXXX( )
XXX-----属性名称, 符合标识符规范
- 注意事项:
以后在书写的代码的时候,写一个类,描述真实存在事物的属性的时候, 需要属性(英文单词字母全部小写)全部加入private
/面试题/
private关键字的特点?
①被private修饰的成员变量及成员方法只能在本类中访问;
class Student{--private--}
class Demo(--无法访问private变量--)
②可以修饰成员变量,也可以修饰成员方法, 就是为了外界不能直接访问
③ 被private修饰的成员变量/成员方法可以间接的通过public方法访问