day03基础3--运算符、成员变量、局部变量、方法

1.运算符

 

1）概念：用于连接表达式的操作数并对操作数执行运算

2）运算符分为5种：

算术运算符、关系运算符、逻辑运算符、复合赋值运算符、三目（条件）运算符

优先级：有括号先算括号里的

1.1算术运算符

整除（/）--只取整数，小数位舍去

取余（%）--取余数，舍去整数

1.2关系（比较）运算符

>  <   >=   <=  !=（不等于）  ==(等于)

输出的结果是boolean类型，结果true/false

1.3逻辑运算符

||（或，shift+backspace下方的键位两次）

1. &&短路与：第一条件为false，第二条件忽略，直接判断为false，&单与：两条件都要执行
2. ||短路或：第一条件为true，第二条件忽略，直接判断为false，单|或：两条件都执行

练习：求平年闰年

package cn.tedu.basic;
import java.util.Scanner;
/*需求：接受用户输入的年份，判断平年闰年
 *1. 四年一闰且百年不闰（能被4整除且不能被100整除）
 *2.或者是四百年一闰（或者能被400整除）
 */
public class TestYear {
	//0.创建程序入口main函数
	public static void main(String[] args) {
	//1.提示用户输入年份
		System.out.println("请输入年份：");
		//扫描键入的内容
		int year = new Scanner(System.in).nextInt();
	//2.定义一个变量用于保存最终结果
		String result = "平年";
	//3.判断是平年还是闰年
		//if(判断条件){符合判断条件后才执行的代码}
		/**解决方案二*/
		//if((小条件1 && 小条件2) || 条件2 ){}
		if((year%4==0 && year%100 != 0) || year%400 == 0) {
			result ="闰年";
		}
		System.out.println(year+"年是"+result);	
	}
}

1.4复合赋值运算符：

1）拼接运算符

1. “+”拼接运算符，输出的结果是String类型
2. 乘（*）或者整除（/）或者%算数运算符高于拼接运算符+，可先运算再拼接
3. +或-则不能在String类型后运算
4. 例子：System.out.println(1+2+3+""+1+2/3);//610
5.          System.out.println(1+2+3+""+1+2+3)//6123

2）赋值运算符

隐式自动转换，把运算结果自动强制转换成赋值变量的类型
算数运算符的优先级大于赋值运算符，运算过程中若有算术运算符要先算，最后再进行赋值运算符运算
例子： Int a =5,b=6;
System.out.println(a*=b+10);
先算b+10=16，再算a=a*16

1.5条件（三目）运算符

格式：条件？表达式1 ：表达式2

条件为true执行表达式1，条件为false执行表达式2

练习：求两个数的最大值

package cn.tedu.basic;

import java.util.Scanner;

/*
*@author 学生：Q
*@vesion ：java1.8.131
*创建时间：2021年6月2日 下午2:25:16
*/
/*需求：接受用户输入的两个整数，比较并输出两者之间的最大值*/
public class TestMaxNumber {
	//0.创建程序入口函数main()
	public static void main(String[] args) {
	//1.提示接收用户输入的数据
		System.out.println("请输入您要比较的第一个数：");
		int a = new Scanner(System.in).nextInt();
		System.out.println("请输入您要比较的第二个数：");
		int b = new Scanner(System.in).nextInt();
		/*三目运算符：表达式？true：false;*/
		//定义一个变量用来保存最大值
		int max = a>b?a:b; 
		System.out.println("最大值是："+max);
		//定义一个变量用来保存最小值
		int min = a>b?b:a;
		System.out.println("最小值是："+min);
		//思考题：
		//若接收三个数字，请比较并输出最大值
		System.out.println("请输入您要比较的第三个数：");
		int c = new Scanner(System.in).nextInt();
		int maxNumber = (a>b?a:b)>c?(a>b?a:b):c;
		System.out.println("最大值是："+maxNumber);
		int minNumber = (a>b?b:a)>c?c:(a>b?b:a);
		System.out.println("最小值是："+minNumber);
		
	}

}

2.方法

1）概念：被命名的代码块,方法可以含参数也可不含参数,可以提高代码的复用性。

2）格式：

3）方法调用顺序图

2.1方法调用的返回值

练习：方法的调用/顺序/返回值

package cn.tedu.method;
/*本类用于测试方法的特性*/
public class TestMethod {
	//1.创建程序入口函数main方法
	public static void main(String[] args) {
	/*通过方法名+参数列表来确定具体调用哪个方法*/
		System.out.println(1);
		method1();
		System.out.println(2);//方法调用有顺序
		method2(10);//光标放在method2上，选择Create method2(),可创建一个方法2
		//method3(1,2);//3
		int result = method3(1,2);/*把返回值返回到调用位置，3赋值给了result*/
		System.out.println(result);//3
	}
	//本方法用于测试方法的返回值，若方法有返回值，可以设置返回值类型
	//若设置了返回值类型，必须在方法里使用return关键字返回对应类型的结果
    private static int method3(int i, int j) {//返回值类型的替换：int替换void，下面加return
		System.out.println(i+j);//3
		return i+j;//3
	}
	//本方法用于测试方法的参数，参数的位置在方法名后的小括号里中
	//格式：(参数类型  参数名)，只有方法定义了参数，调用参数时才能传参数
	private static void method2(int a) {//参数的定义要一致
		System.out.println(a*a);
	}

