JavaSE_day22(回顾之前，方法，数组，学生类以及测试，static静态关键字以及内存图解！！！)

1、A.java

package day22_20221119;

/*
 * 
 * 回顾之前：
 * 		
 * Java中的数据类型：
 * 			基本数据类型：4类8种
 * 						整数：byte short int long
 * 						浮点数:float double
 * 						字符:char
 * 						布尔:boolean
 * 
 * 			引用数据类型:
 * 					数组、类、接口（后面学）
 * 
 * 	基本数据类型的转换
 * 		自动类型转换：byte short char相加默认转成---int类型---long---float---double
	  		由小到大：小类型与大类型相加转成大类型
	  		byte b=10;
	  		int a=b;	
 * 			
 * 
 * 		强制类型转换：（有可能损失精度）
 * 			一般由大到小
 * 			int a=300
 * 			byte b=(byte)a;//有可能损失精度
 * 
 * 运算符
 * 		算术运算符
 * 			++，--
 * 			int a =10;
 * 			a++;
 * 			++a;
 * 			int a = 10;
 * 
 * 			int b = a++; b=10;  //++在后是先拿变量参与运算，然后再自增；
 * 			int b = ++a; b=11;  //++在前是自增完再参与运算 	
 * 		比较运算符
 * 			>,<,>=,<=,==,!=
 * 			比较运算的结果都是boolean类型
 * 			
 * 			
 * 		赋值运算符
 * 			+=
 * 			int a=10;
 * 			byte b=20;
 * 			b+=a;//b=b+a;
 * 			赋值运算符隐含了强制转换
 * 			
 * 		
 * 		逻辑运算符
 * 			连接boolean的表达式
 * 			&  |  ^
 * 			&& ||			
 * 			&&:有false则false，只要前面满足，后面不判断
 * 			||:有true则true，只要前面满足，后面不判断
 * 
 * 
 * */

public class A {
		
	public static void main(String[] args) {
			int a=10;
			byte b=20;
			b+=a;//b=(byte)(b+a)强制转换
//			b=a; 报错，这种无强制转换
			
	}
}

2、B.java

package day22_20221119;

/*
 * 需求：定义一个方法求两个数的和,并在主方法中调用
 * 
 * 方法：类中的一段具有特定功能的程序，提高了代码的复用性和可维护性
 * 定义格式：
 * 			public static 返回值类型（没有返回值就写void） 方法名(参数类型 参数名,参数类型 参数名2) {//形参
 * 				方法体;
 * 				}
 * 调用方式：口诀：输出赋值（调用）是有值，直接调用是void!
 * 		有明确返回值类型：
 * 					赋值调用，将方法的返回值赋值给一个变量  :int  res = addMethod(10,5);  //res=15
 * 					输出调用，使用输出语句直接输出方法的返回值:System.out.println("res:"+addMethod(10,5));
 * 					直接调用，没法获取方法的返回值  :比如直接用addMethod(10,5)虽然执行了这个方法，但是结果呢？？谁来输出?谁来显示?显然并没有！
 * 		没有明确返回值类型：
 * 					直接调用   ：比如直接调用soutMethod();执行方法即可（方法可以有sout语句直接输出到控制台，也可以没有，去做一些不用输出到控制台的基本操作！）
 * 
 * 方法重载：在一个类中有多个重名的方法，这些方法参数不同，和返回值类型无关
 * 
 * 注意：
 * 		形参：方法声明的变量，只能是变量，接收方法调用时传递进来的数据
 * 		实参：调用方法时传递的数据，可以是常量也可以是变量
 * 
 */



public class B {

	//以下代码报错啦，不是方法重载，参数列表和名字一样！，虽然返回数据类型不一样，但是这是无关的的！
	/*public int add(){
		return 0;
	}
	public double add(){
		return 0;
	}*/
	
	
	public static void main(String[] args) {
		//赋值调用
		int sum = sum(10,20);//实参
		System.out.println(sum);
		System.out.println("--------------");
		//输出调用
		int a = 10;
		int b = 20;
		System.out.println(sum(a,b));
	}
	
	public static int sum(int a,int b) {
		/*	
	  	//使用变量接收求和结果并返回
			int sum = a + b;
			return sum;
		*/
		
		//直接返回求和结果
			return a + b;
	}
}

3、C.java

package day22_20221119;

