Java基础知识2
程序流程控制-顺序结构
顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转
程序流程控制-分支结构
根据条件，选择性地执行某段代码（if.....else 和 switch 两种语句）
分支结构1：if语句
if语句三种格式：
1、if(true) { 执行代码块； }
2、if(条件表达式){执行代码块；}
else{执行代码块；}
3、if(条件表达式){ 执行代码块；}
else if（条件表达式）{执行代码块；}....
else{执行代码块；}
if语句练习：
public static void main(String[] args){
/**
* 判断小明的期末成绩
int score = 90;
if(score == 100)
{
System.out.println("奖励一辆BWM");
}
else if (score > 80 && score <=90) {
System.out.println("一台iPhone5s");
}
else if (score >= 60 && score <= 80 ) {
System.out.println("一本参考书");
}
else {
System.out.println("Nothing");
}
*/
/*对下列代码，若有输出，指出输入结果*/
int a = 4;
int y = 1;
if( a > 2){
if(y > 2){
System.out.println(a + y);
System.out.println("atguigu");
}
}
else {
System.out.println("x is " + a);
}
}
分子结构2：switch语句
switch(变量){
case 常量1：
语句1；
break；
case 常量2：
语句2；
break；
......
case 常量N：
语句N；
break；
default：
语句2；
break；
}
switch语句练习
public static void main(String[] args ){
//例子
int i = 123;
switch (i) {
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.err.println("two");
break;
default:
System.out.println("default");
break;
}
/*输入季节，输出季节特色 */
String season = "abc";
switch(season){
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误！，请重新输入：");
break;
}
}
注意：
-
switch（表达式）中的表达式的返回值必须是以下几种类型之一：byte、short、char、int、枚举，String；
-
case 子句中的值必须是常量，且所有case子句中的值应是不同的；
-
default子句是可任选的，当没有匹配的case时，执行default；
-
break语句用来执行完一个case分支后使程序跳出switch语句；如果没有break，程序会顺序执行到switch结尾；
switch语句和if语句的对比
-
如果判断的具体数值不多，且符合byte、short、int、char，虽然两个语句都可以使用，建议使用switch语句，因为效率高；
-
其他情况：对区间判断，对结果为Boolean类型判断，使用if，if的使用范围更广；
程序流程控制-循环结构
循环语句功能：在某些条件满足的情况下，反复执行特定代码的功能；
循环语句的四个组成部分：
-
初始化部分
-
循环条件部分
-
循环体部分
-
迭代部分
循环语句分类：
-
for循环
-
while循环
-
do while 循环
for循环语句
语法格式：for（初始化表达式; 布尔值测试表达式; 更改表达式）{ 语句或语句块}
例子：
for(int i = 1;i < 10;i++){
System.out.println(i);
}
for语句练习
public static void main(String[] agrs){
/**编写程序FooBizBaz.java，从1循环到150并在每行打印一个值，
* 另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,
* 在每个7的倍数行上打印输出“baz”。
for(int i = 1;i < 151;i++){
String str = "";
str += i;
if(i % 3 == 0){
str += "foo";
}
if(i % 5 == 0){
str += "biz";
}
if(i % 7 == 0){
str += "baz";
}
System.out.println(str);
}
*/
/**
//计算1--100的和
int a = 0;
for(int i = 1;i < 101;i++){
a += i;
}
System.out.println(a);
*/
/*打印1~100之间所有奇数的和
int r = 0;
for(int i = 1;i < 101;i++){
if(i % 2 != 0){
r += i;
}
}
System.out.println(r);
*/
/**
* 打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数器的思想）
int y = 0;
int res = 0;
for(int i = 1;i <= 100;i++){
if(i % 7 == 0){
y++;
res += i;
}
}
System.out.println(y);
System.out.println(res);
*/
}
while循环
语法格式：
初始化语句；
while（布尔值测试表达式）{
语句或语句块；
更改语句（i++ 之类）；
}
例子：
public static void main(String args[]){
int result = 0;
int i=1;
while(i<=100) {
result += i;
i++;
}
System.out.println("result=" + result);
}
do while循环语句
语法格式：
初始化语句；
do{
语句或语句块；
更改语句（i++之类）；
}while（布尔值测试表达式）；
例子：
public static void main(String args[]){
int result = 0, i=1;
do{
result += i;
i++;
}while(i<=100);
System.out.println("result=" + result);
}
三种循环语句的差别
public static void main(String args[]){
/**求1到100之间所有偶数的和 用三种循环表示语句
* for循环
int res = 0;
for(int i = 1;i < 101;i++){
if(i % 2 == 0){
res += i;
}
}
System.out.println(res);
//while 语句循环
int i = 0;
int res = 0;
while(i < 101){
if(i % 2 == 0){
res += i;
}
i++;
}
System.out.println(res);
//do-while循环
int res = 0;
int i = 0;
do{
if (i % 2 == 0){
res += i;
}
i++;
}while(i < 101);
System.out.println(res);
*/
}
嵌套循环
-
将一个循环放在另一个循环体内，就形成了嵌套循环。其中：for、while、do..while 均可以作为外层循环和内层循环；
-
实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环体为false时，才会完全跳出循环体，才可结束外层循环的当次循环，开始下一次的循环；
-
设外层循环的次数为m次，内层为n次，则内层循环体实际上需要执行m*n次
例子：
public static void main(String args[]){
//打印9*9乘法表
for(int i =1 ;i <= 9; i++){
for(int j = 1;j <= i;j++){
System.out.print(j + "*" + i + "=" +(i * j)+"\t");
}
System.out.println();
}
/*
//打印1--100之间的质数（质数：大于1的自然数且只能被1和本身整除）
for(int i = 1;i < 101;i++){
int m =0;
for(int j = 1; j <= i;j++){
if(i % j == 0){
m++;
}
}
if(m == 2){
System.out.println(i);
}
}
*/
}
特殊流程控制语句
-
break语句：终止当前所在的循环（结束本层循环）
-
continue语句：终止当前循环，进入下次循环
-
return：结束一个方法（当一个方法执行到一个return语句时，这个方法将被结束）
注意：return直接结束整个方法，不管这个方法return处于多少层循环之内，都将被结束；
例题
public static void main(String args[]){
/**特殊流程控制语句
* break语句：用于终止当前所在的 循环（结束本层循环）；
* continue：用于结束当前这次循环，直接进入下一次循环
* return：结束一个方法，当一个方法执行到一个return 语句时，这个方法结束
* 注意：break--只能用于switch语句和循环语句
* continue--只能用于循环语句
* */
//嵌套循环
System.out.println("完整的循环结果");
for(int i = 1;i < 5;i++){
for(int j = 1;j < 4;j++){
System.out.print(i); //print（）：输入结果不自动换行
System.out.print(j); //println():输入结果自动换行
System.out.println();
}
}
System.out.println();
System.out.println();
//break：终止当前所在的循环
System.out.println("测试break语句：结束当前所在循环");
for(int i = 1;i < 5;i++){
for(int j = 1;j < 4;j++){
if(j == 2){
break;
}
System.out.print(i);
System.out.print(j);
System.out.println();
}
}
System.out.println();
System.out.println();
//continue：结束本次循环，进入下一次循环
System.out.println("测试continue语句：结束本次循环，进入下次循环");
for(int i = 1;i < 5;i++){
for(int j = 1;j < 4;j++){
if(j == 2){
continue;
}
System.out.print(i);
System.out.print(j);
System.out.println();
}
}
System.out.println();
System.out.println();
//return:终止方法
System.out.println("测试return语句：直接终止这个方法");
for(int i = 1;i < 5;i++){
for(int j = 1;j < 4;j++){
if(j == 2){
return;
}
System.out.print(i);
System.out.print(j);
System.out.println();
}
}
}
##
一维数组
声明方式： type var[] 或 type[] var;
一维数组初始化：
-
动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行，如：int arr[] = new int[10];
-
静态初始化：在定义数组的同时就为数组元素分配空间并赋值， 如： int a[] = new int[]{1,2,3,4}
数组的引用
-
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
-
数组元素的引用方式：数组名[ 数组元素下标 ]（数组元素下标可以是整型常量或整型表达式；数组元素下标从0 开始）
-
每个数组都有一个属性length 指明它的长度
-
数组一旦初始化，其长度是不可变的
public static void main(String[] agrs){
/**
* 数组--存放多个数据的集合*/
//一维数组
int a[];
int[] b;
int arr[] = new int[5];//动态赋值
int[] arr1 =new int[]{1,2,3,4,5};//静态赋值
//数组下标从0开始
System.out.println(arr.length);
System.out.println(arr1[1]);
System.out.println(arr1[1*2]);
System.out.println(arr[1]);
}
多维数组
二维数组：数组中的数组
格式（动态初始化）1：int [] [] arr = new int [3] [2];(三个一维数组，每一个一维数组中有两个元素)
格式（动态初始化）2：int [] [] arr = new int [3] [];
格式（静态初始化）3：int[] [] arr = new int [] []{ {1,2,3}，{2,7}，{1,2,3}}；
public static void main(String[] args){
int[][] arr = new int[][]{
{3,8,2},
{2,7},
{9,0,1,6}
};
int len = arr.length;
int res = 0;
for(int i = 0; i < len; i++){
int arr0[] = arr[i];
int llen = arr0.length;
for(int j = 0;j < llen;j++){
res +=arr0[j];
}
}
System.out.println(res);
}
数组练习
public static void main(String[] agrs){
/**
* 数组中涉及的常见算法
* 1、求数组元素的最大值，最小值，求和，平均数
*/
int arr[] = new int[]{1,2,3,4,5,6,7,8 };
int max = arr[0];
int min = arr[0];
int sum = 0;
int avg ;
int i;
for( i = 0;i < arr.length;i++){
if(max < arr[i]){
max = arr[i];
}
}
System.out.println("最大值："+max);
for(int j = 0; j < arr.length;j++){
if(min > arr[j]){
min = arr[j];
}
}
System.out.println("最小值："+min);
//总和，平均数
for(int k = 0;k < arr.length; k++){
sum +=arr[k];
}
System.out.println("总和:"+sum);
System.out.println("平均数：" + (sum / arr.length));
//2、数组的复制
int copy[] =new int[arr.length];
for(i = 0; i < arr.length;i++){
copy[i] = arr[i];
}
for(i = 0;i < copy.length;i++){
System.out.println(copy[i]);
}
System.out.println();
System.out.println();
//3、数组的反转
int temp[] = new int[arr.length];
int k =0;
for(i = arr.length - 1;i >= 0;i--){
//System.out.println(arr[i]);
temp[k] = arr[i];
k++;
}
arr = temp;
for(i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}
冒泡排序
public static void main(String[] args){
*/
/**4、数组元素的排序
冒泡法：排序思想：
相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），
下一次循环是将其它的数进行类似操作
*/
int arr[] = new int[]{10,32,1,234,554,6,21};
int temp;
for(int i = 0;i < arr.length - 1; i++){//循环轮次
for(int j = 0; j < arr.length - 1 - i ;j++){//每一轮次，对数组元素进行排序
if(arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j+ 1] = temp;
}
}
}
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
}