3.JAVA运算符、变量、方法重载

一、运算符

运算符用于链接表达式的操作数，并对操作数执行运算。

例如：表达式num1+num2，其操作数是num1和num2，运算符是“+”。

java中，运算符分为5中类型：

算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符。

根据操作数的不同，运算符又分为单目运算符、双目运算符和三目运算符。

单目运算符只有一个操作数，双目运算符有两个操作数，三目运算符则有三个操作数。

位运算符涉及到二进制位的运算，在java 程序中运用不是很多。

 1.1测试取余和自增自减运算符

package cn.tedu.bassic;
/**本类用于测试取余和自增自减运算符*/
public class TestOperator {
	public static void main(String[] args) {
		//1.测试除法与取余数
				System.out.println(38 / 10);//3
				System.out.println(38 % 10);//8
				
				//2.练习1：获取一个两位数59的十位与个位
				int x = 59;
				System.out.println(x/10);//打印十位,5
				System.out.println(x%10);//打印个位,9
				
				//3.练习2：获取一个三位数159的百位、十位与个位
				int y = 159;
				System.out.println(y / 100);//打印百位
				System.out.println(y / 10 % 10);//打印十位
				System.out.println(y % 10);//打印个位
				
				//4.测试自增自减运算符
				/** 前缀式：符号在前：++a --a ,先改变变量本身的值，再使用，比如打印
				 * 后缀式：符号在后:   a++ a--，先使用，再改变变量本身的值
				 * ++:相当于给变量本身的值+1
				 * --: 相当于给变量本身的值-1*/
				System.out.println("我是一个无情的分界线");
				
				/**普通的四则运算并不会改变变量本身的值
				 *    自增自减运算符才会改变变量本身的值*/
				int z = 1;
				System.out.println(z+4);//5
				System.out.println(z);//1
				
				int a = 1;
				System.out.println(++a);//2
				System.out.println(a);//2
				
				int b = 1;
				System.out.println(b++);//1
				System.out.println(b);//2
				
				int c = 1;
				System.out.println(--c);//0,符号在前，先自减，再打印
				System.out.println(c);//0，上面已经自减过了
				
				int d = 1;
				System.out.println(d--);//1，符号在后，先打印，再自减
				System.out.println(d);//0,打印过后，自减成0
				
				//之前的代码会对后面的代码产生影响，c的值是0
				/**由于程序是从上往下依次执行的
				 * 所以前面的代码会对后面的代码产生影响**/
				System.out.println(c);//0
				System.out.println(--c-c-c--);//1,-1-(-1)-(-1)=1
				System.out.println(c);//-2,经历了两次自减，所以0-2=-2
	}
}

1.2接收用户输入的两个值，并把最大值输出

package cn.tedu.bassic;

import java.util.Scanner;

/**需求：本类用于接收用户输入的两个值，并把最大值输出*/
public class TestMaxNum {

	public static void main(String[] args) {
		System.out.println("请输入您要比较的第一个数：");
		int a =new Scanner(System.in).nextInt();
		System.out.println("请输入您要比较的第四个数：");
		int b =new Scanner(System.in).nextInt();
		/**三目运算符：1?2:3
		 * 1是表达式，如果1的结果为true,结果取2号位置的值
		 * 为false,结果取3号位置的值
		 * */
		int Max=a>b?a:b;
		System.out.println("最大的数为："+Max);
	}

}

1.3求平年闰年

package cn.tedu.bassic;

import java.util.Scanner;

/**本类用于求平年闰年*/
public class Test3_Year {

	public static void main(String[] args) {
		//25
		//求个位数
		//求十位数
		System.out.println("请输入一个两位数：");
		int i = new Scanner(System.in).nextInt();
		int b = i%10;
		int a = i/10;
		System.out.println("该两位数的个位数为："+b);
		System.out.println("该两位数的十位数为："+a);
		
		System.out.println("请输入一个三位数：");
		int i1 = new Scanner(System.in).nextInt();
		int b1 = i1%10;//个位
		int a1 = (i1/10)%10;//十位
		int c = i1/100;//百位
		System.out.println("该两位数的个位数为："+b1);
		System.out.println("该两位数的十位数为："+a1);
		System.out.println("该两位数的百位数为："+c);
		
		
		System.out.println("请输入您要判断的年份：");
		int year = new Scanner(System.in).nextInt();
		String result = "平年";
		
		//3.判断用户输入的年份是否满足闰年的条件
				/**解决方案1*/
				/**条件1:能被4整除,并且不能被100整除*/
				/*if(year % 4 == 0) {//能被4整除
					if(year %100 != 0) {//不能被100整除
						result = "闰年";//符合闰年的条件1,修改结果为闰年
					}
				}
				//条件2:能被400整除
				if(year % 400 == 0) {//能被400整除
					result = "闰年";//符合闰年的条件2,修改结果为闰年
				}*/
				/**解决方案2*/
				/**判断结构 if(判断条件){满足判断条件以后执行的代码} */
				/*if(条件1  || 条件2){是闰年 }
				if((小条件1  && 小条件2) || 条件2){ 是闰年 }
				if((能被4整除  && 不能被100整除) || 能被400整除){ 是闰年 }*/
				if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
					result = "闰年";//符合闰年的条件,修改结果为闰年
				}
				/*if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
					result = "闰年";
				}*/
		
