/*
 不同进制的数据表现：
  二进制：由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); //十六进制
 }
}

/*
 常量：
  在程序执行过程中，其值不发生改变的量。
  
 分类：
  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);
 }
}

/*
 数据类型：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);
 }
}

/*
 看程序写结果
  字符串数据和其他数据做+，结果是字符串类型。
  这里的+不是加法运算，而是字符串连接符。
*/
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
 }
}

/*
 使用变量的时候要注意的问题：
  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的范围内，如果在就不报错。
 }
}