Java中的方法，流程控制+循环

Java中方法的创建，分支结构和循环结构

首先先说一下在Java中的逻辑运算符，便于后面的分支和循环的讲解

• 在逻辑运算符中需要注意到的点有以下几个：
• a++和++a的区别，他们两个的区别在于a++是先使用a的值a再自加，而++a是先自加再被程序所使用。两个的区别在于一个未变化就被使用，一个是变化后再被使用。
• 逻辑运算符中 双与（&&）和单与（&）的区别，逻辑运算大多数是用在后面的分支语句中用于判断，那么&&和&的区别在于当我使用&时，if判断需要对括号内两个条件进行判断当第一个条件为假时，它不会停止而是会继续将下一个条件进行判断。但是使用&&的话，在判断条件时，当第一个条件为假时，它会直接跳出或则结束判断而不会进行下一条件的判断，会节省很多时间。同样的双或（||）和单或（|）也是同样的道理，所以我们在更多时候会使用双与（&&）和双或（||）。
• 其次到三元运算符，三元运算符最大的作用就是用于三元表达式：1 ？2 ：3，这个表示在1条件为真时，返回值为2或者执行2，1条件为假时，返回值为3或者执行3。其实三元表达式和if-else分支语句很相似，所以三元表达式还有一个重要的功能就是可以互相嵌套。比如：

		//求三个数中的最大值
		System.out.println("请输入三个数");
		int b=new Scanner(System.in).nextInt();
		int c=new Scanner(System.in).nextInt();
		int d=new Scanner(System.in).nextInt();
		//这里换成double5类型的数值也可以，没有限制
		int max = b > c ? ( b > d ? b : d) : ( c > d ? c : d);
		//最重要的在三元表达式的嵌套部分，它可以实现多次判断的相互嵌套，有这么一个思想是最好的。
		System.out.println("最大值为："+max);

运算符中比较特殊或者说有注意的点就我自己知道的这么几个。

分支语句if-else和switch-case（重点学习if-else分支语句）

• if-else分支语句：单分支，多分支，嵌套分支

• 单分支：if(判断条件){执行语句1;执行语句2;....}
• 多分支：if(判断条件){满足条件时执行的代码块}else{条件不满足时执行的代码块}
• 嵌套分支：if(判断条件1){满足条件时执行的代码块}else if(判断条件2){满足条件时执行的代码块}else if(判断条件3){满足条件时执行的代码块}else....

		//单分支
		if(判断条件1){
			满足条件时要执行的代码块;
		}
		//多分支
		if(判断条件1){
			满足条件时要执行的代码块;
		}else{
			不满足条件时要执行的代码块;
		}
		//嵌套分支
		//商品打折案例：
		double c = new Scanner(System.in).nextDouble();
		if(c>5000){
			c = c*0.5;
		}else if(c > 2000){
			c = c*0.8;
		}else if(c>1000){
			c = c*0.9;
		}
		System.out.println(c);

• switch-case分支

		int key = new Scanner(System.in).nextInt();//接收键盘输入的值
		switch (key) {//将键盘输入的值传到switch中和下面的case的条件判断，满足谁就执行谁。
		/*在使用switch时不仅仅只局限于数值。
		switch(expr1)中,expr1是一个整数表达式， 
		整数表达式可以是int基本类型或Integer包装类型,
		由于byte,short,char都可以隐含转换为int，所以也支持。在jdk1.7版本后也支持String类型的判断*/
		case 1:
			System.out.println("这是1时要输出的语句");
			break;
		case 2:
			System.out.println("这是2时要输出的语句");
			break;
		case 3:
			System.out.println("这是3时要输出的语句");
			break;
		default:
			System.out.println("不满足时的输出");
			break;
		}
		//在switch中不仅仅是一个匹配问题，当把每一项的break去掉以后，他就不是一个匹配问题，而是一个包含问题，就比如以上代码将break去掉以后，我输入一个2，那么最后的输出结果会是从2开始的3句话。所以这里的switch中不仅仅是匹配问题，还是一个包含问题。

循环结构for，while

• for循环：for(开始条件；循环条件；更改条件){ 循环体代码… }
  

//打印九九乘法表案例
private static void f4() {

       for (int i = 1; i < 9; i++) {//外循环，控制行，是一定的
              for (int j = 1; j <= i; j++) {//内循环，列是不固定的，是递增的
                     System.out.print(i+"*"+j+"="+i*j+" ");//保证第一行打印出来一个*，注意条件
              }
              System.out.println();
       }
}
/*这个是一个循环嵌套的案例，在使用循环嵌套，或者说在联系到数组后的循环我们都经常使用for循环来执行。*/

