1 public static void main(String[] args) {
2          String 王者荣耀 = "王者荣耀";
3          System.out.println(王者荣耀);
4      }

 /*
 　　◆1 bit表示1位，
 　　◆1Byte表示一个字节 1B=8b.
 　　◆1024B = 1 KB
 　　◆1024KB = 1 M
 　　◆1024M = 1G.
 */

 1  package _JDK安装_入门程序_关键字_标识符_常量_变量._3数据类型_基本数据类型;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname DataTypeDemo
 6   * @Package _3数据类型_基本数据类型
 7   * @date 2020/03/29 16:37
 8   * @Description TODO
 9   */
10  /*
11  什么是字节?
12      ◆位(bit):是计算机内部数据储存的最小单位，11001100是一个八位二进制数。
13      ◆字节(byte) :是计算机中数据处理的基本单位，习惯上用大写B来表示。
14      ◆1B (byte，字节) = 8bit(位)
15      ◆字符:是指计算机中使用的字母、数字、字和符号
16      
17      ◆1 bit表示1位，
18      ◆1Byte表示一个字节 1B=8b.
19      ◆1024B = 1 KB
20      ◆1024KB = 1 M
21      ◆1024M = 1G.
22   */
23  public class DataPrimitiveTypeDemo {
24      public static void main(String[] args) {
25          //八大基本数据类型
26          
27          //整数
28          int num1 = 10;//最常用
29          byte num2 = 20;
30          short num3 = 30;
31          long num4 = 30L;//Long 类型要在数字后面加个L
32          
33          //小数:浮点数
34          float num5 = 50.1F;//float类型要在数字后面加个F
35          double num6 = 3.141592653589793238462643;
36          
37          //字符
38          char name = ‘国‘;
39          
40          //字符串， String不是关键字，类
41          //String namea = "秦疆";
42          
43          //布尔值:是非
44          boolean flag = true;
45          //booLean fLag = false;
46      }
47  }

 1  package __数据类型转换_运算符_方法入门._1数据类型转换._1数据类型_自动转换;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname AutomaticConversionDemo
 6   * @Package __数据类型转换_运算符_方法入门.数据类型转换._1数据类型_自动转换
 7   * @date 2020/03/29 18:34
 8   * @Description TODO
 9   * 数据类型转换_自动转换
10   */
11  /*
12  当数据类型不一样时，将会发生数据类型转换。
13      自动类型转换（隐式）
14        右边赋值给左边，因此左边数据类型的取值范围比右边大,才能构成自动类型转换
15          1.特点：代码不需要进行特殊处理，自动完成。
16          2.规则：数据范围从小到大。
17  ?
18      强制类型转换（显式）
19   */
20  public class AutomaticConversionDemo {
21      public static void main(String[] args) {
22          System.out.println("整数int类型："+1024);//这就是一个整数，默认就是int类型
23          System.out.println("浮点数double类型"+3.14);//这就是一个浮点数，默认就是double类型
24  ?
25          //左边是1ong类型，右边是默认的int类型，左右不一样，左边取值范围比右边大
26          //一个等号代表赋值，将右侧的int常量，交给左侧的1ong变量进行存储
27          //int-->1ong，符合了数据范围从小到大的要求
28          //这一行代码发生了自动类型转换。
29          long num1 = 100;
30          System.out.println(num1);//100
31  ?
32          //左边是double类型，右边是float类型，左右不一样,左边取值范围比右边大
33          //float-->double，符合从小到大的规则
34          //也发生了自动类型转换
35          double num2 = 2.5F;
36          System.out.println(num2);//2.5
37  ?
38          //左边是float类型，右边是long类型，左右不一样,左边取值范围比右边大
39          //1ong-->float，范围是float更大一些，符合从小到大的规则
40          //也发生了自动类型转换
41          float num3 = 30L;
42          System.out.println(num3);
43  ?
44      }
45  }

 1  package __数据类型转换_运算符_方法入门._1数据类型转换._2数据类型转换_强制转换;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname CoercionDemo
 6   * @Package __数据类型转换_运算符_方法入门.数据类型转换._2数据类型转换_强制转换
 7   * @date 2020/03/29 18:52
 8   * @Description TODO
 9   */
