1、基本结构
1.1顺序结构
顺序结构是在程序中按顺序从上到下依次执行的过程。
class test { |
java程序的键盘录入也是顺序结构的体现:
/* class test { |
1.2选择结构
根据不同的成立的条件,选择执行不同的代码程序。选择主要分if语句和switch语句。
(1)if的3种结构
第1种是最简单的 if(条件){语句体},只有满足条件的执行。主要是讲以下2种if结构。
if(比较表达式) { //比较表达式成立就执行语句体1,否则执行语句体2 |
/* 由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。 所以,我们就认为他们可以完成一样的操作。 但是,他们就一点区别没有吗?肯定不是。 区别: 三元运算符实现的,都可以采用if语句实现。反之不成立。 什么时候if语句实现不能用三元改进呢? 当if语句控制的操作是一个输出语句的时候就不能。 为什么呢?因为三元运算符是一个运算符,运算符操作完毕就应该有一个结果,而不是一个输出。 */ class IfDemo4 { public static void main(String[] args) { //获取两个数据的最大值 int a = 10; int b = 20; //用if语句实现 int max1; if(a > b) { max1 = a; }else { max1 = b; } System.out.println("max1:"+max1); //用三元改进 int max2 = (a > b)? a: b; System.out.println("max2:"+max2); System.out.println("----------"); //判断一个数据是奇数还是偶数,并输出是奇数还是偶数 int x = 100; if(x%2 == 0) { System.out.println("100是一个偶数"); }else { System.out.println("100是一个奇数"); } //用三元改进 //这种改进是错误的。 //String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");; } } |
if(比较表达式1) { 语句体1; }else if(比较表达式2) { 语句体2; }else if(比较表达式3) { 语句体3; } ... else { //这一块可有可无 语句体n+1; } |
import java.util.Scanner; class IfDemo5 { |
而且if语句可以嵌套使用的,如下
/* 获取三个数据中的最大值 由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。 */ class IfTest4 { public static void main(String[] args) { int a = 10; int b = 30; int c = 20; //三元实现 //int temp = (a>b)? a: b; //int max = (temp>c)? temp: c; //System.out.println("max:"+max); //System.out.println("--------"); //用if语句实现 int max; if(a > b) { if(a > c) { max = a; }else { max = c; } }else { if(b > c) { max = b; }else { max = c; } } System.out.println("max:"+max); } } |
(2)switch语句
switch语句格式: switch语句的注意事项: |
//switch案例1 class SwitchDemo2 { |
switch的面试题,看程序写结果 |
class SwitchTest { public static void main(String[] args) { int x = 2; int y = 3; switch(x){ default: y++; break; case 3: y++; case 4: y++; } System.out.println("y="+y); System.out.println("---------------"); int a = 2; int b = 3; switch(a){ default: b++; case 3: b++; case 4: b++; } System.out.println("b="+b); } } |
(3)if和switch的区别?
if | switch |
基本if选择结构: 处理单一或组合条件的情况 if-else选择结构:处理简单的条件分支情况 多重if选择结构:处理复杂的条件分支情况 嵌套if选择结构:用于较为复杂的流程控制 | 多重分支并且条件判断是等值判断的情况 |
1.3循环结构
循环结构包括for循环,while循环,do...while循环三大循环体。
(1)for循环结构
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
/* 案例:求5的阶乘。 什么是阶乘呢? n! = n*(n-1)! 规则 n! = n*(n-1)*(n-2)*...*3*2*1 求和思想。 求阶乘思想。 */ class ForDemo5 { public static void main(String[] args) { //定义最终结果变量 int jc = 1; for(int x=2; x<=5; x++) { jc *=x; } System.out.println("1-5的阶乘是:"+jc); //当for只执行一条循环语句时,可不用大括号,把那一条循环语句紧跟for()语句后即可 for(int x=0;x<=5;x++) System.out.println("Saturday"); } } |
(2)while循环结构
while循环的基本格式: while(判断条件语句) { 循环体语句; } 扩展格式: 初始化语句; while(判断条件语句) { 循环体语句; 控制条件语句; } |
/* 需求:统计水仙花数有多少个 */ class WhileDemo3 { public static void main(String[] args) { //for循环版本 int count = 0; for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) { count++; } } System.out.println("count:"+count); System.out.println("------------"); //while循环版本 int count2 = 0; int y = 100; while(y<1000) { int ge = y%10; int shi = y/10%10; int bai = y/10/10%10; if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) { count2++; } y++; } System.out.println("count2:"+count2); } } |
(3)do..while循环结构
do...while循环的基本格式:
循环语句的区别: |
class DoWhileDemo { public static void main(String[] args) { //输出10次HelloWorld。 int x = 0; do { System.out.println("HelloWorld"); x++; }while(x<10); System.out.println("--------------"); //求和1-100 int sum = 0; int a = 1; do { sum += a; a++; }while(a<=100); System.out.println(sum); } } |
(注意:循环间是可以嵌套的,但一般最多3层循环嵌套,再多的话会影响性能了)
1.4控制跳转语句
跳转语句一般指break、continue和return
break | continue | retrun |
1、跳出单层循环 2、跳出多层循环 如下: wc:for(int x=0; x<3; x++) { | 1、跳出一次循环,进入下一次的执行 | 1、其实它的作用不是结束循环的,而是结束方法的。 |
//break和continue例子1
public static void main(String[] args) {
for(int i =1;i<4;i++) {
for(int j =1;j<4;j++) {
if(i*j>2) {
continue; //break; 对比下此处break和continue的区别
}
System.out.println("li="+(i*j));
}
System.out.println("wai="+i);
}
}
//break和continue例子2
public static void main(String[] args) {
for(int i =1;i<4;i++) {
for(int j =1;j<5;j++) {
if(j%2==0) {
continue; //break; //对比下continue和break的区别
}
System.out.println("li="+(i*j));
}
System.out.println("wai="+i);
}
}
2、方法
方法:完成特定功能的代码块。
方法格式: //public static int sum(int a,int b){..} 必须要return 返回值 //public static void sum(int a,int b){..} 可System.out.print(内容);输出 方法名:符合命名规则即可。方便我们的调用。 // int result = sum(x,y); //System.out.println(result); 方法的注意事项: |
方法调用案例1 |
/* class FunctionTest4 { |
2.1方法重载
/* 需求:我要求数的和 我们的需求不断的发生改变,我们就对应的提供了多个求和的方法。 但是呢,他们的名字是不一样的。 而我们又要求方法命名做到:见名知意。 但是,很明显,现在没有做到。 那么,肿么办呢? 针对这种情况:方法的功能相同,参数列表不同的情况,为了见名知意,Java允许它们起一样的名字。 其实,这种情况有一个专业名词:方法重载。 方法重载: 在同一个类中,方法名相同,参数列表不同。与返回值类型无关。 (同方法名,但参数列表和返回值类型不同) 参数列表不同: A:参数个数不同 B:参数类型不同 */ |
class FunctionDemo4 { public static void main(String[] args) { //jvm会根据不同的参数去调用不同的功能 System.out.println(sum(10,20)); System.out.println(sum(10,20,30)); System.out.println(sum(10,20,30,40)); System.out.println(sum(10.5f,20f)); } //需求1:求两个数的和 public static int sum(int a,int b) { System.out.println("int"); return a + b; } //需求2:求三数的和 /* public static int sum1(int a,int b,int c) { return a + b + c; } */ public static int sum(int a,int b,int c) { return a + b + c; } //需求3:求四个数的和 /* public static int sum2(int a,int b,int c,int d) { return a + b + c + d; } */ public static int sum(int a,int b,int c,int d) { return a + b + c + d; } public static float sum(float a,float b) { System.out.println("float"); return a + b; } } |
3、数组
数组:存储同一种数据类型的多个元素按顺序排列的容器。
3.1一维数组
3.11一维数组的初始化
动态初始化: 数组声明且为数组元素分配空间与赋值的操作分开进行 | 静态初始化: 在定义数组的同时就为数组元素分配空间并赋值 |
(1)int[] score = new int [3]; //推荐 或int score [] ; score = new int[3] (2)score[0]=98; score[1]=99; score[2]=100; | (1)int[] len1 = {2,3,45,56}; //推荐 (2)int[] len2= new int[] {0,1,2,3,5}; |
可通过数组名.length获得数组的下标长度,但是以0开始。如len2.length=5,下标是len2[0]到len2[4],共存储5个数组值。
注意:考虑到float类型的范围和java自动转型的情况,float数组时命名float f[] = {2.4f, 4.4f, 6.4f};或float f[] = {2 ,4 ,6};这两种方式命名才正确,否则float f[] = {2.4,4.4,6.4};命名是错误的,{2.4,4.4,6.4}是自动转型为double数组类型。
3.12一维数组不同类型的默认值及内存图
数组元素类型 | 元素默认初始值 |
byte | 0 |
short | 0 |
int | 0 |
long | 0L |
float | 0.0F |
double | 0.0 |
char | 0 或写为:’\u0000’(表现为空) |
boolean | false |
引用类型 | nul |
数组是引用数据类型,当数组new初始化时,在堆中开辟空间存储的数据是有默认值为0的。就是数组int[] score = new int [3]声明后没有赋值score[0]到score[2]元素值都为0。如下图(数组初始化及其内存图)
一维数组案例:数组逆序 |
class ArrayTest3 { public static void main(String[] args) { //定义一个数组,并进行静态初始化。 int[] arr = {12,98,50,34,76}; //逆序前 System.out.println("逆序前:"); printArray(arr); //逆序后 System.out.println("逆序后:"); //reverse(arr); reverse2(arr); printArray(arr); } public static void reverse(int[] arr) { for(int x=0; x<arr.length/2; x++) { int temp = arr[x]; arr[x] = arr[arr.length-1-x]; arr[arr.length-1-x] = temp; } } public static void reverse2(int[] arr) { for(int start=0,end=arr.length-1; start<=end; start++,end--) { int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } } //遍历数组 public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x == arr.length-1) { //这是最后一个元素 System.out.println(arr[x]+"]"); }else { System.out.print(arr[x]+", "); } } } } |
3.2二维数组
二维数组:数组元素为一维数组的一个数组。
3.21二维数组的初始化
动态初始化: 数组声明且为数组元素分配空间与赋值的操作分开进行 | 静态初始化: 在定义数组的同时就为数组元素分配空间并赋值 |
int[][] arr = new int[3][2]; arr[0][0]=5; arr[0][1]=6; | int[][] arr = {{1,2,3},{4,5},{6}}; |
(注意:二维数组的遍历,外循环控制的是二维数组的长度,其实就是一维数组的个数。
内循环控制的是一维数组的长度。)
二维数组案例:打印杨辉三角形 |
/* 需求:打印杨辉三角形(行数可以键盘录入) 分析:看这种图像的规律 class Array2Test3 { |