java零基础学习笔记(代码+注解+练习)_java语言基础

package day01; //声明包day01(楼+单元)
public class HelloWorld { //声明类HelloWorld(房子)
	//主方法，为程序的入口(大门口)
	//程序的执行从main开始，main结束则程序结束
	public static void main(String[] args) {
		//输出hello
		//1)严格区分大小写
		//2)所有符号必须是英文模式的
		//3)每句话必须以分号结尾
		//4)println():输出并换行   helloworld
		//  print():输出不换行
		System.out.print("hello"); //双引号中的原样输出
		System.out.println("world");
		System.out.println("下雨啦!");
		System.out.println("欢迎大家");
		System.out.println("当日事当日毕");
	}
}

package day02;
//数据类型的演示
public class DataTypeDemo {
	public static void main(String[] args) {
		//类型间的转换:
		int a = 5;
		long b = a; //自动类型转换
		int c = (int)b; //强制类型转换
		
		long d = 5; //自动类型转换
		double e = 5; //自动类型转换(e的值为5.0)
		
		long f = 10000000000L;
		int g = (int)f;
		System.out.println(g); //强转有可能发生溢出
		double h = 56.987;
		int i = (int)h;
		System.out.println(i); //56，强转有可能丢失精度
		
/*
2.1)整数直接量可以直接赋值给byte,short,char，
        但不能超出范围
2.2)byte,short,char型数据参与运算时，
       系统会一律先将其转换为int再运算
*/		
		byte b1 = 5;
		byte b2 = 6;
		//byte b3 = b1+b2; //编译错误,运算时将b1和b2转成int类型，
		                   //两个int相加，结果还是int类型，
		                   //将int赋值给byte，因为不是直接量，
		                   //所以需要强转
		byte b4 = (byte)(b1+b2); //强转的是运算之后的int结果

		
		/*
		//1)int:整型，4个字节，-21个多亿到21个多亿
		int a = 250; //250为整数直接量，默认为int类型
		//int b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
		//int c = 25.678; //编译错误，整型变量中只能装整数
		System.out.println(5/2); //2
		System.out.println(2/5); //0
		System.out.println(5/2.0); //2.5
		int d = 2147483647; //int的最大值
		d = d+1;
		System.out.println(d); //溢出了，-2147483648(int的最小值)
		
		//2)long:长整型，8个字节，很大很大很大
		//long e = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
		long f = 10000000000L; //长整型直接量需在数字后加L或l
		long g = 1000000000*2*10L;
		System.out.println(g); //200亿   //练习+下课----3:00继续
		long h = 1000000000*3*10L;
		System.out.println(h); //溢出了
		long i = 1000000000L*3*10;
		System.out.println(i); //300亿，有可能溢出时建议在第1个数字后加L
		*/
		
		/*
		//3)double:浮点型，8个字节，很大很大很大
		double a = 3.14; //3.14为浮点型直接量，默认为double型
		double b=3.0,c=2.9;
		System.out.println(b-c); //0.10000000000000009-舍入误差
		
		//4)boolean:布尔型，1个字节
		boolean d = true;  //true为布尔型直接量
		boolean e = false; //false为布尔型直接量
		//boolean f = 25; //编译错误，布尔型只能取值为true或false
		*/
		
		/*
		//5)char:字符型，2个字节
		char c1 = '女'; //字符女
		char c2 = 'f';  //字符f
		char c3 = '6';  //字符6
		char c4 = ' ';  //空格符
		//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
		//char c6 = ''; //编译错误，必须有字符
		//char c7 = '女性'; //编译错误，只能有一个字符
		
		char c8 = 65; //0到65535之间
		System.out.println(c8); //A，输出时会按变量的数据类型来
		
		char c9 = '\'';
		System.out.println(c9); //'
		*/
	}
}

