java基础语法_int public=100哪里错了-CSDN博客

1：关键字

关键字概述：被Java语言赋予特定含义的单词
关键字特点：组成关键字的字母全部小写
关键字注意事项：goto和const作为保留字存在,目前并不使用
类似Notepad++这样的高级记事本,针对关键字有特殊的颜色标记，非常直观

2：标识符

标识符：就是给类，接口，方法，变量等起名字。就是给相应的类接口方法变量等的起名字的

组成规则：
  A:英文字母大小写
  B:数字字符
  C:$和_

注意事项：
  A:不能以数字开头
  B:不能是Java中的关键字
  C:Java语言严格区分大小写

常见的命名规则：见名知意
  举例：我要定义一个学生类
   class Student {}
   class S{}

  包：其实就是文件夹，用于把相同的类名进行区分
   全部小写

   单级：liuyi
   多级：cn.itcast
    cn
     itcast

  类或者接口：
   一个单词：单词的首字母必须大写
    举例：Student,Dog
   多个单词：每个单词的首字母必须大写
    举例：HelloWorld,StudentName


  方法或者变量：
   一个单词：单词的首字母小写
    举例：main,age
   多个单词：从第二个单词开始，每个单词的首字母大写
    举例：studentAge,showAllNames()

  常量：
   一个单词：全部大写
    举例：PI
   多个单词：每个字母都大写，用_隔开
    举例：STUDENT_MAX_AGE

  规律是这样的
   在最高级的起名字时要将首字母和相应的第二个单词的子目是要大写的
    在给相应的变量起名字是要将第一个首字母是小写得而将第二个单词的首字母是要大些
     在相应的常量在起名字是要将所有的单词是要全部的大些的

class MakeNameDemo {
public static void main(String[] args) {
  //正确做法
  int x = 100;

  //不能以数字开头
  //int 1y = 100;
  int y1 = 100;

  //不能是Java中的关键字
  //int public = 100;
  int Public = 100;
}
}

3：注释
(1)就是对程序进行解释说明的文字
(2)分类：
  A:单行注释 //
  B:多行注释 /**/
  C:文档注释(后面讲) /** */

注释的作用
A:解释说明程序，提高了代码的阅读性。
B:可以帮助我们调试程序。

需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台

分析： A:要写一个Java程序，必须定义类

B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法

C:把数据输出在控制台，必须使用输出语句

实现： A:java语言提供了一个关键字：class用来定义类，后面跟的是类名

B:main方法的格式是固定的： public static void main(String[] args) { }

C:输出语句的格式是固定的： System.out.println("HelloWorld"); "HelloWorld"这个内容是可以改变的

这是我的HelloWorld案例

class HelloWorld { /* 为了程序能够独立运行，定义main方法 main方法是程序的入口

vm自动调用 */

public static void main(String[] args) { //为了把数据显示在控制台，我们就使用了输出语句

System.out.println("HelloWorld");

}

4：常量
常量：
  在程序执行过程中，其值不发生改变的量。

分类：
  A:字面值常量
  B:自定义常量(后面讲)

字面值常量
  A:字符串常量用双引号括起来的内容。
   举例："hello","world","HelloWorld"
  B:整数常量所有的整数
   举例：100,200
  C:小数常量所有的小数
   举例：10.23,110.11
  D:字符常量用单引号括起来的内容
   举例：'a','A','0'
   错误的：'ab'
  E:布尔常量比较特殊
   举例：true,false
  F:空常量后面讲
   举例：null

class ConstantDemo {
public static void main(String[] args) {
  //字符串常量的输出
  System.out.println("hello");

  //整数常量的输出
  System.out.println(100);

  //小数常量的输出
  System.out.println(100.10);

  //字符常量的输出
  System.out.println('a');
  System.out.println('A');
  System.out.println('0');
  //这个是有问题的
  //System.out.println('ab');

  //布尔常量的输出
  System.out.println(true);
  System.out.println(false);
}
}

5：进制转换
不同进制的数据表现：
  二进制：由0，1组成。以0b开头。
  八进制：由0,1,...7组成。以0开头。
  十进制：由0,1,...9组成。默认整数是十进制。
  十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。
class JinZhiDemo {
public static void main(String[] args) {
  System.out.println(100); //十进制

  System.out.println(0b100); //二进制
  System.out.println(0100); //八进制
  System.out.println(0x100); //十六进制
}
}

图一：进制概述以及二进制，八进制，十六进制图解

图二：进制快速转化

图三任意进制到十进制的转换

图四十进制到任意进制的转换

图五原码反码补码的讲解

6：变量与数据类型

数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。

数据类型分类：A:基本数据类型 B:引用数据类型(类,接口,数值)
基本数据类型:4类8种
  A:整数   占用字节数
   byte   1
   short   2
   int     4
   long    8

  B:浮点数
   float    4
   double    8

  C:字符
   char   2
  D:布尔
   boolean   1
注意：
   整数默认是int类型
   浮点数默认是double类型。

   长整型后缀用L或者l标记。建议使用L。
   单精度浮点数用F或者f标记。建议使用F。

图六变量的概述及格式

*/
class DataTypeDemo {
public static void main(String[] args) {
  //定义变量的格式：
  //数据类型变量名 = 初始化值;

  //定义一个字节变量
  byte b = 10;
  System.out.println(10);
  System.out.println(b);

  //定义一个短整型变量
  short s = 100;
  System.out.println(s);

  //定义一个整型变量
  int i = 1000;
  System.out.println(i);

  //超过了int的范围
  //int j = 1000000000000;
  long j = 1000000000000L;
  //long j = 100L;
  System.out.println(j);

  //定义浮点数据变量
  float f = 12.345F;
  System.out.println(f);

  double d = 12.345;
  System.out.println(d);

  //定义字符变量
  char ch = 'a';
  System.out.println(ch);

  //定义布尔变量
  boolean flag = true;
  System.out.println(flag);
}
}

/*
使用变量的时候要注意的问题：
  A:作用域
   变量定义在哪个大括号内，它就在这个大括号内有效。
   并且，在同一个大括号内不能同时定义同名的变量。

  B:初始化值
   没有初始化值的变量不能直接使用。
   你只要在使用前给值就行，不一定非要在定义的时候立即给值。
   推荐在定义的时候给值。

   定义变量的格式：
    a:数据类型变量名 = 初始化值;
    b:数据类型变量名;
      变量名 = 初始化值;

  C:在一行上建议只定义一个变量
   可以定义多个，但是不建议
*/
class DataTypeDemo2 {
public static void main(String[] args) {
  //定义变量
  int x = 100;

  //错误，不能有同名的
  //int x = 200;

  //定义变量必须给值
  //int y;
  //System.out.println(y);

  int z;
  z = 100;
  System.out.println(z);

  //在一行上定义多个变量
  //int a = 10; int b = 20; int c = 30;
  //上面的写法可以，但是不建议。
  int a = 10;
  int b = 20;
  int c = 30;

  //int d, e;
  //d = 40;
  //e = 50;

  //int f,int g; //错误
  //int h; int i; //正确
}
}

/*
+是一个运算。做加法运算的。

一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。

注意：boolean类型不能转换为其他的数据类型    默认转换(从小到大的转换)
  A:byte,short,char—int—long—float—double
  B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型

图七不同数据类型变量参与运算图解

class DataTypeDemo3 {
public static void main(String[] args) {
  //直接输出的方式做加法
  //System.out.println(3 + 4);

  //两个int类型做加法
  int x = 3;
  int y = 4;
  int z = x + y;
  System.out.println(z);

  //定义一个byte类型，一个int类型，做加法
  byte a = 3;
  int b = 4;
  System.out.println(a + b);

  //可能损失精度
  //byte c = a + b;
  int c = a + b;
  System.out.println(c);
}
}

/*
强制转换：
  从大的数据类型到小的数据类型。

  格式：
   目标数据类型变量 = (目标数据类型) (被转换的数据);

  注意：
   不要随意的去使用强制转换，因为它隐含了精度损失问题。
*/
class DataTypeDemo4 {
public static void main(String[] args) {
  byte a = 3;
  int b = 4;

  //这个肯定没有问题
  //int c = a + b;

  //byte c = 7;
  //这个是有问题的
  //byte c = a + b;
  //用强制类型转换改进
  byte c = (byte) (a + b);
  System.out.println(c);
}
}

思考题1：请问下面这个有没有问题
  double d = 12.345;
  float f = d;

思考题2：看看下面两个定义有没有区别呢?
  float f1 = (float)12.345;
  float f2 = 12.345f;

