变量的基本使用


声明变量
int a;
赋值
a = 60; //应该这么说: 把 60 赋给 a
使用 System.out.println(a);


也可以一步到位 int a = 60; 通常我们是一步完成

  1. public class Var01 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //声明变量
  7.         int a;
  8.         a = 100;
  9.         System.out.println(a); 
  11.         //还可以这样使用
  12.         int b = 800;
  13.         System.out.println(b); 
  14.     }
  15. }

image.png

  1. public class Var02 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  5.         //记录人的信息
  6.         int age = 30;
  7.         double score = 88.9;
  8.         char gender = '男';
  9.         String name = "king";
  10.         //输出信息, 快捷键
  11.         System.out.println("人的信息如下:");
  12.         System.out.println(name);
  13.         System.out.println(age);
  14.         System.out.println(score);
  15.         System.out.println(gender);
  18.     }
  19. }

变量注意事项

image.png

变量的细节

  1. public class VarDetail { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  5.         //变量必须先声明，后使用, 即有顺序
  6.         int a = 50;//int
  7.         System.out.println(a);//50
  8.         //该区域的数据/值可以在同一类型范围内不断变化
  9.         //a = "jack"; //× a是整型 不能在赋值字符串
  10.         a = 88; //对 变量可以重新赋值
  11.         System.out.println(a);//88
  13.         //变量在同一个作用域内不能重名
  14.         //int a = 77;//错误  
  17.     }
  18. }
  20. class Dog {
  21.     public static void main(String[] args) {
  22.         int a = 666;//对 因为在Dog这个作用域中 没有在vardetail中 不在同一个作用域 不冲突
  23.     }
  24. }

程序中 +号的使用

image.png

  1. public class Homework01 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         int n1;
  7.         n1 = 13;
  8.         int n2;
  9.         n2 = 17;
  10.         int n3;
  11.         n3 = n1 + n2;
  12.         System.out.println("n3 = " + n3);//30
  13.         int n4 = 38;
  14.         int n5 = n4 - n3;
  15.         System.out.println("n5 = " + n5);//8
  17.     }
  18. }

数据类型

image.png

整数类型

image.png

  1. public class IntDetail { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //Java的整型常量（具体值）默认为 int 型，声明long型常量须后加‘l’或‘L’
  7.         int n1 = 1;//4个字节
  8.         //int n2 = 1L;//不对  无法把long型放入int中 放不下
  9.         long n3 = 1L;//对
  11.     }
  12. }

浮点类型

Java的浮点类型可以表示一个小数
float是单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方，float占用4个字节的存储空间
double是双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的308次方，double占用8个字节的存储空间
默认小数都用double来表示，所以如果要用float的话，则应该在其后加上f

  1. public class FloatDetail { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         //Java 的浮点型常量(具体值)默认为double型，声明float型常量，须后加‘f’或‘F'
  7.         //float num1 = 1.1; //错误 默认是double 8个字节  无法将8个字节的小数放到4个字节的folat存储空间中
  8.         float num2 = 1.1F; //对的
  9.         double num3 = 1.1; //对
  10.         double num4 = 1.1f; //对
  12.         //十进制数形式：如：5.12       512.0f        .512   (必须有小数点）
  13.         double num5 = .123; //等价 0.123  点前面的0可以省掉调
  14.         System.out.println(num5);
  15.         //科学计数法形式:如：5.12e2 [5.12 * 10的2次方 ]      5.12E-2   [] 
  16.         System.out.println(5.12e2);//512.0
  17.         System.out.println(5.12E-2);//0.0512 5.12*10 -2次方
  20.         //通常情况下，应该使用double型，因为它比float型更精确。
  21.         //[举例说明]double num9 = 2.1234567851;float num10 =  2.1234567851F;
  22.         double num9 =  2.1234567851;
  23.         float num10 =  2.1234567851F;
  24.         System.out.println(num9); //2.1234567851
  25.         System.out.println(num10); //2.1234567
  28.     }
  29. }