package day02;
//变量的演示
public class VarDemo {
	public static void main(String[] args) {
		//1.变量的声明:----在银行开帐户
		int a; //声明一个整型的变量，名为a
		int b,c,d; //声明三个整型的变量，名为b,c,d
		//int a; //编译错误，变量不能同名
		
		//2.变量的初始化:----给帐户存钱
		int e = 250; //声明整型变量e并赋值为250
		int f;   //声明整型变量f
		f = 250; //给变量f赋值为250
		
		//3.变量的使用:----用的是帐户里面的钱
		int g = 5;
		int h = g+10; //取出g的值5，加10后，再赋值给变量h
		System.out.println(h);   //输出变量h的值15
		System.out.println("h"); //输出h，双引号中的原样输出
		g = g+10; //在g本身基础之上增10
		System.out.println(g); //15
		
		//System.out.println(i); //编译错误，变量i未声明
		int i;
		//System.out.println(i); //编译错误，变量i未初始化
		
		//4.变量的命名:
		int a1,a_5$,_3c,$_;
		//int a*b; //编译错误，不能包含*号等特殊符号
		//int 1a; //编译错误，不能以数字开头
		int aa = 5;
		//System.out.println(aA); //编译错误，严格区分大小写
		//int class; //编译错误，不能使用关键字
		int 年龄; //允许中文，但不建议(必须杜绝)
		int age; //建议"英文的见名知意"
		int score,myScore,myJavaScore; //建议"驼峰命名法"
		
	}
}

package day03;
//if结构的演示
public class IfDemo {
	public static void main(String[] args) {
		//1)偶数的判断:
		int num = 6;
		if(num%2==0) {
			System.out.println(num+"是偶数");
		}
		System.out.println("over");
		
		//2)满500打8折
		double price = 600.0; //消费金额
		if(price>=500) { //满500
			price *= 0.8; //打8折
		}
		System.out.println("最终消费金额为:"+price);
		
		
		/*
		 * if结构: 1条路
		 * 1)语法:
		 *    if(boolean){
		 *      语句块---------基于条件执行的
		 *    }
		 * 2)执行过程:
		 *    判断boolean的值:
		 *      若为true，则执行语句块
		 *      若为false，则if结束
		 */
	}
}

package day03;
//if...else结构的演示
public class IfElseDemo {
	public static void main(String[] args) {
		//1)奇数、偶数的判断:
		int num = 1;
		if(num%2==0) {
			System.out.println(num+"是偶数");
		}else {
			System.out.println(num+"是奇数");
		}
		System.out.println("over");
		
		//2)满500打8折，不满500打9折:
		double price = 300.0; //消费金额
		if(price>=500) { //满500
			price *= 0.8; //打8折
		}else { //不满500
			price *= 0.9; //打9折
		}
		System.out.println("最终消费金额为:"+price);	
					
		
		/*
		 * if...else结构: 2条路
		 * 1)语法:
		 *    if(boolean){
		 *      语句块1
		 *    }else{
		 *      语句块2
		 *    }
		 * 2)执行过程:
		 *    判断boolean的值:
		 *      若为true，则执行语句块1(整个结束)
		 *      若为false，则执行语句块2(整个结束)
		 * 3)说明: 语句块1和语句块2，必走其中之一
		 */
		
		//问: 块1和块2，有可能同时执行吗?-------不可能
		//问: 块1和块2，有可能同时都不执行吗?---不可能
		
	}
}

