Java基础

一、前言

1.Linux:

1)开源的操作系统、免费

主要是服务器端操作系统，
java主要是服务器端开发，所以必须会Linux

2)Linux与Windows目录结构的区别:

2.1)文件系统不同:        Linux:目录  Windows:盘符
2.2)外部设备映射不同:        Linux:挂载点 Windows:盘符
2.3)安全级别不同:        Linux:高 Windows:低

3)Linux常用命令:

3.1)pwd:显示当前工作目录
3.2)ls:查看当前工作目录的内容
3.3)cd:改变当前工作目录
3.4)绝对路径:相对于根目录的位置，以/开头       cd /a/b 
3.5) 相对路径:相对于当前目录的位置    cd a/b
3.6)  cd ..:返回上一级目录

2.java开发环境:

1)java编译运行过程:

    .java源文件，经过编译，生成.class字节码文件      JVM加载.class并运行.class    --------跨平台，一次编程到处使用

2)JVM:java虚拟机

  2.1)JVM:java虚拟机        加载.class并运行.class
  2.2) JRE:java运行环境            除了包含JVM以外还包含运行java程序所必须的环境        JRE=JVM+java系统类库
  2.3)  JDK:java开发工具包        除了包含JRE以外还包含开发java程序所必须的命令工具 	 JDK=JRE+编译、运行等工具
  2.4)  运行java程序的最小环境是JRE
  2.5)  开发java程序的最小环境是JDK

3)配置环境变量:

3.1)JAVA_HOME:指向jdk的安装目录
3.2)CLASSPATH:表示类的搜索路径， 一般简写为.
3.3)PATH:指向jdk下的bin目录      javac,java...都在bin目录下  

二、变量的演示

1.前言

1.变量:存数的，代词，指代所存的那个数
  1)声明:
      int a;
      int b,c,d;
  2)初始化:第一次赋值
      int a=250;
      int b;
      b=250;
  3)使用:
    3.1)必须与数据类型匹配
        int a=25.678; //错
    3.2)用之前必须声明并初始化
        System.out.println(m); //错
	int m;
	System.out.println(m); //错
    3.3)对变量的使用就是对它所存的数的使用
        int a=5;
	int b=a+10; //取出a的值5，加10后赋值给b
	a=a+100; //在a本身基础之上增100
  4)命名:
    4.1)只能包含字母、数字、_和$符
        不能以数字开头
    4.2)严格区分大小写
    4.3)不能使用关键字
    4.4)可以中文命名，但不建议
        建议"见名知意"和"驼峰命名法"

2.变量的演示

//变量的演示
public class VarDemo {
	public static void main(String[] args) {		
		
		//1.变量的声明
		int a; //声明一个整型变量，名为a
		int b,c,d; //声明三个整型变量，名为b,c,d

		//2.变量的初始化:第一次赋值
		int a=250; //声明整型变量a并赋值为250
		int b; //声明整型变量b
		b=250; //给变量b赋值为250
		
		//3.变量的使用:
		//  1)变量的使用必须与数据类型匹配
		//  2)变量在使用之前必须声明并且初始化
		//  3)对变量的操作就是对那个数的操作
		//int a=25.678; //编译错误，数据类型不匹配
		
		//System.out.println(c); //编译错误，c未声明
		//int b;
		//System.out.println(b); //编译错误，b未初始化
		
		int c=5;
		int d=c+10; //取出c的值5，加10后，赋值给d
		System.out.println(d); //输出d的值15
		
		int e=10;
		e=e+100; //取出e的值10，加100后，赋值给e
		         //在本身基础之上增100
		System.out.println(e); //输出e的值110

		
	/*
		   4)变量的命名:
				4.1)只能包含字母、数字、_和$符
					不能以数字开头
				4.2)严格区分大小写
				4.3)不能使用关键字
				4.4)可以中文命名，但不建议
					建议"见名知意"和"驼峰命名法"
		*/
		int a1,a_2,a_$5y;
		//int a*b; //编译错误，不能包含*号
		//int 1a; //编译错误，不能以数字开头
		//int class; //编译错误，不能使用关键字
		//Int a; //编译错误，严格区分大小写
		int 年龄; //正确，但不建议
		int age; //建议"见名知意"
		int score,myScore,myJavaScore; //驼峰命名法

		/*
		 * 补充:
		 * 1.变量的作用域/范围:
		 *     从变量的声明开始，到包含它最近的大括号结束
		 * 2.变量的重名问题:
		 *     变量作用域重叠时，变量不能同名
		 */
		
		int a=5;
		if(a>2){
			//int a=55; //编译错误，作用域重叠时不能同名
			int b=8;
		}else{
			int b=88;
		}
		
		
		
		int a=5;
		if(a>2){
			int b=8;
			System.out.println(a);
			System.out.println(b);
		}
		System.out.println(a);
		//System.out.println(b); //编译错误，b超出作用范围了
		
		
	}
}

3.变量的演示

三、数据类型的演示

1.前言

