JAVA萌新学习day5

一.复习一下

import java.util.Random;
import java.util.Scanner;
public class ReviewDemo{
	public static void main(String[] args){
		System.out.println("第一周复习");
		
		
		
		//方法的调用
		//变量使用的方法调用
		//variableUse();
		//运算符方法的调用
		//operatorUse();
		//operatorUse2();
		//if else 使用
		//ifDemo();
		//switchUse();
		//forUse();
		//whileUse();
		//doWhileUse();
	
	}
	//一个类中可以写很多方法
	/*
	声明了一个无参数无返回值的方法，方法名叫variableUse
	*/
	//第二天，变量的使用
	public static void variableUse(){
		
		System.out.println("variableUse变量的使用");
		
		System.out.println("基础类型变量使用演示");
		/*
		1. 变量：计算机的本质是处理数据，要想向计算机中保存数据(处理数据)，需要先申请一块内存空间，
		用来存储数据，每一块申请的空间有一个地址，是一个十六进制数，比如0x1234.
			因为内存地址不方便记，所以我们需要给地址起一个名字，这个地址中可以保存指定类型的数据
			通过起的名字，就可以在内存中找到保存的数据
			
			我们管 起的这个名字 叫变量
			变量 都是有类型的 什么类型的变量，保存什么类型的数据
			基本类型变量有四类八种
			整型 byte short int long
			浮点型 float double
			字符型 char  '6'  'y'
			布尔型 boolean
		
		*/
		//整型变量声明
		
		//变量声明的格式   变量类型 空格 变量名 =  变量值;
		byte byteVariable =  1;
		
		byteVariable= 2;
		
		byteVariable++;
		System.out.println(byteVariable);
		
		//3
		
		byteVariable= 20;
		
		
		
		short shortVariable = 20;
		int age = 18;
		long year =  2060L;//长整型以大Ｌ结尾
		System.out.println(byteVariable);
		System.out.println(shortVariable);
		System.out.println(age);
		System.out.println(year);
		//浮点型
		float floatVariable = 1.23F;
		double doubleVariable = 3.141;
		System.out.println(floatVariable);
		System.out.println(doubleVariable);
		//字符型
		char sex = '男';
		System.out.println(sex);
		//布尔型
		boolean flag = true;  //或 false
		System.out.println(flag);
		
		char aValue = 97;
		System.out.println(aValue);
		
		//变量 有自己的生命周期，有效范围 超过有效范围，就不能再使用这个变量
		//变量在自己的作用范围内（有效范围或叫作用域）不能有和自己同名的变量
		//变量声明后可以多次赋值和修改值
		int newAge =  18;
		//int newAge ;
		
		aValue = 10;
		
		newAge = 20;
		
		System.out.println("newAge的值是:" + newAge);
		
		System.out.println("做真实的自己，" + "用良心做教育");
		
		//如果 加号两边的变量至少有一个是字符串，那么加号的功能 就是字符串连接符
		//如果 加号两边的变量是数字类型 那么加号的功能 就是 数学上的求和
		System.out.println("1 +  2  = " + (1+2) );
		
		int count = 1800;
		//强制类型转换 语法为 在小括号中加上要转换成的类型
		//强制类型转换的前提是, 我们明确知道，这次转换不会丢失数据
		//大数据转小类型的时候，需要强转
		byte byteI = (byte)count;
		
		byte byteA = 20;
		//小类型数据保存到大类型变量中，自动提升类型
		int newCount = byteA;
		
		//参与运算的变量，都会提升为和最大类型相批配的类型
		//比如 int+short  short类型会自动提升为int
		
		
		System.out.println(byteI);
		
	}
	//第二天，算术运算符的使用
	public static void operatorUse(){
		System.out.println("基本运算符使用演示");
		//算术运算符  加+ 减- 乘* 除/ 取模% 自增++ 自减--
		//定义一个整型变量,变量名为firstNumber,赋值为100
		int firstNumber = 100;
		//求两个firstNumber相加的结果
		int count = firstNumber + firstNumber;
		System.out.println("两个firstNumber相加的结果是:" + count);
		//求两个firstNumber相减的结果
		//因为count变量已经定义过，所以不能再次定义，可以直接使用，重新赋值
		count = firstNumber - firstNumber;
		System.out.println("两个firstNumber相减的结果是:" + count);
		//求两个firstNumber相乘的结果
		count = firstNumber * firstNumber;
		System.out.println("两个firstNumber相乘的结果是:" + count);
		//求两个firstNumber相除的结果，相除结果是商的值
		count = firstNumber / firstNumber;
		System.out.println("两个firstNumber相除的结果是:" + count);
		//相除举例
		int  testNumber = 10/3;
		System.out.println("10/3=" + testNumber);
		//求firstNumber除以7的余数是多少(取模运算符),和商无关
		count = firstNumber % 7;
		System.out.println("firstNumber % 7结果为:" + count);
		//自增运算符 ++,分为前自增和后自增，
		//前自增的意思是，在变量参与运算前加一后，再参与运算
		//后自增的意思是，在变量参与运算后加一
		//定义一个整型变量 变量名为 maxNumber,赋值为10
		int maxNumber = 10;
		int tempNumber = maxNumber++;//后自增，后加加
		System.out.println("tempNumber="+tempNumber);
		System.out.println("maxNumber="+maxNumber);
		tempNumber = ++maxNumber;//前自增，使用前自已加一后再参与运算
		System.out.println("tempNumber="+tempNumber);
		System.out.println("maxNumber="+maxNumber);
		//自减运算符 --，分为前自减和后自减，
		//前自减的意思是，在变量参与运算前减一后，再参与运算
		//后自减的意思是，在变量参与运算后减一
		tempNumber = maxNumber--;//后自减，使用后自已减一
		System.out.println("tempNumber="+tempNumber);
		System.out.println("maxNumber="+maxNumber);
		//前自减的意思是，在变量参与运算前减一后再参与运算
		tempNumber = --maxNumber;//前自减，自已减一后参与运算
		System.out.println("tempNumber="+tempNumber);
		System.out.println("maxNumber="+maxNumber);
	}