		System.out.println(year+"年是："+result);

	}

}

二、变量

可以改变的数，称为变量。

一般通过三部分来描述一个变量。变量类型，变量名，变量值。

其中三部分都是可以改变的，根据需要来确定即可。

变量的使用原则：就近原则。尽量控制到最小范围。

2.1局部变量（方法里）

定义在方法里，或者局部代码块中。

注意：必须手动初始化，来分配内存。如：int i=5;

作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。

2.2成员变量（类内方法外）

定义在类里。

注意：不用初始化，也会自动被初始化成默认值。

作用域是整个类中，类消失了，变量才释放。

2.3方法

2.3.1概述

被命名的代码块，方法可以含参数可以不含参数。

可以提高代码的复用性。

2.3.2形式

方法的修饰符  方法的返回值  方法名(【参数列表...】)   {方法体;}

  public static         void            main    (String[] args)           {}

 2.4方法练习

2.4.1测试方法

package cn.tedu.method;
/**本类用于测试方法*/
public class TestMethod {
	int a = 0;//成员变量
	//1.创建程序的入口函数
	public static void main(String[] args) {
		int a = 0;//局部变量 
		System.out.println(1);
		/**通过方法名+参数列表的方式来调用方法的功能**/
		method1();//调用方法
		System.out.println(2);
		method2(23);
		int result = method3(2,6);
		System.out.println(result);
		String x = method4(1,2,"3");
		System.out.println(x);
		
	}
	/**如果方法想要返回值，必须修改返回值类型
	 * 并且return对应类型的结果
	 * 如果方法的返回值类型是void，不容许有返回值*/
	/**用来测试方法的返回值类型*/
	public static int method3(int i, int j) {
		/**通过return关键字将方法结果返回到调用位置*/
		return i+j;
	}
	
	public static String method4(int i, int j, String s) {
		
		return i+j+s;
	}

	/**方法的修饰符 方法的返回值类型  方法名（方法参数）{方法体}*/
	/**测试方法调用顺序*/
	public static void method1() {
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
	}
	/**用来测试方法的参数，参数的位置在小括号里*/
	public static void method2(int a) {
		System.out.println("王林修道"+a+"年");
	}
}

2.5方法的重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。

程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。

2.5.1测试方法的重载

package cn.tedu.method;
/**本类用于测试方法的重载*/
public class TestMethodOverload {

	public static void main(String[] args) {
		/**我们根据方法名+参数列表确定具体调用哪个方法
		 * 方法的重载：
		 * 在同一个类中，存在方法名相同，但参数列表不同的方法
		 * 如果在同类中，同名方法的参数个数不同，一定构成重载，
		 * 如果在同类中，同名方法的参数个数不同，需要看对应位置上参数的类型，
		 * 而不是参数名，与参数名无关
		 * 
		 * (int i,String s)与(int s,String i)--不构成重载
		 *(int i,String s)与(String i,int s) --构成重载*/
		//2.调用方法。
		method();
		//4.调用method(int)
		method(2);
		//6.调用method(int String)
		method(3,"弹指间灰飞烟灭");

	}
	//1.创建一个无参的method()
	public static void method() {
		System.out.println("仙逆");
		
	}
	//3.创建一个含参的method(int)
	public static void method(int i) {
		System.out.println("求魔"+i);
		
	}	
	//5.创建一个含参的method(int i,String s)
	public static void method(int i,String s) {
		System.out.println("一念永恒"+i+"白小纯"+s);
		
	}	
	
}

2.6拓展

2.6.1&和&&的区别

当一个&表达式在求值的时候，两个操作数都会被求值，&&更像是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会计算第二个操作数。如果第一个操作数 取值为fale,第二个操作数就不会被求值。