2.基本数据类型
  1)int:整型，4个字节，-21个多亿到21个多亿
    1.1)整数直接量默认为int型
    1.2)两个整数相除，结果还是整数，小数位无条件舍弃
    1.3)整数运算时超出范围，为溢出，是需要避免的
  2)long:长整型，8个字节，很大很大
    2.1)长整型直接量在数字后加l或L
    2.2)运算时有可能超范围，建议第一个数字后加L
    2.3)System.currentTimeMillis()可以获取
        自1970.1.1零时到此时此刻的毫秒数
  3)double:浮点型，8个字节
    3.1)小数直接量默认为double型
    3.2)double运算时会有舍入误差，精确运算场合不可使用
  4)char:字符型，2个字节
    4.1)采用Unicode编码格式，每个字符都有一个对应的码
        实质上存的是码(int)，表现形式是字符(char)
    4.2)字符需放在单引号中，有且仅有一个
    4.3)特殊符号需转义(\)
  5)boolean:布尔型，1个字节
    5.1)只能取值为true和false
3.数据类型间的转换:
    数据类型从小到大依次为:
      byte-short-int-long-float-double
           char--
  1)两种类型:
    1.1)自动类型转换:从小类型到大类型
    1.2)强制类型转换:从大类型到小类型
          (要转换成的类型)变量
	  强转有可能溢出和精度丢失
  2)两点规则:
    2.1)整数直接量可以直接赋值给byte,short,char，
        但是不能超范围
    2.2)byte,short,char类型的变量参与运算时，
        先一律转换为int再运算

2.数据类型的演示

//数据类型的演示
public class DataTypeDemo {
	public static void main(String[] args) {		
		
		//1.int:整型，4个字节，-21个多亿到21个多亿
		int a=250; //250叫整数直接量，默认为int型
		//int b=10000000000; //编译错误，100亿默认为int型，但超出int范围了
		
		System.out.println(5/2); //2，两个整数相除，结果还是整数，小数位被舍弃了
		System.out.println(2/5); //0，小数位被舍弃了
		
		int c = 2147483647;
		c=c+1;
		System.out.println(c); //-2147483647，溢出了，是需要被避免的



		
		//2.long:长整型，8个字节，很大很大
		long a=250L; //250L叫长整型直接量
		//long b=10000000000; //编译错误，100亿为int型，但超范围了
		long c=10000000000L;
		
		//有可能超int范围时，将L写在第一个数字的后面
		long d = 1000000000*2*10L;
		System.out.println(d); //200亿
		long e = 1000000000*3*10L;
		System.out.println(e); //溢出了
		long f = 1000000000L*3*10;
		System.out.println(f); //300亿
		
		//获取自1970.1.1零时到此时此刻的毫秒数
		long g = System.currentTimeMillis();
		System.out.println(g);
		

		//3.double:浮点型，8个字节
		double a=25.678; //25.678为浮点型直接量，默认为double型
		float b=25.678F; //25.678F为float型直接量
		
		double c=3.0;
		double d=2.9;
		System.out.println(c-d); //0.10000000000000009，舍入误差


		//4.boolean:布尔型，1个字节，只能取值为true和false
		boolean b1 = true; //声明布尔型变量b1并赋值为true
		boolean b2 = false;
		//boolean b3 = 250; //编译错误，数据类型不匹配


		//5.char:字符型，2个字节  ‘0’码48(1-49)  ‘a’码97  ‘A’码65  eg：int n=‘2’+‘2’//50+50=100
		char c1 = '中';
		char c2 = 'a';
		char c3 = '1';
		char c4 = ' ';
		//char c5 = ''; //编译错误，必须有字符
		//char c6 = '男性'; //编译错误，只能有一个字符
		
		char c7 = 65;
		System.out.println(c7); //A
		
		char c8 = '\'';
		System.out.println(c8); //'
		
		System.out.println(2+2); //4
		System.out.println('2'+'2'); //100,'2'的码50加上'2'的码50，结果为100
		System.out.println(2+'2'); //52,2加上'2'的码50，结果为52

     

		/*数据类型的转换
		数据类型间的转换:
			数据类型从小到大依次为:
			  byte-short-int-long-float-double
				   char--
		  整数类型：
          整数类型变量用来表示整数的数据类型。整数类型又分为字节型（byte）、短整型（short）、整型（int）、长整型（long）这四种。

          浮点类型：
          浮点类型用来表示小数的数据类型。浮点类型分为float（单精度型）和double（双精度类型）这两种。
		  float（单精度型）一般在精度要求不高的时候使用。double（双精度类型）一般在数值精度高的时候使用。

          字符类型：
          字符类型的关键字是“char”。

          布尔类型：
          布尔类型是表示逻辑值的基本数据类型。boolean常量有“真”和“假”这两个状态。一般用true表示“真”、false表示“假”。它的定义方法是在变量名前加上类型关键字boolean。

		  1)两种类型:
			1.1)自动类型转换:从小类型到大类型
			1.2)强制类型转换:从大类型到小类型
				  (要转换成的类型)变量
			  强转有可能溢出和精度丢失
		  2)两点规则:
			2.1)整数直接量可以直接赋值给byte,short,char，
				但是不能超范围
			2.2)byte,short,char类型的变量参与运算时，
				先一律转换为int再运算

			仅以byte为例进行阐述，byte为一字节8位，最高位是符号位。
			最大值是01111111(补码)，补码即原码： -n = ~n + 1  max+1=min 
			 最大值为：2^0+2^1+2^2+2^3+2^4+2^5+2^6=(1-2)2^7/(1-2)=2^7-1=127

			最小值是10000000(补码)，首先计算反码(补码-1)： 
			01111111 
			然后计算原码： 
			10000000 
			最大值为：-2^7=-128

        */
		int a=5;
		long b=a; //自动类型转换
		int c=(int)b; //强制类型转换
		
		long d=5; //自动类型转换
		double e=5; //自动类型转换
		float f=(float)5.678; //强制类型转换
		
		long g = 10000000000L;
		int h = (int)g;
		System.out.println(h); //溢出，强转有可能会溢出
		
		double i = 56.987456;
		int j = (int)i;
		System.out.println(j); //56，强转有可能会精度丢失
		
		//多种类型参与运算时，系统自动向较大的类型转换
		int k=5/2;
		System.out.println(k); //2
		double l=5/2;
		System.out.println(l); //2.0，5/2的结果为int型的2，自动类型转
		double m=5/2.0;
		System.out.println(m); //2.5，5.0/2的结果为double型，所以能保留小数位
		
		//两点规则:
		//1)整数直接量可以直接赋值给byte,short,char，
		//  但不能超范围
		//2)byte,short,char型变量参与运算时，
		//  先一律转换为int再运算
		short b1 = 5;
		short b2 = 6;
		short b3 = (short)(b1+b2);
		System.out.println(b3);
		
		
	}
}