package day03;
//运算符的演示
public class OperDemo {
	public static void main(String[] args) {
		/*
		 * 6.条件/三目运算符:
		 *   1)语法:
		 *      boolean?数1:数2
		 *   2)执行过程:
		 *      整个表达式是有结果的，结果要么是数1，要么是数2
		 *      判断boolean的值:
		 *        若为true，则整个表达式的结果为?后面的数1
		 *        若为false，则整个表达式的结果为:后面的数2
		 */
		int a = 5;
		int flag = a>0?1:-1;
		System.out.println(flag); //1
		
		
		
		
		/*
		 * 5.字符串连接运算符:
		 *   1)+:
		 *     1.1)若两边为数字，则做加法运算
		 *     1.2)若两边出现了字符串，则做字符串连接
		 */
		
		int age = 37;
		System.out.println("age="); //age=
		System.out.println(age);    //37
		System.out.println("age="+age); //age=37
		System.out.println("我的年龄是:"+age); //我的年龄是:37
		System.out.println("我今年"+age+"岁了"); //我今年37岁了
	
		String name = "WKJ";
		System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
		System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年37岁了
		
		System.out.println(10+20+""+30); //3030----String
		System.out.println(""+10+20+30); //102030--String
		System.out.println(10+20+30+""); //60------String
		
		
			
		
		
		/*
		 * 4.赋值运算符:
		 *   1)简单赋值运算符:=
		 *   2)扩展赋值运算符:+=,-=,*=,/=,%= (在本身基础之上做操作)
		 *                   注意:扩展赋值自带强转功能
		 */
		    
		/*        
		//面试题:
		short s = 5;
		s += 10; //相当于 s = (short)(s+10);
		//s = s+10; //编译错误，需强转
		            //改正:s=(short)(s+10);
		*/
		/*
		int a = 5;
		a += 10; //相当于a=(int)(a+10)
		System.out.println(a); //15
		a *= 2; //相当于a=a*2
		System.out.println(a); //30
		a /= 6; //相当于a=a/6
		System.out.println(a); //5
		*/
		
		
		
		
		
		/*
		 * 3.逻辑运算符:
		 *   1)&&:短路与(并且)，两边都为真则为真，见false则false
		 *        ----当第1个数为false时，发生短路(后面的不执行了)
		 *     ||:短路或(或者)，有真则为真，见true则true
		 *        ----当第1个数为true时，发生短路(后面的不执行了)
		 *      !:逻辑非(取反)，非真则假，非假则真
		 *   2)逻辑运算是建立在关系运算的基础之上的
		 *     逻辑运算的结果也是boolean型
		 */
		
		/*
		int a=5,b=10,c=5;
		boolean b1 = b>=a && c<b;
		System.out.println(b1);          //true&&true=true
		System.out.println(b<=c && a>b); //false&&false=false
		System.out.println(a==c && b<c); //true&&false=false
		System.out.println(a!=c && b>a); //false&&true=false
		
		System.out.println(); //换行
		System.out.println(b>=a || c<b); //true||true=true
		System.out.println(b<=c || a>b); //false||false=false
		System.out.println(a==c || b<c); //true||false=true
		System.out.println(a!=c || b>a); //false||true=true
		
		System.out.println(); //换行
		boolean b2 = !(a<b);
		System.out.println(b2);     //!true=false
		System.out.println(!(a>b)); //!false=true
		
		boolean b3 = a>b && c++>2;
		System.out.println(b3); //false
		System.out.println(c);  //5，发生短路了

		boolean b4 = a<b || c++>2;
		System.out.println(b4); //true
		System.out.println(c);  //5，发生短路了
		*/
		
		
		
		
			
		
		
		/*
		 * 2.关系运算符:
		 *   1)>(大于)、<(小于)
		 *     >=(大于或等于)、<=(小于或等于)
		 *     ==(等于)、!=(不等于)
		 *   2)关系运算的结果为boolean型
		 *     关系成立则为true，关系不成立则为false
		 */
		
		/*
		int a=5,b=10,c=5;
		boolean b1 = a>b;
		System.out.println(b1);   //false
		System.out.println(c<b);  //true
		System.out.println(b>=a); //true
		System.out.println(a<=c); //true
		System.out.println(a==c); //true
		System.out.println(a!=c); //false
		
		System.out.println(a+c>b);  //false
		System.out.println(a%2==0); //false
		System.out.println(c++>5);  //false--此处c已经变为6了
		System.out.println(c++>5);  //true
		*/
		
		
	
		
		/*
		 * 1.算术运算符:+,-,*,/,%,++,--
		 *   1)%:取模/取余，余数为0即为整除
		 *   2)++/--:自增1/自减1，可在变量前也可在变量后
		 *     2.1)单独使用时，在前在后都一样
		 *     2.2)被使用时，在前在后不一样
		 *           a++的值为a-----(a--的值a)
		 *           ++a的值为a+1---(--a的值为a-1)
		 */
		
		/*
		int a=5,b=5;
		//1)将a++的值5赋值给c
		//2)a自增1变为6
		int c = a++;
		//1)将++b的值6赋值给d
		//2)b自增1变为6
		int d = ++b;
		System.out.println(a); //6
		System.out.println(b); //6
		System.out.println(c); //5
		System.out.println(d); //6
		*/
		/*
		int a=5,b=5;
		int c = a--;
		int d = --b;
		System.out.println(a); //4
		System.out.println(b); //4
		System.out.println(c); //5
		System.out.println(d); //4
		*/
		
		/*
		int a=5,b=5;
		a++; //相当于a=a+1
		++b; //相当于b=b+1
		System.out.println(a); //6
		System.out.println(b); //6
		*/
		/*
		int a=5,b=5;
		a--; //相当于a=a-1
		--b; //相当于b=b-1
		System.out.println(a); //4
		System.out.println(b); //4
		*/
		
		
		
		/*
		System.out.println(5%2); //1，商2余1
		System.out.println(8%2); //0，商4余0----整除
		System.out.println(2%8); //2，商0余2
		*/
	}
}

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请选择功能: 1.显示全部  2.查询登录  0.退出");
		int command = scan.nextInt();
		
		switch(command) {
		case 1:
			System.out.println("显示全部记录业务");
			break;
		case 2:
			System.out.println("查询登录业务");
			break;
		case 0:
			System.out.println("欢迎下次再来");
			break;
		default:
			System.out.println("输出错误");
		}
		
	}
}