浮点型陷阱

  2. public class floatdetail { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //浮点数使用陷阱: 2.7 和 8.1 / 3  比较
  8.         //看看一段代码
  9.         double num11 = 2.7; //输出2.7
  10.         double num12 = 8.1 / 3;    // 输出 2.6999999999999997
  11.         System.out.println(num11);
  12.         System.out.println(num12);//接近2.7的一个小数，而不是2.7
  13.         //得到一个重要的使用点: 当我们对运算结果是小数的进行相等判断是，要小心
  14.         //应该是以两个数的差值的绝对值，在某个精度范围类判断
  15.         if( num11 == num12) {
  16.             System.out.println("num11 == num12 相等");
  17.         } //不会输出结果 因为num11 不等于num12
  19.         //比较计算出来的值正确的写法 
  20.         if(Math.abs(num11 - num12) < 0.000001 ) {
  21.             System.out.println("差值非常小，到我的规定精度，认为相等...");
  22.         }
  23.         // 可以通过java API  math.abs 比较两个数值绝对值的差值
  24.         System.out.println(Math.abs(num11 - num12));
  25.         //细节:如果是直接查询得的的小数或者直接赋值，是可以判断相等
  28.     }
  29. }

关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
尾数部分可能丢失，造成精度损失(小数都是近似值)。
符号位
  在最高二进制位上分配1位表示浮点数的符号，0表示正数，1表示负数。
指数位
在符号位右侧分配8位用来存储指数
尾数位
  最右侧分配连续23位用来存储有效数字

java api

JDKAPI_1.6_zh中文.CHM
image.png

image.png

字符类型char

字符类型可以表示单个字符,字符类型是 char，char 是两个字节(可以存放汉字)

  1. //演示char的基本使用
  2. public class Char01 { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  6.         char c1 = 'a';
  7.         char c2 = '\t';
  8.         char c3 = '韩';
  9.         char c4 = 97; //说明: 字符类型可以直接存放一个数字
  10.         // 输出c4的时候 会输出97对应的ASSIC码对应的字符 a
  11.         System.out.println(c1);
  12.         System.out.println(c2);
  13.         System.out.println(c3);
  14.         System.out.println(c4);//当输出c4时候，会输出97表示的字符 => 编码的概念
  16.     }
  17. }

ASCII码对照表.png

字符类型使用细节

image.png

  2. public class CharDetail { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //在java中，char的本质是一个整数，在默认输出时，是unicode码对应的字符
  8.         //要输出对应的数字，可以(int)字符
  9.         char c1 = 97;
  10.         System.out.println(c1); // a
  12.         char c2 = 'a'; //输出'a' 对应的 数字
  13.         System.out.println((int)c2);//输出 97
  14.         char c3 = '韩';
  15.         System.out.println((int)c3);//38889
  16.         char c4 = 38889;
  17.         System.out.println(c4);//韩
  19.         //char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.
  21.         System.out.println('a' + 10);//107 字符于数字运算 得到的是字符对应的数字与数字的相加
  23.         //课堂小测试
  24.         char c5 = 'b' + 1;//98+1==> 99
  25.         System.out.println((int)c5); //99
  26.         System.out.println(c5); //99->对应的字符->编码表ASCII(规定好的)=>c
  27.         //输出99在编码表ASCII 表中对应的汉字
  28.     }
  29. }

image.png

unicode介绍
image.png

utf-8介绍
image.png

布尔类型boolean

image.png

  1. public class Boolean01 { 
  2.     //编写一个main方法
  3.     public static void main(String[] args) {
  4.         //演示判断成绩是否通过的案例
  5.         //定义一个布尔变量
  6.         boolean isPass = true;
  7.         if(isPass == true) {
  8.             System.out.println("考试通过，恭喜");
  9.         } else {
  10.             System.out.println("考试没有通过，下次努力");
  11.         }
  12.     }
  13. }

基本数据类型转换

image.png

自动类型转换注意和细节

image.png

  1. public class AutoConvert { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  5.         //演示自动转换
  6.         int num = 'a';//ok char -> int
  7.         double d1 = 80; //ok int -> double
  8.         System.out.println(num);//97
  9.         System.out.println(d1);//80.0
  10.         //
  11.     }
  12. }