四、Scanner的演示

1.前言

4.Scanner的用法
  1)在package下:
      import java.util.Scanner;
  2)在main大括号中:
      Scanner scan = new Scanner(System.in);
  3)在第2步之下:
      System.out.println("请输入年龄:");
      int age = scan.nextInt();

2.Scanner的演示

//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);
	}
}

五、运算符的演示

1.前言

1.运算符:
  1)算术运算符:+,-,*,/,%,++,--
    1.1)%:取模/取余，余数为0即为整除
    1.2)++/--:自增1/自减1，可在变量前也可在变量后
        1.2.1)单独使用时，在前在后无差别
        1.2.2)被使用时，在前在后有差别
                 a++的值为a的值
                 ++a的值为a+1的值
  2)关系运算符:
    2.1)>(大于),<(小于)
	>=(大于或等于),<=(小于或等于)
	==(等于),!=(不等于)
    2.2)关系运算的结果为boolean型
	关系成立则为true，关系不成立则为false
  3)逻辑运算符:
    3.1)&&:短路与(并且)，两边都为真则为真，见false则false
	   第一个数为false，则短路(第二个数不走了)
	||:短路或(或者)，有一边为真则为真，见true则true
	   第一个数为true，则短路(第二个数不走了)
	! :逻辑非(取反)，非真则假，非假则真
    3.2)逻辑运算是建立在关系运算基础之上的
	逻辑运算的结果也是boolean型
  4)赋值运算符:
    4.1)简单赋值运算:=
    4.2)扩展赋值运算:+=,-=,*=,/=,%=
  5)字符串拼接运算符:
    5.1)+:
	5.1.1)若两边都是数字，则做加法运算
	5.1.2)若有一边为字符串，则做字符串连接
  6)三目/条件运算符:
    6.1)语法:
          boolean ? 数1 : 数2
    6.2)执行过程:
          计算boolean的值:
            若为true，则整个的结果为数1
            若为false，则整个的结果为数2

2. 运算符的演示

//运算符的演示
public class OperDemo {
	public static void main(String[] args) {
		
		
		/*
		 * 1.算术运算符:+,-,*,/,%,++,--
		 *   1)%:取模/取余，余数为0即为整除
		 *   2)++/--:自增1/自减1，可在变量前也可在变量后
		 *     2.1)单独使用时，在前在后无差别
		 *     2.2)被使用时，在前在后有差别:(值就近原则)
		 *           a++的值为a的值
		 *           ++a的值为a+1的值
		 */
		
        System.out.println(5%2); //1,商2余1
		System.out.println(8%2); //0,商4余0，整除
		System.out.println(2%8); //2,商0余2
		System.out.println(8.4567%2); //0.4567


		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;
		int c=a++;
		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;
		System.out.println(a++); //5
		System.out.println(a);   //6
		System.out.println(++b); //6
		System.out.println(b);   //6

		/*
		 * 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(a>=c); //true
		System.out.println(c<=b); //true
		System.out.println(a==c); //true
		System.out.println(a!=c); //false

        
		/*
		 * 3.逻辑运算符:
		 *   1)&&:短路与(并且)，两边都为真则为真，见false则false
		 *        第一个数为false，则短路(第二个数不走了)
		 *     ||:短路或(或者)，有一边为真则为真，见true则true
		 *        第一个数为true，则短路(第二个数不走了)
		 *     ! :逻辑非(取反)，非真则假，非假则真
		 *   2)逻辑运算是建立在关系运算基础之上的
		 *     逻辑运算的结果也是boolean型
		 */
		
		int a=5,b=10,c=5;
		
		boolean b4=a<b || c++>2;
		System.out.println(b4); //true
		System.out.println(c);  //5,发生短路了  
		
		
		boolean b3=a>b && c++>2;
		System.out.println(b3); //false
		System.out.println(c);  //5，发生短路了
		
		
		boolean b2=!(a>b);
		System.out.println(b2);     //!false=true
		System.out.println(!(c<b)); //!true=false
		
		System.out.println(a>b || c<b);  //false||true=true
		System.out.println(a==c || b<c); //true||false=true
		System.out.println(a!=c || a>b); //false||false=false
		System.out.println(a==c || a<b); //true||true=true
		
		boolean b1 = a>b && c<b; 
		System.out.println(b1);          //false&&true=false
		System.out.println(a==c && b<c); //true&&false=false
		System.out.println(a!=c && a>b); //false&&false=false
		System.out.println(a==c && a<b); //true&&true=true
		
		
		/*
		 * 4.赋值运算:
		 *   1)简单赋值运算:=
		 *   2)扩展赋值运算:+=,-=,*=,/=,%=
		 */
		
		int a=5;
		a+=10; //相当于a=a+10
		System.out.println(a); //15
		a*=2; //相当于a=a*2;
		System.out.println(a); //30
		

		/*
		 * 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岁了
		
		System.out.println(10+20+""+30); //"3030"
		System.out.println(10+20+30+""); //"60"
		System.out.println(""+10+20+30); //"102030"
		
		
		
		/*
		 * 6.三目/条件运算:
		 *   1)语法:
		 *       boolean ? 数1 : 数2
		 *   2)执行过程:
		 *       计算boolean的值:
		 *         若为true，则整个的结果为数1
		 *         若为false，则整个的结果为数2
		 */
		int a=55,b=8;
		int max=a>b?a:b;
		System.out.println("max="+max);	//55	
		
	}
}