  f1其实是通过一个double类型转换过来的。
  而f2本身就是一个float类型。

class DataTypeDemo5 {
public static void main(String[] args) {
  //把double赋值给float，加了强制类型转换
  double d = 12.345;
  float f = (float)d;

  //看看下面两个定义有没有区别呢?
  float f1 = (float)12.345;
  float f2 = 12.345F;
}
}

/*
面试题：
  byte b1=3,b2=4,b;
  b=b1+b2;
  b=3+4;
  哪句是编译失败的呢？为什么呢？
  b = b1 + b2;是有问题的。
  因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。
  常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。
*/
class DataTypeDemo6 {
public static void main(String[] args) {
  //定义了三个byte类型的变量，b1，b2，b3
  //b1的值是3，b2的值是4，b没有值
  byte b1 = 3,b2 = 4,b;

  //b = b1 + b2; //这个是类型提升，所有有问题

  b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
}
}

/*
byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?

练习：byte b = (byte)300;
*/
class DataTypeDemo7 {
public static void main(String[] args) {
  //因为byte的范围是：-128到127。
  //而130不在此范围内，所以报错。
  //byte b = 130;

  //我们可以使用强制类型转换
  byte b = (byte) 130;

  //结果是多少呢?
  System.out.println(b);
}
}
/*
分析过程：
  我们要想知道结果是什么，就应该知道是如何进行计算的。
  而我们又知道计算机中数据的运算都是补码进行的。
  而要得到补码，首先要计算出数据的二进制。

  A:获取130这个数据的二进制。
   00000000 00000000 00000000 10000010
   这是130的原码，也是反码，还是补码。
  B:做截取操作，截成byte类型的了。
   10000010
   这个结果是补码。
  C:已知补码求原码。
     符号位  数值位
   补码： 1   0000010

   反码： 1   0000001

   原码： 1   1111110
*/

/*
看程序写结果

通过字符和一个整数相加，我们给出一张表：ASCII码表。
  通过看完这张表以后，我们要记住三个值：
   'a'  97
   'A'  65
   '0'  48
*/
class DataTypeDemo8 {
public static void main(String[] args) {
  //直接输出一个字符
  System.out.println('a'); //a
  //输出一个字符和一个整数做加法
  System.out.println('a'+1); //98
}
}

/*
看程序写结果
  字符串数据和其他数据做+，结果是字符串类型。
  这里的+不是加法运算，而是字符串连接符。
*/
class DataTypeDemo9 {
public static void main(String[] args) {
  System.out.println("hello"+'a'+1); //helloa1
  System.out.println('a'+1+"hello"); //98hello

  System.out.println("5+5="+5+5); //5+5=55
  System.out.println(5+5+"=5+5"); //10=5+5
}
}

7 运算符：
就是对常量和变量进行操作的符号。

分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符

算术运算符：
  +,-,*,/,%,++,--

注意事项：
  A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
  B:/获取的是除法操作的商，%获取的是除法操作的余数

class OperatorDemo {
public static void main(String[] args) {
  //定义变量
  int x = 3; //把3赋值给int类型的变量x
  int y = 4;

  System.out.println(x+y);
  System.out.println(x-y);
  System.out.println(x*y);
  System.out.println(x/y); //整数相除只能得到整数

  //我就想得到小数，该肿么办呢?
  //只需要把操作的数据中任意的一个数据变为浮点数
  System.out.println(x*1.0/y);

  //%的应用
  System.out.println(x%y); //得到的是余数
}
}

++,--运算符的使用：
  单独使用：
   放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
  参与运算使用：
   放在操作数的前面，先自增或者自减，然后再参与运算。
   放在操作数的后面，先参与运算，再自增或者自减。

作用：就是对变量进行自增1或者自减1。

class OperatorDemo2 {
  public static void main(String[] args) {
   //定义两个变量
   int x = 3;
   int y = 4;

   //字符串的拼接
   //System.out.println("x:"+x);
   //System.out.println("y:"+y);

   System.out.println("x:"+x+",y:"+y);

   //单独使用
   //x++;
   //y--;
   ++x;
   --y;
   //System.out.println(x);
   System.out.println("x:"+x+",y:"+y);

   //意外的类型,常量是不可以这样做的
   //System.out.println(10++);

   System.out.println("-------------------");
   //参与运算使用
   int a = 3;
   int b = 4;

   //int c = a++;
   //int d = b--;

   int c = ++a;
   int d = --b;

   System.out.println("a:"+a); //4, 4
   System.out.println("b:"+b); //3, 3
   System.out.println("c:"+c); //3, 4
   System.out.println("d:"+d); //4, 3
  }
}

+的用法：
  A:加法
  B:正号
  C:字符串连接符

class OperatorDemo3 {
public static void main(String[] args) {
  //加法
  System.out.println(3+4);

  //正号
  System.out.println(+4);

  System.out.println('a');
  System.out.println('a'+1); //这里是加法

  //字符串连接符
  System.out.println("hello"+'a'+1);
  System.out.println('a'+1+"hello");
}
}

++,--的练习题

第一题：
int a = 10;
int b = 10;
int c = 10;

a = b++;
c = --a;
b = ++a; 先自加后的出运算
a = c--;
请分别计算出a,b,c的值

int x = 4;
int y = (x++)+(++x)+(x*10);
请分别计算出x,y的值

class OperatorTest {
public static void main(String[] args) {
  int a = 10;
  int b = 10;
  int c = 10;

  a = b++; //a=10,b=11,c=10
  c = --a; //a=9,b=11,c=9
  b = ++a; //a=10,b=10,c=9
  a = c--; //a=9,b=10,c=8

  System.out.println("a:"+a);
  System.out.println("b:"+b);
  System.out.println("c:"+c);
  System.out.println("--------------");

  int x = 4;
  int y = (x++)+(++x)+(x*10);
  //4+6+60
  //x=5,6

  System.out.println("x:"+x);
  System.out.println("y:"+y);
}
}

8 赋值运算符：
  基本的赋值运算符：=
   把=右边的数据赋值给左边。

  扩展的赋值运算符：+=,-=,*=,/=,%=
   += 把左边和右边做加法，然后赋值给左边。
   a+=a :等于a=a+a;
class OperatorDemo {
public static void main(String[] args) {
  //定义一个变量
  int x = 10;

  //其他用法
  int a,b;
  a = b = 10;
  System.out.println(a);
  System.out.println(b);
  System.out.println("-----------");

  //定义一个变量
  int y = 10;

  y += 20; // y=y+20;

  System.out.println(y); // 30

}
}

面试题：
  short s=1;s = s+1;

  short s=1;s+=1;
  上面两个代码有没有问题，如果有，那里有问题。

  为什么第二个木有问题呢?
   扩展的赋值运算符其实隐含了一个强制类型转换。
    这是非常重要得要记住啊扩展的有一个强制类型转换的问题