/*
 * 需求：定义一个元素类型为int的数组，遍历数组并求和
 * 		
 * 数组：用于存储多个元素的一种容器
 * 数组的特点:
 * 			元素类型必须一致
 * 			元素有整数索引
 * 			一旦定义好长度则无法改变（集合就不一样了，类似可变长度数组）
 * 			可以存储基本数据类型，也可以存储引用数据类型
 * 定义格式：
 * 			动态初始化
 * 				元素类型[] 数组名 = new 元素类型[10];
 * 			静态初始化
 * 				元素类型[] 数组名 = {元素1,元素2,元素3};
 * 				元素类型[] 数组名  = new 元素类型[]{元素1,元素2,元素3};
 * 
 */


public class C {
	
	public static void main(String[] args) {
		//使用静态初始化定义数组
		int[] arr = {1,2,3,4,5};
		//定义一个变量用于存储求和结果
		int sum = 0;
		/*
		String str="hell";
		str.length();
		*/
		//遍历数组，求和
		for(int x = 0;x < arr.length;x++) {//集合是size(),字符串长度是length()
			sum += arr[x];
		}
		System.out.println(sum);
	}
}

4、D.java

package day22_20221119;

/*
 * 定义一个标准的学生类，在主方法中创建对象并调用
 * 			姓名，年龄，性别3个成员变量
 * 			无参，有参两个构造方法
 * 			为每个成员变量定义getter/setter方法
 * 			定义一个show方法，输出成员变量
 */


public class D_Student {
	
	//面向对象三大特性之一：封装（继承，多态）
	private String name;//姓名
	private int age;//年龄
	private String gender;//性别
	
	
//以下内容：可以通过右键-Source	--根据需要便捷生成！
	//无参构造
	public D_Student() {}
	//有参构造
	public D_Student(String name,int age,String gender) {
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	
	//name
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	//age
	public int getAge() {
		return age;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	//gender
	public String getGender() {
		return gender;
	}
	
	public void setGender(String gender) {
		this.gender = gender;
	}
	
	//show：用于输出所有的成员变量
	public void show() {
		System.out.println(name + "," + age + "," + gender);
	}
}

package day22_20221119;

/*
 * D_Student的测试类，可以对类中的方法和属性进行操作！
 * 
 * */

public class D_StuTest {

	public static void main(String[] args) {
		//创建学生对象
		D_Student s = new D_Student();
		//为成员变量进行赋值
		s.setName("张三");
		s.setAge(18);
		s.setGender("男");
		s.show();
		
		System.out.println("----------");
		
		D_Student s2 = new D_Student("李四",20,"其他");
		s2.show();
		System.out.println("-----");
		System.out.println(s2.getName());
		System.out.println(s2.getAge());
		System.out.println(s2.getGender());
	}
}

5、E.java   

static:

        在同一个类中直接用变量或者方法名

        在不同类中用对象或者类名来调用变量或者方法 

package day22_20221119;
/*
 * 
 * static::静态关键字，他是一个关键字，用来修饰成员变量和成员方法
 * static特点：
 * 				被所有的对象所共享！
 * 				可以直接使用类名来调用
 * 				静态所修饰的成员加载优先于对象
 * 				随着类的加载而加载
 * 图解：
 */

public class E_Student {

		String name;
		int age;
		static String graduateFrom;//毕业院校
		static int a=10;
		
		public void show() {
			System.out.println(name + "," + age + "," + graduateFrom);
		}
	}

package day22_20221119;
/*
 * 
 * 测试类
 * 
 * static:静态关键字，他是一个关键字，用来修饰成员变量和成员方法
 * static特点：
 * 				被所有的对象所共享！
 * 				可以直接使用类名来调用
 * 				静态所修饰的成员"加载"优先于对象
 * 				随着类的加载而加载
 * 图解：
 * 
 * 
 */
public class E_StuTest {

	public static void main(String[] args) {
//		System.out.println("a1:"+E_Student.a);//优先加载，数值是10
		
//		E_Student.graduateFrom = "金灵教育"; //类名直接调用！
		
		//创建学生类的对象
		E_Student s = new E_Student();
		//为对象的成员变量进行赋值
		s.name = "小苍同学";
		s.age = 18;
		s.graduateFrom = "金灵教育1";  //对象直接调用！
		/*s.a=20;
		System.out.println("a2:"+s.a);  //改变a的值
		*/
		s.show();
		
		E_Student s2 = new E_Student();
		s2.name = "小波同学";
		s2.age = 20;
		s2.graduateFrom = "金灵教育2";  //对象直接调用！
		s2.show();
		/*s.a=20;
		System.out.println("a3:"+s.a);  //改变a的值
	*/
		System.out.println("-----");
		s.show();
	/*	s.a=20;
		System.out.println("a4:"+s.a);  //改变a的值
	*/
	}
}

static内存图解：