六、分支结构

1.前言

2.分支结构:
  1)if结构:1条路
  2)if...else结构:2条路
  3)if...else if结构:多条路
  4)switch...case结构:多条路
    优点:效率高、结构清晰
    缺点:整数、相等
    break:跳出switch

2.分支结构的演示

//分支结构的演示
public class IfDemo {
	public static void main(String[] args) {
		int num = 4;
		switch(num){ //byte,short,char,int
		case 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);
		}
		
	    int num = 5;
		if(num%2==0){
			System.out.println(num+"是偶数");
		}else{
			System.out.println(num+"是奇数");
		}
		System.out.println("over");
		
		
		
		int num = 5;
		if(num%2==0){
			System.out.println(num+"是偶数");
		}
		System.out.println("over");
		
		
	}
}

3.其它

3.1判断一个整数是否是奇数

public boolean isOdd(int i)
方法一：
public boolean isOdd(int i) {
 if (i % 2 == 1) {
 return true;
 } else {
 return false;
 }
}
方法二：
public boolean isOdd(int i) {
 return i % 2 == 1 || i % 2 == -1;
}

并且在提示之后优化成这样：
public boolean isOdd(int i) {
 return i % 2 != 0;
}
方法三：奇数和偶数转换成二进制有什么区别？”“奇数最后一位是1，偶数最后一位是0。”
public boolean isOdd(int i) {
 return (i & 1) == 1;
}
& 与运算 :见0则0   0 & 0 = 0     0 & 1 = 0    1 & 0 = 0    1 & 1 = 1
案例：(常用来截取数据) 如下运算的逻辑意义：将n的后8位截取下来
  n = 00100100 10100100 00111101 11010110(n = 0x24a43dd6)
  m = 00000000 00000000 00000000 11111111(m = 0xff)
&---------------------------------------- 
  i = 00000000 00000000 00000000 11010110(i = n & m; // i = 0xd6)

3.2闰年的判断

import java.util.Scanner;
//闰年的判断  1.能被4整除，但不能被100整除。2.能被400整除。
public class LeapYear {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年份:");
		int year = scan.nextInt();
		
		//判断一个年份是否是闰年
		boolean flag = (year%4==0 && year%100!=0) 
				       || 
				       year%400==0;
		
		String str = flag ? year+"是闰年" : year+"不是闰年";
		System.out.println(str);
	}
}

3.3成绩等级判断

//成绩等级判断
public class ScoreLevel {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入成绩:");
		int score = scan.nextInt();
		
		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-不及格");
		}		
	}
}

3.4年龄判断程序

import java.util.Scanner;
//年龄判断程序
public class Age {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入年龄:");
		int age = scan.nextInt();
		
		//输出age是否在18到50之间
		System.out.println(age>=18 && age<=50);
	}
}

3.5收银柜台程序

import java.util.Scanner;
//收银柜台程序
public class Cashier {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入单价:");
		double unitPrice = scan.nextDouble();
		System.out.println("请输入数量:");
		double amount = scan.nextDouble();
		System.out.println("请输入金额:");
		double money = scan.nextDouble();
		
		//计算总价(单价*数量)
		double totalPrice=unitPrice*amount;
		if(totalPrice>=500){ //满500
			totalPrice*=0.8; //打8折
		}
		
		if(money>=totalPrice){ //够
			double change=money-totalPrice; //计算找零(金额-总价)
			System.out.println("总价:"+totalPrice+"，找零:"+change);
		}else{ //不够
			System.out.println("ERROR!您给的钱不够!");
		}
		
		
	}
}

3.6命令解析程序

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("输入错误");
		}
		
	}
}