	public static void operatorUse2(){
		System.out.println("赋值运算符使用");
		//基本赋值
		int firstNumber = 10;
		System.out.println("firstNumber=" + firstNumber);
		//简化组合赋值
		int tempNumber=10 ;
		tempNumber += 5;//相当于  tempNumber = tempNumber + 5;
		System.out.println("tempNumber=" + tempNumber);
		tempNumber -= 5;//相当于  tempNumber = tempNumber - 5;
		
		
		System.out.println("tempNumber=" + tempNumber);
		tempNumber *= 5;//相当于  tempNumber = tempNumber * 5;
		System.out.println("tempNumber=" + tempNumber);
		tempNumber /= 5;//相当于  tempNumber = tempNumber / 5;
		System.out.println("tempNumber=" + tempNumber);
		tempNumber %= 5;//相当于  tempNumber = tempNumber % 5;
		System.out.println("tempNumber=" + tempNumber);
		
		System.out.println("关系运算符使用");
		//关系运算符比较后的结果是布尔值 true  或 false
		int secondNumber = 20;
		
		boolean result = secondNumber > firstNumber;
		System.out.println("secondNumber > firstNumber:"+ result);
		result = secondNumber < firstNumber;
		System.out.println("secondNumber < firstNumber:"+ result);
		//等于用双等号
		result = (secondNumber == firstNumber);
		System.out.println("secondNumber == firstNumber:"+ result);
		result = (secondNumber != firstNumber);
		System.out.println("secondNumber != firstNumber:"+ result);
		//修改secondNumber的值为10
		secondNumber = 10;
		result = secondNumber <= firstNumber;
		System.out.println("secondNumber <= firstNumber:"+ result);
		result = secondNumber >= firstNumber;
		System.out.println("secondNumber >= firstNumber:"+ result);
		
		//逻辑运算符 参与逻辑运算的变量需要为布尔类型
		//逻辑与 两个变量或表达式同时为真时结果为真，否则为假
		boolean flag = true & false;
		System.out.println("true & true=" + flag);
		//逻辑或 两个变量或表达式有一个为真时结果为真，否则为假
		flag = false | false;
		System.out.println("true | false=" + flag);
		//逻辑非 变量或表达式的值为真时，结果为假，为假时结果为真
		flag =	!false;
		System.out.println(" !false=" + flag);
		//逻辑异或 两个变量或表达式相同时为假，不相同为真
		flag =	true^false;
		System.out.println(" true^false=" + flag);
		//如果参与逻辑运算的是表达式，会优先把表达式的值计算出来，用结果的
		//逻辑值再参与运算
		int a = 10;
		int b = 5;
		boolean x = a>b;
		boolean y = 4<8;
		
		flag = a>b & 4<8;//x & y
		System.out.println(" a>b & 4<8 =" + flag);
		
		//短路与 当第一个表达式结果为假的时候，不会计算第二个表达式的值
		//（相当于忽略第二个表达式，也就是第二个表达式不会参与运算）
		int aNumber = 10;
		int bNumber = 20;
		//短路或 当第一个表达式结果为真的时候不会计算第二个表达式的值
		//（相当于忽略第二个表达式，也就是第二个表达式不会参与运算）
		//aNumber++;
		//&&
		boolean resultFlag = aNumber<bNumber || aNumber++>0;
		System.out.println(" resultFlag =" + resultFlag);
		
		System.out.println(" aNumber =" + aNumber);
		
		//三目运算符
		//执行规则，先计算第一个表达式的值（结果需要为布尔值），如果为真，则整个表达式
		//的值为冒号前面表达式（第二个表达式）的值，否则结果为冒号后面表达式（第三个表达
		//式）的值
		//结果   =   第一个表达式？第二个表达式：第三个表达式
		
		
		int cNumber = aNumber>bNumber ? 50:100;
		System.out.println(" cNumber =" + cNumber);
		
		int score = 60;
		//双引号括起来的为字符串
		String str = score>85?"优秀": (score>75?"良好":"及格");
		System.out.println(" str =" + str);
		
		System.out.println("第一个数:" + 1 +",第二个数："+aNumber );
		
		//第一个数:1,第二个数：10
		int a1= 10,a2=20,a3=30;
		int s = a1+a2+a3;
		// a1+a2+a3=60  10+20+30 = 60
		System.out.println(a1+ "+" + a2 + "+" +a3 + "=" +  (a1+a2+a3) );
		//System.out.println("a1+a2+a3="+ s);
	}
	public static void ifDemo(){
		System.out.println("选择语句的基本使用");
		//第一种格式 只有if语句
		//定义一个整型变量age，赋值为22
		int age =20;
		//格式：if 后面是小括号，小括号里面是一个逻辑表达式，后面是一对大括号
		//如果逻辑表达式的值为真，则执行大括号里的代码，否则跳过
		if(age>=20 && age<30){
			System.out.println("age=" + age);
		}
		System.out.println("程序继续执行");
		System.out.println("...时间过了三年");
		age = age + 3;
		//第二种格式,在第一种格式基础上多了一个else语句，else后面跟一对大括号
		//如果if语句小括号中的表达式的值为假，则执行else语句中的代码
		if(age == 23){
			System.out.println("恭喜，最佳年龄");
		}
		else{
			System.out.println("恭喜，正常年龄");
		}
		//第三方格式 if    else if    else
		//执行规则:先检查if语句的条件，如果为真，执行if语句中的代码
		//如果为假，检查第二个else if语句的条件，如果为真，执行里面的代码
		//如果为假，执行后面的检查
		//if和else语句同一级别只能有一个，但else if可以有任意多个
		//如果某一个语句条件为真，其它语句不会再执行
		if(age < 20){
			System.out.println("年龄太小，不符合规定");
			/* if(a<10){
				System.out.println("小学没毕业");
			} */
		}
		else if(age>=30){
			System.out.println("年龄太大，不符合规定");
		}
		else if(age>=10){
			System.out.println("没有执行");
		}
		else{
			System.out.println("年龄适合");
		}
		
		//产生两个1-6的随机数
		//首先判断出是大还是小
		//如果小于等于6，我们再判断是否小于3，如果小于，打印出两个数分别是多少
		//如果大于6，我们再判断这两个数是否相等，如果相等打印出这个数，否则
		//打印出这两个数
		//创建一个随机数产生对象
		Random random = new Random();
		//int    random = 10;
		//产生两个1-6的随机数
		int firstNumber = random.nextInt(6)+1;
		int secondNumber = random.nextInt(6)+1;
		//计算两个数的和
		int sum = firstNumber + secondNumber;
		if(sum<=6){
			if(sum<3){
				System.out.println("sum=" + sum);
				//System.out.println("firstNumber:" + firstNumber+",secondNumber"+secondNumber);
			}
			else{
				System.out.println("sum=" + sum);
			}
		}
		else{
			if(firstNumber == secondNumber){
				System.out.println("firstNumber=" + firstNumber);
			}
			else{
				
				System.out.println("firstNumber:" + firstNumber+",secondNumber"+secondNumber);
			}
		}
	}