10  /*
11      强制类型转换（显式）
12         右边赋值给左边，但是左边的数据类型的取值范围比右边小，可以进行强制类型转换，达到数据存储的结果
13              1.特点：代码需要进行特殊的格式处理，不能自动完成。
14              2.格式：范围小的类型范围小的变量名=（范围小的类型）原本范围大的数据；
15   */
16  public class CoercionDemo {
17      public static void main(String[] args) {
18          //左边是int类型，右边是1ong类型，不一样
19          //long-->int，不是从小到大
20          //不能发生自动类型转换！
21          //格式：范围小的类型 范围小的变量名=（范围小的类型）原本范围大的数据；
22          int num = (int) 100L;
23          System.out.println(num);
24  ?
25      }
26  }

 1 package __数据类型转换_运算符_方法入门._1数据类型转换._2数据类型转换_强制转换;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname CoercionDemo
 6   * @Package __数据类型转换_运算符_方法入门.数据类型转换._2数据类型转换_强制转换
 7   * @date 2020/03/29 18:52
 8   * @Description TODO
 9   */
10  /*
11      强制类型转换（显式）
12          注意事项：
13              1.强制类型转换一般不推荐使用，因为有可能发生【浮点数】精度损失、【整数】数据溢出。
14              2.byte/short/char这三种类型都可以发生数学运算，例如加法“。
15              3.byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
16              4.boolean类型不能发生数据类型转换
17   */
18  public class CoercionErroDemo {
19      public static void main(String[] args) {
20          //1ong强制转换成为int类型
21          int num1 = (int) 6000000000L;//数据溢出异常
22          System.out.println(num1);//1705032704【17个亿】
23  ?
24          //double-->int，强制类型转换
25          int num2 = (int) 3.9;//精度损失
26          System.out.println(num2);//3,这并不是四舍五入，所有的小数位都会被舍弃掉
27  ?
28          char c = ‘A‘;//这是一个字符型变量，里面是大写字母A
29          System.out.println(c + 1);//66，也就是大写字母A被当做65进行处理
30          //计算机的底层会用一个数字（二进制）来代表字符A，就是65T
31          //一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
32  ?
33          byte num4 =40;//注意！右侧的数值大小不能超过左侧的类型范围
34          byte num5=50;
35          //byte+byte-->int+int-->int
36          int result1=num4 +num5;
37          System.out.println(result1);//90
38  ?
39          short num6=60;
40          //byte+short-->int +int-->int
41          //int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
42          short result2=(short) (num4 +num6);
43          System.out.println(result2);//100
44  ?
45      }
46  }

1  type varName[=value][{,varName[=value]}];
2  /*
3  type:数据类型
4  varName；变量名
5  [{,varName[=value]}]:不建议使用
6  数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量
7  []表示里面的内容可以省略
8  */
9  int a = 1,b = 2,c = 3;//不建议使用

 1  package __数据类型转换_运算符_方法入门._1数据类型转换._3变量的作用域;
 2  ?
 3  /**
 4   * @Author Admin
 5   * @Classname Variable
 6   * @Package __数据类型转换_运算符_方法入门._1数据类型转换._3变量的作用域
 7   * @GreatDate 2020/04/27 08:27:01
 8   * @Description TODO 变量的作用域
 9   */
10  public class Variable {
11      static int allClicks = 0;//类变量，从属于类
12      String str = "hello world";//实例变量，从属于对象
13      public void method() {
14          int i = 0;//局部变量 仅在方法中有效
15      }
16  public static void main(String[] args) {
17      Variable v = new Variable();
18      System.out.println(Variable.allClicks);
19      System.out.println("---------------------");
20      System.out.println(v.str);
21      System.out.println("---------------------");
22      v.method();
23      }
24  }

1 static final double PI = 3.14;
2 final static double PI = 3.14;//都是一样的，不过写变量时，一般把final写在static之前.

 2 
 3 /**
 4  * @author Admin
 5  * @Classname ArithmeticDemo
 6  * @Package __数据类型转换_运算符_方法入门._2运算符._1四则运算符
 7  * @date 2020/03/29 20:34
 8  * @Description TODO
 9  */