3.7其它

public class Homework {
	public static void main(String[] args) {
        	
		//1.求两个数中的最大值
		int a=55,b=8;
		int max=a>b?a:b;
		System.out.println("max="+max);


			
		//2.两个数的排序
		int a=8,b=5;
		if(a>b){
			int t=a;
			a=b;
			b=t;
		}
		System.out.println("a="+a);
		System.out.println("b="+b);
		

		//3.三个数的排序
		int a=88,b=10,c=5;
		if(a>b){ //保证a<b
			int t=a;
			a=b;
			b=t;
		}
		if(a>c){ //保证a<c
			int t=a;
			a=c;
			c=t;
		}
		if(b>c){ //保证b<c
			int t=b;
			b=c;
			c=t;
		}
		System.out.println("a="+a);
		System.out.println("b="+b);
		System.out.println("c="+c);
		
			
		//4.判断一个年份是否是闰年
		int year = 2001;
		if(year%4==0 && year%100!=0 || year%400==0){
			System.out.println(year+"是闰年");
		}else{
			System.out.println(year+"不是闰年");
		}
		
		

		//5.根据年份和月份，算天数
		int year=2001; //年份
		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="+days);	
		
		/*
		 * 补充:
		 * 1.变量的作用域/范围:
		 *     从变量的声明开始，到包含它最近的大括号结束
		 * 2.变量的重名问题:
		 *     变量作用域重叠时，变量不能同名
		 */
		
		int a=5;
		if(a>2){
			//int a=55; //编译错误，作用域重叠时不能同名
			int b=8;
		}else{
			int b=88;
		}
		
		
		
		int a=5;
		if(a>2){
			int b=8;
			System.out.println(a);
			System.out.println(b);
		}
		System.out.println(a);
		//System.out.println(b); //编译错误，b超出作用范围了	
	
	}
}

import java.util.Scanner;
//猜字符游戏
public class GuessingGame {
	//主方法
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		char[] chs = generate(); //生成随机字符数组
		System.out.println(chs); //作弊
		int count = 0; //猜错的次数
		while(true){ //自造死循环 //exit
			System.out.println("猜吧!");
			String str = scan.next().toUpperCase(); //接收用户输入的字符串，并转换为大写字母
			if(str.equals("EXIT")){ //判断输入的是否是EXIT
				System.out.println("下次再来吧!");
				break;
			}
			char[] input = str.trim().toCharArray(); //去掉字符串两边的空格，并将其转换为字符数组
			int[] result = check(chs,input); //对比随机字符数组与用户输入的字符数组
			if(result[0]==chs.length){ //位置对个数为5表明猜对了
				int score = 100*chs.length-10*count; //每个字符100分，猜错一次扣10分
				System.out.println("恭喜你猜对了，得分为:"+score);
				break;
			}else{ //猜错了
				count++; //猜错次数增1
				System.out.println("字符对个数:"+result[1]+"，位置对个数:"+result[0]);
			}
		}
	}
	
	//生成随机字符数组
	public static char[] generate(){
		char[] chs = new char[5]; //随机字符数组
		char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
				'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
				'W', 'X', 'Y', 'Z' }; //随机生成的字符的范围
		boolean[] flags = new boolean[letters.length]; //开关数组，默认值为false，表示字符未存过
		for(int i=0;i<chs.length;i++){ //遍历随机字符数组
			int index;
			do{
				index = (int)(Math.random()*letters.length); //生成随机字符数组下标
			}while(flags[index]==true); //当index下标对应的开关为true时，表示字符已存过，则重新生成index下标
			                            //当index下标对应的开头为false时，循环结束，false表示未存过，则可以继续存储
			chs[i] = letters[index]; //基于下标去letters中获取对应的字符，而后赋值给chs中的每一个元素
			flags[index]=true; //将下标对应的开头改为true，表明字符已存过
		}
		return chs;
	}
	
	//对比:随机字符数组与用户输入的字符数组
	public static int[] check(char[] chs,char[] input){
		int[] result = new int[2]; //result[0]为位置对个数，result[1]为字符对个数
		for(int i=0;i<chs.length;i++){ //遍历随机字符数组
			for(int j=0;j<input.length;j++){ //遍历用户输入的字符数组
				if(chs[i]==input[j]){ //字符对
					result[1]++; //字符对个数增1
					if(i==j){ //位置对
						result[0]++; //位置对个数增1
					}
					break;
				}
			}
		}
		return result;
	}
}

七、循环演示

1. 前言

1.循环:反复执行一段相同或相似的代码
2.循环的三要素:
  1)循环变量的初始化
  2)循环的条件(以循环变量为基础)
  3)循环变量的改变(向着循环的结束变)
  循环变量:在循环过程中所改变的那个量
3.循环结构:
  3.1)while:先判断后执行，有可能一次都不执行
  3.2)do...while:先执行一次再判断，至少执行一次
                 第1要素与第3要素相同时
  3.3)for:应用率最高
4.break:跳出循环
  continue:跳过循环体中剩余语句而进入下一次循环

1.三种循环更佳适用情况:
  1)while:"当..."循环
  2)do..while:"直到..."循环
              第1要素与第3要素相同时首选
  3)for:固定次数循环，应用率最高