数据类型转换细节

  1. //自动类型转换细节
  2. public class AutoConvertDetail { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  6.         //细节1： 有多种类型的数据混合运算时，
  7.         //系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算
  8.         int n1 = 10; //ok
  9.         //float d1 = n1 + 1.1;//错误 1.1小数默认是double类型  n1 + 1.1 => 结果类型是 double double->folat不可以
  10.         //double d1 = n1 + 1.1;//对 n1 + 1.1 => 结果类型是 double
  11.         float d1 = n1 + 1.1F;//对 n1 + 1.1 => 结果类型是 float
  13.         //细节2: 当我们把精度(容量)大 的数据类型赋值给精度(容量)小 的数据类型时，
  14.         //就会报错，反之就会进行自动类型转换。
  15.         //
  16.         //int n2 = 1.1;//错误 double -> int 
  18.         //细节3: (byte, short) 和 char之间不会相互自动转换
  19.         //当把具体数赋给 byte 时，(1)先判断该数是否在byte范围内，如果是就可以
  20.         byte b1 = 10; //对  , -128-127
  21.         // int n2 = 1; //n2 是int 
  22.         // byte b2 = n2; //错误，原因： 如果是变量赋值，判断类型 n2 int4个字节 byte 1个字节
  23.         // 
  24.         // char c1 = b1; //错误， 原因 byte 不能自动转成 char
  25.         // 
  26.         // 
  28.         //细节4: byte，short，char  他们三者可以计算，在计算时首先转换为int类型
  30.         byte b2 = 1;
  31.         byte b3 = 2;
  32.         short s1 = 1;
  33.         //short s2 = b2 + s1;//错, b2 + s1 => int  整数默认是int 
  34.         int s2 = b2 + s1;//对, b2 + s1 => int
  36.         //byte b4 = b2 + b3; //错误: b2 + b3 => int 
  37.         //
  39.         //boolean 不参与转换
  40.         boolean pass = true;
  41.         //int num100 = pass; // boolean 不参与类型的自动转换
  43.         //自动提升原则： 表达式结果的类型自动提升为 操作数中最大的类型
  44.         //看一道题
  46.         byte b4 = 1;
  47.         short s3 = 100;
  48.         int num200 = 1;
  49.         float num300 = 1.1F;
  51.         double num500 = b4 + s3 + num200 + num300; //float -> double
  52.     }
  53. }

强制类型转换

也就是把之前不能转的 通过强制的方法转过去
将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符( )，但可能造成精度降低或溢出,格外要注意。

  2. public class ForceConvert { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //演示强制类型转换
  8.         int n1 = (int)1.9; //强制吧1.9double类型转成int
  9.         System.out.println("n1=" + n1);//1, 造成精度损失
  11.         int n2 = 2000;
  12.         byte b1 = (byte)n2;
  13.         System.out.println("b1=" + b1);//造成 数据溢出 b1=-48
  14.     }
  15. }

强制类型转换细节说明

image.png

  2. public class ForceConvertDetail { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //演示强制类型转换
  8.         //强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
  9.         //int x = (int)10*3.5+6*1.5;//编译错误： double -> int  只把10强转换为int  计算结果是double转int报错
  10.         int x = (int)(10*3.5+6*1.5);// (int)44.0 -> 44  把整个后面括号内的值强转
  11.         System.out.println(x);//44
  14.         char c1 = 100; //ok
  15.         int m = 100; //ok
  16.         //char c2 = m; //错误
  17.         char c3 = (char)m; //ok
  18.         System.out.println(c3);//100对应的字符, d字符
  21.     }
  22. }
  1. public class Homework01 { 
  3.     //编写一个main方法
  4.     public static void main(String[] args) {
  6.         int n1;
  7.         n1 = 13;
  8.         int n2;
  9.         n2 = 17;
  10.         int n3;
  11.         n3 = n1 + n2;
  12.         System.out.println("n3 = " + n3);//30
  13.         int n4 = 38;
  14.         int n5 = n4 - n3;
  15.         System.out.println("n5 = " + n5);//8
  17.     }
  18. }

基本数据类型和String 类型的转换

