- 顺序结构：先执行a，在执行b。
- 选择结构：如果…，则…。
- 循环结构：如果…，则再继续…。
-
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("辅音字母");
}
}
}
-
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 + " "); } } } -
语句块(有时叫做复合语句)，是用花括号扩起的任意数量的简单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("程序运行结果为：");
}
}
注意：
6、方法重载
实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。
return 语句终止方法的运行并指定要返回的数据。
Java中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：
基本类型传递的是该数据值的copy值。
引用类型传递的是该对象引用的copy值，但指向的是同一个对象。
-
定义：
方法重载是指一个类中定义多个方法的方法名相同，但是参数不同。
-
构成方法重载的条件：
（1）形参类型、形参个数、形参顺序不同。
（2）只有返回值不同（返回值类型）不构成方法的重载。
（3）只有形参名称不同，不构成方法重载。
-
定义：递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
-
递归结构
（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类型 |
-
递归缺陷
但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。
- 在不要求高性能的情况下使用递归。
一、选择题
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); } } }
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）