	public static void switchUse(){
		//定义一个变量，代表月份
		int month = 10;
		//switch语句说明
		/*
		1.switch后面的小括号是一个表达式，类型可以是byte short int char String
		2.case关键字后面是 常量,表示某种可能或条件
		3.当某一个case的常量值和表达式值相同，就执行此case语句
		4.break关键字为跳出，也就是不再执行其它case语句
		5.所有case子句的常量值不能重复
		*/
		switch(month){
			case 4:
				//break;
			case 6:
				//break;
			case 9:
				//break;
			case 11:
				System.out.println(month+"月有30天");
				int a=10;//代表n行代码，无实际作用
				break;
			case 1:
			case 3:
			case 5:
			case 7:
			case 8:
			case 10:
			case 12:
				System.out.println(month+"月有31天");
				int b=10;//代表n行代码，无实际作用
				break;
			case 2:
				System.out.println(month+"月有28或29天");
				break;
			default:
				System.out.println("你是地球人吗？");
				break;
		}
	}

	public static void forUse(){
		System.out.println("For循环的基本使用");
		
		/*
		for(表达式1 ; 表达式2; 表达式3){
			循环体代码
		}
		表达式1 为 循环的初值（初始条件）
		表达式2 为 循环结束的条件
		表达式3 为 改变循环的条件（触发循环变量改变的条件）
		1.执行过程：先执行表达式1，后检查表达式2，如果表达式2的值为真，则执行循环
		体，接着执行表达式3，再次检查表达式2，如果为真，继续执行循环体，如果为假，
		结束循环
		*/
		//输出1-100间能被三整除的数的个数和能同时被3和5整除的数的个数
		// 28888512
		int a3 = 0;
		int a35 = 0; 
		for(int i=0 ; i<100; i++){
			System.out.print( i+ " ");
			if((i+1)%10==0){
				System.out.println();
			}
			if(i%3==0){
				int number = 10;//用户输入
				//int number = 10;//用户输入
				 a3++;
			}
			//int number = 10;//用户输入
			if(i%3==0&&i%5==0){
				a35++;
			}
		}
		int d = 4;
		int e =5;
		
		int c= add(d,e);
		
		add(9,5);
		
		c = add(10,5);
		
		System.out.println("100以内能被3整除的数有:" + a3 + "个");
		System.out.println("100以内能被3和5同时整除的数有:" + a35 + "个");
	}
	//方法声明中的参数，形参,调用方法时的传的值，叫实参
	public static String add(Stirng a,int b){
		
		String  c = "" + (a+b)  ;//= a+b;
		
		return c;
		
	}
	public static void whileUse(){
		System.out.println("While循环基本使用");
		//打印1-100自然数的和
		/*
		1.循环的初始条件，即定义循环变量，并赋初值
		2.循环的结束条件（小括号中的条件表达式）
		3.循环体的实现，在大括号中写实现的逻辑代码
		4.循环体需要有触发循环结束的条件，即循环变量改变的条件
		5.while循环执行过程，先计算条件表达式的值，如果为真，执行循环体，然后再次
		计算条件表达式的值，如果为真，再次执行循环体（只要为直一直重复），否则结束
		6.如果想提前结束循环，使用break语句
		*/
		//定义变量i,赋值为1,从自然数1开始累加
		int i = 1;
		//定义变量sum,赋值为0,用来记录最后的结果
		int sum = 0;
		//循环开始，检查条件是否为真
		while(i<=100){
			//将当前的数加到最后的结果sum中
			sum = sum + i;
			//修改循环变量的值，即触发循环条件的改变，避免死循环
			i++;
			//int a =0;
		}
		System.out.println("1-100自然数的和是:" + sum);
		//打印1-100以内自然数 所有奇数的和
		int j = 1;
		int sum2 = 0;
		while(j<=100){
			if(j%2!=0){
				sum2 += j;
			}
			j++;
		}
		System.out.println("1-100自然数的奇数和是:" + sum2);
		
		//打印1-100以内自然数 所有偶数的和
		j = 1;
		sum2 = 0;
		while(j<=100){
			if(j%2!=0){
				//跳过本次循环，执行下一次，即再次检查循环条件
				j++;
				continue;
			}
			else{
				sum2 += j;
				j++;
			}	
		}
		System.out.println("1-100自然数的偶数和是:" + sum2);
	}
	