	//2.创建自定义方法，以及方法的调用顺序。但打印输出还是要在main方法里，这个过程叫调用
	/*方法定义的格式：方法的修饰符    方法的返回值类型   方法名（方法的参数）{方法体}*/
	public static void method1() {//static是因为main方法里有，保持一致
		System.out.println(5);
		System.out.println(6);
		System.out.println(7);
		
	}
}

注意：返回值类型void如果被其他类型替代，方法里都会retrun同样的类型

比如int代替void，return返回的也是int类型

2.2方法的重载

1）重载的定义：在同一个类中存在多个同名的方法，但它们的参数列表（参数个数+数据类型）各不相同的现象

2）注意：程序在调用方法时,可以通过传递给他们的不同个数和不同类型的参数来决定具体调用哪个方法.

练习：同类多个同名方法的重载现象

package cn.tedu.method;
//本类用于测试方法的重载
public class TestMethodOverload {
	//0.创建程序入口main函数
	public static void main(String[] args) {
		/*1.根据  方法名+参数列表  来确定具体调用哪个方法*/
		/*2.方法的重载的定义：
		 * 在同一个类中，存在多个同名的方法，但参数列表（参数的个数和类型）不同的方法
		 * 若在一个类中存在多个同名方法，方法的参数个数不同，一定构成重载，例如f();和f(666);
		 * 若在一个类中存在多个同名方法，方法的参数个数相同，需要查看对应位置上的类型(类型相同，不构成重载，类型不同，构成重载),与参数无关
		 * 例如：f(String a,int b)  f(String b ,int a)---不构成重载，调用时无法判断该调用哪一个
		 * f(String a ,int b) f(int a，String b) ---构成重载
		 * 注意：方法的重载看的是参数的类型，与参数的名字无关
		 */
//		f();
//		f(666);
		f("皮皮虾",3);
		f(6,"下班");
	}
	    //3.创建一个f(String,int),含有一个String和一个int类型参数的f方法
	    private static void f(String string, int i) {
		System.out.println(string+"今晚吃了"+i+"碗米饭！");	
	}
	    private static void f( int string,String i) {
			System.out.println(string+"点"+i);//和上一个方法重载了,不会被f("皮皮虾",3);调用
	}
		//2.创建一个f(int),含有一个int类型参数的f方法
        private static void f(int i) {
		System.out.println("有参数"+i);		
	}
		//1.创建一个无参的f()方法
	    private static void f() {
		System.out.println("无参数~");		
	}
}

2.3方法的重写与重载区别:

1）重载:在同一个类中,存在方法名相同,但参数列表不同的方法

参数列表不同是指:参数个数不同/对应位置上的参数类型不同,与参数名无关

2）重写:发生在两个类中,子类继承父类，对父类方法进行修改，规则：两同两小一大

3.成员变量和局部变量

3.1成员变量

1. 定义：在类里，在方法外的变量被称为成员变量，
2. 注意：成员变量可以不用初始化赋值，有默认值
3. 作用域：整个类中,类消失了,变量才会释放

   

   练习：成员变量的默认值

package cn.tedu.basic;
/*本类用于测试各种类型的默认值*/
public class TestVarvirble {
	//在类中，在方法外的变量被称为成员变量，成员变量可以不用初始化赋值
	static String name;
	static byte a;
	static short b;
	static int c;
	static long d;
	static float e;
	static double f;
	static char g;
	static boolean h;
	
	public static void main(String[] args) {
		System.out.println(name);//引用类型默认值null
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);//整数类型默认值0
		System.out.println(e);
		System.out.println(f);//浮点型默认值0.0
		System.out.println(g);//char类型默认值/u0000，打印输出是空格
		System.out.println(h);//boolean类型默认值false
	}
}

3.2局部变量

1. 定义：在方法内或者局部代码块中
2. 注意：必须手动初始化赋值，也可以先定义类型再赋值
3. 作用范围：作用在方法里或者局部代码块中，方法运行完毕，局部变量才会消失

3.3成员变量与局部变量的区别

注意：当成员变量和局部变量同名时，变量的赋值会采用就近原则

练习：同名成员变量与局部变量测试

package cn.tedu.basic;
/*本类用于测试成员变量和局部变量*/
public class TestVarvirble2 {
	//2.定义成员变量
	/*1)位置：类里方法外
	 *2)使用时，可不初始化赋值，会自动赋予对应类型的默认值
	 *3)作用范围：整个类中都生效，类消失，成员变量才消失
	 */
	static int sum;
	static int a ;
	//1.创建程序入口函数main()
	public static void main(String[] args) {
		//3.定义局部变量
		/*1)位置：方法里或者局部代码块中
		 *2)使用时，局部变量必须手动初始化(自己赋值)
		 *3)作用范围：在方法里，方法结束，局部变量释放
		 */
		int a = 0;
		int sum = 100;
		//变量使用规则：就近原则
		System.out.println(sum);//100
		System.out.println(a);//0
	}	
}