02数据类型和运算符

  1 数据类型和运算符
  2 
  3 
  4 标识符
  5 常作用    
  6 常量、变量、方法、类和包等的名称
  7 命名规则
  8 必须以字母、_下划线、美元符$开头。
  9 其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合
 10 大小写敏感，长度无限制。
 11 不可以是Java的关键字。
 12 注意
 13 Java不采用通常语言使用的ASCII字符集
 14 Java采用unicode这样的标准的国际字符集。因此，这里的字母的含义：英文、汉字等等。(不建议大家使用汉字来定义标识符！
 15 常量和变量
 16 常量变量定义
 17 在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
 18 变量举例：
 19 在2D游戏程序中，需要代表人物的位置，则需要2个变量，一个是x坐标，一个是y坐标，在程序运行过程中，这两个变量的值会发生改变
 20 常量举例
 21 代表常数，便于程序的修改（例如：圆周率的值）
 22 增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）
 23 
 24 在实际的程序中，可以根据数据在程序运行中是否发生改变，来选择应该是使用变量代表还是常量代表
 25 数据类型
 26 整型  
 27 整型变量：
 28 整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ‘(建议使用大写，小写容易误认为数字1)
 29 浮点型
 30  浮点类型常量：
 31 浮点型变量：
 32 float类型：单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
 33 double类型：双精度类型  精度是float类型的两倍，尾数可以精确到16位有效数字，绝大部分应用程序都采用double类型。
 34 注意
 35 浮点常量默认为double。要变为float，需在后面增加F/f.  如： 3.14F
 36 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
 37 
 38  字符型
 39   布尔型
 40 boolean类型有两个值，true和false
 41 
 42 boolean 类型用来判断逻辑条件，一般用于程序流程控制 
 43 
 44 实践：
 45 请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==fasle 和 ==true。
 46 
 47 
 48 运算符
 49 算术运算符
 50 +：字符串相加，只要有一个操作数是字符串，自动变为字符串相连
 51 
 52   关系运算符
 53 关系运算符用来进行比较运算
 54 
 55 关系运算的结果是布尔值：true/false
 56 
 57 
 58 Scanner的用法
 59 package scanner;
 60 
 61 /**
 62  * lang包是java的核心包，系统会自动加载lang包的内容
 63  * 所以使用lang包中的内容不需要导入
 64  * 
 65  * 除了lang包以外，其他的内容使用之前都必须要先导入
 66  */
 67 import java.util.Scanner;
 68 
 69 public class ScannerDemo {
 70     public static void main(String[] args) {
 71 //        创建Scanner的变量
 72         Scanner sc = new Scanner(System.in);
 73         System.out.println("请输入第一个数字");
 74         int n1 = sc.nextInt();
 75         System.out.println("请输入第二个数字");
 76         int n2 = sc.nextInt();
 77         System.out.println("两个数字之和是："+(n1+n2));
 78 
 79     }
 80 }
 81 
 82 
 83 位运算符 
 84 位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。
 85 如果操作的对象是char、byte、short，位移动作发生前其值会自动晋升为int，运算结果也为int。
 86 package bit;
 87 /**
 88  * 位运算符
 89  * @author tang
 90  *
 91  */
 92 public class Test {
 93     public static void main(String[] args) {
 94         int a = 11;
 95         int b = 8;
 96         //按位与
 97         /**
 98          * 首先将表达式两边的数组转换为2进制
 99          * 对应的位进行比较
100          * 如果对应的位上都是1 则结果的这一位为1
101          * 如果对应的位上有一个是0 则结果的这一位是0
102          * 1011
103          * 1010
104          * 1010
105          * 
106          */
107         System.out.println(a & b);
108         
109         /**
110          * 按位或
111          * 首先将表达式两边的数组转换为2进制
112          * 对应的位进行比较
113          * 如果对应的位上都是0 则结果的这一位为0
114          * 如果对应的位上有一个是1 则结果的这一位是1
115          * 1011
116          * 1000
117          * 1011
118          */
119         System.out.println(a | b);
120         
121         /**
122          * 按位异或 ^
123          * 首先将表达式两边的数组转换为2进制
124          * 对应的位进行比较
125          * 对应的位上的值相等 则结果这一位为0
126          * 对应的位上的值不等，则结果这一位为1
127          * 1011
128          * 1000
129          * 0011
130          */
131         System.out.println(a ^ b);
132         
133         /**
134          * 位移运算符
135          * a << n;
136          * 运算规则   箭头向左   二进制后面多加几个0
137          *             箭头向右   二进制后面少几位
138          * 10
139          */
140         a = 8;
141         System.out.println(a << 2);
142         System.out.println(a / 2);
143     }
144 }
145 
146 
147 
148  条件运算符
149 语法格式
150 x ? y : z 
151 唯一的三目运算符
152 执行过程
153 其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。  
154 经常用来代替简单的if-else判断
155 
156 优先顺序：  赋值<三目<逻辑<关系<算术<单目
157 
158 package bit;
159 /**
160  * 三目运算符
161  * @author tang
162  *
163  */
164 public class Test02 {
165     public static void main(String[] args) {
166         /**
167          * 三目运算符的语法
168          * 布尔值的表达式？值1:值2
169          * 如果布尔值表达式返回true  则三目运算符返回值1
170          * 如果布尔值表达式返回false 则三目运算符返回值2
171          */
172         
173         int score = 69;
174         System.out.println(score >= 60?"及格":"不及格");
175         int b = 10;
176         System.out.println("abc"+(score + b));
177     }
178 }
179 
180 
181 
182 命名规则(规范)  
183 所有变量、方法、类名：见名知意
184 
185 变量、方法名：
186 首字母小写和驼峰原则
187 run(), runRun(),  age     ageNew   monthSalary
188 userName
189 
190 常量：
191 大写字母和下划线：MAX_VALUE
192 
193 类名：
194 首字母大写和驼峰原则:  Man, GoodMan
195 
196 //代码的第一行非注释的内容一定是 标记包名
197 package com.gzsxt.test;
198 //创建一个java文件的时候，系统会同时生成一个跟文件同名的 java的class
199 //文件的命名必须遵守以下规则：
200 //1，首字母大写，以后每个单词的首字母也大写
201 //2，命名要见名知意
202 //public 是一个访问修饰符  代表公共的公开的，意思就是修饰的内容在整个项目中都可以被调用
203 // class 是java的关键字  用来标记一个java的类
204 
205 /*
206  * 多行注释
207  * 凡是在  /*和 * /之间的内容都是注释的内容 
208  * 
209  */
210 
211 /**
212  * 文档注释  
213  * @author tang
214  *
215  */
216 public class HelloWorld { //开始的大括号   可以独自占一行也可以跟在代码后面
217     //static 修饰符，表示静态的     所有静态的内容都是可以通过类名直接调用
218     // void 代表没有返回值，如果这里有返回值，则void会变成返回值的类型
219 //    main   方法名   
220 //    main 方法是程序的入口，执行一个程序的系统会首先去寻找main方法，来执行main方法中的代码
221     
222     public static void main(String[]args){
223 //        输出一句话在控制台
224 //        双引号来标记java中的字符串
225         System.out.println("我的第一是的发顺丰个java程序");
226     }//结束的大括号一定要独自占一行
227 }
228 
229 
230 final 常量  
231 package day02;
232 /**
233  * 使用final来修饰一个变量，则该变量就变为常量
234  * 在常量的整个声明周期中只能被赋值一次
235  * 常量的命名规则   全部是大写字母  如果有多个单词  则通过下划线来链接多个单词
236  * @author tang
237  *
238  */
239 public class FinalDemo {
240     public static void main(String[] args) {
241         int age = 10;
242         System.out.println(age);
243         final int USER_AGE;
244         USER_AGE = 20;
245         
246         String studentName;
247         
248         
249     }
250     
251     public static void setUserName(){
252         
253     }
254 }
255 
256 
257 
258 package day02;
259 /**
260  * 变量的三要素
261  * 1,变量类型 
262  * 2,变量名 
263  * 3,作用域    从声明的位置开始   到   第一个结束的大括号
264  * @author tang
265  *
266  */
267 public class Test {
268     public static void main (String [] args){
269         //在java中所有用到的东西都必须要先声明 （有些是系统声明好的，就可以直接使用）
270         //声明变量的语法     数据类型  变量名 = 值
271         //           数据类型  变量名;
272         //           变量名 = 值;
273         
274         int x;  
275         x = 180;
276         int y = 200;
277         
278         float w = 100.2f;
279         
280         //不建议使用这种方式声明
281         int a , b ;
282         
283         // byte 字节 类型    取值范围  -128 ~ 127
284         byte b1 = 100;
285         byte age = 127;
286         
287         //short 短整型  占用两个字节   -2^15 ~ 2^15-1  
288         short s = 30000;
289         
290         //int  整型   占用4个字节       -2^31 ~2^31-1 
291         int sal = 2100000000;
292         
293         //long  长整型    占用8个字节   -2^63 ~ 2^63-1
294         //java 中所有的整数类型都默认是int类型  如果需要long类型则要在数字后面加一个l L
295         long money = 88888888888888L;
296         
297         //在java中 整数类型默认使用int 如果长度不够，使用long类型
298         
299         
300         //带小数的类型     所有带小数的数字 默认都是double类型   
301         //float类型 占用4个字节    小数点后面最多保留7位有效数字
302         float f  = 3.1234567890F;
303         //double 类型   占用8个字节  小数点后面最多保留16位有效数字
304         double d = 1.123456789012;
305         System.out.println(d);
306         
307         
308         //在java中  双引号标记一个字符串
309         //单引号标记一个字符   char
310         //java使用的是unicode字符集   所以java中一个字符可以是一个汉字
311         char c = ‘a‘;
312         char r = ‘\‘‘;
313         System.out.println("abc"+r+"def");
314         
315         
316         //布尔值类型
317         //取值只能是true 或者false  
318         //如果值为true 则在内存中保存的是1  如果是false 在内存中保存的是0
319         //布尔值只占用一个二进制的位      就是八分之一个字节
320         //多用于条件判断
321         boolean b2 = true;
322         System.out.println(59 > 60);
323         
324 
325   
326  赋值运算符：
327 package flg;
328 
329 public class Test {
330     public static void main(String[] args) {
331         int a = 10;
332         String  str01 = "abc";
333         /**
334          * 1,当加号两边出现的都是数字类型，则作为数学运算
335          * 2,当加号两边出现了字符串类型 ，则作为连接符来使用，将加号两边的内容链接在一起形成一个新的字符串
336          */
337 //        System.out.println(a+10+str01);
338 //        System.out.println(str01+a+ 10);
339 //        System.out.println(a/6);
340         
341         //% 求模   求余数
342         //System.out.println(10%6);
343         
344         // ++ 自增运算
345         //a ++;  //等同于  a = a + 1;   等同于 a += 1;
346         // -- 自减运算
347         //a --;  //等同于 a = a - 1;
348         
349         
350         //扩展运算符
351         // += 
352 //        a += 10;//等同于  a = a + 10;
353 //        a -= 10;//等同于  a = a - 10;
354 //        a /= 10;//等同于 a = a / 10;
355 //        a *= 10;//等同于 a = a * 10;
356 //        a %= 10;//等同于 a = a % 10;
357         
358 
359 逻辑运算符 ：
360 逻辑运算符与布尔操作数一起使用，组成逻辑表达式
361 逻辑表达式的结果是布尔值
362 &和&&的区别
363 “&”:无论任何情况，“&”两边的表达式都会参与计算。
364 “&&”: 当“&&”的左边为false，则将不会计算其右边的表达式。即左false则false
365 “|”和“||”的区别与“&”和“&&”的区别类似。
366 
367 package flg;
368 /**
369  * 逻辑运算符
370  * 运算符两边出现的都是返回布尔值的表达式
371  * 运算结果也是布尔值表达式
372  * @author tang
373  *
374  */
375 public class Test02 {
376     public static void main(String[] args) {
377  
378 //        
379         /**
380          *短路与   && 
381          * 表达式两边的布尔值都返回true 则结果为true
382          * 如果表达式两边的布尔值有一个为false 则结果为false
383          * 如果第一个表达式就能确定返回结果  就不在去执行第二个表达式
384          * 
385          * 逻辑与  &
386          * 表达式两边的布尔值都返回true 则结果为true
387          * 如果表达式两边的布尔值有一个为false 则结果为false
388          * 如果第一个表达式就能确定返回结果  仍然要去执行第二个表达式
389          */
390         int a = 10;
391         int b = 20;
392         
393         boolean bl = a<1 && b>1/0;
394         System.out.println(bl);
395         
396         
397         /**
398          * 短路或 ||
399          * 当表达式两边的布尔值有一个返回true 则结果就为true
400          * 当表达式两边的布尔值都返回false  则结果为false 
401          * 当第一个表达式就已经可以确定返回结果了  就不再执行第二个表达式
402          * 
403          * 
404          * 逻辑或 |
405          * 当表达式两边的布尔值有一个返回true 则结果就为true
406          * 当表达式两边的布尔值都返回false  则结果为false 
407          * 当第一个表达式就已经可以确定返回结果了  仍然会继续执行第二个表达式
408          * 
409          */
410         
411 //        System.out.println(a > 1 || b/0 > 100);
412         
413         
414         //逻辑非
415         //取反  
416         //System.out.println(!(a>10));
417         
418         //逻辑异或  ^
419         //表达式两边的布尔值相同   则返回false 
420         //表达式两边的布尔值不相同  则返回true
421         System.out.println(false ^ true);
422         
423     }
424 
425 基本数据类型的类型转换
426 在赋值运算或算术运算时，要求数据类型相同，否则要进行类型转换
427 
428 转换方式：
429 自动转换
430 强制转换
431 
432 除boolean类型外，所有的基本数据类型因为各自的精度不同，赋值时都要考虑这个问题
433 除boolean类型外，所有的基本数据类型包括：整型，浮点型，字符型。
434 package 类型转换;
435 /**
436  * 基本数据类型的类型转换
437  * @author tang
438  *
439  *    类型转换分为两种情况
440  *    一，自动类型转换
441  *        1，低精度 向高精度转换
442  *        2，低位向高位转换
443  *    二，强制类型转换
444  *        1，高精度向低精度转换
445  *            可能会损失精度
446  *        2，高位向低位转换
447  *            可能会损失大小
448  *        
449  */
450 public class Test {
451     public static void main(String[] args) {
452         int  a = 10;
453         float f = 1.23f;
454         f = a;
455         long lo = 123L;
456         
457         
458         //__________________________
459         
460         int b = 270;
461         byte bt = (byte)b;
462         System.out.println(bt);
463         //00000001 00001110
464         
465         
466         f = 3.14f;
467         int c =  (int)f;
468         System.out.println(c);
469     }
470 }
471 
472 
473 
474 package test;
475 
476 import java.util.Scanner;
477 
478 /**
479  * 练习3:商场推出幸运抽奖活动 根据抽奖规则计算会员卡号各位数字之和为16,则为幸运会员
480  * @author tang
481  *
482  */
483 public class Test03 {
484     public static void main(String[] args) {
485         Scanner input = new Scanner(System.in);
486         System.out.println("请输入四位数的会员卡卡号");
487         //接收到用户输入的卡号
488         int cardNo = input.nextInt();
489         //求出卡号千位上的数字
490         int k  = cardNo/1000;
491         //求出卡号百位上的数字
492         int b = (cardNo%1000)/100;
493         //求出卡号十位上的数字
494         int s = (cardNo%100)/10;
495         //求出卡号个位上的数字
496         int g = cardNo%10;
497 //        求和
498         int sum = k + b + s + g;
499         String message = (sum == 16)?"恭喜你，中奖了！":"很遗憾，本次没有中奖";
500         System.out.println(message);
501