	public static void doWhileUse(){
		System.out.println("DoWhile循环基本使用");
		/*
		语法格式：do{循环体代码}while(条件表达式);
		1.执行流程：先执行do关键字后面大括号中的 代码
		  然后检查while后面的 条件表达式 的值
		  如果为真，再次执行 循环体代码，否则结束循环
		2.与while循环相比，dowhile至少会执行一次
		*/
		//打印1-100以内能同时被3和5整除的数
		int i = 1;
		
		//如何输出类似效果:15+30+45+60+75+90=315
		int sum = 0;
		String info = "";
		
		boolean state = true;//第一次
		
		do{
			//同时被3和5整除的数
			if(i%3==0 && i%5==0){
				sum += i;
				//continue
				//break;
				
				if(state){
					info =  info + i ;
					state = false;
				}
				else{
					info =  info +"+"+ i ;
				}
				//state = false;
				
				System.out.println("同时被3和5整除的数是："+ i);
			}
			i++;//触发循环结束的条件变化
		
		}while(i<100);
		System.out.println(info + "=" + sum);
	}
}

二.先做个小题

/*
1.接收用户输入一个2-6的整数，比如输入5
2.计算 5+55+555+5555+55555 = ？
*/
//导入就收处理键盘输入类所在的包
import java.util.Scanner;

