Java 控制结构与方法

控制结构： 

 控制结构是对我们程序执行顺序的一种控制，它规定了我们语句块的执行顺序和流程。

分支结构：

 关系运算符和逻辑运算符：

关系运算符：== != > >= < <=
逻辑运算符：&& || !

int a = 10;
int b = 20;
if ( b == 20 || a == 10 && a < 10 ){
System.out.pr
intln("分支1");
}else{
System.out.pr
intln("分支2");
}

  循环结构：

Break

Break  在循环中的作用是 跳出一个循环或者结束一个循环 （跳出当前循环）

public class Hello {
     public static void main(String[] args) {
        for(int i=0;i<=10;i++) {
            System.out.println(i);
            
        }
    }
}

输出 ：0.1.2.3.4.5.6.7.8.9.10

 加上break之后：

public class Hello {
     public static void main(String[] args) {
        for(int i=0;i<=10;i++) {
            System.out.println(i);
            break;
        }
    }
}
输出 0  

 直接执行了一次 ， 就跳出当前循环体了。想想这只是跳出单个循环 如果双重循环， 或者多重循环我们怎么办呢 ? 有人会说 每个循环加个break  。  不存在的， 这时候我们通常会引入一个标志量的概念。

同样的例子：

public class Hello {
     public static void main(String[] args) {
         boolean flag = true ;
        for(int i=1;i<=10;i++) {        
            System.out.println("跑了"+i+"圈哦");
          for(int j = 1;j<10;j++) {
              System.out.println("走了"+j+"圈");
             if(j==3) {
                 flag=false;
                 break;     
             }
          }    
          if (flag !=true) {
            break;
        }                    
        }
    }
}
 设置一个标志量，当读取到这个标志量和之前设置的不符合， 就可以选择跳出。

 Continue

立即结束本次循环，继续执行下一次循环 。

依旧举个栗子

public class Hello {
     public static void main(String[] args) {
        for(int i=0;i<=10;i++) {        
            if (i == 5) {
                continue;
            }
            System.out.println(i);
        }
    }
}
 输出 0.1.2.3.4.6.7.8.9.10         跳过了5

控制结构 

顺序，

分支  ： if ，if  else ， if else  if  ，  

 switch （只能作用于32位及以下的数据，不能匹配String 和 32 位以上的。JDK 1.7以上的能匹配字符串，不能作用long。匹配case 使用，如果没有break  则一直顺序执行case 知道遇到case 为止）

循环：

 for  （初始条件；循环条件，步进），while ， do - while （先执行do）

continue 和break 

continue  ： 跳出本次循环执行下一次循环。 

break  ：  跳出当前循环。

方法: 

方法及方法的声明

 面向对象中函数称为方法，本质一样  

 方式一：无参数有返回值的声明，其格式为 

访问修饰符 数据类型 方法名([参数列表]){
// 方法体
return 值;
} 

public int getValue(){
return 3;
} 
或者
public int getValue(){
int number = 3;
return number;
//返回值的数据类型必须与声明时的数据类型相一致!!!

} 

方式二： 无参数无返回值的声明，其格式为 

访问修饰符 void 方法名([参数列表]){
// 方法体
}

public void eat(){
System.out.println("吃饺子...");
}
void表示无返回值， 在方法体最后不需要return!!!

方法调用实例：

public class First {
public static void main(String[] args) {
First f = new First();
int m = f.getMax();
System.out.println(m);
} 
public int getMax(){
int max = 0;
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字：");
int a = sc.nextInt();
System.out.println("请输入第二个数字：");
int b = sc.nextInt();
max = a>b?a:b;//三目运算符 
sc.close();
return max;
}
}

  参数

参数的分类：
– 形参：声明方法时，所定义的参数；

      访问修饰符 类型 方法名(类型 参数名1,类型 参数名2){ }
– 实参：调用方法时，所传入的值，个数、类型、顺序必须与形参相同；

      方法名(值); 或 对象名.方法名(值); 或 类名.方法名(值); 

– 可变长参数：java1.5增加的新特性，可变参数适用于参数不确定，类型确定的情况，java把可变参数当作数组处理；

   访问修饰符 类型 方法名(类型 参数名1,类型 参数名2){ }

Static 关键字

含义

静态的， 在内存中具有唯一的存储空间； 特点 能够被同一个类的多个对象或方法所共享；

能修饰全局变量(称为： 类变量或静态变量)， 其格式为：访问修饰符 static 数据类型 变量名; 

能修饰方法(称为： 类方法或静态方法)， 其格式为： 访问修饰符 static 类型 方法名([参数列表]){ }

重载：

 含义：

在本类中， 方法名相同，参数个数，顺序，类型只要有一个不同，即为重载。与返回值无关。

public class Hello {
    public void  Overloading(String name){
        System.out.println("原始 方法");
    }
    public int Overloading(int a) {
        System.out.println("重载 一");
        return a;      
    }
    public void  Overloading(String name,int a){
        System.out.println("重载 二");
    }
    
}