   s += 1;
   不是等价于 s = s + 1;
   而是等价于 s = (s的数据类型)(s + 1);
class OperatorTest {
public static void main(String[] args) {
  //short s = 1;
  //s = s + 1;
  //System.out.println(s);

  short s = 1;
  s += 1; //好像是 s = s + 1;
  System.out.println(s);
}
}

9比较运算符：
==,!=,>,>=,<,<=

特点：
  无论你的操作是简单还是复杂，结果是boolean类型。

注意事项：
  "=="不能写成"="。== 好像比较的是内存当中的值是不是相等的
*/
class OperatorDemo {
public static void main(String[] args) {
  int x = 3;
  int y = 4;
  int z = 3;

  System.out.println(x == y);
  System.out.println(x == z);
  System.out.println((x+y) == (x+z));
  System.out.println("------------");

  System.out.println(x != y);
  System.out.println(x > y);
  System.out.println(x >= y);
  System.out.println(x < y);
  System.out.println(x <= y);
  System.out.println("------------");

  int a = 10;
  int b = 20;

//boolean flag = (a == b);
  //boolean flag = (a = b); //这个是有问题的，不兼容的类型
  //System.out.println(flag);

  int c = (a = b); //把b赋值给a，然后把a留下来
  System.out.println(c); // 就是a的值
}
}

10 逻辑运算符：
  &,|,^,!
  &&,||

特点：
  逻辑运算符一般用于连接boolean类型的表达式或者值。他们的结果是布尔类型的

  表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
   算术表达式：a + b
   比较表达式：a == b

结论：
  &逻辑与:有false则false。当两个是相同时的到的就是正确的就是true
  |逻辑或:有true则true。有一个是正确的是就是正确的
  ^逻辑异或:相同为false，不同为true。和|是相反的
   举例：情侣关系。男男,男女,女男,女女
  !逻辑非:非false则true，非true则false。
   特点：偶数个不改变本身。

class OperatorDemo {
public static void main(String[] args) {
  int a = 3;
  int b = 4;
  int c = 5;

  //&逻辑与
  System.out.println((a > b) & (a > c)); //false & false = false
  System.out.println((a > b) & (a < c)); //false & true = false
  System.out.println((a < b) & (a > c)); //true & false = false
  System.out.println((a < b) & (a < c)); //true & true = true
  System.out.println("---------------");

  //|逻辑或
  System.out.println((a > b) | (a > c)); //false | false = false
  System.out.println((a > b) | (a < c)); //false | true = true
  System.out.println((a < b) | (a > c)); //true | false = true
  System.out.println((a < b) | (a < c)); //true | true = true
  System.out.println("---------------");

  //^逻辑异或
  System.out.println((a > b) ^ (a > c)); //false ^ false = false
  System.out.println((a > b) ^ (a < c)); //false ^ true = true
  System.out.println((a < b) ^ (a > c)); //true ^ false = true
  System.out.println((a < b) ^ (a < c)); //true ^ true = false
  System.out.println("---------------");

  //!逻辑非
  System.out.println(!(a > b)); //!false = true
  System.out.println(!(a < b)); //!true = false
  System.out.println(!!(a > b)); //!!false = false
  System.out.println(!!!(a > b)); //!!false = true
}
}

&&和&的区别? 同理||和|的区别?
  A:最终结果一样。
  B:&&具有短路效果。左边是false，右边不执行。

开发中常用的逻辑运算符：
  &&,||,!

class OperatorDemo2 {
public static void main(String[] args) {
  int a = 3;
  int b = 4;
  int c = 5;

  //&&双与
  System.out.println((a > b) && (a > c)); //false && false = false
  System.out.println((a > b) && (a < c)); //false && true = false
  System.out.println((a < b) && (a > c)); //true && false = false
  System.out.println((a < b) && (a < c)); //true && true = true
  System.out.println("----------------");

  int x = 3;
  int y = 4;

  //boolean b1 = ((x++ == 3) & (y++ == 4));
  //boolean b1 = ((x++ == 3) && (y++ == 4));
  //boolean b1 = ((++x == 3) & (y++ == 4));
  boolean b1 = ((++x == 3) && (y++ == 4));
  System.out.println("x:"+x);
  System.out.println("y:"+y);
  System.out.println(b1);
}
}

11位运算符：
  &,|,^,~
  <<,>>,>>>

注意：
  要做位运算，首先要把数据转换为二进制。
*/
class OperatorDemo {
public static void main(String[] args) {
  //&,|,^,~

  int a = 3;
  int b = 4;

  System.out.println(3 & 4);
  System.out.println(3 | 4);
  System.out.println(3 ^ 4);
  System.out.println(~3);
}
}
分析：因为是位运算，所以我们必须先把数据换算成二进制。

3的二进制：11
  00000000 00000000 00000000 00000011
4的二进制：100
  00000000 00000000 00000000 00000100

&位与运算：有0则0。
  00000000 00000000 00000000 00000011
    &00000000 00000000 00000000 00000100
  -----------------------------------
  00000000 00000000 00000000 00000000
  结果是：0

|位或运算：有1则1。
  00000000 00000000 00000000 00000011
    |00000000 00000000 00000000 00000100
  -----------------------------------
  00000000 00000000 00000000 00000111
  结果是：7

^位异或运算：相同则0，不同则1。
  00000000 00000000 00000000 00000011
    &00000000 00000000 00000000 00000100
  -----------------------------------
  00000000 00000000 00000000 00000111
  结果是：7

~按位取反运算符：0变1，1变0
  00000000 00000000 00000000 00000011
    ~11111111 11111111 11111111 11111100 (补码)

    补码：11111111 11111111 11111111 11111100
    反码：11111111 11111111 11111111 11111011
    原码：10000000 00000000 00000000 00000100
  结果是：-4

^的特点：一个数据对另一个数据位异或两次，该数本身不变。
class OperatorDemo2 {
public static void main(String[] args) {
  int a = 10;
  int b = 20;

  System.out.println(a ^ b ^ b); //10
  System.out.println(a ^ b ^ a); //20
}
}

<<:左移左边最高位丢弃，右边补齐0
>>:右移最高位是0，左边补齐0；最高为是1，左边补齐1
>>>:无符号右移无论最高位是0还是1，左边补齐0

面试题：
  请用最有效率的方式写出计算2乘以8的结果?
   2 * 8

   2 << 3

class OperatorDemo3 {
public static void main(String[] args) {
  //<< 把<<左边的数据乘以2的移动次幂
  System.out.println(3 << 2); //3*2^2 = 3*4 = 12;

  //>> 把>>左边的数据除以2的移动次幂
  System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
  System.out.println(24 >>> 2);

  System.out.println(-24 >> 2);
  System.out.println(-24 >>> 2);
}
}

计算出3的二进制：11
  00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100

>>的移动：
计算出24的二进制：11000
  原码：10000000 00000000 00000000 00011000
  反码：11111111 11111111 11111111 11100111
  补码：11111111 11111111 11111111 11101000

  11111111 11111111 11111111 11101000
  1111111111 11111111 11111111 111010(00) 补码

  补码：1111111111 11111111 11111111 111010
  反码：1111111111 11111111 11111111 111001
  原码：1000000000 00000000 00000000 000110

  结果：-6

>>>的移动：
  计算出24的二进制：11000
  原码：10000000 00000000 00000000 00011000
  反码：11111111 11111111 11111111 11100111
  补码：11111111 11111111 11111111 11101000

  11111111 11111111 11111111 11101000
  0011111111 11111111 11111111 111010(00)


面试题：
  请自己实现两个整数变量的交换
  注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
class OperatorTest {
public static void main(String[] args) {
  int a = 10;
  int b = 20;

  System.out.println("a:"+a+",b:"+b);

  //方式1：使用第三方变量(开发中用的)
  /*
  int c = a;
  a = b;
  b = c;
  System.out.println("a:"+a+",b:"+b);
  System.out.println("------------");
  */

  //方式2：用位异或实现(面试用)
  //左边：a,b,a
  //右边：a ^ b
  /*
  a = a ^ b;
  b = a ^ b; //a ^ b ^ b = a
  a = a ^ b; //a ^ b ^ a = b
  System.out.println("a:"+a+",b:"+b);
  */

  //方式3：用变量相加的做法
  /*
  a = a + b; //a=30
  b = a - b; //b=10
  a = a - b; //a=20
  System.out.println("a:"+a+",b:"+b);
  */

  //方式4：一句话搞定
  b = (a+b) - (a=b); //b=30-20=10,a=20
  System.out.println("a:"+a+",b:"+b);
}
}

12 三木运算
单目运算符：~3
双目运算符：3 + 4

三目运算符：
  格式：比较表达式?表达式1:表达式2;

