1、控制语句
- 顺序结构:先执行a,在执行b。
- 选择结构:如果…,则…。
- 循环结构:如果…,则再继续…。
2、选择结构
-
if单选择结构
if(布尔表达式){ 语句块 }
Math类的使用
1**.**java.lang包中的Math类提供了一些用于数学计算的方法。
2.Math.random()该方法用于产生一个0到1区间的double类型的随机数,但是不包括1。
int i = (int) (6 * Math.random()); //产生:[0,5]之间的随机整数
- if-else双选择结构
if(布尔表达式){
语句块1
}else{
语句块2
}
-
if-else if-else多选择结构
if(布尔表达式1) { 语句块1; } else if(布尔表达式2) { 语句块2; }…… else if(布尔表达式n){ 语句块n; } else { 语句块n+1; }
/** * 随机生成一个100以内的成绩,当成绩在85及以上的时候输出”等级A”,70以上到84之间输出”等级*B”,60到69之间输出”等级C”,60以下输出”等级D”。 **/ public class Test1{ public static void main(String[] args){ int score=(int)(100*Math.random()); System.out.println("成绩:"+score); if(score>=85){ System.out.println("等级A"); }else if(score>70){ System.out.println("等级B"); }else if(score>=60){ System.out.println("等级C"); }else{ System.out.println("等级D"); } } }
-
switch结构
switch (表达式) {
case 值1:
语句序列1;
[break];
case 值2:
语句序列2;
[break];
… … … … …
[default:
默认语句;]
}
package com.test;
//判断元音字母还是辅音字母
public class Test2 {
public static void main(String[] args) {
int num=(int)(26*Math.random());
char word=(char)('a'+num);
System.out.print("随机字母:"+word+"\t");
switch (word) {
case 'a':
case 'o':
case 'u':
case 'i':
case 'e':
System.out.print("元音字母");
break;
case 'y':
case 'w':
System.out.print("半元音字母");
break;
default:
System.out.print("辅音字母");
}
}
}
3、循环结构
-
while循环(当型)
while (布尔表达式) { 循环体; }
**【示例】**while循环结构:求1到100之间的累加和
package com.test;
public class Test3 {
public static void main(String[] args) {
int sum=0;//记录和的值
int count=0;//记录循环次数
while(count<=100) {
sum+=count;//等价于sum=sum+count;
count++;
}
System.out.println("从1到"+count+"的和为:"+sum);
}
}
-
do-while(直到型)
do { 循环体; } while(布尔表达式) ;
**重点:**do-while循环至少会执行一次,先执行后判断。
-
for循环(当型)
for (初始表达式; 布尔表达式; 迭代因子) { 循环体; }
-
嵌套循环
public class Test4 { public static void main(String args[]) { for (int i=1; i <=5; i++) { for(int j=1; j<=5; j++){ System.out.print(i+" "); } System.out.println(); } } }
-
break和continue
(1)break用于强行退出循环,不执行循环中剩余的语句。
(2) continue 语句用在循环语句体中,用于终止某次循环过程,即跳过循环体中尚未执行的语句,接着进行下一次是否执行循环的判定。
-
continue用在while,do-while中,continue 语句立刻跳到循环首部,越过了当前循环的其余部分。
-
continue用在for循环中,跳到for循环的迭代因子部分。
**注意:**带标签break和continue:控制嵌套循环跳转(打印101-150之间所有的质数)
public class Test5 { public static void main(String args[]) { outer: for (int i = 101; i < 150; i++) { for (int j = 2; j < i / 2; j++) { if (i % j == 0){ continue outer; } } System.out.print(i + " "); } } }
-
4、语句块
语句块(有时叫做复合语句),是用花括号扩起的任意数量的简单Java语句。块确定了局部变量的作用域。块中的程序代码,作为一个整体,是要被一起执行的。块可以被嵌套在另一个块中,但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量,而外部不能使用语句块中定义的变量,因为语句块中定义的变量作用域只限于语句块。
5、方法
方法就是一段用来完成特定功能的代码片段,类似于其它语言的函数。方法是类和对象行为特征的抽象。
方法声明格式:
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句;… … …
}
方法调用方式:
对象名.方法名(实参列表)
方法的详细说明
形式参数:在方法声明时用于接收外界传入的数据。
实参:调用方法时实际传给方法的数据。
返回值:方法在执行完毕后返还给调用它的环境的数据。
返回值类型:事先约定的返回值的数据类型,如无返回值,必须显示指定为为void。
示例:
public class Test6{
//main方法:程序的入口
public static void main(String[] args){
int num1=10;
int num2=20;
//加载add方法所对应的类
Test6 ts=new Test6();
//调用add方法
int sum=ts.add(num1,num2);
//调用print方法
print();
//打印输出add方法的结果
System.out.println("sum="+sum);
}
//两个数求和的方法,没有用static修饰,需要用类调用
public int add(int num1,int num2){
int sum=num1+num2;
return sum;
}
//打印的方法,用static修饰,直接在main方法里面调用
public static void print(){
System.out.print("程序运行结果为:");
}
}
注意:
实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
return 语句终止方法的运行并指定要返回的数据。
Java中进行方法调用中传递参数时,遵循值传递的原则(传递的都是数据的副本):
基本类型传递的是该数据值的copy值。
引用类型传递的是该对象引用的copy值,但指向的是同一个对象。
6、方法重载
-
定义:
方法重载是指一个类中定义多个方法的方法名相同,但是参数不同。
-
构成方法重载的条件:
(1)形参类型、形参个数、形参顺序不同。
(2)只有返回值不同(返回值类型)不构成方法的重载。
(3)只有形参名称不同,不构成方法重载。
7、递归结构
-
定义:递归是一种常见的解决问题的方法,即把问题逐渐简单化。递归的基本思想就是“自己调用自己”,一个使用递归技术的方法将会直接或者间接的调用自己。
-
递归结构
(1)定义递归头。
(2)递归体。
-
示例:计算n!
public class Test7 {
public static void main(String[] args) {
long d1 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果:%s%n", 10, factorial(10));
long d2 = System.currentTimeMillis();
System.out.printf("递归费时:%s%n", d2-d1); //耗时:32ms
}
/** 求阶乘的方法*/
static long factorial(int n){
if(n==1){//递归头
return 1;
}else{//递归体
return n*factorial(n-1);//n! = n * (n-1)!
}
}
}
System.out.printf();常用控制符:
格式控制字符 | 结果 |
---|---|
%d | 整数 |
%8d | 整数,左对齐,输出宽度为8 |
-6% | 整数,左对齐,输出宽度为6 |
%f | 浮点数 |
%8f | 浮点数,右对齐,输出宽度为8 |
%.2f | 浮点数,精确到百分位 |
%16.3f | 浮点数,精确到千分位,输出宽度为16 |
%s | 输出为String类型 |
-
递归缺陷
但是递归调用会占用大量的系统堆栈,内存耗用多,在递归调用层次多时速度要比循环慢的多,所以在使用递归时要慎重。
- 在不要求高性能的情况下使用递归。
8、练习题
一、选择题
1.分析如下Java代码,编译运行的输出结果是( A)。(选择一项)
public static void main(String[ ] args) {
boolean a=true;
boolean b=false;
if (!(a&&b)) {
System.out.print("!(a&&b)");
}else if (!(a||b)) {
System.out.println("!(a||b)");
}else {
System.out.println("ab");
}
}
A!(a&&b)
B.!(a||b)
C.ab
D.!(a||b)ab
2.下列选项中关于变量x的定义,(CD )可使以下switch语句编译通过。(选择二项)
**注意:**case里面只能是long、int、string
switch(x) {
case 100 :
System.out.println("One hundred");
break;
case 200 :
System.out.println("Two hundred");
break;
case 300 :
System.out.println( "Three hundred");
break;
default :
System.out.println( "default");
}
Adouble x = 100;
B.char x = 100;
C.String x = “100”;
D.int x = 100;
3.给定如下Java代码,编译运行的结果是( A)。(选择一项)
public class Test {
public static void main(String[] args) {
int sum=0;
for(int i=1;i<10;i++){
do{
i++;
if(i%2!=0)
sum+=i;
}while(i<6);
}
System.out.println(sum);
}
}
A8
B.15
C.24
D.什么也不输出
4.以下选项中添加到代码中横线处会出现错误的是(BD )。(选择二项)
public class Test {
public float aMethod(float a, float b) {
return 0;
}
}
A.
public float aMethod(float a, float b, float c) {
return 0;
}
B.
public float aMethod(float c, float d) {
return 0;
}
C.
public int aMethod(int a, int b) {
return 0;
}
D.
private int aMethod(float a, float b) {
return 0;
}
5.以下关于方法调用的代码的执行结果是(B )。(选择一项)
public class Test {
public static void main(String args[]) {
int i = 99;
mb_operate(i);
System.out.print(i + 100);
}
static void mb_operate(int i) {
i += 100;
}
}
A.99
B.199
C.299
D.99100
二、简答题
-
if多分支语句和switch语句的异同之处。
相同点:都是⽤来处理多分⽀条件的结构。
不同点:switch语句只能处理等值条件判断的情况,⽽且条件只能是整型变量或字符型变量或字符串类型变量。 -
break和continue语句的作用。
相同点:都是⽤来处理多分⽀条件的结构。
不同点:switch语句只能处理等值条件判断的情况,⽽且条件只能是整型变量或字符型变量或字符串类型变量。 -
在多重循环中,如何在内层循环中使用break跳出外层循环。
相同点:都是⽤来处理多分⽀条件的结构。
不同点:switch语句只能处理等值条件判断的情况,⽽且条件只能是整型变量或字符型变量或字符串类型变量。 -
方法重载的定义、作用和判断依据。
相同点:都是⽤来处理多分⽀条件的结构。
不同点:switch语句只能处理等值条件判断的情况,⽽且条件只能是整型变量或字符型变量或字符串类型变量。 -
递归的定义和优缺点。
递归的基本思想就是“⾃⼰调⽤⾃⼰”,⼀个使⽤递归技术的⽅法将会直接或者间接的调⽤⾃⼰。
简单的程序是递归的优点之⼀。但是递归调⽤会占⽤⼤量的系统堆栈,内存耗⽤多,在递归调⽤层次多时速度要⽐循环慢的多,所以在使⽤
递归时要慎重。
三、编码题
-
从键盘输入某个十进制整数数,转换成对应的二进制整数并输出。
public class Test1{ public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.print("请输入一个十进制正整数:"); int num= sc.nextInt(); int num1=num; long outPut=0; int len=1; while(num>0) { outPut=outPut+(num%2)*len; num=num/2; len=len*10; } System.out.printf("十进制数%d对应的二进制数为:%s",num1, outPut); } }
-
编程求:∑1+∑2+……+∑100。
public class Test { public static void main(String[] args) { int sum=0; for(int i=1;i<=100;i++) { sum+=sum(i); } System.out.print("运行结果为:"+sum); } public static int sum(int num) { int sum=0; for(int i=1;i<=num;i++) { sum+=i; } return sum; } }
-
编写递归算法程序:一列数的规则如下: 1、1、2、3、5、8、13、21、34… 求数列的第40位数是多少。
public class Test { public static void main(String[] args) { System.out.println("斐波那契数列第40位是:"+fb(40)); } public static int fb(int n) { int sum=0; if(n<=2) { return 1; }else { return fb(n-2)+fb(n-1); } } }