package day04;
//do...while结构的演示
public class DoWhileDemo {
	public static void main(String[] args) {
		/*
		 * do...while结构:
		 * 1)语法:
		 *    do{
		 *      语句块
		 *    }while(boolean);
		 * 2)执行过程:
		 *    先执行语句块，再判断boolean的值，若为true则
		 *    再执行语句块，再判断boolean的值，若为true则
		 *    再执行语句块，再判断boolean的值，若为true则
		 *    再执行语句块，如此反复，直到boolean为false时循环结束
		 */
	}
}

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
		System.out.println(num); //作弊
		
		//假设num=250
		//300(大),200(小),250(对)
		int guess;
		do {
			System.out.println("猜吧!");
			guess = scan.nextInt();  //1+3
			if(guess>num) {
				System.out.println("太大了");
			}else if(guess<num) {
				System.out.println("太小了");
			}else {
				System.out.println("恭喜你猜对了!");
			}
		}while(guess!=num); //2
		//1)写大小等的提示  2)代数  3)将do..while猜重写一次

	
		
		/*
		//300(大),200(小),250(对)
		System.out.println("猜吧!");
		int guess = scan.nextInt(); //1.
		while(guess!=num) { //2.
			if(guess>num) {
				System.out.println("太大了");
			}else {
				System.out.println("太小了");
			}
			System.out.println("猜吧!");
			guess = scan.nextInt(); //3.
		}
		System.out.println("恭喜你猜对了!");
		*/
	}
}

package day04;
//if...else if结构的演示
public class IfElseIfDemo {
	public static void main(String[] args) {
		/*
		 * if...else if结构: 多条路
		 * 1)语法:
		 *     if(boolean-1){
		 *       语句块1
		 *     }else if(boolean-2){
		 *       语句块2
		 *     }else if(boolean-3){  //2分钟自己想
		 *       语句块3
		 *     }else{
		 *       语句块4
		 *     }
		 * 2)执行过程:
		 *    判断boolean-1,若为true则执行语句块1(结束),若为false则
		 *    再判断boolean-2,若为true则执行语句块2(结束),若为false则
		 *    再判断boolean-3,若为true则执行语句块3(结束),若为false则执行语句块4(结束)
		 * 3)说明:
		 *    语句块1/2/3/4，只执行其中之一
		 */
	}
}

package day04;
import java.util.Scanner; //1.
//Scanner的演示
public class ScannerDemo {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in); //2.
		System.out.println("请输入年龄:");
		int age = scan.nextInt(); //3.
		System.out.println("请输入价格:");
		double price = scan.nextDouble();
		
		System.out.println(age);
		System.out.println(price);
	}
}

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入成绩:");
		double score = scan.nextDouble();
		
		//888,-56,95,85,65,45
		if(score<0 || score>100) {
			System.out.println("成绩不合法");
		}else if(score>=90) { //合法
			System.out.println("A-优秀");
		}else if(score>=80) {
			System.out.println("B-良好");
		}else if(score>=60) {
			System.out.println("C-中等");
		}else {
			System.out.println("D-不及格");
		}
	}
}

