一.复习一下
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;//长整型以大L结尾
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();
}
}
}