public class ReviewTest
{
	public static void main(String[] args)
	{
		//创建一个Scanner类的对象，类似声明一个变量
		Scanner input = new Scanner(System.in);
		//提示信息，告知用户如何操作
		System.out.println("请输入一个2-6的整数:");
		//调用nextInt方法，获得用户输入的数字
		int number = input.nextInt();
		
		String str = addNumber(number);
		
		System.out.println(str);
	}
	
	//输入5，输出5+55+555+5555+55555 = ？
	public static String addNumber(int number)
	{
		
		String str = " ";
		int sum = 0;
		
		for(int i = 1 ; i <= number ; i++)
		{
			int result = resultByIndex(i , number);
			sum += result;
			if(i != 1)
			{
				str = str + "+" + result;
			}
			else
			{
				str = str + result;
			}
		}
		str = str + "=" + sum;
		
		return str;
	}
	
	public static int resultByIndex(int i , int number)
	{
		switch(i)
		{
			case 1:
				return number;
			case 2:
				return number*10+number;
			case 3:
				return number*100+number*10+number;
			case 4:
				return number*1000+number*100+number*10+number;
			case 5:
				return number*10000+number*1000+number*100+number*10+number;
			case 6:
				return number*100000+number*10000+number*1000+number*100+number*10+number;
				
		}
		
		return 0;
	}
}

当然根据今天的学习，我们还有第二种方法

/*
1.接收用户输入一个2-6的整数，比如输入5
2.计算   5+55+555+5555+55555 = ?

n
   1+2+3+4= ?

   
*/
//导入接收处理键盘输入类所在的包
import java.util.Scanner;

public class ReviewTest{
	public static void main(String[] args){
		//创建一个Scanner类的对象，类似声明一个变量
		Scanner input = new Scanner(System.in);
		//提示信息，告知用户如何操作
		System.out.println("请输入一个2-6的整数：比如输入4");
		//获得用户输入的数字
		int number = input.nextInt();
		
		String str = addNumber(number);
		
		System.out.println(str);
		
	}
	//输入5,输出5+55+555+5555+55555 = ?
	public static String addNumber(int number){
		
		String str="";
		int sum = 0;
		
		for(int i=1;i<=number;i++){
			int result =  resultByIndex(i,number);
			sum += result;
			if(i!=1){
				str= str+ "+" +result;
			}
			else{
				str= str +result;
			}
		}
		str = str + "=" + sum;
		
		return str;
	}
	
