-------android培训、java培训、期待与您交流-------
01语句while
循环结构
代表语句:while do while for
while(条件表达式)
{
执行语句;
}
do
{
执行语句;
}while(条件表达式);
02语句do while
while:先判断条件,只有条件满足才执行循环体
do while:先执行循环体,再判断条件,条件满足,再执行循环体
简单一句话:do while特点是条件无论是否满足,循环体至少被执行一次。
语句结束有两种方式:要么后面跟大括号,要么跟分号
03语句for
格式
for(初始化表达式;循环条件表达式;循环后的操作表达式) for(int x=0;x<3;x++)
{
执行语句;
}
注:
a.for里面的两个表达式运行的顺序,初始化表达式只读一次,判断循环条件为真就执行循环体,然后再执行循环后的操作表达式,接着继续判断循环条件,重复这个过程,直到条件不满足为止
b.while与for可以互换,区别在于for为了循环而定义的变量再for循环结束就是再内存中释放,而while循环使用的变量在循环结束后还可以继续使用
c.最简单无限循环格式:while(true),for(;;)无限循环存在的原因是并不知道循环多少次,而是根据某些条件来控制循环
1.初始化表达式只执行一次
2.只有条件不满足循环就结束
04while和for的区别
1.变量有自己的作用域,对于for来讲:如果将用于控制循环的增量定义再for语句中,那么该变量只在for语句内有效,for语句执行完毕,该变量再内存中被释放
2.for和while可以进行互换,如果需要定义循环增量,用for更合适
3.当要对某些语句执行很多次时,就使用循环结构
05循环语句的其他特点
1.强调循环条件表达式必须知道真假,条件既不是真也不是假,编译就是失败的
2.初始化表达式只要是一个执行语句,它就可以作为一个合法表达式存在
3.语法格式:当多表达式出现时,用逗号分隔开
4.初始化表达式可以不写,循环后的操作表达式也可以不写,循环条件表达式不写,默认为true
06for语句练习——累加计数器
1.获取1~10的和,并打印
int sum = 0; //1.定义变量用于存储不断变化的和
int x = 1 ; //2.定义变量,记录住不断变化的被加的数
while(x<=10) //3.定义循环,重复加法的过程
{
sum = sum +x; // 循环注意:一定要明确哪些语句需要参与循环,哪些不需要
x++;
}
System.out.println("sum="+sum);
int sum = 0;
for(int x=0; x<=10; x++) //用for语句写更合适(因为循环中的变量x运行完就不需要在内存中存在了)
{
sum += x;
}
System.out.println("for sum = "+sum);
其实这就是累加思想(一个数不断的变大或者一个数不断地变小以记录住不断变化的结果;字符串的不断延长);
记住代码只能解决一个问题,记住思想,能够解决一类问题
原理:通过变量记录住每次变化的结果(循环操作后的结果) 通过循环的形式,进行累加动作
一说累加,不多说,搞一变量,搞一循环(要有循环,没有循环就不叫累加了)
2.1~100之间7的倍数的个数,并打印
思路:
1,先对1~100进行循环(遍历)通过循环的形式。
2,在遍历的过程中,定义条件,只对7的倍数进行操作
3,因为7的倍数不确定,只要符合条件,就通过一个变量来记录住这个变化的次数
步骤:
1,定义循环语句,选择for语句;
2,在循环中定义判断,只要是7的倍数即可,使用if语句。条件:7的倍数x%7==0;
3,定义变量,该变量随着7的倍数的出现而自增
int count = 0;
for(int x=1; x<=100; x++)
{
if(x%7==0) // 这个数据的状态变化用这个记录器(count)
// System.out.println("x="+x); // 来记录 这个记录器不一定是自增的
count++; // 也可以是自减(手机的使用寿命)
}
System.out.println("count="+count);
计数器思想:
通过一个变量记录住数据的状态变化
也需要通过循环完成
如果再有一样需求说想获取某一个里面符合条件的有多少个时,要立刻想计数器 计数器中的条件根据需求来定
07for嵌套
//语句嵌套形式,其实就是语句中还有语句
//循环嵌套
for(int x=0; x<3; x++)
{
for(int y=0; y<4; y++)
{
System.out.print("*")
}
System.out.println();//只有一个功能就是换行
}
****
****
**** 对于打印长方形:外循环控制行数,内循环控制的是每一行的列数,也就是一行中元素的个数
练习
*****
****
***
**
*
分析:发现图形有很多行,每一个行有很多列
要使用嵌套循环。原理:形象说法:大圈套小圈(毕老师独家)
for(int x=0;x<5;x++)
{
for(int y=x;y<5;y++)
{
System.out.print("*")
}
System.out.println();
08for嵌套练习
*
**
***
****
*****
for(int x=0; x<5; x++)
{
for(int y=0; y<=x; y++) // 若写成y<x 0到0就是null 会空出来一行
{
System.out.print("*");
}
System.out.println();
}
不是规律的规律:尖朝上,可以改变条件,让条件随着外循环变化;
尖朝下,可以改变初始化值,让初始化随着外循环变化
1
12
123
1234
12345
for(int x=1; x<=5; x++)
{
for(int y=1; y<=x; y++) //思考:第一列都是1,每一行的列的变化在自增
{
System.out.print(y);
}
System.out.println();
}
09for嵌套 九九乘法表
九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
尖朝上,改变循环条件 y<x
被乘数每一行的第一列都是1, y=1
乘数随着行数的递增而递增 x=1;x<=3;x++
for(int x=1; x<=3; x++)
{
for(int y=1; y<=x; y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t"); // 这个表达式里边分清楚谁是变化的,谁是不变的
} // \t制表符,
System.out.println();
}
10-语句(break-continue)
其他流程控制语句
break(跳出)(跳出当前循环)
continue(继续)
break语句:应用范围:选择结构和循环结构
continue语句:应用与循环结构
注
a.这两个语句离开应用范围,存在是没有意义的
b.这两个语句单独存在 下面都不可以有语句,因为执行不到
c.continue语句是结束本次循环继续下次循环
d.标号的出现,可以让这两个语句作用于指定的范围 只能用于循环上,给循环起名字的一种方式
//break
w:for(int x=0; x<3; x++)
{
q:for(int y=0; y<4; y++)
{
System.out.println("x="+x);
break q; //不写标号,默认跳出内循环
}
}
//continue:只能作用于虚幻结构,继续循环 特点:结束本次循环继续下次循环
w:for(int x=0; x<3; x++)
{
q:for(int y=0; y<4; y++)
{
System.out.println("x="+x);
continue w;
} // 记住: 1.break和continue语句作用的范围
// 2.break和continue单独存在时,下面不可以有任何语句,因为都执行不到
}
11-语句(练习)
----*
---* *
--* * *
-* * * *
* * * * *
for(int x=0; x<5; x++)
{
for(int y=x+1; y<5; y++) // y=x+1 消除前面的空格,缩短距离
{
System.out.print("-")
}
for(int z=0;z<=x;z++)
{
System.out.print("* ")
}
System.out.println();
}
* * * * *
-* * * *
--* * *
---* *
----*
for(int x=0; x<5; x++)
{
for(int y=0; y<x; y++)
{
System.out.print(" ");
}
for(int z=x; z<5;z++)
{
System.out.print("* ");
}
System.out.println();
}
12-函数概述
函数的定义
函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法;
格式
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,....)
{
执行语句;
return 返回值;
}
返回值类型:函数运行后的结果的数据类型
参数类型:是形式参数的数据类型 (就是定义一个变量,用来接收你给的那个要运算的值)
形式参数:是一个变量,用于存储调用函数时传递给函数的实际参数
实际参数:传递给形式参数的具体数值
return:用于结束函数
返回值:该值会返回给调用者
发现以上的运算,因为获取不同数据的运算结果,代码出现了重复
为了提高代码的复用性,对代码进行抽取
将这个部分定义成一个独立的功能,方便日后使用
java中对功能的定义是通过函数的形式来体现的
//需要定义功能,完成一个整数的*3+5的运算
1.先明确函数定义的格式
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,....)
{
执行语句;
return 返回值;
}
public static int getResult(int num)
{
return num*3+5; //实际上是把一部分代码封装起来,实现了复用性
}
怎么使用
getResult(7); 可以被重复使用
函数的特点
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写
//当函数运算后,没有具体的返回值时,这时返回值类型用一个特殊的关键字来标识,该关键字就是void,void代表的是函数没有具体返回值的情况;当函数的返回值类型是void时,函数中的return语句可以省略不写
注意
函数中只能调用函数,不可以在函数内部定义函数
定义函数时,函数的结果应该返回给调用者,交由调用者处理
13-函数(应用)
函数的应用
我们在编写程序实际上就是在不断的实现功能,而java当中,最小的功能单元就是函数。所以日后再写代码时,你只要在处理或者定义功能,都把它定义到一个独立的函数中去,而不要再把代码乱七八糟都塞在主函数里。这时,主函数的功能就剩一个:调用函数(用主函数调用写好的函数,运行一下来测试函数运行的结果是否正确)。这样方便后期的复用。
必须要掌握的一个思想(贯穿于其他语言)
如何定义一个函数呢?
1.既然函数是一个独立的功能,那么该功能的运算结果是什么先明确
因为这是在明确函数的返回值类型
2.在明确在定义该功能的过程中是否需要未知的内容参与运算(在编写功能内部细节时,这个细节是我完全独立能编写完,还是依靠调用者给我一些数据才能完成细节的编写 )
因为是在明确函数的参数列表(参数的类型和参数的个数)
练习
需求:定义一个功能,完成3+4的运算,并将结果返回给调用者
1.明确功能的结果:是一个整数的和
2.在实现该功能的过程中是否哟未知内容参与运算/没有
其实这两个功能就是在明确函数的定义
1.是在明确函数的返回值类型
2.明确函数的参数列表(参数的类型和参数的个数)
public static int getSum()
{
return 3+4;
}
以上这个函数的功能,结果是固定的,毫无扩展性而言
为了方便用户需求,由用户来指定加数和被加数,这样,功能才有意义
思路:
1.功能结果是一个和,返回值类型是int
2.有未知内容参与运算,有两个,这两个未知内容的类型都是int
public static int getSum(int x,int y)
{
return x+y;
}
需求:判断两个数是否相同
思路:
1.明确功能的结果:结果是:boolean
2.功能是否有未知内容参与运算。有,两个整数
public static boolean compare(int a,int b)
{
if(a==b)
return true;
else // 能否省略:如果a和b不相等,直接读false这句话
return false;
}
上面的if语句可以简写成一下格式:
return (a==b)?true:false; //三元运算符
return a==b; //a==b,==是比较运算符,运算完直接有个真假值出现,往回一返就ok(最简单)
这就是代码基本的简化过程
需求:定义功能,对两个数进行比较,获取较大的数
public static int getMax(int a,int b)
{
if(a>b)
return a;
else
return b;
}
//下面为简化格式
{
return (a>b)?a:b;
}
小问题:定义函数时,你只要完成相对应的功能就可以了,不要做过多的功能!
这个功能定义思想有问题,为什么呢?因为只为完成加法运算,至于是否要对和进行打印操作,那是调用者的事,不要在该功能中完成
public static int getMax(int a,int b)
{
System.out.println(a+b);
return;
}
14函数(练习)
1.定义一个功能,用于打印矩形。
2.定义一个打印99乘法表功能的函数。
定义一个功能,用于打印矩形。
思路:
1.确定结果:没有,因为直接打印,所以返回值类型是void
2.有未知内容吗?有,两个,因为矩形的行和列不确定
public static void draw(int row,int col)
{
for(int x=0; x<row; x++)
{
for(int y=0; y<col; y++)
{
System.out.print("*");
}
System.out.println();
}
}
定义一个打印99乘法表功能的函数。
qublic static void print99()
{
for(int x=1; x<=9; x++)
{
for(int y=1; y<=x;y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
总结:将代码搞一个地方存起来(函数是用于存放代码的),存完后,给这个地方起一个名字,想什么时候用,到这个地方照这个名字就可以了;一找到这个名字,虚拟机自动就找符合这个名称的函数
提高复用性,函数的最基本体现。
15函数(重载)overload
函数的重载
重载的概念:在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可
重载的特点:与返回值类型无关,只看参数列表
重载的好处:方便与阅读,优化了程序设计
//定义一个加法运算,获取两个整数的和
public static int add(int x,int y) // 函数名称(add)的作用:用于标识函数;方便与调用;用与通过这个名称,体现这个函数的功能
{
return x+y; // 定义名称要有意义,这个意义就是为了阅读性而体现的
} // 定义函数名的重点是 实现函数的功能
//定义一个加法运算,获取三个整数的和
public static int add(int x,int y,int z) // 因为功能一致,所以用的功能名称也一致
{
return x+y+z;
}
函数就相当于 这样就又一次提高代码的复用性
public static int add(int x,int y,int z)
{
return add(x,y)+z;
}
函数重载:保证名称一致就可以了
什么时候用重载?
当定义的功能相同,但参与运算的未知内容不同,那么,这时候就定义一个函数名称以表示该功能,方便阅读,而通过参数列表的不同来区分多个同名函数。
public static void print99(int num)
{
for(int x=1; x<=num; x++)
{
for(int y=1; y<=x;y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
功能一致,参数不同 一个有参数一个没有参数
//打印99乘法表
qublic static void print99()
{
for(int x=1; x<=9; x++)
{
for(int y=1; y<=x;y++)
{
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
函数就相当于
qublic static void print99()
{
print99(9);调用上面的函数
}
16函数(重载练习)
void show(int a,char b,double c){}
a
void show(int x,char y,double z){} 没有,因为和原函数一样
b
int show(int a,double c,char b){} 重载,因为参数类型不同,注意:重载和返回值类型没关系
c
void show(int a,double c,char b){} 重载,因为参数类型不同,注意:重载和返回值类型没关系
d
boolean show(int c,char b){} 重载了,因为参数个数不同
e
void show(double c){} 重载了,因为参数个数不同
f
double show(int x,char y,double z){}没有,这个函数不可以和给定函数同时存在与一个类中
(都叫show函数,参数也一致,调用show函数的时候,它到底是没有返回值还是返回double不确定)
重载的特点:与返回值类型无关,只看参数列表
重载的好处:方便与阅读,优化了程序设计
17数组(概述——内存结构)
数组的定义
概念:同一种类型数据的集合。其实数组就是一个容器
数组的好处:可以自动给数组中的元素从0开始编号,方便操作这些元素
格式1:
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例:int[] arr = new int[5]; 5是元素的个数 右边部分定义了一个真实存在的数组,存储5个元素
这个数组为了方便使用,就定义了一个名称arr
任何一个变量它都得有自己的数据类型,因为得确定变量中要存什么东西,前面[]前的int代表数组中存的元素的类型;而变量arr不是int类型;是数组类型(数组是一种单独的数据类型)
格式2
元素类型[] 数组名 = new 元素类型[]{元素,元素,.....};
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
其中 关键字new表示:用来在内存中产生一个容器实体
任何一个应用程序在运行时都需要在内存中开辟一个空间,
内存结构
java程序在运行时,需要在内存中分配空间。为了提高运算效率,又对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据的方式和内存管理方式
栈内存:用于存储局部变量,当数据使用完,所占空间会自动释放
堆内存:
数组和对象,通过new建立的实例都存放在堆内存中
每一个实体都有内存地址值
实体中的变量都有默认初始化值
实体不再被使用,会在不确定的时间内被垃圾回收器回收
方法区
本地方法区
寄存器
在主函数中定义一个int x = 3;其实这个3就在主函数的内存区域当中:主函数运行时会在栈内存中开辟一个空间,这个空间里就会有一个变量叫做x,值是3;这个区域就是主函数区域,
int[] x = new int[3];
x[0] = 59;在数组中赋值
x = null; x不再指向这个数组而是指向空
这句话在内存中是什么样的呢?
在栈内存中定义x,(凡是局部变量(定义在方法中、方法中参数上的变量、for循环当中)都在栈内存中)这个局部变量会在栈内存当中开辟一个空间,凡是new出来的实体都在堆内存中(堆里面放的就是实体 包括数组和对象);右边这部分一new就在堆内存中产生了一个空间,因为要放三个元素,所以分配成三个格子,而每一个格子都有一个编号分别为数组中的[0](0角标位)[1][2]。这个堆怎么和x联系起来呢?
堆内存的特点:
1.
对内存中的每一个实体都有一个存放位置(内存中的地址值),数组在内存中存放时,总有一个起始位置,这个起始位置如果用十六进制(因为表示起来更短一些)来表示0x0078,那么用它来标识数组位置的话,我们只需要将这个地址值赋给x。 ( 这是一个赋值动作:赋的不是数组本身,是数组在内存中的地址) x就有值了,x就指向了这个数组或者叫x引用了这个数组【为什么叫引用数据类型(数组没有真正的存放到x变量中去,而是只存放数组的地址,在引用这个数组而已)】
//打印数组中角标为0的元素的值:格式:System.out.println(x[0]); 数组一被定义,里边的元素都有值
2.堆内存中的实体是用于封装数据的,对内存中的实体化的值都有默认初始化值 默认值根据你数组中元素的类型而定 如果是int型数组 默认为0 double 0.0 fload 0.0f boolean false
3.垃圾回收机制
在堆内存当中没有任何引用所使用它的话,我们视它为垃圾,这个垃圾不会立刻被内存清除掉,而是在不定时间内,启动垃圾回收机制,将这个数组实体在堆内存中清除
引用数据类型不同之处
两个引用指向同一个对象或者叫做同一个数组 两个引用在同时操作同一个数组