image.png

  2. public class StringToBasic { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  7.         //基本数据类型->String
  9.         int n1 = 100;
  10.         float f1 = 1.1F;
  11.         double d1 = 4.5;
  12.         boolean b1 = true;
  13.         String s1 = n1 + "";
  14.         String s2 = f1 + "";
  15.         String s3 = d1 + "";
  16.         String s4 = b1 + "";
  17.         System.out.println(s1 + " " + s2 + " " + s3 + " " + s4);
  19.         //String->对应的基本数据类型
  20.         String s5 = "123";
  21.         //会在OOP 讲对象和方法的时候回详细
  22.         //解读 使用 基本数据类型对应的包装类，的相应方法，得到基本数据类型
  23.         int num1 = Integer.parseInt(s5);
  24.         double num2 = Double.parseDouble(s5);
  25.         float num3 = Float.parseFloat(s5);
  26.         long num4 = Long.parseLong(s5);
  27.         byte num5 = Byte.parseByte(s5);
  28.         boolean b = Boolean.parseBoolean("true");//布尔类型只能转成True False
  29.         short num6 = Short.parseShort(s5);
  31.         System.out.println("===================");
  32.         System.out.println(num1);//123
  33.         System.out.println(num2);//123.0
  34.         System.out.println(num3);//123.0
  35.         System.out.println(num4);//123
  36.         System.out.println(num5);//123
  37.         System.out.println(num6);//123
  38.         System.out.println(b);//true
  40.         //怎么把字符串转成字符char -> 含义是指 把字符串的第一个字符得到
  41.         //解读  s5.charAt(0) 得到 s5字符串的第一个字符 '1'
  42.         System.out.println(s5.charAt(0)); //根据下标转换
  44.     }
  45. }

基本数据类型和String 类型的转换细节

在将 String 类型转成 基本数据类型时， 要确保string类型能够转换成有效的数据 ，
比如 我们可以把 “123” , 转成一个整数，但是不能把 “hello” 转成一个整数

  1. /**
  2.  * 演示字符串转基本数据类型的细节
  3.  */
  4. public class StringToBasicDetail { 
  6.     //编写一个main方法
  7.     public static void main(String[] args) {
  9.         String str = "hello";//编译并不会报错 因为没有语法错误 但是执行的时候会报错
  10.         //转成int
  11.         int n1 = Integer.parseInt(str);
  12.         System.out.println(n1);
  13.     }
  14. }

如果格式不正确，就会抛出异常，程序就会终止
**

  3. public class Homework02 { 
  5.     //±àдһ¸ömain·½·¨
  6.     public static void main(String[] args) {
  7.         char c1 = '\n'; 
  8.         char c2 = '\t'; 
  9.         char c3 = '\r'; 
  10.         char c4 = '\\'; 
  11.         char c5 = '1'; 
  12.         char c6 = '2'; 
  13.         char c7 = '3'; 
  14.         System.out.println(c1);
  15.         System.out.println(c2);
  16.         System.out.println(c3);
  17.         System.out.println(c4);
  18.         System.out.println(c5);
  19.         System.out.println(c6);
  20.         System.out.println(c7);
  21.     }
  22. }
  2. public class Homework03 { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  6.         //编程，保存两本书名，用+拼接，看效果。保存两个性别，
  7.         //用加号拼接，看效果。保存两本书价格，用加号拼接，看效果
  9.         String book1 = "天龙八部";
  10.         String book2 = "笑傲江湖";
  11.         System.out.println(book1 + book2);//天龙八部笑傲江湖
  13.         //性别应该使用char保存
  14.         char c1 = '男';
  15.         char c2 = '女';
  16.         System.out.println(c1 + c2);//得到  男 字符码值 + 女 字符码值
  18.         //保存两本书价格
  19.         double price1 = 123.56;
  20.         double price2 = 100.11;
  21.         System.out.println(price1 + price2);//就是 123.56+100.11
  22.     }
  23. }
  2. public class Homework04 { 
  4.     //编写一个main方法
  5.     public static void main(String[] args) {
  6.         /*
  7.          姓名    年龄    成绩    性别    爱好
  8.          xx        xx    xx    xx    xx
  10.         要求：
  11.         1) 用变量将姓名、年龄、成绩、性别、爱好存储
  12.         2) 使用+
  13.         3) 添加适当的注释
  14.         4) 添加转义字符, 使用一条语句输出
  16.          */
  17.         //姓名
  18.         String name = "jack";
  19.         int age = 20;
  20.         double score = 80.9;
  21.         char gender = '男';
  22.         String hobby = "打篮球";
  23.         //输出了信息, 可以使用换行
  24.         System.out.println("姓名\t年龄\t成绩\t性别\t爱好\n" + name + "\t" 
  25.             + age + "\t" + score + "\t" + gender + "\t" + hobby);
  26.     }
  27. }