package day04;
//switch...case结构的演示
public class SwitchCaseDemo {
	public static void main(String[] args) {
		int num = 4;
		switch(num) { //byte,short,int,char,String(JDK1.7开始支持)
		case 1: //if(num==1)
			System.out.println(111);
			break;
		case 2: //以此为入口
			System.out.println(222);
			break; //跳出switch
		case 3:
			System.out.println(333);
			break;
		default: //所有case都未匹配时才执行
			System.out.println(666);
		}
	}
}

package day04;
//while结构的演示
public class WhileDemo {
	public static void main(String[] args) {
		//2)输出9的乘法表:
		int num = 1;
		while(num<=9) {
			System.out.println(num+"*9="+num*9);
			num=num+2;  //num++;
		} 
		System.out.println("over");
		/* 
		 *                   num=1
		 * true  输出1*9=9   num=3
		 * true  输出3*9=27  num=5
		 * true  输出5*9=45  num=7
		 * true  输出7*9=63  num=9
		 * true  输出9*9=81  num=11
		 * false while循环结束
		 * 输出over
		 */
		
		
	
		
		
		/*
		//1)输出10次"行动是成功的阶梯"
		int times = 0;    //1.循环变量的初始化
		while(times<10) { //2.循环的条件
			System.out.println("行动是成功的阶梯");
			times++;      //3.循环变量的改变
		}
		System.out.println("over");
		*/
		/*
		 *            times=0
		 * true  输出   times=1 
		 * true  输出   times=2
		 * true  输出   times=3
		 * true  输出   times=4
		 * ...        times=5/6/7/8
		 * true  输出   times=9
		 * true  输出   times=10
		 * false while循环结束
		 * 输出over
		 */
		
		
		
		
		/*
		 * while结构:
		 * 1)语法:
		 *    while(boolean){
		 *      语句块----------反复执行的代码
		 *    } 
		 * 2)执行过程:
		 *    判断boolean的值，若为true则执行语句块，
		 *    再判断boolean的值，若为true则再执行语句块，
		 *    再判断boolean的值，若为true则再执行语句块，
		 *    如此反复，直到boolean的值为false时循环结束
		 */
	}
}

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		int score = 0; //得分
		for(int i=1;i<=10;i++) { //10次
			int a = (int)(Math.random()*100); //加数a(0到99之间的随机数)
			int b = (int)(Math.random()*100); //加数b(0到99之间的随机数)
			int result = a+b; //存和
			System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题
			
			System.out.println("算吧!---(提示:输出-1可提前结束)");
			int answer = scan.nextInt(); //2)答题
			
			if(answer==-1) { //3)判题
				break;
			}
			if(answer==result) {
				System.out.println("答对了");
				score += 10; //答对1题加10分
			}else {
				System.out.println("答错了");
			}
		}
		System.out.println("得分为:"+score);
		
	}
}

package day05;
//数组的演示
public class ArrayDemo {
	public static void main(String[] args) {
		//3.数组的访问:---访问的是数组中的元素
		int[] arr = new int[3];
		arr[0] = 100; //给arr中第1个元素赋值为100
		arr[1] = 200; //给arr中第2个元素赋值为200
		arr[2] = 300; //给arr中第3个元素赋值为300
		//arr[3] = 400; //运行时，会发生数组下标越界异常
		System.out.println(arr.length); //3
		System.out.println(arr[arr.length-1]); //输出arr中最后一个元素的值
		
		
		
		
		/*
		//1)数组的定义:
		//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
		int[] arr = new int[10];
		
		//2)数组的初始化:
		int[] arr1 = new int[4]; //0,0,0,0
		int[] arr2 = {2,4,7,9}; //2,4,7,9
		int[] arr3 = new int[] {2,4,7,9}; //2,4,7,9
		int[] arr4;
		//arr4 = {2,4,7,9}; //编译错误，此方式只能声明同时初始化
		arr4 = new int[] {2,4,7,9}; //正确
		*/
	}
}

