java入门-----基本语法之语句的使用

选择结构语句：

if条件语句：

if语句是指如果满足某种条件，就进行某些处理

if（条件语句）//判断语句
{
代码块//执行语句
}
1
2
3
4

举例：

public class HelloWorld{
    public static void main(String[]args) {
        int x = 8;
        if (x < 10)//x满足小于10，则if执行语句
            System.out.println("x 是个位数");
    }
}
1
2
3
4
5
6
7

输出：

x 是个位数
1

if…else语句：

满足if后面的条件，就执行if语句中的处理，否则执行else中的

 if（条件语句）//判断语句
{
 代码块//执行语句
   }
  else
 {
   代码块//执行语句2
 }
1
2
3
4
5
6
7
8

举例：

public class HelloWorld{
    public static void main(String[]args) {
        int x = 19;
        if (x < 10)//x<10不满足，执行else
            System.out.println("x 是个位数");
        else
        {
            System.out.println("x 不是个位数");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

输出：

x 不是个位数
1

if…else if…else语句：

满足那个判断条件，就执行相应的代码块，否则执行else

 if（条件语句）//判断语句
 {
代码块//执行语句
 }
 else if（判断条件2）
 {
代码块//执行语句2
}
else if（判断条件n）
{
 代码块//执行语句n
}
else
{
执行语句n+1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

举例：

public class HelloWorld{
    public static void main(String[]args) {
        int x = 100;
        if (x < 10)
            System.out.println("x 是个位数");
        else if(x>10&&x<100)
        {
            System.out.println("x 是两位数");
        }
        else
        {
            System.out.println("x 是三位数");
        }
    }
}
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

x 是三位数
1

三元运算符：

在C语言中，我们就已经接触过三元算术符，在Java中，它的使用方法和C语言中相同

举例：

public class HelloWorld{
    public static void main(String[]args) {
       int a=10;
       int b=3;
       int max=a>b?a:b;
       System.out.println("10和3中较大的数是"+max);
    }
}
1
2
3
4
5
6
7
8

输出：

10和3中较大的数是10
1

使用三目运算符需要注意以下几点：

1：条件运算符“？”和“：”，是一对运算符，不能分开单独使用。

2：条件运算符的优先级低于关系运算符与算术运算符，但高于赋值运算符

3：条件运算符可以进行嵌套，结合方向自右向左，例如，a>b?a:c>d?c:d应该理解为a>b?a:(c>d?c:d),这也是条件运算符的嵌套情形，即三元表达式中的表达式2又是一个三元表达式

Switch语句：

在C语言中，Switch后面的表达式必须是基本数据类型中的整型类型使用switch，这些类型包括int、char等

在JDK5之前，Switch语句中的表达式可以是byte，short，char,int类型的值，如果传入其他类型的值，程序会报错

JDK5引入了新特性，enum枚举可以作为Switch语句表达式的值，JDK7中也引入了新特性，Switch可以接受一个string的值。

swtich(表达式)  {    
                 case 常量1 :
                   要执行的语句;
                   break;
                 case 常量2 :
                   要执行的语句;
                   break;
                 case 常量3 :
                   要执行的语句;
                    break;
                 default:
                   要执行的语句;
                   break;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

举例：

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);
       System.out.println("请输入你的成绩");
       int score=sc.nextInt();
       switch(score/10)
       {
           case 10:
           case 9:
               System.out.println("您的成绩非常棒！");break;
           case 8:
               System.out.println("您的成绩很好！");break;
           case 7:
               System.out.println("您的成绩还需要加强！");break;
           case 6:
               System.out.println("您的成绩刚及格！");break;
           default:
               System.out.println("您需要好好努力了！");break;
       }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

注：和C语言中的Switch语句相同，一定不要忘记加break，否则会导致输出结果不符合预期效果。

输出：

请输入你的成绩
78
您的成绩还需要加强！
1
2
3

while循环语句：

while循环语句与选择语句类似，都是根据判断条件决定是否执行大括号内的执行语句，区别在于，while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会进行执行，直到条件不成立，while循环结束。

while(表达式)

{

循环语句1；

循环语句2；

…

循环语句N；
}
1
2
3
4
5
6
7
8
9
10
11
12

举例：

public class HelloWorld {
    public static void main(String[] args) {
       int number=0;
       int sum=0;
       while(number<50)//循环结束的条件-----number>=50
       {
           sum+=number;
           number++;
       }
       System.out.println("sum为"+sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

输出：

sum为1225
1

do…while循环语句：

和while不同的是，该循环体会无条件的执行一次，然后再根据while后面的条件决定是否再执行。

do{

语句序列

} while(条件表达式); //注意！语句结尾处的分号";"一定不能少

public class HelloWorld {
    public static void main(String[] args) {
       int number=6;
       do
       {
           number++;
           System.out.println("number is"+number);//执行一次
       }while(number<6);//不符合要求跳出循环
    }
}
1
2
3
4
5
6
7
8
9
10

输出：

number is7
1

for循环语句：

for(循环变量的初始化;循环判断;循环迭代）{
循环体;
}

public class HelloWorld {
    public static void main(String[] args) {
       int i=0;
       for(i=0;i<10;i++)//for循环结束的条件，i>=10
       {
           System.out.println(i);
       }
    }
}
1
2
3
4
5
6
7
8
9

输出：

0
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
10

循环嵌套：

当满足外层循环，才能进入内层循环，内层循环不满足时，再跳出内层循环，对外层循环进行判断。

for(初始化表达式;循环条件;操作表达式){

…

for(初始化表达式;循环条件;操作表达式){

执行语句

…

}

}

举例：

public class HelloWorld {
    public static void main(String[] args) {
       int i,j;
       int sum=0;
       for(i=0;i<10;i++)//外层循环
       {
           for(j=0;j<10;j++)//内层循环
           {
               sum+=i+j;
           }
       }
        System.out.println("sum is"+sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

sum is900
1

break VS continue：

break语句：

在Switch条件语句和循环语句中都可以进行使用，当它出现在Switch语句中，作用是终止某个case并跳出Switch结构，当它出现在循环语句中，作用是跳出循环执行后续代码。

举例：

我们现在通过上述在Switch结构那部分所举的实例来感受一下break的作用。

import java.util.Scanner;
public class HelloWorld {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入你的成绩");
        int score=sc.nextInt();
        switch(score/10)
        {
            case 10:
            case 9:
                System.out.println("您的成绩非常棒！");
            case 8:
                System.out.println("您的成绩很好！");
            case 7:
                System.out.println("您的成绩还需要加强！");
            case 6:
                System.out.println("您的成绩刚及格！");break;
            default:
                System.out.println("您需要好好努力了！");break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出：

请输入你的成绩
82
您的成绩很好！
您的成绩还需要加强！
您的成绩刚及格！
1
2
3
4
5

我们输入的成绩符合case为8的这个语句，但是结果输出了不止一条语句，其原因就是在case 8和case 7语句后面并没有break,直到case 6后面才有break出现，此时才能跳出Switch结构，由此可见，break在Switch结构中的重要性。

但是需要注意的是，break在嵌套循环中，他只能一次性跳出一个循环，也就是说，当它处于内层循环时，他只能跳出内层循环，而不能直接跳出外层循环，如果想要跳出外层循环，需要再使用一个break。

continue语句：

它的作用是终止本次循环，执行下一次循环。

举例：

public class HelloWorld {
    public static void main(String[] args) {
        for(int i=0;i<10;i++)
        {
            if(i%2==0)//打印偶数
                System.out.println(i);
            continue;
        }
    }
}
1
2
3
4
5
6
7
8
9
10

输出结果：

0
2
4
6
8
1
2
3
4
5

if的判断条件是偶数项会被输出，当i增大到1时，已经不满足i%2==0，但是因为else的执行语句为continue，所以此时本次循环结束，给i++,再将i的值在for循环的条件语句哪里进行判断，执行下一次循环。

如果我们将continue换成break，此时输出结果只有0

方法：

修饰符：

方法的修饰符很多，例如，对方问权限进行限定的修饰符，static修饰符，final修饰符等。

返回值类型：

用于限定方法返回值的数据类型

参数类型：

用于限定调用方法时传入参数的数据类型。

参数名：

是一个变量，用于接收调用方法时传入的数据

return关键字：

用于返回方法指定类型的值并结束方法。

返回值：

被return语句返回的值，该值会返回给调用者。

举例：

public class HelloWorld {
    public static void main(String[] args) {
        printRectangle(3, 5);
        printRectangle(2, 4);
        printRectangle(6, 10);
    }
    //定义了一个方法printRectangle，printRectangle为方法名height和width为参数
    public static void printRectangle(int height, int width) {
    //void表示返回值的类型
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                System.out.print("*");//print打印、println
            }
            System.out.print("\n");
        }
        System.out.print("\n");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出：

*****
*****
*****

****
****

**********
**********
**********
**********
**********
**********
1
2
3
4
5
6
7
8
9
10
11
12
13

方法的调用和函数调用有点相似，但不同之处是，函数调用必须要声明函数，但方法的调用是不需要声明，而是需要将要调用的方法用class类的那个大括号包裹进去。

方法的重载：

在平时生活中经常会出现这样的情况，一个班里可能同时有两个叫小明的同学，甚至有多个，但是他们的身高，体重，外貌等其他方面有所不同，老师点名时会根据他们的特征来区分，在编程语言里也存在，这种情况参数不同的方法有着相同的名字，调用时根据参数不同确定调用哪个方法。这就是java方法重载机制。

所谓方法重载，就是在同一个作用域内方法名相同但参数个数或者参数类型不同的方法，例如，在同一个作用域同时定义三个add（）方法，这三个add（）方法就是重载函数。

举例：

public class HelloWorld {
    public static void main(String[] args) {
       int sum1=add(1,2);
       int sum2=add(1,2,3);
       double sum3=add(1.2,2.3);
       System.out.println("sum1="+sum1);
       System.out.println("sum2="+sum2);
       System.out.println("sum3="+sum3);
    }
    public static int add(int x,int y)//实现两个值整数的相加
    {
        return x+y;
    }
    public static int add(int x,int y,int z)//实现三个整数的相加
    {
        return x+y+z;
    }
    public static double add(double x,double y)//实现两个双精度浮点数的相加
    {
        return x+y;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出：

sum1=3
sum2=6
sum3=3.5
1
2
3

虽然上述定义的三个方法是同名的，但由于他们的参数个数或参数类型的不同，从而形成了方法的重载，在main（）函数中调用方法add时，通过传入的不同的参数便可以确定调用那个重载的方法。