第二周总结
1.循环结构
循环结构语句分类:
for循环
while循环
do-while循环
for循环:
for循环的格式:
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
执行流程:
1)初始化语句给变量进行赋值,只执行一次
2)判断这个条件表达式是否成立,
如果成立,就执行循环体语句,在去执行步长语句 (++,--)
3)再次判断条件表达式是否成立,如果成立,继续上面执行方式...
...
...
4)一直循环到条件表达式不成立的时候,for循环结束!
for循环应用:
1)求1-100之间的和
2)1-100之间的偶数和
3)求5的阶乘!
4)求水仙花数
while循环:
while循环语句格式:
基本格式
while(初始化语句以及条件表达式){
循环体语句;
步长语句(控制体语句) ;
}
扩展格式:(推荐)
初始化语句;
while(条件表达式){
循环体语句;
步长语句(控制体语句) ;
}
执行流程:
1)首先初始化语句进行赋值
2)判断条件表达式是否成立,如果成立,执行循环体语句
再次执行步长语句;
3)继续判断条件表达式是否成立,如果成立,执行循环体语句
再次执行步长语句;
...
...
4)当条件表达式为false,不成立,while循环语句结束
while循环和for循环的区别:
while循环和for循环的区别:
1)从格式上不太一样
for(初始化语句;条件表达式;步长语句){
循环体;
}
初始化语句;
while(条件表达式){
循环体语句;
步长语句;
}
2)从内存角度:(是否节省内存空间)
变量: 编译时期变量 运行时期变量
int i = 10 ; Integer(引用类型) i = 100 ;
for循环:for循环语句结束,变量从内存中释放掉了,节省内存空间(优先)
while循环:while循环语句结束,依然可以访问变量,耗费内存空间
变量/对象 最终程序结束,都需要垃圾回收器GC
(jvm:假想计算机--->开启:垃圾回收线程)
3)应用场景:是否明确次数
针对for循环:(使用居多) 明确循环次数
举例: == :基本类型: int a = 10 ; int b = 20 ;
模拟用户登录, 给三次机会! (String类:equals())
针对while循环:(使用:仅此for) :不明确循环次数
举例:
猜数字游戏: (不知道猜多少次,能猜中!)
键盘录入一个数据
死循环:
两个死循环
格式1:
for(;;){
循环体语句;
}
格式2 :(推荐)
while(true){
循环体语句;
}
获取随机数:
获取随机数的方法
使用:
public static double random() :取值范围[0.0,1.0)
static:静态的 (面向对象讲)
需求:使用Math类中的方法 random()获取一个1-100之间的随机数
然后在键盘录入一个int类型的数据,猜产生的随机数!
//获取一个随机数:使用jdk提供的一个类Math
//double number = Math.random() ;
//获取1-100之间的随机数 (整数:默认int类型)
//int number = (int)(Math.random()*100 + 1);
do-while循环:
do-while循环语句的格式: (开发中:使用不多,在java原码中)
格式:
初始化语句;
do{
循环体语句;
步长语句(控制体语句) ;
}while(条件表达式) ;
执行流程:
1)初始化语句赋值
2)直接执行循环体语句---->步长语句--->条件表达式
....
....
特点:循环体至少执行一次 (它和while,for的区别)
for循环嵌套:
for循环的嵌套:
for(初始化语句;条件表达式;步长语句){
//循环体语句
for(初始化语句;条件表达式;步长语句){
}
}
跳转控制语句:
跳转控制语句:
break :中断,结束
continue: 结束当前循环,立即进入下一次循环
return :结束方法方法去使用的!(结合方法)
break:中断,结束的意思
不能单独使用,没有意义!
在switch中以及循环中使用!
循环中使用:
1)可以在单层循环中使用
2)早期的使用:用在for循环嵌套中使用(外层循环,内层循环)
标签语句
给外层循环/内层循环中起一个名字
格式:标签名称:for(初始化语句;条件表达式;步长语句){...}
标签名称:for(){}
循环嵌套:应用场景:
后期使用:
增强for循环: 遍历集合
类上于: HashMap<String,ArrayList<>> 集合嵌套集合
2.方法
方法概述:
什么是方法:
将一个独立的代码块{}抽取出来并为当前这个起名字!(作用:提高代码的复用性)
方法的概念:
使用{}将代码包裹起来,并给这个代码起一个名字:方法名
---->以后直接使用方法名调用. {}代码块
如何定义方法?
两种:
有返回值类型的方法的定义
没有返回值类型的方法定义
第一种:有返回值类型的方法的定义
固定格式:
public static 返回值类型 方法名(形式参数类型1 参数名称1,形式参数类型2 参数名称2...) {
业务需求...
return 结果;
}
格式的详细介绍:
权限修饰符:public(公共的,访问权限足够大) static(静态)
返回值类型:数据类型(目前基本数据类型:四类八种: )
举例:求两个数据之后 结果:int类型
方法名:遵循标识符的规则(见名知意)
单个单词:全部小写
多个单独:第一个单词小写,从第二个单词开始,每个单词首字母大写,其余小写
小驼峰命名法!
形式参数类型:数据类型(目前基本数据类型:四类八种: )
参数名称:变量名称
return: 这个方法调用完毕了,带回具体的结果!
有返回值类型的方法调用:
1)单独调用(没有意义)
2)输出调用:不推荐
3)赋值调用:推荐
定义有具体返回值类型的方法的定义的注意事项!
1)方法和方法平级关系,不能嵌套使用!
特殊:方法递归(IO流后面讲):方法调用方法本身的一种现象!
2)定义方法注意两个明确
明确返回值类型
明确参数类型以及参数个数
3)定义方法的时候:
参数类型必须携带的!
public static int add(x,y){} 错误的:
因为Java是一种强类型语言:语法非常严谨的,以及格式是有要求的!
4)定义方法的时候,()后面不要出现; (目前来说没意义的方法!)
5)调用方法的时候,实际参数不需要携带数据类型
没有具体返回值类型的方法 定义以及调用:
方法定义:
public static 返回值类型 方法名(形式参数列表(包含数据类型+变量名)...){
要么 return 结果;
要么没有具体结果;
}
Java的语法:
方法本身的定义:需要返回值类型,但是如果需求本身就没有具体返回结果,如何定义方法呢?
语法要求:如果没有具体返回值结果,使用void 来代替 返回值类型(位置)
注意:Java中不存在void类型(替代词)
没有具体返回值类型的方法的定义格式:
public static void 方法名(形式参数类型1 变量名1,形式参数类型2 变量名2...){
直接输出语句或者其他业务操作;
}
没有具体返回值类型的方法调用
单独调用
赋值调用
输出调用
3.数组
什么数组: 引用数据类型
数组:是可以存储元素的一种容器!
前提:元素的数据类型必须一致的!
如何定义呢?
格式:
数据类型[] 数组名称 ;
数据类型 数组名称[] ;
举例:
int[] arr; (习惯于第一种) 定义了一个int类型数组arr变量
int arr[] ;定义了一个int类型的arr数组
异常: 后期Throwable:异常的总称
程序出问题了!
严重问题:
error : 内存异常了 (通过一些第三方工具避免了!)
举例: 一些软件通过一些特殊的操作:造成软件崩溃了!
数组的初始化:
数组的初始化:
1)动态初始化:指定了数组长度,系统默认给定数组的元素值!
2)静态初始化:指定了具体的元素的内容,系统默认指定数组的长度!
动态初始化:
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;
举例:
int[] arr = new int[3] ; //创建了一个数组对象,分配3个长度
int arr[] = new int[2] ;//.创建了一个数组对象,分配2个长度
数组中元素的的访问方式:
数组名称[角标]来访问
角标(下标/索引):都是从0开始记录元素的!
数组的静态初始化 :指定数组的元素内容,系统给它默认长度
格式:
标准格式:
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3....} ;
举例:
int[] arr = new int[]{11,22,33} ;
简化格式:
数据类型[] 数组名称 ={元素1,元素2,元素3....} ;
数据类型 数组名称[] ={元素1,元素2,元素3....} ;
举例:
定义数组的时候:不能动,静集合(只能其中一种初始化方式!)
int[] arr = new int[3]{1,2,3} ; //错误的!
简化格式举例:
int[] arr = {1,2,3} ;
异常:
异常:
Exception: 能够通过本身代码来解决问题
编译时期异常:只要不是运行时期的异常都属于编译时期(不解决,编译通过不了)
RuntimeExcetion:运行时期异常
在执行过程中,由于代码结构不严谨,导致的问题!
第一个异常:数组角标越界!
java.lang.ArrayIndexOutOfBoundsException:
出现的原因: 访问不存在的角标!就出异常了
解决方案: 改动角标值即可!
第二个异常:空指针异常:
java.lang.NullPointerException:
出现的原因:
某个对象都为null,还需要使用对象访问内容或者调用其他功能!
解决方案:
只需要对某个对象做一个非空判断!(逻辑判断)
数组的应用:
数组的应用:
1)数组的遍历
2)最值问题
最大值/最小值
3)数组的元素逆序
4)数组元素查表法
数组名称[index:角标]访问元素
5)数组的元素基本查找:
查询数组中的元素在数组索引值! (有一定的耗时:从头查到末尾)
查询的数组: 可以无序的,也可以有序
冒泡排序:
冒泡排序思想
两两比较,将较大的值往后放;第一次比较完毕,最大值就出现在最大索引处!
依次这样比较:
规律:
第一次:有0个不比
第二次:有1个不比
...
...
比较的次数:数组长度-1次
public static void bubboleSort(int[] arr){
for(int x = 0 ; x < arr.length-1 ; x ++){ //x = 0 ; 1 2,3 控制比较的次数
for(int y = 0 ; y < arr.length-1-x ; y++){//y表示元素的角标
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
二维数组:
二维数组:
它就是一个包含多个一维数组的数组!
举例:
Java基础班(将一个班级看一个数组)
JavaEE2008 JavaEE2007 JavaEE2006
二维数数组的定义格式:
数据类型[] 数组名称[] ;
数据类型[][] 数组名称 ; (推荐)
二维数组的初始化:
动态初始化: 指定数组长度,系统给数组中元素分配默认值
1)动态初始化格式1:
数据类型[][] 数组名称 = new 数据类型[m][n] ;
m:表示当前二维数组中的一维数组的个数
n:表示每一个一维数组的长度
int[][] arr = new int[3][2] ;
int[] arr[] = new int[3][2] ;
2)二维数组格式2:
数据类型[][] 数组名称 = new 数据类型[m][] ;
数据类型[] 数组名称[] = new 数据类型[m][] ;
举例
int[] arr[] = new int[2][] ;
//上面:当前二维arr中有2个一维数组,但是不知道2个一维数组的长度
//所以,需要动态给定一维数组的长度
注意:
int x,y[] ; //x是普通遍历,y是一维数组
int x[][],y[] ;//x是二维数组,y是一个维数组!
3)二维数组格式3
标准格式:
数据类型[][] 数组名称 =new 数据类型[][]{{元素1,元素2,...},{元素1,元素2...},{元素1,元素2...}};
简化格式:
数据类型[][] 数组名称 = {{元素1,元素2,...},{元素1,元素2...},{元素1,元素2...}}
//错误的书写格式:
int[][] arr = new int[3][2]{{1,2,3},{4,5,6}} ;
//要么动态初始化/要么静态初始化
二维数组应用:
二维数组应用:
杨辉三角形
4.面对对象
面向对象概述:
Java语言:就是一种面向对象编程语言
面向对象本质其实就是一个面向过程的!(基于面向过程)
面向过程:代表语言:C语言
1)需求分析 :遍历数组
2)将分析结果使用功能改进
3)需要书写功能的业务操作(将元素一一获取出来,直接输出/按照特定格式输出)
4)在main方法中调用---输出数组的元素!
生活中的面向过程:
买电脑----->自己需求(看电脑配置)----->自己去赛格电脑城
----->砍价---->被坑了买了电脑
炒菜----->菜市场---->买菜----->砍价---->摘菜---->洗菜---->切菜---->
炒菜出锅
洗衣服----->脏衣服---->盆子装水,洗衣液---->泡一泡----->搓一搓---->透一透
----->拧一拧----->晾一晾
生活中的面向对象:
买电脑---->找一个懂行的朋友(告诉我需要的配置)------>买到了电脑
炒菜------>找一个对象------->等待出锅
洗衣服---->脱下脏衣服----->全自动洗衣机(一键)----->晾一晾
面向对象思想特点:
1)符合现实世界事物生活中的思想行为习惯!
2)让我们执行者变成了指挥者(角色发生了改变!)
3)让复杂的事情简单化!
Java中面向对象的设计原则:
需要不断的创建对象,使用对象,指挥对象做事情(举例:Scanner类:键盘录入)
5.类与对象
事物:
描述现实世界真是存在的!
举例:人----事物
长方形---事物
人(事物)-------和使用Java代码体现出来呢?
属性:年龄,身高,性别,体重,姓名...
行为:不断的学习.../基本的人具备的...
Java中最基本的单元:class 类 :来描述现实世界事物的一组属性和行为的集合!
如何使用java代码定义一个类---->描述事物
class Person{//人类---->描述人的属性以及行为
//位置:成员位置
//成员变量
String name ; ----->(人)事物的属性:姓名
int age ; ------->(人)事物的属性:年龄
String sex ; ------>(人)事物的属性:性别
String address ; ----->(人)事物的属性:地址
//人的学习的行为
public void study(){
//int a = 10 ;//局部变量(方法定义中:局部位置)
System.out.println("人都需要学习...") ;
}
}
Java代码中:成员变量(类中,方法外!)------------->现实事物的属性!
成员方法: 去掉static关键字
人的行为:学习()-------->study() :直接输出(没有具体返回值)
public void study(){
System.out.println("人都需要学习...") ;
}
Java面向对象设计原则:不断地创建对象,使用对象,指挥对象做事情
创建对象的格式:
类名 对象名 = new 类名() ;
要给具体的人赋值属性 :
对象名.成员变量= 值; (需要和数据类型保持一致!)
使用人的功能:学习,打游戏,睡觉
对象名.成员方法名() ;
成员变量和局部变量的区别:
成员变量和局部变量的区别:
1)书写位置不同
成员变量:在类中,方法外定义的变量!
局部变量:在方法声明上或者是方法定义中!
public void show(String name){
int num = 200 ;
System.out.println(name+num) ;
}
2)内存中的位置不同
成员变量:在堆内存中
局部变量:在栈内存中
3)生命周期不同:
局部变量:随着方法调用而存在,随着方法调用完毕而消失!
成员变量:随着对象的创建完毕而存在,随着对象被GC回收掉而消失
对象的回收:
并不是立即回收,而是等待垃圾回收器空闲时回收掉!
4)初始化不同:
成员变量:可以不进行初始化,因为它在堆内存中(跟对象有关系),存在系统默认初始化
局部变量:必须在使用之前对象局部变量进行初始化,否则报错"可能尚未初始化变量xx"
形式参数是基本类型以及引用类型(类)的情况:
方法的形式参数是基本类型:
形参的改变对实际参数没有影响(是什么类型,传递对应的数据值即可!)
Java最终研究的就是引用类型!
方法的形式参数是引用类型: 形式参数的改变:会直接影响实际参数!
数组,类,接口
匿名对象:
匿名对象:
概念:没有名字的对象!
之前的格式:
类名 对象名 = new 类名() ;
匿名对象的创建格式:
new 类名() ;
特点:
1)可以作为形式参数传递!
2)匿名对象不要使用多次,使用一次即可!
匿名对象,应用场景:
移动端:android 大量去使用匿名对象 或者匿名内部类
匿名对象创建完毕,使用完毕就立即被回收(节省内存空间)
6.封装
封装的概念:
封装的概念:
Java提供这样一种技术:
将一个类的成员变量私有化,外界不能够直接方案,可以通过
一些公共的方法(set/get...)间接的访问!
private关键字:
private:私有的,外界不能访问的!只能在本类中访问
(但是可以间接通过公共的成员方法来访问私有成员变量/成员方法)
它可以修饰成员变量,也可以修饰成员方法
关键字:this
this:代表当前类对象的地址值引用!
为了区分:局部变量隐藏成员变量: this.成员变量;
构造方法:
一个类的成员组成:
1)成员变量
2)成员方法
3)构造方法
什么是构造方法:
特点:
1)方法名和类名相同
2)没有具体的返回值类型
3)连void都没有
权限修饰符 方法名和类名相同(){ //无参构造方法
}
构造方法的作用:给对象的成员进行数据初始化的!
构造方法:
构造方法是可以重载的:
无参构造方法
有参构造方法
注意事项:
在写一个类的时候,没有提供无参构造方法,系统默认提供无参构造方法!
如果开发者提供有参构造方法,系统不会提供无参构造方法了,所以永远给出无参构造方法!
static关键字:
static关键字的特点:
1)被static修饰的成员,随着类的加载而加载 (类就加载一次!)
javac xxx.java---->xxx.class (字节码文件)
java xxx ---->运行---->加载类的时候,对象还没开始创建
2)优先于对象存在
对象的创建是在类加载的后面
3)有被共享,共用的意思
这句话:告诉我们什么时候使用static修饰变量,方法
能够描述被共用,共享的时候
举例:
班级号可以被共用
饮水机:可以被共用
水杯中的水(不能共用)
4)最重要的特点:
被static修饰的变量以及方法可以被类名直接访问!(推荐类名直接访问)
这些被static修饰变量/方法,也可以通过对象名来访问(不推荐!)
关于static关键字的注意事项:
1)static关键字中 没有this的关键字的
2)关于访问的问题:
非静态的成员方法,既可以访问静态的变量,也可以非静态的变量
也可以访问静态的方法以及非静态的成员方法
静态的方法只能静态的变量/方法
给定义数组,静态初始化,完成它的遍历功能
如果遍历的功能,去掉了static,只能通过创建当前类对象,访问这个方法!
带有main方法类----->测试类--->创建别的类的对象,访问当前本身类的方法!
//自定义一个针对数组的工具类
//一般情况:工具类的无参构造方法私有的
class ArrayTool{
//私有的无参构造方法
private ArrayTool(){ //私有的目的:为了外界不能直接创建该类对象!
}
文档说明书的制作:
文档说明书的制作:
1)定义工具类 ArrayTool
2)无参构造方法私有化,外界不能创建该类对象,里面所有的功能全都是static的
3)在工具类中,对所有的功能加入文档注释
4)针对ArrayTool.java文件产生一个文档说明
打开dos--->进入到ArrayTool.java所在目录中
javadoc -d 目录名 -author -version ArrayTool.java
这是一个针对数组操作的工具类
@author apple
@version V1.0
代码块:
Java中代码块:
使用{}包起来的内容,就称为代码块!
分类:
1)局部代码块
在局部位置中定义的{},作用:限定变量的声明周期
2)构造代码块
在类的成员位置中定义{},
特点:在当前类中,有限执行构造代码块,然后在执行构造方法...
(每次执行构造方法之前先执行构造代码块)
构造代码块的作用:对当前类的数据进行初始化!(很少用,笔试题!)
3)静态代码块
在{}的前面加上static
static{
....
}
静态代码块随着的类的加载而加载,由于类加载一次,静态代码块执行一次!
优先级:
静态代码块 > 构造代码块 >构造方法
3397
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