package day05;
//for结构的演示
public class ForDemo {
	public static void main(String[] args) {
		/*
		//输出9的乘法表，只要不能被3整除的(要1/2/4/5/7/8)
		for(int num=1;num<=9;num++) {
			if(num%3!=0) {
				System.out.println(num+"*9="+num*9);
			}
		}
		*/
		
		/*
		//输出9的乘法表，跳过能被3整除的(3/6/9我不要)
		for(int num=1;num<=9;num++) {
			if(num%3==0) {
				continue; //跳过循环体中剩余语句而进入下一次循环
			}
			System.out.println(num+"*9="+num*9);
		}
		*/
		/*
		 * num=1   输出1*9=9
		 * num=2   输出2*9=18
		 * num=3 
		 * num=4   输出4*9=36
		 * num=5   输出5*9=45
		 * num=6  
		 * num=7   输出7*9=63
		 * num=8   输出8*9=72
		 * num=9 
		 * num=10
		 */
		
		
		
		
		
		for(int num=1;num<=9;num++) {
			if(num==5) { //在某种特殊条件下提前结束循环
				break; //跳出循环
			}
			System.out.println(num+"*9="+num*9);
		}
		
	
		
		/*
		int num=1;
		for(;num<=9;num++) {
			System.out.println(num+"*9="+num*9);
		}
		*/
		/*
		for(int num=1;num<=9;) {
			System.out.println(num+"*9="+num*9);
			num++;
		}
		*/
		/*
		for(;;) { //没有条件的循环就是个死循环
			System.out.println("我要学习...");
		}
		*/
		/*
		for(int i=1,j=5;i<6;i+=2,j-=2) {
			
		}
		*/
		/*
		 * i=1,j=5
		 * i=3,j=3
		 * i=5,j=1
		 * i=7,j=-1
		 */
		
		
		
		
		
		
		/*
		for(int times=0;times<10;times++) {
			System.out.println("行动是成功的阶梯");
		}
		for(int num=1;num<=9;num++) {
			System.out.println(num+"*9="+num*9);
		}
		for(int num=1;num<=9;num+=2) {
			System.out.println(num+"*9="+num*9);
		}
		//for中的循环变量num，作用范围仅在for中
		for(int num=9;num>=1;num--) {
			System.out.println(num+"*9="+num*9);
		}
		*/
		
		/*
		 * 执行过程:
		 * num=9  true  9*9=81
		 * num=8  true  8*9=72
		 * num=7  true  7*9=63
		 * num=6  true  6*9=54
		 * num=5  true  5*9=45
		 * num=4  true  4*9=36
		 * num=3  true  3*9=27
		 * num=2  true  2*9=18
		 * num=1  true  1*9=9
		 * num=0  false for循环结束
		 */
		
		
		
		
		
		/*
		 * for结构:
		 * 1)语法:
		 *    //    1       2      3
		 *    for(要素1 ; 要素2 ; 要素3){
		 *      语句块/循环体    //4
		 *    }
		 * 2)执行过程:
		 *    12432432432432432
		 */
	}
}

package day05;
//求数组元素的最大值
public class MaxOfArray {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) { //遍历所有元素
			arr[i] = (int)(Math.random()*100); //给每个元素都赋值为:0到99之间的随机数
			System.out.println(arr[i]); //输出每个元素的值
		}
		
		//假设arr的元素为: 23,56,89,4
		int max = arr[0]; //假设第1个元素为最大值
		for(int i=1;i<arr.length;i++) { //遍历剩余元素
			if(arr[i]>max) { //若剩余元素大于max
				max=arr[i];  //则修改max为较大的
			}
		}
		System.out.println("最大值为:"+max);
		//max=23/56/89

		
	}
}

package day05;
//九九乘法表
public class MultiTable {
	public static void main(String[] args) {
		for(int num=1;num<=9;num++) { //控制行
			for(int i=1;i<=num;i++) { //控制列
				System.out.print(i+"*"+num+"="+i*num+"\t");
			}
			System.out.println(); //换行
		}
		/*
		 * num=3
		 *  i=1 1*3=3
		 *  i=2 2*3=6
		 *  i=3 3*3=9
		 *  i=4 false
		 *  换行
		 * num=2
		 *  i=1 1*2=2
		 *  i=2 2*2=4
		 *  i=3 false
		 *  换行
		 * num=1
		 *  i=1 1*1=1
		 *  i=2 false
		 *  换行
		 */
		
	}
}