  比较表达式:结果是一个boolean类型。

  执行流程：
   根据比较表达式的计算返回一个true或者false。
   如果是true，就把表达式1作为结果。
   如果是false，就把表达式2作为结果。

class OperatorDemo {
public static void main(String[] args) {
  int x = 100;
  int y = 200;

  int z = ((x > y)? x: y);

  //int z = ((x < y)? x: y);

  //int z = ((x == y)? x: y);

  //报错
  //int z = ((x = y)? x : y);

  System.out.println("z:"+z);
}
}

练习：
  获取两个整数中的最大值
  获取三个整数中的最大值
  比较两个整数是否相同

class OperatorTest {
public static void main(String[] args) {
  //获取两个整数中的最大值
  int x = 100;
  int y = 200;

  int max = (x > y? x: y);
  System.out.println("max:"+max);
  System.out.println("--------");

  //获取三个整数中的最大值
  int a = 10;
  int b = 30;
  int c = 20;

  //分两步：
  //A:先比较a,b的最大值
  //B:拿a,b的最大值在和c进行比较
  int temp = ((a > b)? a: b);
  //System.out.println(temp);
  int max1 = (temp > c? temp: c);
  System.out.println("max1:"+max1);

  //一步搞定
  //int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
  //这种做法不推荐。
  //int max2 = a > b?a > c? a: c:b > c? b: c;
  //System.out.println("max2:"+max2);
  System.out.println("--------");

  //比较两个整数是否相同
  int m = 100;
  int n = 200;

  //boolean flag = (m == n)? true: false;
  boolean flag = (m == n);
  System.out.println(flag);
}
}

13 键盘输入
为了让程序的数据更符合开发的数据，我们就加入了键盘录入。
让程序更灵活一下。

那么，我们如何实现键盘数据的录入呢?
  A:导包
   格式：
    import java.util.Scanner;
   位置：
    在class上面。
  B:创建键盘录入对象
   格式：
    Scanner sc = new Scanner(System.in);
  C:通过对象获取数据
   格式：
    int x = sc.nextInt();
import java.util.Scanner;

class ScannerDemo {
public static void main(String[] args) {
  //创建键盘录入数据对象
  Scanner sc = new Scanner(System.in);

  System.out.println("请你输入一个数据：");
  int x = sc.nextInt();

  System.out.println("你输入的数据是："+x);
}
}

键盘录入练习：
键盘录入两个数据，并对这两个数据求和，输出其结果
import java.util.Scanner;

class ScannerTest {
public static void main(String[] args) {
  //键盘录入两个数据，并对这两个数据求和，输出其结果
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  System.out.println("请输入第一个数据：");
  int x = sc.nextInt();

  System.out.println("请输入第二个数据：");
  int y = sc.nextInt();

  System.out.println("请输入第三个数据：");

  int z = sc.nextInt();

  //把键盘录入的数据进行相加即可
  int sum = (x + y + z);
  System.out.println("sum:"+sum);
}
}

键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

import java.util.Scanner;

class ScannerTest2 {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  System.out.println("请输入第一个数据：");
  int a = sc.nextInt();

  System.out.println("请输入第二个数据：");
  int b = sc.nextInt();

  //获取这两个数据中的最大值
  int max = (a > b? a: b);
  System.out.println("max:"+max);
}
}

练习：
键盘录入三个数据，获取这三个数据中的最大值
键盘录入两个数据，比较这两个数据是否相等

import java.util.Scanner;

class ScannerTest3 {
public static void main(String[] args) {
  //键盘录入三个数据，获取这三个数据中的最大值

  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  System.out.println("请输入第一个数据：");
  int a = sc.nextInt();

  System.out.println("请输入第二个数据：");
  int b = sc.nextInt();

  System.out.println("请输入第三个数据：");
  int c = sc.nextInt();

  //获取这三个数据中的最大值
  int temp = ((a > b)? a: b);
  int max = (temp > c? temp : c);
  System.out.println("max:"+max);
  System.out.println("------------------");

  //键盘录入两个数据
  System.out.println("请输入第一个数据：");
  int x = sc.nextInt();

  System.out.println("请输入第二个数据：");
  int y = sc.nextInt();

  //比较这两个数据是否相等
  boolean flag = (x == y);
  System.out.println("flag:"+flag);
}
}

14：流程控制语句：

   可以控制程序的执行流程。

分类：
  顺序结构
  选择结构
  循环结构

顺序结构：
  从上往下，依次执行。
*/
class ShunXuJieGouDemo {
public static void main(String[] args) {
  System.out.println("程序开始了");

  System.out.println("我爱Java");

  System.out.println("程序结束了");
}
}

15 选择结构：
  if语句
  switch语句

if语句：
  格式1
  格式2
  格式3

if语句的格式：
  if(比较表达式) {
   语句体;
  }

  执行流程：
   先计算比较表达式的值，看其返回值是true还是false。
   如果是true，就执行语句体；
   如果是false，就不执行语句体；

class IfDemo {
public static void main(String[] args) {
  int x = 10;

  if(x == 10) {
   System.out.println("x等于10");
  }

  if(x == 20) {
   System.out.println("x等于20");
  }

  System.out.println("over");
}
}

if语句的注意事项：
  A:比较表达式无论简单还是复杂，结果必须是boolean类型
  B:if语句控制的语句体如果是一条语句，大括号可以省略；
    如果是多条语句，就不能省略。建议永远不要省略。
  C:一般来说：有左大括号就没有分号，有分号就没有左大括号
class IfDemo2 {
public static void main(String[] args) {
  int x = 10;

  if(x == 10) {
   System.out.println("x等于10");
  }

  if((x > 5) || (x == 10)) {
   System.out.println("x大于或者等于10");
  }
  System.out.println("-------------------");

  int a = 100;

  /*
  if(a == 100) {
   System.out.println("a的值是100");
  }
  */

  if(a != 100) {
   System.out.println("a的值是100");
   System.out.println("over");
  }
  System.out.println("-------------------");

  int b = 100;
  if(b != 100); //这里其实是有语句体的，只不过是空语句体。

  //代码块
  {
   System.out.println("b的值是100");
   System.out.println("over");
  }
}
}

if语句格式2：
  if(比较表达式) {
   语句体1;
  }else {
   语句体2;
  }
执行流程：
  首先计算比较表达式的值，看其返回值是true还是false。
  如果是true，就执行语句体1；
  如果是false，就执行语句体2；

注意：else后面是没有比较表达式的，只有if后面有。
class IfDemo3 {
public static void main(String[] args) {
  //判断两个数据是否相等

  int a = 10;
  int b = 20;

  if(a == b) {
   System.out.println("a等于b");
  }else {
   System.out.println("a不等于b");
  }
}
}

由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。
所以，我们就认为他们可以完成一样的操作。
但是，他们就一点区别没有吗?肯定不是。

区别：
  三元运算符实现的，都可以采用if语句实现。反之不成立。

  什么时候if语句实现不能用三元改进呢?
   当if语句控制的操作是一个输出语句的时候就不能。
   为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
class IfDemo4 {
public static void main(String[] args) {
  //获取两个数据的最大值
  int a = 10;
  int b = 20;

  //用if语句实现
  int max1;
  if(a > b) {
   max1 = a;
  }else {
   max1 = b;
  }
  System.out.println("max1:"+max1);

  //用三元改进
  int max2 = (a > b)? a: b;
  System.out.println("max2:"+max2);
  System.out.println("----------");

  //判断一个数据是奇数还是偶数,并输出是奇数还是偶数
  int x = 100;

  if(x%2 == 0) {
   System.out.println("100是一个偶数");
  }else {
   System.out.println("100是一个奇数");
  }

  //用三元改进
  //这种改进是错误的。
  //String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");;
}
}

if语句的格式3：
  if(比较表达式1) {
   语句体1;
  }else if(比较表达式2) {
   语句体2;
  }else if(比较表达式3) {
   语句体3;
  }
  ...
  else {
   语句体n+1;
  }