10 public class ArithmeticDemo {
11     //四则运算符（二元运算符，算术运算符）
12     public static void main(String[] args) {
13         //两个常量之间可以进行数学运算
14         System.out.println(20 + 30);
15         //两个变量之间也可以进行数学运算
16         int a = 20;
17         int b = 30;
18         System.out.println(a - b);//-10
19         //变量和常量之间可以混合使用
20         System.out.println(a * 10);//200
21         int x = 10;
22         int y = 3;
23         int result1 = x / y;
24         System.out.println(result1);//3
25         int result2 = x % y;
26         System.out.println(result2);//余数，模，1
27         //int +double-->double+double-->double
28         double result3 = x + 2.5;
29         System.out.println(result3);//12.5
30         //--------------------------------------------
31         System.out.println("----------------------");
32         //运算中隐含的自动类转换
33         long l = 1234541541454L;
34         int i = 123;
35         short s = 10;
36         byte e = 8;
37         System.out.println(l + i + s + e);//1234541541595 long
38         System.out.println(i + s + e);//141 int
39         System.out.println(s + e);//18 int
40         //System.out.println((String)(e + s));//18 int
41         
42     }
43 }

 1  package __数据类型转换_运算符_方法入门._2运算符._1四则运算符_取模运算符._加号的多种用法;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname PlusDemo
 6   * @Package __数据类型转换_运算符_方法入门._2运算符._1四则运算符._加号的多种用法
 7   * @date 2020/03/29 20:50
 8   * @Description TODO
 9   */
10  /*
11      + 可以使用拼接字符串
12   */
13  public class PlusDemo {
14      public static void main(String[] args) {
15          //字符串类型的变量基本使用
16          //数据类型 变量名称 = 数据值;
17          
18          String str1 = "Hello";
19          System.out.println(str1);//Hello
20          System.out.println("Hello" + "World");//HelloWorld
21          String str2 = "Java";
22          //String+int-->String
23          System.out.println(str2 + 20);//Java20
24          //优先级问题
25          //String+int+int
26          //String +int
27          //String
28          System.out.println(str2 + 20 + 30);//Java2030
29          System.out.println(str2 + (28 + 30));//Java58
30      }
31  }

 1 package __数据类型转换_运算符_方法入门._2运算符._2自增自减运算符._1自增运算符;
 2 
 3 /**
 4  * @author Admin
 5  * @Classname IncreaseDemo
 6  * @Package __数据类型转换_运算符_方法入门._2运算符._2自增自减运算符
 7  * @date 2020/03/29 21:10
 8  * @Description TODO
 9  * 自增运算符
10  */
11 public class IncreaseOperatorDemo {
12     public static void main(String[] args) {
13         int num1 = 10;
14         System.out.println(num1);//10
15         //单独使用时，前++和后++，都是表示加1
16         ++num1;//单独使用，前++
17         System.out.println(num1);//11
18         num1++;//单独使用，后++
19         System.out.println(num1);//12
20         System.out.println("================");
21         //与打印操作混合的时候
22         int num2 = 20;
23         //混合使用，先++，变量立刻马上变成21，然后打印结果21
24  //num2 =(num2 + 1);执行完这行代码后，先给num2自增（+1），再赋值num2
25         System.out.println(++num2);//21
26         System.out.println(num2);//21
27         System.out.println("================");
28         int num3 = 30;
29         //混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
30 //(num3 = num3) + 1执行完这行代码后，先减num3赋值num3,再自增（+1）
31         System.out.println(num3++);//30
32         System.out.println(num3);//31
33     }
34 }

 1  package __数据类型转换_运算符_方法入门._2运算符._2自减自减运算符._2自减运算符;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname DecreaseDemo
 6   * @Package __数据类型转换_运算符_方法入门._2运算符._2自减自减运算符.自减运算
 7   * @date 2020/03/29 21:18
 8   * @Description TODO
 9   * 自减运算