package day06;
import java.util.Arrays;
//数组的演示
public class ArrayDemo {
	public static void main(String[] args) {
		//8)数组的排序:
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) {
			arr[i] = (int)(Math.random()*100);
			System.out.println(arr[i]);
		}
		
		Arrays.sort(arr); //对arr升序排列
		
		System.out.println("升序后:");
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		
		System.out.println("降序后:");
		for(int i=arr.length-1;i>=0;i--) {
			System.out.println(arr[i]);
		}
		
		
		
		
		
		/*
		//7)数组的复制:
		int[] a = {10,20,30,40,50};
		//数组的扩容(创建了一个更大的新数组，并将源数组数据复制进去)
		a = Arrays.copyOf(a,a.length+1);
		for(int i=0;i<a.length;i++) {
			System.out.println(a[i]);
		}
		*/
		/*
		int[] a = {10,20,30,40,50};
		//a:源数组
		//b:目标数组
		//6:目标数组的长度(元素个数)
		//--若目标数组长度大于源数组长度，则末尾补默认值
		//--若目标数组长度小于源数组长度，则从末尾截掉
		int[] b = Arrays.copyOf(a,6); //灵活性差
		for(int i=0;i<b.length;i++) {
			System.out.println(b[i]);
		}
		*/
		
		/*
		int[] a = {10,20,30,40,50};
		int[] b = new int[6]; //0,0,0,0,0,0
		//a:源数组
		//1:源数组的起始下标
		//b:目标数组
		//0:目标数组的起始下标
		//4:要复制的元素个数
		System.arraycopy(a,1,b,0,4); //灵活性好
		for(int i=0;i<b.length;i++) {
			System.out.println(b[i]);
		}
		*/
	}
}

package day06;
import java.util.Arrays;
//求数组元素的最大值，并将最大值放在数组最后一个元素的下一个位置
public class MaxOfArray {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++) { //遍历所有元素
			arr[i] = (int)(Math.random()*100); //给每个元素都赋值为:0到99之间的随机数
			System.out.println(arr[i]); //输出每个元素的值
		}
		
		int max = arr[0]; //假设第1个元素为最大值
		for(int i=1;i<arr.length;i++) { //遍历剩余元素
			if(arr[i]>max) { //若剩余元素大于max
				max=arr[i];  //则修改max为较大的
			}
		}
		System.out.println("最大值为:"+max);
		
		//数组的扩容
		arr = Arrays.copyOf(arr,arr.length+1);
		//将最大值max放到arr数组的最后一个元素上
		arr[arr.length-1] = max;
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		
	}
}

package day06;
import java.util.Arrays;
//方法的演示
public class MethodDemo {
	public static void main(String[] args) {
		//say();
		
		/*
		//sayHi(); //编译错误，有参则必须传参
		//sayHi(250); //编译错误，数据类型必须匹配
		sayHi("zhangsan"); //String name="zhangsan"
		sayHi("lisi"); //String name="lisi"
		*/
		
		/*
		sayHello("zhangsan",25);
		sayHello("lisi",27);
		*/
		
		/*
		double a = getNum(); //getNum()的值就是return后的那个数
		System.out.println(a); //8.88----模拟后期对返回值的操作	
		*/
		
		/*
		int b = plus(5,6);  //----实参
		System.out.println(b); //11----模拟后期对返回值的操作	
		
		int m=5,n=6;
		int c = plus(m,n); //传的是m和n里面的那个数----实参
		System.out.println(c); //11----模拟后期对返回值的操作	
		*/
		
		/*
		int[] d = testArray();
		Arrays.sort(d); //模拟后期对返回值的操作	
		for(int i=0;i<d.length;i++) { //模拟后期对返回值的操作	
			System.out.println(d[i]);
		}
		*/
		
		/*
		sayHello("zhangsan",25);
		sayHello("lisi",48);
		*/
	
		a(); //方法的嵌套调用---111,333,222
		
	}  //练习+下课--------5:30
	
	public static void a() {
		System.out.println(111);
		b();
		System.out.println(222);
	}
	public static void b() {
		System.out.println(333);
	}
	

	
	
	
	//无参有返回值
	public static int[] testArray() {
		int[] arr = {25,36,8,2};
		return arr;
	}
	