执行流程：
  首先计算比较表达式1看其返回值是true还是false，
  如果是true，就执行语句体1，if语句结束。
  如果是false，接着计算比较表达式2看其返回值是true还是false，

  如果是true，就执行语句体2，if语句结束。
  如果是false，接着计算比较表达式3看其返回值是true还是false，
  ...

  如果都是false，就执行语句体n+1。
import java.util.Scanner;

class IfDemo5 {
public static void main(String[] args) {
  //需求：键盘录入一个成绩，判断并输出成绩的等级。
  /*
   90-100 优秀
   80-90 好
   70-80 良
   60-70 及格
   0-60   不及格
  */

  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  //录入数据
  System.out.println("请输入你的考试成绩：");
  int score = sc.nextInt();

  /*
  if(score>=90 && score<=100) {
   System.out.println("优秀");
  }else if(score>=80 && score<90) {
   System.out.println("好");
  }else if(score>=70 && score<80) {
   System.out.println("良");
  }else if(score>=60 && score<70) {
   System.out.println("及格");
  }else {
   System.out.println("不及格");
  }
  */
  //这样写已经满足我的基本要求，但是可能别人在使用的时候，不会按照你要求的数据给出了。
  //在做一个程序的基本测试的时候，一定要考虑这样的几个问题：
  //正确数据，错误数据，边界数据。
  //而我们刚才写的程序并没有处理错误数据，所以这个程序不是很好，要改进
  /*
  if(score>=90 && score<=100) {
   System.out.println("优秀");
  }else if(score>=80 && score<90) {
   System.out.println("好");
  }else if(score>=70 && score<80) {
   System.out.println("良");
  }else if(score>=60 && score<70) {
   System.out.println("及格");
  }else if(score>=0 && score<60){
   System.out.println("不及格");
  }else {
   System.out.println("你输入的成绩有误");
  }
  */

  //另一种判断改进
  if(score<0 || score>100) {
   System.out.println("你输入的成绩有误");
  }else if(score>=90 && score<=100) {
   System.out.println("优秀");
  }else if(score>=80 && score<90) {
   System.out.println("好");
  }else if(score>=70 && score<80) {
   System.out.println("良");
  }else if(score>=60 && score<70) {
   System.out.println("及格");
  }else {
   System.out.println("不及格");
  }
}
}

if语句格式2的练习：
A:获取两个数据中较大的值
B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数

import java.util.Scanner;

class IfTest {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  //获取两个数据中较大的值
  System.out.println("请输入第一个数据：");
  int a = sc.nextInt();
   //要用到一个变量接受当前将要输入的数据

  System.out.println("请输入第二个数据：");
  int b = sc.nextInt();

  //定义一个变量接收最大值
  int max;

  if(a > b) {
   max = a;
  }else {
   max = b;
  }

  System.out.println("max:"+max);
  System.out.println("----------------");

  //判断一个数据是奇数还是偶数
  System.out.println("请输入你要判断的数据：");
  int x = sc.nextInt();

  if(x%2 == 0) {
   System.out.println(x+"这个数据是偶数");
  }else {
   System.out.println(x+"这个数据是奇数");
  }
}
}

三种if语句分别适合做什么事情呢?
  格式1：适合做单个判断
  格式2：适合做两个判断
  格式3：适合做多个判断

需求：
  键盘录入x的值，计算出y的并输出。

  x>=3 y = 2x + 1;
  -1<=x<3 y = 2x;
  x<=-1 y = 2x – 1;

分析：
  A:由于数据要键盘录入，所以必须使用Scanner。
  B:由于是三种判断，所以我们选择if语句格式3。
import java.util.Scanner;

class IfTest2 {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  System.out.println("请输入x的值：");
  int x = sc.nextInt();

  //定义一个y
  int y;

  //用if语句格式3进行判断
  if(x >= 3) {
   y = 2*x + 1;
  }else if(x>=-1 && x<3) {
   y = 2*x;
  }else {
   y = 2*x - 1;
  }

  System.out.println("y:"+y);
}
}

键盘录入月份的值，输出对应的季节。

春 3,4,5
夏 6,7,8
秋 9,10,11
冬 12,1,2

分析：
  A:键盘录入月份的值，所以我们要使用Scanner。
  B:我们应该判断这个月份在那个季节，而这个判断情况较多，所以，用if语句格式3。

if语句的使用场景：
  A:针对表达式是一个boolean类型的判断
  B:针对一个范围的判断
import java.util.Scanner;

class IfTest3 {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  //录入数据
  System.out.println("请你输入一个月份:");
  int month = sc.nextInt();

  //第三种格式实现即可
  if(month<1 || month>12) {
   System.out.println("你输入的月份有误");
  }else if(month == 1) {
   System.out.println("冬季");
  }else if(month == 2) {
   System.out.println("冬季");
  }else if(month == 3) {
   System.out.println("春季");
  }else if(month == 4) {
   System.out.println("春季");
  }else if(month == 5) {
   System.out.println("春季");
  }else if(month == 6) {
   System.out.println("夏季");
  }else if(month == 7) {
   System.out.println("夏季");
  }else if(month == 8) {
   System.out.println("夏季");
  }else if(month == 9) {
   System.out.println("秋季");
  }else if(month == 10) {
   System.out.println("秋季");
  }else if(month == 11) {
   System.out.println("秋季");
  }else {
   System.out.println("冬季");
  }
  System.out.println("--------------");

  //这个程序确实是符合了我们的需求，但是就是看起来比较麻烦
  //那么，我们能不能改进一下呢?
  //month == 3
  //month == 4
  //month == 5
  //我们发现，上面三个都是春季。
  //而他们本身每一个都是一个boolean表达式
  //所以，我们就可以考虑使用逻辑运算符给他们连接起来改进
  if(month<1 || month>12) {
   System.out.println("你输入的月份有误");
  }else if(month==3 || month==4 || month==5) {
   System.out.println("春季");
  }else if(month==6 || month==7 || month==8) {
   System.out.println("夏季");
  }else if(month==9 || month==10 || month==11) {
   System.out.println("秋季");
  }else {
   System.out.println("冬季");
  }
  System.out.println("--------------");

  //这个时候，程序代码以及可以了。
  //但是呢，假如我要求你输入一个月份，判断是上半年还是下半年。
  //这个时候，我们的判断条件连接就是6个boolean表达式
  //我们可能还有更多的连接
  //这个时候，其实我们还有另外的一种改进方案：
  //month == 3
  //month == 4
  //month == 5
  //month>=3 && month<=5
  //用范围也是可以改进的。
  if(month<1 || month>12) {
   System.out.println("你输入的月份有误");
  }else if(month>=3 && month<=5) {
   System.out.println("春季");
  }else if(month>=6 && month<=8) {
   System.out.println("夏季");
  }else if(month>=9 && month<=11) {
   System.out.println("秋季");
  }else {
   System.out.println("冬季");
  }
  System.out.println("--------------");
}
}

获取三个数据中的最大值

由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。
class IfTest4 {
public static void main(String[] args) {
  int a = 10;
  int b = 30;
  int c = 20;

  //三元实现
  //int temp = (a>b)? a: b;
  //int max = (temp>c)? temp: c;
  //System.out.println("max:"+max);
  //System.out.println("--------");

  //用if语句实现
  int max;
  if(a > b) {
   if(a > c) {
    max = a;
   }else {
    max = c;
   }
  }else {
   if(b > c) {
    max = b;
   }else {
    max = c;
   }
  }
  System.out.println("max:"+max);
}
}

16：switch语句格式：
  switch(表达式) {
   case 值1:
    语句体1;
    break;
   case 值2:
    语句体2;
    break;
   ...
   default:
    语句体n+1;
    break;
  }

格式的解释：
  switch:表示这是switch选择结构
  表达式:这个地方的取值是有限定的
   byte,short,int,char
   JDK5以后可以是枚举
   JDK7以后可以是字符串
  case:后面跟的是要和表达式进行比较的值
  语句体:要执行的代码
  break:表示中断，结束的意思，可以控制switch语句的结束。
  default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