2.嵌套循环:
  1)循环中套循环，多行多列时使用，
    外层控制行，内层控制列
  2)执行过程:外层走一次，内层走所有次
  3)建议:嵌套层次越少越好
    能用一层就不用两层，能用两层就不用三层
    若需求必须通过三层以上来解决，说明设计有问题
  4)break只能跳出一层循环

2.while的演示

//while的演示
public class WhileDemo {
	public static void main(String[] args) {
		
		int num=1; //1
		while(num<=9){ //2
			System.out.println(num+"*9="+num*9);
			num++; //3
		}
		System.out.println("over");
		
		
		int count=0;     //1.循环变量的初始化
		while(count<10){ //2.循环的条件
			System.out.println("行动是成功的阶梯");
			count++;     //3.循环变量的改变
		}
		System.out.println("over");
		
		/*
		 * 执行过程:
		 * count=0 true 输出
		 * count=1 true 输出
		 * count=2 true 输出
		 * count=3 true 输出
		 * count=4 true 输出
		 * count=5 true 输出
		 * count=6 true 输出
		 * count=7 true 输出
		 * count=8 true 输出
		 * count=9 true 输出
		 * count=10 false while循环结束
		 * 输出over
		 */
	}
}

3.for循环的演示

//for循环的演示
public class ForDemo {
	public static void main(String[] args) {
		int sum=0; 
		for(int num=1;num<=100;num++){
			if(num%10!=3){
				sum+=num;
			}
		}
		System.out.println("sum="+sum);
		
		
		
		int sum=0; 
		for(int num=1;num<=100;num++){
			if(num%10==3){ //3,13,23,33...
				continue; //跳过剩余语句而进入下一次循环(去到num++)
			}
			sum+=num;
		}
		System.out.println("sum="+sum);
		
		/*
		 * num=1 sum=1
		 * num=2 sum=1+2
		 * num=3
		 * num=4 sum=1+2+4
		 */
		
		
		
		
		/** 死循环*/
		
		for(;;){ //死循环
			System.out.println("我要学习");
		}
		
		
		
		//求1到100的累加和 1+2+3+...+99+100=?
		int sum=0; //和
		for(int num=1;num<=100;num++){
			sum+=num; //在本身基础之上操作
		}
		System.out.println("sum="+sum);
		
		/*
		 * 执行过程:
		 * sum=0
		 * num=1 sum=1
		 * num=2 sum=1+2
		 * num=3 sum=1+2+3
		 * num=4 sum=1+2+3+4
		 * ...
		 * num=100 sum=1+2+3+4+...+100
		 * num=101 false for循环结束
		 */	
		
		
		
		for(int count=0;count<10;count++){
			System.out.println("行动是成功的阶梯");
		}
		System.out.println("over");
		
		/*
		 * 执行过程:
		 * count=0 true 输出
		 * count=1 true 输出
		 * count=2 true 输出
		 * ....
		 * count=9 true 输出
		 * count=10 false for循环结束
		 * 输出over
		 */
		
	}
}

4.随机加法运算器

//随机加法运算器
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); //加数
			int b = (int)(Math.random()*100); //加数
			int result=a+b; //存答案
			System.out.println("("+i+")"+a+"+"+b+"=?"); //1.出题
			
			System.out.println("算吧!");
			int answer = scan.nextInt(); //2.答题
			
			if(answer==-1){
				break;
			}
			if(answer==result){ //3.判题
				System.out.println("答对了");
				score+=10; //答对一题加10分
			}else{
				System.out.println("答错了");
			}
			
		}
		System.out.println("得分:"+score);
	}
}

5.猜数字游戏

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);
		
		int guess;
		do{
			System.out.println("猜吧!");
			guess = scan.nextInt(); //1,3
			if(guess==0){
				break;
			}
			if(guess>num){
				System.out.println("太大了");
			}else if(guess<num){
				System.out.println("太小了");
			}
		}while(guess!=num); //2
		if(guess==num){
			System.out.println("恭喜你，猜对了!");
		}else{
			System.out.println("下次再来吧!");
		}
		
		/*
		System.out.println("猜吧!");
		int guess = scan.nextInt(); //1.
		while(guess!=num){ //2.
			if(guess==0){
				break;
			}
			if(guess>num){
				System.out.println("太大了");
			}else{
				System.out.println("太小了");
			}
			System.out.println("猜吧!");
			guess = scan.nextInt(); //3.
		}
		if(guess==num){
			System.out.println("恭喜你，猜对了!");
		}else{
			System.out.println("下次再来吧!");
		}
		*/
	}
}

6.其它案例

public class Homework {
	public static void main(String[] args) {
		/*  1/1+1/2+1/3+...+1/n=?  */
		int n=15;
		double sum = 0; //和
		for(int i=1;i<=n;i++){ //n次
			sum=sum+1.0/i;
		}
		System.out.println("sum="+sum);
		
		/*9+99+999+...+9999999999=?*/
		long sum = 0; //和
		long num = 0; //加数
		for(int i=1;i<=10;i++){ //10次
			num=num*10+9;
			sum=sum+num;
		}
		System.out.println("sum="+sum);		
		
		/*
		 * sum=0 num=0
		 * i=1 num=9     sum=9
		 * i=2 num=99    sum=9+99
		 * i=3 num=999   sum=9+99+999
		 * i=4 num=9999  sum=9+99+999+9999
		 */
		
		
		/*     
		 *     num=0      num=num  *10+9
		 * i=1 num=9      num=0    *10+9
		 * i=2 num=99     num=9    *10+9
		 * i=3 num=999    num=99   *10+9
		 * i=4 num=9999   num=999  *10+9
		 * i=5 num=99999  num=9999 *10+9
		 */
	}
}