	//有参有返回值
	public static int plus(int num1,int num2) { //----形参
		int num = num1+num2;
		return num; //返回的是num里面的那个数
		
		//return num1+num2; //返回的是num1与num2的和
	}
	
	//无参有返回值
	public static double getNum() {
		//--若方法有返回值，则在方法中必须出现return，
		//--并且return后的数必须与返回值类型匹配
		
		//return; //编译错误，return后必须跟一个数
		//return "abc"; //编译错误，return后的数必须与返回值匹配
		return 8.88; //1)结束方法的执行  2)返回结果给调用方
	}
	
	
	//无参无返回值
	public static void say() {
		System.out.println("大家好，我叫WKJ，今年37岁了");
	}
	
	//有参无返回值
	public static void sayHi(String name) {
		System.out.println("大家好，我叫"+name+"，今年37岁了");
	}
	
	//有参无返回值
	public static void sayHello(String name,int age) {
		if(age>=40) { //在某种特定条件下提前结束方法
			return; //结束方法的执行
		}
		System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
	}
	
}

练习:

package oo.day11;
//练习
public class Day03Test {
	public static void main(String[] args) {
		//2.闰年、平年的判断:
		/*
		int year = 2020; //年份 2019,2000
		if((year%4==0 && year%100!=0) || year%400==0) {
			System.out.println(year+"是闰年");
		}else {
			System.out.println(year+"是平年");
		}
		*/ 
		int year = 2019; //年份
		boolean flag = (year%4==0 && year%100!=0) || year%400==0;
		String str = flag ? year+"是闰年" : year+"是平年";
		System.out.println(str);
		
		
		//1.求两个数中的最大值:
		/*
		int a=8,b=55;
		int max; //最大值
		if(a>b) {
			max = a;
		}else {
			max = b;
		}
		System.out.println("最大值为:"+max);
		*/
		/*
		int a=8,b=55;
		int max = a>b?a:b;
		System.out.println("最大值为:"+max);
		*/
	}
}

package oo.day11;
//练习
public class Day04Test {
	public static void main(String[] args) {
		//根据年份和月份，计算天数:
		int year = 2021; //年份
		int month = 5;   //月份
		int days = 0;    //天数
		switch(month) {
		case 1:
		case 3:
		case 5:
		case 7:
		case 8:
		case 10:
		case 12:
			days = 31;
			break;
		case 4:
		case 6:
		case 9:
		case 11:
			days = 30;
			break;
		case 2:
			if((year%4==0 && year%100!=0) || year%400==0) {
				days = 29;
			}else {
				days = 28;
			}
		}
		System.out.println("天数为:"+days);
		
	
		//1)ScoreLevel成绩等级判断程序
		//2)CommandBySwitch命令解析程序
		//3)Guessing猜数字-------------做do...while版
		
	}
}

package oo.day11;
import java.util.Scanner;
public class Day05Test {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		double[] scores = new double[6]; //分数数组
		for(int i=0;i<scores.length;i++) { //遍历所有分数
			System.out.println("请输入第"+(i+1)+"个学生的成绩:");
			scores[i] = scan.nextDouble();
		}     
		//练习: 1)Addition随机加法运算器  2)MaxOfArray数组元素最大值
		//计算总分和平均分
		double total = 0.0; //总分
		for(int i=0;i<scores.length;i++) {
			total += scores[i];
		}
		double avg = total/scores.length;   //平均分
		System.out.println("总分为:"+total+"，平均分为:"+avg);
	
	}
}

package oo.day11;
public class Day06Test {
	public static void main(String[] args) {
//1)定义方法generate  2)用于生成指定长度的int数组
//3)数组中的元素为0到指定范围的随机数 
//4)并将该数组返回 //5)main中调用方法测试
		int[] arr = generate(5,10);
		for(int i=0;i<arr.length;i++) { //模拟对返回值的操作
			System.out.println(arr[i]); //可以输出数据、可以排序、可以复制...
		}
	} 
	public static int[] generate(int len,int max) {
		int[] arr = new int[len];
		for(int i=0;i<arr.length;i++) {
			arr[i] = (int)(Math.random()*max);
		}
		return arr;
	}
	
}