面试题：
  byte可以作为switch的表达式吗?
  long可以作为switch的表达式吗?
  String可以作为switch的表达式吗?

案例：
  键盘录入一个数据，根据这个数据，我们输出对应的星期?
   键盘录入1,对应输出星期一
   键盘录入2,对应输出星期二
   ...
   键盘录入7,对应输出星期日

分析：
  1:键盘录入，用Scanner实现
  2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句

注意：
  A:遇到左大括号缩进一个tab的位置。
  B:关联不是很大的语句间空行
*/
import java.util.Scanner;

class SwitchDemo {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  //控制键盘录入数据
  System.out.println("请输入一个数据(1-7):");
  int week = sc.nextInt(); //3

  //switch判断语句
  switch(week) {
   case 1:
    System.out.println("星期一");
    break;
   case 2:
    System.out.println("星期二");
    break;
   case 3:
    System.out.println("星期三");
    break;
   case 4:
    System.out.println("星期四");
    break;
   case 5:
    System.out.println("星期五");
    break;
   case 6:
    System.out.println("星期六");
    break;
   case 7:
    System.out.println("星期日");
    break;
   default:
    System.out.println("你输入的数据有误");
    break;
  }
}
}

switch语句的注意事项：
  A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
  B:default可以省略吗?
   可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
   特殊情况：
    case就可以把值固定。
    A,B,C,D
  C:break可以省略吗?
   可以省略，但是结果可能不是我们想要的。
   会出现一个现象：case穿透。
   最终我们建议不要省略
  D:default一定要在最后吗?
   不是，可以在任意位置。但是建议在最后。
  E:switch语句的结束条件
   a:遇到break就结束了
   b:执行到末尾就结束了
import java.util.Scanner;

class SwitchDemo2 {
public static void main(String[] args) {
  //创建键盘录入对象
  Scanner sc = new Scanner(System.in);

  //控制键盘录入数据
  System.out.println("请输入一个数据(1-7):");
  int week = sc.nextInt(); //3

  //定义常量
  //int number = 3;
  //然后把case后面的值改为number，就会报错

  //switch判断语句
  switch(week) {
   case 1:
    System.out.println("星期一");
    break;
   case 2:
    System.out.println("星期二");
    break;
   case 3:
    System.out.println("星期三");
    break;
   case 4:
    System.out.println("星期四");
    break;
   case 5:
    System.out.println("星期五");
    break;
   case 6:
    System.out.println("星期六");
    break;
   case 7:
    System.out.println("星期日");
    break;
   default:
    System.out.println("你输入的数据有误");
    //break;
  }
}
}

17：循环结构(for语句)

需求：请在控制台输出10次"HelloWorld"
class Demo {
public static void main(String[] args) {
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
}
}
class Demo {
public static void main(String[] args) {

     for (int a =0; a<10 ;a++ )
     {
   System.out.println("HelloWorld");
     }
}

循环语句：for循环,while循环,do...while循环。

for循环格式：
  for(初始化语句;判断条件语句;控制条件语句) {
   循环体语句;
  }

  执行流程：
   A:执行初始化语句
   B:执行判断条件语句,看其返回值是true还是false
    如果是true，就继续执行
    如果是false，就结束循环
   C:执行循环体语句;
   D:执行控制条件语句
   E:回到B继续。

注意事项：
  A:判断条件语句无论简单还是复杂结果是boolean类型。
  B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
  C:一般来说：有左大括号就没有分号，有分号就没有左大括号

需求：请在控制台输出10次"HelloWorld"
*/
class ForDemo {
public static void main(String[] args) {
  //最原始的做法
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("HelloWorld");
  System.out.println("----------");

  //这种做法不好,代码的重复度太高。
  //所以呢，我们用循环改进
  for(int x=1;x<=10;x++) {
   System.out.println("HelloWorld");
  }
}
}

/*
需求：请在控制台输出数据1-10
*/
class ForDemo2 {
public static void main(String[] args) {
  //原始做法
  System.out.println(1);
  System.out.println(2);
  System.out.println(3);
  System.out.println(4);
  System.out.println(5);
  System.out.println(6);
  System.out.println(7);
  System.out.println(8);
  System.out.println(9);
  System.out.println(10);

  System.out.println("-------------");

  //如何改进呢?用循环改进
  for(int x=1; x<=10; x++) {
   System.out.println(x);
  }

  System.out.println("-------------");

  //从0开始
  for(int x=0; x<10; x++) {
   System.out.println(x+1);
  }
}
}

/*
需求：求出1-10之间数据之和

分析：
  0+1=1
   1+2=3
    3+3=6
     6+4=10
      10+5=15
        ...

  由此可见我们要定义两个变量：
   一个变量用于存储第一个加数，第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。
   一个变量用于存储第二个加数，第二个加数其实就是每次的数据变化的值。

求和思想。
*/
class ForDemo3 {
public static void main(String[] args) {
  //原始做法
  System.out.println(1+2+3+4+5+6+7+8+9+10);

  //定义第一个加数
  int sum = 0;

  for(int x=1; x<=10; x++) {
   //这里的x其实是第二个加数
   sum = sum + x;
   /*
    0 + 1 = 1
      1 + 2 = 3
        3 + 3 = 6
        ...
   */

   //sum += x;
  }

  System.out.println("sum:"+sum);
}
}

/*
需求：
  A:求1-100之和。
  B:求出1-100之间偶数和
  C:求出1-100之间奇数和(自己做)
*/
class ForDemo4 {
public static void main(String[] args) {
  //求1-100之和。
  int sum1 = 0;

  for(int x=1; x<=100; x++) {
   sum1 +=x;
  }

  System.out.println("1-100之和是："+sum1);
  System.out.println("------------------");

  //求出1-100之间偶数和
  //方式1
  int sum2 = 0;

  for(int x=1; x<=100; x++) {
   if(x%2 == 0) {
    sum2 += x;
   }
  }

  System.out.println("1-100偶数之和是："+sum2);
  System.out.println("------------------");

  //方式2
  int sum3 = 0;

  for(int x=0; x<=100; x+=2) {
    sum3 += x;
  }

  System.out.println("1-100偶数之和是："+sum3);
  System.out.println("------------------");
}
}

/*
需求：求5的阶乘。

什么是阶乘呢?
  n! = n*(n-1)! 规则
  n! = n*(n-1)*(n-2)*...*3*2*1

求和思想。
求阶乘思想。
*/
class ForDemo5 {
public static void main(String[] args) {
  //定义最终结果变量
  int jc = 1;

  //这里的x其实可以直接从2开始
  //for(int x=1; x<=5; x++)

  for(int x=2; x<=5; x++) {
   jc *=x;
  }

  System.out.println("1-5的阶乘是："+jc);
}
}

/*
天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。

需求：在控制台输出所有的”水仙花数”

分析：
  我们都不知道什么叫"水仙花数"，你让我怎么做呢?

  所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
  举例：153就是一个水仙花数。
  153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153

  A:三位数其实是告诉了我们范围。
  B:通过for循环我们就可以实现获取每一个三位数
    但是麻烦是如何获取这个三位数的个,十,百位上的数据

    我们如何获取一个数据的个,十,百呢?
   假设有个一个数据:153
   ge: 153%10 = 3
   shi: 153/10%10 = 5
   bai：153/10/10%10 = 1
   qian：x/10/10/10%10
   wan: x/10/10/10/10%10
   ...

  C:让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
    如果相同，就把该数据在控制台输出。
*/
class ForDemo6 {
public static void main(String[] args) {
  //三位数其实是告诉了我们范围。
  for(int x=100; x<1000; x++) {
   int ge = x%10;
   int shi = x/10%10;
   int bai = x/10/10%10;

   //让ge*ge*ge+shi*shi*shi+bai*bai*bai和该数据比较
   if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
    //如果相同，就把该数据在控制台输出。
    System.out.println(x);
   }
  }
}
}