import java.util.Scanner;

public class GuessingGame {
	public static void main(String[] args) {
		// 表示玩家猜测的次数
		int count = 0;
		// 用于保存判断的结果
		int[] result = new int[2];
		Scanner scanner = new Scanner(System.in);
		System.out.println("GuessingGame>欢迎尝试猜字母游戏！");
		// 表示猜测的字符串
		char[] chs = generate();
		System.out.println(chs);
		System.out.println("GuessingGame>游戏开始，请输入你所猜的5个字母序列：（exit——退出）");
		while (true) {
			String inputStr = scanner.next().trim().toUpperCase();
			if ("EXIT".equals(inputStr)) {
				System.out.println("GuessingGame>谢谢你的尝试，再见！");
				break;
			}

			char[] input = inputStr.toCharArray();
			result = check(chs, input);
			if (result[0] == chs.length) {// 完全猜对的情况
				int score = 100 * chs.length - count * 10;
				System.out.println("GuessingGame>恭喜你猜对了！你的得分是：" + score);
				break;
			} else {
				count++;
				System.out.println("GuessingGame>你猜对" + result[1] + "个字符，其中"
						+ result[0] + "个字符的位置正确！（总次数=" + count + "，exit——退出）");
			}
		}
		scanner.close();
	}

	/**
	 * 随机生成需要猜测的字母序列
	 * 
	 * @return 存储随机字符的数组
	 */
	public static char[] generate() {
		
		char[] letters = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
				'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
				'W', 'X', 'Y', 'Z' };
		boolean[] flags = new boolean[letters.length];
		char[] chs = new char[5];
		for (int i = 0; i < chs.length; i++) {
			int index;
			do {
				index = (int) (Math.random() * (letters.length));
			} while (flags[index]);// 判断生成的字符是否重复
			chs[i] = letters[index];
			flags[index] = true;
		}
		return chs;
	}

	/**
	 * 比较玩家输入的字母序列和程序所生成的字母序列，逐一比较字符及其位置，并记载比较结果
	 * 
	 * @param chs
	 *            程序生成的字符序列
	 * @param input
	 *            玩家输入的字符序列
	 * @return 存储比较的结果。返回值int数组 的长度为2，其中，索引为0的位置
	 *         用于存放完全猜对的字母个数(字符和位置均正确)，索引为1的位置用于存放猜对的字母个数(字符正确，但是位置不正确)。
	 */
	public static int[] check(char[] chs, char[] input) {
		int[] result = new int[2];
		for (int i = 0; i < input.length; i++) {
			for (int j = 0; j < chs.length; j++) {
				if (input[i] == chs[j]) {// 判断字符是否正确
					result[1]++;
					if (i == j) {// 判断位置是否正确
						result[0]++;
					}
					break;
				}
			}
		}
		return result;
	}
}

//九九乘法表：正三角形乘法口诀 从左到右写
/*
  1*1=1
  1*2=2  2*2=4
    *    *
    *    *           *****
  1*9=9  2*9=18                    9*9=81
*/

public class NstFor {
	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  换行
		 * num=2
		 *   i=1 1*2=2
		 *   i=2 2*2=4
		 *   i=3  换行
		 * num=1
		 *   i=1 1*1=1
		 *   i=2  换行
		 */
		
	}
}

八、数组演示

1.前言

3.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
    数据结构:将数据按照某种特定的结构来保存
             数怎么存
  2)设计良好的数据结构会导致好的算法
4.数组:
  1)相同数据类型元素的集合
  2)数组是一种数据类型(引用类型)
  3)数组的定义:
      int[] arr = new int[10];
  4)数组的初始化:
      int[] arr = new int[3];       //0,0,0
      int[] arr = {1,4,7};          //1,4,7
      int[] arr = new int[]{1,4,7}; //1,4,7
      int[] arr;
      arr = {1,4,7}; //编译错误
      arr = new int[]{1,4,7}; //正确
	  int[] arr = new int[]{}：//创建一个int类型的数组,名字为arr但是里面没有任何东西,所以长度为0
  5)数组的访问
    5.1)通过数组名.length获取数组的长度
        int[] arr = new int[3];
        System.out.println(arr.length); //3
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到数组.length-1
	int[] arr = new int[3];
        arr[0] = 100; //给arr中的第1个元素赋值为100
        arr[1] = 200;
	arr[2] = 300;
	arr[3] = 400; //异常(数组下标越界)
        System.out.println(arr[arr.length-1]); //输出数组中的最后一个元素
	arr[arr.length-1] = 800;
  6)数组的遍历:
      int[] arr = new int[3];
      for(int i=0;i<arr.length;i++){
        arr[i] = 100;
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }
  7)数组的复制:
      System.arraycopy(a,1,a1,0,4);
      int[] a1 = Arrays.copyOf(a,6);
      a = Arrays.copyOf(a,a.length+1);
  8)数组的排序:
      Arrays.sort(arr); //arr升序排
      冒泡排序