	public static int resultByIndex(int i,int number){
		
		int resultNumber = 0;
		int tempValue =1;
		for(int j=1;j<=i;j++){
			tempValue= power(j-1) *number;
			resultNumber += tempValue;
		}
		return resultNumber;
		
		/* switch(i){
			case 1:
				return number;
			case 2:
				return number*10+number;
			case 3:
				return number*100+number*10+number;
			case 4:
				return number*1000+number*100+number*10+number;
			case 5:
				return number*10000+number*1000+number*100+number*10+number;
			case 6:
				return number*100000+number*10000+number*1000+number*100+number*10+number;
		} */
		
		//return 0;
	}
	public static int power(int power){
		int result=1;
		if(power==0){
			return 1;
		}
		for(int i=0;i<power;i++){
			result*=10;
		}
		return result;
	}
}

三.继续做个小题

//实现 5+55+555+5555+55555 = ?
public class Test
{
	public static void main(String[] args)
	{
		int number = 5;
		
		//1+2+3+4+5 = 15
		//5+55+555+5555+55555 = ?
		//1!+2!+3!+4!+5!
		
		int sum = 0;
		String str = " ";
		
		for(int i = 1 ; i <= number ; i++)
		{
			sum += numberbyi(i);
			
			str = str + i;
		}
	}
	public static int numberbyi(int i)
	{
		return 0;
	}
}

四.方法的基本使用

//方法的基本使用

/*
方法的执行过程
当程序中遇到调用的方法时，程序执行转移到方法内的代码，当方法内的代码
执行完成或遇到return语句方法执行结束，返回方法调用的地方继续执行后续
代码。
*/

public class MethodDemo
{
	public static void main(String[] args)
	{
		System.out.println("方法的基本使用");
		/*
		第一个无参数无返回值的方法调用
		调用的语法：方法名，后面跟一对空的小括号
		*/
		firstMethod();
		
		/*
		第二个无参数有返回值的方法调用
		如果想保存方法返回的结果，就需要声明和返回值类型相同的变量来接收
		*/
		int number = secondMethod();
		
		/*
		第三个有参数无返回值的方法调用
		需要根据形参类型，传递一个实参数值
		*/
		number = 10;
		thirdMethod(9);
		thirdMethod(number);
		System.out.println(number);
		
		/*
		第四个有参数有返回值的方法调用
		*/
		//如果不需要结果，就不需要用变量接收
		add(4,5);
		int sum = add(6,7);
		System.out.println("sum" + sum);
	}
	
	//1.无参数无返回值的方法声明
	/*
	public关键字为声明公有方法，static关键字为声明静态方法
	void说明方法无返回值firstMethod为方法的名字，由我们定义，像变量名一样
	方法名后面的小括号中为参数列表，如果什么都不写就是没有任何参数
	*/
	public static void firstMethod()
	{
		System.out.println("我是无参无返回值的方法调用");
	}
	
	//2.有返回值无参数的方法
	public static int secondMethod()
	{
		System.out.println("我是无参有返回值的方法调用");
		return 10;
	}
	
	//3.有一个参数无返回值的方法
	public static void thirdMethod(int number)
	{
		number++;
		System.out.println("我是有参数无返回值的方法调用，参数值是" + number);
	}
	
	//4.有参数有返回值的方法
	public static int add(int a, int b)
	{
		System.out.println("add:" + a + "," + b);
		return a + b;
	}
}

五.还是来做个小题把

import java.util.Scanner;

public class HomeWork
{
	public static void main(String[] args)
	{
		System.out.println("做一个乘法表");
		
		Scanner str = new Scanner(System.in);
		System.out.println("请输入1-9的数字：");
		int number = str.nextInt();
		
		if(number > 9)
		{
			System.out.println("你还是个人？");
			
		}
		else
		{
			thirdMethod(number);
		
		}
		
		
	}
	public static void thirdMethod(int a)
	{
		for(int i = 1;i <= a; i++)
		{
			for(int j = 1; j <= i; j++)
			{
				System.out.print( j + "*" + i + "=" + ( j * i) + " " );
			}
			System.out.println();
		}
	}
}