/*
练习：
  请在控制台输出满足如下条件的五位数
  个位等于万位
  十位等于千位
  个位+十位+千位+万位=百位

分析：
  A:五位数就告诉了我们范围。
  B:分解每一个五位数的个，十，百，千，万位上的数据
  C:按照要求进行判断即可
*/
class ForDemo7 {
public static void main(String[] args) {
  //五位数就告诉了我们范围。
  for(int x=10000; x<100000; x++) {
   //分解每一个五位数的个，十，百，千，万位上的数据
   int ge = x%10;
   int shi = x/10%10;
   int bai = x/10/10%10;
   int qian = x/10/10/10%10;
   int wan = x/10/10/10/10%10;

   //按照要求进行判断即可
   if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
    System.out.println(x);
   }
  }
}
}

/*
需求：统计”水仙花数”共有多少个

分析：
  A:首先必须知道什么是水仙花数
   所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
   举例：153就是一个水仙花数。
   153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
  B:定义统计变量，初始化值是0
  C:三位数告诉了我们范围，用for循环就可以搞定
  D:获取每一个三位数的个，十，百的数据
  E:按照要求进行判断
  F:如果满足要求就计数。
*/
class ForDemo8 {
public static void main(String[] args) {
  //定义统计变量，初始化值是0
  int count = 0;

  //三位数告诉了我们范围，用for循环就可以搞定
  for(int x=100; x<1000; x++) {
   //获取每一个三位数的个，十，百的数据
   int ge = x%10;
   int shi = x/10%10;
   int bai = x/10/10%10;

   //按照要求进行判断
   if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
    //如果满足要求就计数。
    count++;
   }
  }

  System.out.println("水仙花数共有"+count+"个");
}
}

/*
需求：请统计1-1000之间同时满足如下条件的数据有多少个：
   对3整除余2
   对5整除余3
   对7整除余2

分析：
  A:定义统计变量,初始化值是0
  B:1-1000之间是一个范围，用for很容易就可以实现。
  C:每个数据要同时满足如下要求
   x%3==2
   x%5==3
   x%7==2
  D:如果满足条件，统计数据++即可，最后输出统计变量
*/
class ForDemo9 {
public static void main(String[] args) {
  //定义统计变量,初始化值是0
  int count = 0;

  //1-1000之间是一个范围，用for很容易就可以实现。
  for(int x=1; x<=1000; x++) {
   /*
    每个数据要同时满足如下要求
    x%3==2
    x%5==3
    x%7==2
   */
   if(x%3==2 && x%5==3 && x%7==2) {
    count++;
    System.out.println(x);
   }
  }

  //输出数据
  System.out.println("满足这样条件的数据共有："+count+"个");
}
}

18：while循环的基本格式：
  while(判断条件语句) {
   循环体语句;
  }

  扩展格式：

  初始化语句;
     while(判断条件语句) {
    循环体语句;
    控制条件语句;
  }

  通过这个格式，我们就可以看到其实和for循环是差不多的。

  for(初始化语句;判断条件语句;控制条件语句) {
   循环体语句;
  }
*/
class WhileDemo {
public static void main(String[] args) {
  //输出10次"HelloWorld"
  //for语句版
  for(int x=0; x<10; x++) {
   System.out.println("HelloWorld");
  }
  System.out.println("--------------");
  //while语句版
  int x=0;
  while(x<10) {
   System.out.println("HelloWorld");
   x++;

   // 就是把条件写在了里面了而已
  }

}
}

/*
练习：用while循环实现
左边：求出1-100之和
右边：统计水仙花数有多少个

初始化语句;
while(判断条件语句) {
   循环体语句;
   控制条件语句;
}

for(初始化语句;判断条件语句;控制条件语句) {
  循环体语句;
}

*/
class WhileDemo2 {
public static void main(String[] args) {
  //求出1-100之和
  //for语句版本
  int sum = 0;

  for(int x=1; x<=100; x++) {
   sum+=x;
  }

  System.out.println("sum:"+sum);
  System.out.println("--------");
  //while语句版本
  int sum2 = 0;

  int y=1;
  while(y<=100) {
   sum2+=y;
   y++;
  }

  System.out.println("sum2:"+sum2);
  System.out.println("--------");
}
}

/*
需求：统计水仙花数有多少个
*/
class WhileDemo3 {
public static void main(String[] args) {
  //for循环版本
  int count = 0;

  for(int x=100; x<1000; x++) {
   int ge = x%10;
   int shi = x/10%10;
   int bai = x/10/10%10;

   if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
    count++;
   }
  }

  System.out.println("count:"+count);
  System.out.println("------------");

  //while循环版本
  int count2 = 0;

  int y = 100;
  while(y<1000) {
   int ge = y%10;
   int shi = y/10%10;
   int bai = y/10/10%10;

   if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
    count2++;
   }

   y++;
  }

  System.out.println("count2:"+count2);
}
}

/*
while循环和for循环的区别?
  使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
            因为变量及早的从内存中消失，可以提高内存的使用效率。

  其实还有一种场景的理解:
   如果是一个范围的，用for循环非常明确。
   如果是不明确要做多少次，用while循环较为合适。
    举例：吃葡萄。
*/
class WhileDemo4 {
public static void main(String[] args) {
  //for循环实现
  for(int x=0; x<10; x++) {
   System.out.println("学习Java技术哪家强,中国北京传智播客");
  }
  //这里不能在继续访问了
  //System.out.println(x);

  //while循环实现
  int y = 0;
  while(y<10) {
   System.out.println("学习Java技术哪家强,中国北京传智播客");
   y++;
  }
  //这里是可以继续访问的
  System.out.println(y);
}
}

/*
我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。
请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?

分析：
  A:定义一个统计变量，默认值是0
  B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度
    我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
  C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?
    折叠一次有什么变化呢?就是厚度是以前的2倍。
  D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
  E:输出统计变量。
*/

class WhileDemo5 {
public static void main(String[] args) {
  //定义一个统计变量，默认值是0
  int count = 0;

  //最高山峰是珠穆朗玛峰：8848m这是最终的厚度
  //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度
  //为了简单，我把0.01变成1，同理8848就变成了884800
  int end = 884800;
  int start = 1;

  while(start<end) {
   //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++
   count++;

   //折叠一次有什么变化呢?就是厚度是以前的2倍。
   start *= 2;

   System.out.println("第"+count+"次厚度是"+start);
  }

  //输出统计变量。
  System.out.println("要叠"+count+"次");
}
}

19 do...while循环的基本格式：
  do {
   循环体语句;
  }while(判断条件语句);

  扩展格式；
  初始化语句;
  do {
   循环体语句;
   控制条件语句;
  }while(判断条件语句);
*/
class DoWhileDemo {
public static void main(String[] args) {
  //输出10次HelloWorld。
  int x = 0;
  do {
   System.out.println("HelloWorld");
   x++;
  }while(x<10);

  System.out.println("--------------");

  //求和1-100
  int sum = 0;
  int a = 1;
  do {
   sum += a;
   a++;
  }while(a<=100);

  System.out.println(sum);
}
}

/*
循环语句的区别:
  do...while循环至少执行一次循环体。
  而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

那么，我们一般使用哪种循环呢?
  优先考虑for，其次考虑while，最后考虑do...while
*/
class DoWhileDemo2 {
public static void main(String[] args) {
  int x = 3;
  while(x < 3) {
   System.out.println("我爱林青霞");
   x++;
  }

  System.out.println("--------------");

  int y = 3;
  do {
   System.out.println("我爱林青霞");
   y++;
  }while(y < 3);
}
}

/*
注意死循环：
  A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
  B:两种最简单的死循环格式
   while(true){...}
   for(;;){...}

*/
class DoWhileDemo3 {
public static void main(String[] args) {
  int x = 0;
  while(x < 10) {
   System.out.println(x);
   x++;
  }
  System.out.println("--------------");

  /*
  while(true) {
   System.out.println("今天我很高兴，学习了死循环");
  }
  */

  for(;;){
   System.out.println("今天我很高兴，学习了死循环");
  }

  //System.out.println("--------------");
}
}