2.数组演示

import java.util.Arrays;
//数组的演示
public class ArrayDemo {
	public static void main(String[] args) {
	
		//1.数组的定义
		int[] arr = new int[10];	

		//2.数组的初始化
		int[] arr = new int[3]; //0,0,0
		int[] arr1 = {1,3,5};   //1,3,5
		int[] arr2 = new int[]{1,3,5}; //1,3,5
		int[] arr3;
		//arr3 = {1,3,5}; //编译错误，只能声明同时初始化
		arr3 = new int[]{1,3,5}; //正确
		int[] arr = new int[]{}：//创建一个int类型的数组,名字为arr但是里面没有任何东西,所以长度为0
        
		//声明int型数组a，包含10个元素
		//每个元素都是int型，默认值为0
		int[] a = new int[10];
		//声明double型数组d，包含20个元素
		//每个元素都是double型，默认值为0.0
		double[] d = new double[20];
		//声明boolean型数组b，包含40个元素
		//每个元素都是boolean型，默认值为false
		boolean[] b = new boolean[40];

        
		//3.数组的访问
		int[] arr = new int[3];
		System.out.println(arr.length); //3
		arr[0] = 100; //给arr中第一个元素赋值为100
		arr[1] = 200;
		arr[2] = 300;
		//arr[3] = 400; //数组下标越界异常
		System.out.println(arr[arr.length-1]); //输出arr中最后一个元素的值

		//4.数组的遍历
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++){ //遍历arr数组
			arr[i] = (int)(Math.random()*100);
			System.out.println(arr[i]);
		}
		

		
		//5.数组的复制
		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]);// 10,20,30,40,50 ,0
		}	
		
		
		int[] a = {10,20,30,40,50};
		//a:源数组
		//a1:目标数组
		//6:目标数组的长度
		int[] a1 = Arrays.copyOf(a,6);
		for(int i=0;i<a1.length;i++){
			System.out.println(a1[i]);// 10,20,30,40,50 ,0
		}
		
		
		
		int[] a = {10,20,30,40,50};
		int[] a1 = new int[6];
		//a:源数组
		//1:源数组的起始下标
		//a1:目标数组
		//0:目标数组的起始下标
		//4:要复制的元素的个数
		System.arraycopy(a,1,a1,0,4);
		for(int i=0;i<a1.length;i++){
			System.out.println(a1[i]);
		}
		
	  //6.数组的排序
		int[] arr = {23,45,4,27,5,87,9};
		for(int i=0;i<arr.length-1;i++){ //控制轮数
			for(int j=0;j<arr.length-1-i;j++){ //控制每轮比较的次数
				if(arr[j]>arr[j+1]){ //每一次都是和它的下一个元素比
					int t=arr[j]; //符合条件则交换
					arr[j]=arr[j+1];
					arr[j+1]=t;
				}
				//若前数大于后数则交换，保证前数小于后数--升序
				//若前数小于后数则交换，保证前数大于后数--降序
			}
		}
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		
		
		int[] arr = {26,34,1,3,68};
		Arrays.sort(arr); //对arr升序排列
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
		
		
	}
}

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);
			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]);
		}
       /**	   
			冒泡原理:
			1)四个数冒3轮
			2)每一轮都是从第1个元素开始比，
			  每一次都是和它的下一个元素比
			  若符合条件则交换
			3)冒出来的数就不带它玩了

				 arr.length-1-i
			i=0  比3次
			i=1  比2次
			i=2  比1次  

			int[] arr = {89,23,36,1}; //升序
			第一轮:
			  89和23比，换，23,89,36,1
			  89和36比，换，23,36,89,1
			  89和1比， 换，23,36,1,89-----89冒出来了
			第二轮:
			  23和36比，不换
			  36和1比， 换，23,1,36,89-----36冒出来了
			第三轮:
			  23和1比， 换，1,23,36,89-----23冒出来了
	   
	   */
	   int[] arr = {89,23,36,1};
       for(int i=0;i<arr.length-1;i++){ //控制轮
		  for(int j=0;j<arr.length-1-i;j++){ //控制每轮的次数
			if(arr[j]>arr[j+1]){ //每次和它下一个元素比
			  int t=arr[j];
			  arr[j]=arr[j+1];
			  arr[j+1]=t;
			}
		  }
		}


     
		
	}
}

import java.util.Arrays;
//作业讲解 Math.sqrt(num)返回x的平方根 
public class Homework {
	public static void main(String[] args) {
		int count = 0; //计数器
		for(int num=2;num<=100;num++){
			boolean flag = true; //1.假设是质数：质数定义为在大于1的自然数中，除了1和它本身以外不再被整除。
			for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/
				if(num%i==0){
					flag = false; //2.表示不是质数
					break;
				}
			}
			if(flag){ //3.判断得结论
				count++; //有一个质数则个数增1
				System.out.print(num+"\t");
				if(count%10==0){ //每10个换一行
					System.out.println();
				}
			}
		}
		
		
	}
}