10   */
11  public class DecreaseOperatorDemo {
12      public static void main(String[] args) {
13          int num1 = 10;
14          System.out.println(num1);//10
15          //单独使用时，前--和后--，都是表示减1
16          --num1;//单独使用，前--
17          System.out.println(num1);//9
18          num1--;//单独使用，后--
19          System.out.println(num1);//8
20          System.out.println("================");
21          int num4 = 40;
22          //和赋值操作混合
23          int result1=--num4;
24  //混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
25          /*num4 = (num4 - 1);执行完这行代码后，
26              先给num4自减（-1），再赋值num4,再赋值result1
27         */
28          System.out.println(result1);//39
29          System.out.println(num4);//39
30          System.out.println("================");
31          int num5=50;
32  //混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
33          /*(num5 = num5) - 1执行完这行代码后，
34            先给num5赋值，再赋值result2，再自减（-1）
35          */
36          int result2=num5--;
37          System.out.println(result2);//50
38          System.out.println(num5);//49
39          System.out.println("================");
40      }
41  }
42  ?

 1 package __数据类型转换_运算符_方法入门._2运算符._4比较_关系运算符;
 2 
 3 /**
 4  * @author Admin
 5  * @Classname CompareDemo
 6  * @Package __数据类型转换_运算符_方法入门._2运算符._4比较运算符
 7  * @date 2020/03/29 22:08
 8  * @Description TODO
 9  * 比较运算符
10  */
11 public class CompareOperatorDemo {
12     public static void main(String[] args) {
13 
14         System.out.println(10>5);//true 
15         int num1=10;
16         int num2=12;
17         System.out.println(num1<num2);//true 
18         System.out.println(num2>=100);//false
19         System.out.println(num2<=100);//true 
20         System.out.println(num2<=12);//true 
21         System.out.println("===============");
22         System.out.println(10==10);//true
23         System.out.println(20!=25);//true 
24         System.out.println(20!=20);//false 
25         int x=2;
26         //System.out.println(1<x<3);//错误写法!编译报错!不能连着写。
27     }
28 }

 1 package __数据类型转换_运算符_方法入门._2运算符._5逻辑运算符._1短路与$短路或逻辑运算符;
 2 
 3 /**
 4  * @author Admin
 5  * @Classname LogicDemo
 6  * @Package __数据类型转换_运算符_方法入门._2运算符._5逻辑运算符
 7  * @date 2020/03/29 22:32
 8  * @Description TODO
 9  */
10 //逻辑运算符短路与&&和短路或||
11 public class LogicalOperatorsDemo {
12     public static void main(String[] args) {
13         //短路与&& 只要第一个表达式的值是false的，
14         // 第二个表达式的值，就不需要进行运算了
15         int j = 2;
16         System.out.println( j== 1 && j++ ==2  );
17         //因为j==1返回false,所以右边的j++就没有执行了，
18         // 所以j的值，还是2
19         System.out.println(j);
20 
21         System.out.println("------------------------------");
22         //短路或|| 只要第一个表达式的值是true的，
23         // 第二个表达式的值，就不需要进行运算了
24         int i = 2;
25         System.out.println( i== 2 || i++ ==2  );
26         //因为j==2返回true,所以右边的j++就没有执行了，
27         // 所以i的值，还是2
28         System.out.println(i);
29 
30         System.out.println("------------------------------");
31         //取反！
32         //真变为假
33         //假变为真
34         boolean b = true;
35         System.out.println(b); //输出true
36         System.out.println(!b);//输出false
37 
38         System.out.println("------------------------------");
39         //异或^
40         //不同，返回真
41         //相同，返回假
42         boolean a = true;
43         boolean c = false;
44 
45         System.out.println(a^c); //不同返回真
46         System.out.println(a^!c); //相同返回假
47     }
48 }

 1 package __数据类型转换_运算符_方法入门._2运算符._3赋值运算翻;
 2  ?
 3  /**
 4   * @author Admin
 5   * @Classname AssignmentDemo
 6   * @Package __数据类型转换_运算符_方法入门._2运算符._3赋值运算翻
 7   * @date 2020/03/29 21:54
 8   * @Description TODO
 9   * 复合赋值运算符
10   */
11  public class AssignmentDemo {
12      public static void main(String[] args) {
13          int a = 10;
14          //按照公式进行翻译：a=a+5
15          //a=10+5；
16               //a=15；
17               //a本来是10，现在重新赋值得到15
18          a += 5;
19          System.out.println(a);//15
20  ?
21          int x = 10;
22          //x=×%3；
23                   //x=10%3；
24                   //x=1；
25                   //x本来是10，现在重新赋值得到1
26          x %= 3;
27          System.out.println(x);//1
28      }
29  }