语句与数组
1.流程控制
1.1 顺序结构
顺序结构就是一直执行下去的语句结构。就是我们前面所做的那种。
1.2 判断结构
判断结构可根据不同的判断条件执行不同的语句，判断条件就是关系表达式。
判断结构包括：if条件语句和 switch语句。
1）if语句
定义 ：在某个条件成立的情况下执行某段程序，如果条件不成立，就执行另外的语句。
If 条件语句也分为：简单的if条件语句、if…else…语句和 if .. else if … 多分支语句
if (判断条件)
{
复合语句...
}
else if(判断条件)
{
复合语句...
}
...//可以有零个或多个else if语句
else//最后的else语句也可以省略
{
复合语句...
}2) switch语句
语句特点：
1.switch语句选择的类型只有四种：byte,short,int,char(JDK 7 新增功能可以放下String类型).
2.case 之间与default 没有顺序。先执行第一个case,没有匹配的case 就执行default.
3.结束switch语句有两种情况，遇到break,执行到switch语句结束。
4.如果匹配的case 或者default没有对应的break,那么程序会继续向下执行，执行可能执行的语句，直到遇到break或者switch结尾结束。
switch(表达式){
case 常量表达式 1 ： 语句序列 1 ；break; //break可有可无
case 常量表达式 2 ： 语句序列 2 ；break; //break可有可无
case 常量表达式 3 ： 语句序列 3 ；break; //break可有可无
.。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
case 常量表达式 n ： 语句序列 n ；break; //break可有可无
default ： 语句序列 n + 1 ; break; 最后的break的确可省。
}1.3 循环结构
循环结构：通过循环语句让同一段代码反复执行多次，执行完毕程序才会继续往后运行
1）while
while语句是“当型”循环语句，也就是条件表达式成立时，执行循环体中的内容。其语法格式为：
while(条件表达式){
循环体
}public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int count = 1 ;
//循环条件
while(count <= 10 ){
if(count < 10)
//循环输出1~10的数
System.out.print(count + ",");
else
System.out.print(count);
//count ++ 变量自增
count ++;
}
}
}
输出：
1,2,3,4,5,6,7,8,9,10 注：若有时循环条件难以写出，可直接在“()”填写true（所谓死循环）,而后在循环体中加入判断条件，当满足条件时执行break语句就可以跳出循环。
while(true){
If (条件表达式)break;
}2) do….while 语句
do … while先执行一次循环体，然后判断while中的表达式，如果是true继续执行，如果是false则跳出循环。
所以do …while 至少要执行循环体一次。
其语法格式为：
do{
循环体
} while(条件表达式)3) for 语句
语法格式：
for(表达式1; 表达式2;表达式3){
语句序列
}表达式1：该表达式用于初始化循环控制变量，它只在循环开始时执行一次。
表达式2：循环条件表达式，它的类型为boolean，如果表达式的值为true，则执行一次循环体。
表达式3：该表达式用于改变循环体变量的值。
for循环的执行过程如下：
1.执行表达式1，完成某一变量的初始化工作，如 int I = 0;
2.判断表达式2的值，如I < 100。若表达式2的值为true,则执行一次循环体，然后执行第三步，否则，退出循环体结束for循环。
3.执行表达式3，这部分通常执行循环控制变量的修改。
4. 跳转到第二步继续执行循环。
具体如下图：
4）嵌套的循环
当循环结构的循环体中又包含循环结构时，循环结构就呈嵌套的形式。三种循环语句可以相互嵌套。
代码实例：输出九九乘法表
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i= 1 ; i < 10 ; i ++ ){
//输出九九乘法表的一行
for(int j = 1 ; j <= i ; j ++){
//输出九九乘法表的一小列
System.out.print(j + "*" + i + "=" + j * i + " ");
} //第一行换一行
System.out.println();
}
}
}
输出：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 5) 循环的跳转
continue、break、return
continue：结束本次循环，继续执行下一次（只是不执行contine下面的内容）
break：结束循环
return：结束方法
其中continue 、break 是可以用标记来实现跳转的。
用九九乘法表看看标记的作用
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
outer: for (int i = 1; i < 10; i++) {
for (int j = 1; j <= i; j++) {
if (i == 2)
// 中断外循环 连空行也不输出
continue outer;
if (i == 3)
// 中断内循环 这里是因为在这循环里i == 2 , 所以作用相当于break
continue;
if (i == 6)
// 跳出内循环 只是结束一层循环
break;
if (i == 8)
// 跳出外循环 跳出时循环已结束
break outer;
// 输出九九乘法表的一列
System.out.print(j + "*" + i + "=" + j * i + " ");
}
// 第一循环换一行
System.out.println();
}
}
}
输出：
1*1=1
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 4. 函数
定义：函数就是定义在类中的具有特定功能的一段独立小代码。函数也称为方法。
格式：
[访问修饰符] [静态修饰符] 返回值类型函数名（参数类型 形式参数1，参数类型 形式参数2）{
执行语句
return 返回值;
} 参数说明：
返回值类型：函数运行后的结果的数据类型 ，不需要返回，返回值类型为 void 。
参数类型：是形式参数的数据类型。
实际参数：是一个变量，用于存储调用函数时传递函数的实际参数。
return: 用于结束函数。
返回值：该值会返回给调用者。
函数的特点
1． 定义函数可以将功能代码进行封装。
2． 全类对该功能的复用。
3． 函数只有被调用才会执行。
4． 函数的出现提高了代码的复用性。
5． 对于没有具体返回值的情况，返回值用关键字void表示，那么该函数中的return如果在最后一行可以省略不写。
注意：1.函数中只能调用函数，不可以函数内部定义函数.
2.定义函数时，函数的结果应该返回给调用者，交由调用者处理。
3.写代码的规范：主类只负责调用，其他功能在其他类中完成！方便后来的复用。
数组
定义：具有相同数据类型的一组数据的集合。Java中数组是被看作一个对象，程序设计中引入数组可更有效地管理和处理数据。数组分为一维与多维数组。
初始化一维数组，初始化一维数组有两种方法：
1）静态初始化int arr [] = new int []{34,65,87,41};
2）动态初始化int arr [] = new int [4]; arr[0] = 34 ; arr[1] = 68 ; arr[2] =87 ; arr[3] = 41 ;
数组的长度：数组的长度可以通过数组名.length 获得。
数组的遍历：可以通过已知的数组长度来达到遍历数组的目的，也可以通过JDK1.5的新增功能来遍历数组。
数组的下标：数组的下标由0开始，所以数据的最大下标为 (数组名.length -1);
数组常见的异常：如果访问数组时索引越界（小于0或者大于length-1），会抛出异常：ArrayIndexOutOfBoundsExcepion
如果访问数组的引用为空(null)，会抛出空指针异常：NullPointerException
public class TestWhile {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = { 54, 41, 74, 96, 87, 45, 65, 41 };
System.out.println("数组的长度：" + arr.length);
System.out.println("数组中的元素有：");
//根据数组长度遍历数组
for (int i = 0; i < arr.length; i++) {
if (i != arr.length -1)
//根据数组下标输出数组成员
System.out.print(arr[i] + ",");
else
System.out.println(arr[i]);
}
}
}
输出：
数组的长度：8
数组中的元素有：
54,41,74,96,87,45,65,41多维数组：所谓多维数组就是二维和大于二维的数组。多维数组的声明其实就是用一维数组的嵌套声明实现的。拿二维数组来举例，二维数组就是一个所有元素都是一维数组的一组数组。
二维数组也有两个方法初始化：
1） int [] [] a = new int [2][4];
2） int [] [] a = new int [2] []; a[0] = new int [4] ; a [1] = new int[4];（就是分别跟N个一维数组赋值）
上述代码创建的二维数组就是两个长度为4的一维数组组成。
论坛上看到的题目：求最值和素数
/**
1.输入10个数，求最值。
2.求输入的10个数是中素数之和。
要求：
1.使用多种方法来操作，比较方法的优缺点。
2.在每个方法的注释上写清楚编程思路。
3.一定要使程序清晰。
*/
import java.util.Arrays;
import java.util.Scanner;
public class Practice
{
public static void main(String[] args)
{
Practice pra = new Practice();
pra.manager();
System.out.println("Hello World!");
}
//代理类---其实可以写在main()中，不过想想还是分开吧！
public void manager(){
Scanner input = new Scanner(System.in);
System.out.println("请输入十个数：");
int count = 0 ;
int [] arr = new int[10];
//循环向数组输出数值
while (count < 10)
{
System.out.print("输入第" + (count + 1 ) + "个数：" );
arr[count++] = input.nextInt();
}
System.out.println("数组中的素数之和为：" + getPrime(arr));
//比较大小的有三种方法
//1.直接比大小，最简单的方法
System.out.println("输入数最大值为：" + getMax(arr));
//2.用数组的sort()方法排序：数组中的下标最大值为最大值
System.out.println("输入数最大值为：" + getMax2(arr));
//冒泡排序法
System.out.println("输入数最大值为：" + getMax3(arr));
//选择排序法
System.out.println("输入数最大值为：" + getMax4(arr));
}
//求最佳的方法1，直接遍历比较，返回最大值者
public int getMax(int [] arr){
//设第一个数为最值
int max = arr[0];
//循环比较
for ( int i = 1; i < arr.length ; i ++ )
{
//若大于max,则将其值赋予max
if (max < arr[i])
{
max = arr[i];
}
}
//返回max
return max;
}
//直接用Arrays中的方法实现排序
public int getMax2(int [] arr){
Arrays.sort(arr);
//返回数组的最后一位，也就是最大值了
return arr[arr.length -1];
}
/*
*冒泡排序法：一个一个比较大小，大的向极位移动
*优点就是实现思想比较简单，让人容易了解，比较稳定
*缺点就是要经常作变量交换，比较耗时
* */
public int getMax3(int [] arr){
//一个中间变量，用来作变量交换
int temp;
//遍历数组
for (int i = 1 ; i < arr.length ; i ++)
{
//比较相邻的幸免于难，较大者则往后
for ( int j = 0 ; j < arr.length - i ; j ++ )
{
//若前一位数比后一位数大，则交换位置
if (arr[j] > arr[j+1])
{
temp = arr[j];
arr[j ] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//返回最后一位数组，即是最大值
return arr[arr.length -1];
}
/*直接排序法，就是遍历数组将最大值放在最后位，次值放在后二位的做法
* 优点：算法交换的次数比冒泡排序要少，所以比较节省时间
* 缺点：比较不稳定
* */
public int getMax4(int [] arr){
//设中间值，作数据交换之用
int temp;
//遍历数组
for ( int i = 1 ; i < arr.length ; i ++)
{ //索引变量
int index = 0 ;
//比较各数，排序
for ( int j = 1 ; j <= arr.length - i ; j ++ )
{
//比较两者，大者下标为index
if (arr[j] > arr[index])
{
index = j;
}
}
temp = arr[arr.length - i];
//循环结束后再将其进入数据交换
arr[arr.length - i] = arr[index];
arr[index] = temp;
}
return arr[arr.length -1];
}
//求素数的方法
public int getPrime(int [] arr ){
//获取数组中的素数之和
int sum = 0;
System.out.print("数组中的素数为：");
//遍历数组
for ( int i = 0; i < arr.length ; i ++ )
{
/*
* 用一个布尔常量表示是否是素数
* 判断数组中的每一个数是否是素数，循环条件为该数的 1 / 2 ，因为除了2外偶数都不是素数，
* 而将该数除以 它一半和之前的数就可以判断它是否为素数
* */
boolean isPrime = true;
for ( int j = 2 ; j <= arr[i] / 2; j ++ )
{
//如果一个数能被它一半以下的数整除，那它就不是素数
if ( arr[i] % j == 0)
{
//此处的布尔值为不是素数
isPrime = false;
//一旦能整除退跳出循环，不用再判断
break;
}
}
if (isPrime)
{
//输出素数
System.out.print(arr[i] + "\t");
//将它们的和相加
sum += arr[i];
}
}
System.out.println("素数之和为：" + sum);
//返回素数结果
return sum;
}
}3.编程练习
3.1按输入的数字输出相应长度的菱形
import java.util.Scanner;
public class Diamond {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print("请输入要输出的菱形的长度：");
int num = input.nextInt();
printDiamond(num);
}
public static void printDiamond(int num) {
// 计算菱形的大小，若输入为双数则加一
if (num % 2 == 0)
num++;
for (int i = 0; i < num / 2 + 1; i++) {
// 输出左上角的空白
for (int j = num / 2 + 1; j > i + 1; j--)
{
System.out.print(" ");
}
// 输出菱形上半部分实体
for (int j = 0; j < 2 * i + 1; j++)
{
System.out.print("*");
}
System.out.println();
}
for (int i = num / 2 + 1; i < num; i++) {
// 输出左下角的空白
for (int j = 0; j < i - num / 2; j++)
{
System.out.print(" ");
}
// 输出菱形下半部分实体
for (int j = 0; j < 2 * num - 2 * i - 1; j++)
{
System.out.print("*");
}
System.out.println();
}
}
}
输出：
请输入要输出的菱形的长度：12
*
***
*****
*******
*********
***********
*************
***********
*********
*******
*****
***
*public class Diamond {
public static void main(String[] args) {
manager();
}
private static void manager() {
// TODO Auto-generated method stub
//设总和为sum
double sum = 0;
//循环加1~1/20之间的和
for(int i = 1; i <= 20 ; i ++ ){
//每个阶乘的值
double partSum = 1 ;
for (int j = 1; j <= i; j++) {
//j的阶乘
partSum *= j;
}
sum += 1 / partSum;
}
//输出
System.out.println("1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = " + sum);
}
}
输出：
1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = 1.71828182845904553.3打印出10行的杨辉三角;
/**
* 思路：杨辉三角的定义,
* 一个数前提：端点的数为1.
* 1、每个数等于它上方两数之和。
* 2、每行数字左右对称，由1开始逐渐变大。
* 3、第n行的数字有n项。
* 由杨光三角的定义可知，此数列应用二维数组来做
* 且每一个一维数组的长度为其下标加一
* 由定义可知，除杨辉三角的边界为1外，其里面的元素triangle[i][j] = triangle[i-1][j] + triangle[i][j-1];
*
* */
public class YanghuiTriangle
{
public static void main(String[] args)
{
//调用输出杨辉三角的方法
triangle();
}
//输出杨辉三角的方法
public static void triangle(){
//新建一个长度为10的二维数组
int [] [] triangle = new int [10][] ;
//按二维数组的长度来循环
for ( int i = 0 ; i < triangle.length ; i ++ )
{
//输出左边的空格
for(int j = triangle.length -1 - i; j > 0 ; j --){
System.out.print(" ");
}
//每次循环都新建一个一维数组，长度为数组元素下标加一
triangle [i] = new int[i + 1];
for ( int j = 0 ; j <= i ; j ++)
{
//边界输出1
if(i == 0 || j == 0 || j == i )
triangle[i][j] = 1;
else
//里面的元素按上面的公式定来计算
triangle[i][j] = triangle[i - 1] [j] + triangle[i -1][j -1];
//输出每个值
System.out.print(triangle[i][j] + " ");
}
//第一循环换一行
System.out.println();
}
}
}
输出：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1 
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