20：循环嵌套

/*
需求：请输出一个4行5列的星星(*)图案。
结果：
  *****
  *****
  *****
  *****

循环嵌套：就是循环语句的循环体本身是一个循环语句。

通过结果我们知道这样的一个结论：
  外循环控制行数
  内循环控制列数
*/
class ForForDemo {
public static void main(String[] args) {
  //原始做法
  System.out.println("*****");
  System.out.println("*****");
  System.out.println("*****");
  System.out.println("*****");
  System.out.println("-------------");

  //虽然可以完成需求，但是不是很好
  //如果是多行多列就会比较麻烦
  //所以我们准备改进
  //如何改进呢?
  //我先考虑如何实现一行*的问题
  //System.out.println("*****");
  //我们要想的是如何实现一次输出一颗*的问题
  //System.out.println("*");
  //System.out.println("*");
  //现在虽然可以一次一颗*，但是却换行了，我要求不能换行，怎么办呢?
  //输出语句的另一种格式：System.out.print(); 这个是不带换行的
  //System.out.print("*");
  //System.out.print("*");
  //System.out.print("*");
  //System.out.print("*");
  //System.out.print("*");
  //如果我要在一行上打出多颗*，比较麻烦，而代码是重复的，所以我决定用循环改进
  for(int x=0; x<5; x++) {
   System.out.print("*");
  }
  //我们可以通过空的输出语句实现换行：System.out.println();
  System.out.println();

  //既然我可以打出一行，我就可以打出第二行
  for(int x=0; x<5; x++) {
   System.out.print("*");
  }
  //我们可以通过空的输出语句实现换行：System.out.println();
  System.out.println();

  //同理打出第三行，第四行
  for(int x=0; x<5; x++) {
   System.out.print("*");
  }
  //我们可以通过空的输出语句实现换行：System.out.println();
  System.out.println();

  //既然我可以打出一行，我就可以打出第二行
  for(int x=0; x<5; x++) {
   System.out.print("*");
  }
  //我们可以通过空的输出语句实现换行：System.out.println();
  System.out.println();
  System.out.println("-----------------");
  //同样的代码出现了4次，说明我们程序写的不好，用循环改进
  for(int y=0; y<4; y++) {
   for(int x=0; x<5; x++) {
    System.out.print("*");
   }
   //我们可以通过空的输出语句实现换行：System.out.println();
   System.out.println();
  }
}
}

/*
需求：请输出下列的形状
  *
  **
  ***
  ****
  *****
*/
class ForForDemo2 {
public static void main(String[] args) {
  //通过简单的观察，我们看到这是一个行是5，列数是变化的形状
  //我们先打印出一个5行5列的形状
  for(int x=0; x<5; x++) {
   for(int y=0; y<5; y++) {
    System.out.print("*");
   }
   System.out.println();
  }

  System.out.println("--------------");

  //我们实现了一个5行5列的形状
  //但是这不是我们想要的
  //我们要的是列数变化的
  //列数是如何变化的呢?
  //第一行：1列 y=0,y<=0,y++
  //第二行：2列 y=0,y<=1,y++
  //第三行：3列 y=0,y<=2,y++
  //第四行：4列 y=0,y<=3,y++
  //第五行：5列 y=0,y<=4,y++
  //在看外循环x的变化，恰好就是x=0,1,2,3,4
  //所以这个最终版的程序就是如下
  for(int x=0; x<5; x++) {
   for(int y=0; y<=x; y++) {
    System.out.print("*");
   }
   System.out.println();
  }
}
}

/*
需求：在控制台输出九九乘法表。

首先我们写出九九乘法表：
  1*1=1
  1*2=2 2*2=4
  1*3=3 2*3=6 3*3=9
  1*4=4 2*4=8 3*4=12 4*4=16
  ...
  1*9=9 2*9=18 3*9=27 ...

我们先把这个九九乘法表看出是这样的一个形状：
  *
  **
  ***
  ****
  *****
  ******
  *******
  ********
  *********

注意：
  '\x' x表示任意，这种做法叫转移字符。

  '\t' tab键的位置
  '\r' 回车
  '\n' 换行
*/
class ForForDemo3 {
public static void main(String[] args) {
  for(int x=0; x<9; x++) {
   for(int y=0; y<=x; y++) {
    System.out.print("*");
   }
   System.out.println();
  }
  System.out.println("--------------");
  //为了使用数据，我们从1开始
  for(int x=1; x<=9; x++) {
   for(int y=1; y<=x; y++) {
    System.out.print(y+"*"+x+"="+y*x+"\t");
   }
   System.out.println();
  }
}
}

21跳转语句

控制跳转语句：
  break:中断
  continue:继续
  return:返回

break:中断的意思
使用场景：
  A:switch语句中
  B:循环语句中。
   (循环语句中加入了if判断的情况)
  注意：离开上面的两个场景，无意义。

如何使用呢?
  A:跳出单层循环
  B:跳出多层循环
   要想实现这个效果，就必须知道一个东西。带标签的语句。
   格式：
    标签名: 语句
*/
class BreakDemo {
public static void main(String[] args) {
  //在 switch 或 loop 外部中断
  //break;

  //跳出单层循环
  for(int x=0; x<10; x++) {
   if(x == 3) {
    break;
   }
   System.out.println("HelloWorld");
  }

  System.out.println("over");
  System.out.println("-------------");

  wc:for(int x=0; x<3; x++) {
   nc:for(int y=0; y<4; y++) {
    if(y == 2) {
     //break nc;
     break wc;
    }
    System.out.print("*");
   }
   System.out.println();
  }
}
}

/*
continue:继续

使用场景：
  循环中。离开此场景无意义。

测试，找到和break的区别：
  break:跳出单层循环
  continue:跳出一次循环，进入下一次的执行

练习题：
  for(int x=1; x<=10; x++) {
   if(x%3==0) {
    //在此处填写代码
   }
   System.out.println(“Java基础班”);
  }

  我想在控制台输出2次:“Java基础班“
   break;
  我想在控制台输出7次:“Java基础班“
   continue;
  我想在控制台输出13次:“Java基础班“
   System.out.println(“Java基础班”);

*/
class ContinueDemo {
public static void main(String[] args) {
  for(int x=0; x<10; x++) {
   if(x == 3) {
    //break;
    continue;
   }

   System.out.println(x);
  }
}
}

/*
return:返回

其实它的作用不是结束循环的，而是结束方法的。
*/
class ReturnDemo {
public static void main(String[] args) {
  for(int x=0; x<10; x++) {
   if(x == 2) {
    System.out.println("退出");
    //break;
    //continue;
    return;
   }

   System.out.println(x);
  }

  System.out.println("over");
}
}

/*
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
请问，经过多少天，小芳才可以存到100元钱。

分析：
  A:小芳的妈妈每天给她2.5元钱
   double dayMoney = 2.5;
  B:她都会存起来
   double daySum = 0;
  C:从第一天开始存储
   int dayCount = 1;
  D:经过多少天，小芳才可以存到100元钱。
   double result = 100;
  E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
   说明要判断dayCount的值，如果对5整除就减去6元钱。
    daySum -= 6;
    由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加
    daySum += dayMoney;
  F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。
*/
class WhileDemo {
public static void main(String[] args) {
  //每天要存储的钱是2.5元
  double dayMoney = 2.5;

  //存钱的初始化值是0
  double daySum = 0;

  //从第一天开始存储
  int dayCount = 1;

  //最终存储不小于100就不存储了
  int result = 100;

  //因为不知道是多少天，所以我用死循环，
  while(true) {
   //累加钱
   daySum += dayMoney;

   //一旦超过100元我就退出循环。
   if(daySum >= result) {
    System.out.println("共花了"+dayCount+"天存储了100元");
    break;
   }

   if(dayCount%5 == 0) {
    //花去6元钱
    daySum -= 6;
    System.out.println("第"+dayCount+"天花了6元钱");
   }

   //天数变化
   dayCount++;
  }
}
}