• while循环分为：单独的while(判断条件){执行的代码块}，do{要执行大代码块}while(判断条件);—do-while的区别在于无论条件成不成立，都会将代码块先执行一遍，之后再进行判断。

		//这里是一个死循环案例，没有什么特殊点，和for(;;)死循环不同的在于这个需要true才能判断死循环。
		while(true){
			System.out.println("这是一个死循环");
		}

//从这个案例可以看出do-while循环是先执行一遍再进行循环判断。
		int i = 0;
		do {
			i++;
			System.out.println("i");
		} while (i>2);
//这里突然想到一个问题，那我可不可以把int i = 0；放在循环体中呢？

		do {
			int i = 0;
			i++;
			System.out.println("i");
		} while (i>2);
		//其实这样是不行的，因为我的判断条件里的i是需要一个全局变量，而我的int i = 0；在循环体中是属于一个局部变量和判断条件中的i是不一样的；

方法的创建和调用

• 方法的创建：被命名的代码块，方法可以含参数可以不含参数可以提高代码的复用性。方法形式：修饰符 返回值 方法名(【参数】){ 方法体; }

//方法的创建如下：
//在创建方法时，分为三个部分：修饰符 返回值 方法名（）{}，这个方法可以是有参的也可以是无参的函数
//void表示空，表示不需要返回值。
	public void f(){
		System.out.println("这是一个方法");
	}
	//方法创建的第二种类型，不需要修饰符，只是确定是否需要返回值
	void f2(){
		System.out.println("这是不含修饰符，只标明返回值的方法");
	}
	//第三种有参需要返回值的方法声明，主要的点在于最后需要return一个返回值。
	public int f3(int a){
		System.out.println("这是一个不需要void，但是需要返回值的类型");
		return a;
	}
	//还有一种方法的声明方法是和类名同名的方法为构造方法
	public class lianxi {
	//在这里声明了一个空的构造方法。这种方法不需要修饰符和返回值等修饰，方法名也是固定的和类名一致。
			lianxi(){}
		
	}

• 方法的调用：方法的调用分为：
• 对象名.方法名；
• 类名.方法名；
• 方法名；（这个比较特殊，使用方法名直接调用时需要在方法声明时加上static关键字）
• new 构造方法名；

public class Ff {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ff f = new Ff();//创建一个对象，使用对象调用方法
		f.h2();
		new Ff().h2();//上面两行代码也可以直接简写成这样，它的意思也是new一个对象去调用方法
		//类名调用方法名，这个也需要在方法声明时加上static关键字
		Ff.h3();
		//方法名调用方法,直接使用方法名调用方法，主要也是要加上static关键字
		h1();

	}
	public static void h1(){
		System.out.println("方法名直接调用：");
	}
	public void h2(){
		System.out.println("对象名调用方法");
	}
	public static void h3(){
		System.out.println("类名调用方法");
	}
	

}

public class Ff {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Ff f = new Ff();//创建一个对象，使用对象调用函数
		f.h2();
		new Ff().h2();//上面两行代码也可以直接简写成这样，它的意思也是new一个对象去调用函数
		//类名调用函数名，这个也需要在函数声明时加上static关键字
		Ff.h3();
		//方法名调用函数,直接使用方法名调用方法，主要也是要加上static关键字
		h1();
		//new调用构造方法
		new gzff();

	}
	public static void h1(){
		System.out.println("函数名直接调用：");
	}
	public void h2(){
		System.out.println("对象名调用函数");
	}
	public static void h3(){
		System.out.println("类名调用函数");
	}

}
class gzff{
	gzff(){
		System.out.println("new 调用构造方法");
	}
}

在这里解释一下，为什么那个构造方法我要重新写一个类来实现，是因为我第一次写构造方法调用后发现，只要每一个使用Ff()；的地方，我的构造方法都会被调用，意思是上面的代码中，无论是Ff a = new Ff(); a.h1();还是new Ff().h1;都会调用构造方法，输出一句“构造方法已被使用”。

个人觉得方法以及方法写好以后封装，在之后的Java学习中是最常用到，所以应该要形成一个写方法的习惯。不能所有代码都在主函数中实现。