Java05

Java 基础 05: 类型转换

类型转换

由于 Java 是强类型语言, 所以要进行有些运算的时候, 需要用到类型转换.

低 ------------------------------------------------>高

byte,short,char -> int -> long -> float -> double// 小数的优先级一定大于整数

运算中, 不同类型的数据先转换为同一类型, 然后进行运算.

强制类型转换

l 自动类型转换的逆过程, 将容量大的数据类型转换为容量小的数据类型. 使用时要加上强制转换符 (()), 但可能造成精度降低或溢出, 格外要注意.(什么叫做逆转换呢? 比如我们 byte b = 9;int i = b;(这两行属于正常的隐式转换数据类型, 它是自动的). 但是我们反过来讲, 比如 int k =7;byte b0 = k; 这样就不行了, 不能把 int 类型转换为 byte 类型, 不能自动转换, 如果我们要强制转换呢? 例如 int k = 7;byte b0 = (byte)k;(这个就是强制转换数据类型, 它是手动的, 强制的转换数据类型要用英文的小括号() 括起来).)

l 通常, 字符串不能之间转换为基本类型, 但通过基本类型对应的包装类则可以实现把字符串转换成基本类型.

? 如: String a = "43";int i = lnteger.parselnt(a);

? boolean 类型不可以转换为其它的数据类型.

自动类型转换

自动类型转换: 容量小的类型自动转换为容量大的数据类型. 数据类型按容量大小排序为:

低 ------------------------------------------------>高

byte,short,char -> int -> long -> float -> double

例如 byte 转换成 int(byte b = 2;int x = b; 输出 System.out.print(x); 输出结果为 2); 假如你想大转小, int 转换成 byte, 例: int i = 0;byte b = i; 这样是错误的, 异常的, 这种异常叫做编译期异常, 只有在 Javac 的时候可以发现.

l 有多种数据类型的数据混合运算时, 系统首先自动将所有数据转换成容量最大的那种数据类型, 然后再进行计算.(例如 int I = 1;short s = 2;byte b = 3; 然后 i + s + b;// 问题, 他们相加最后得到的数字 6 是一个什么声明类型呢? 在计算过程中 i,s,b 这三个变量会做数据类型的转化吗? 答案是会, 转化为最大的 int:int x = i + s +b;)在计算过程中, 整数类型是 int 的范围最大, 所以 s 和 b 都分别先转换成 int 类型然后进行加的运算, 最终的结果是 int 类型的数据.(char 是字符为什么也能参加运算呢? 比如 char c = 'a';byte b0 = 2;int k = c + bo; 输出结果是 99, 这明明是个字符, 为什么可以和数字相加? 原因是 ASCII 码:"上个世纪 60 年代, 美国制定了一套字符编码, 对英语字符与二进制位之间的关系, 做了统一规定. 这被称为 ASCII 码. ASCII 码一共规定了 128 个字符的编码, 比如空格"SPACE"是 32(二进制 00100000), 大写的字母 A 是 65(二进制 01000001)." 实际上我们 char 定义的英文字符都是有一个数字的, 所以我们用 char 类型的数据在与数字进行数学运算的时候, 它是转化为相对应的 ASCII 码的值然后再进行的计算)

l Byte,short,char 之间不会相互转换, 它们三者在计算时首先转换为 int 类型.

l 当把任何基本数据的值和字符串值进行连接运算时(+), 基本类型的值将自动转换为字符串类型.(例如我们先建立一个 String str = "abc";int i = 1; 然后 System.out.println(str + i); 输出它, 结果为 abc1, 实际上把 1 也定义为字符了, 他们不会相加, 不论加多少个都是一样的.)

注意: 当这个有一系列的 + 的运算的时候, 如果某个部分其中含有字符串, 那么这个字符串前面挨着的 + 开始一直往后都是要按照字符串拼接计算去看

public class Dome04 {
     public static void main(String[] args){
         int i = 128;
         byte b = (byte)i;// 内存溢出
         // 我们再转化的途中尽量要避免这种内存溢出的情况, 因为内存溢出, 你也不知道变成什么, 以及超过它大小了
         System.out.println(i);
         System.out.println(b);
         // 强制转换      (类型)变量名     高 -->低
         //byte b = (byte)i; 这种加 () 里面输入类型的称为强制转化
 ?
         // 自动转换      低 -->高
         int i1 = 128;
         double b1 = i1;
         // 我们由低转到高的时候不用加任何东西它也不会报错
         System.out.println(i1);
         System.out.println(b1);
 ?
 ?
         /* 注意点
         1. 不能对布尔值进行转换
         2. 不能把对象类型转换为不相干的类型
         3. 在把高容量转化到低容量的时候, 需要强制转化, 反之完全不用动
         4. 转换的时候可能存在内存溢出或者精度问题!
          */
 ?
         System.out.println("==========================================");
         System.out.println((int)23.7);  //23
         System.out.println((int)-45.89f);   //-45
 ?
 ?
         System.out.println("==========================================");
         char c = 'a';
         int d = c + 1;
         System.out.println(d);
         System.out.println((char)d);
 ?
     }
 }
public class Dome05 {
     public static void main(String[] args){
         // 操作比较大的数的时候, 注意溢出问题
         //JDK7 新特性, 数字之间可以用下划线分割
         int money = 10_0000_0000;
         int years = 20;
         int total = money * years;//-1474836480, 计算的时候溢出了
         long total2 = money * years;//-1474836480, 默认是 int, 计算完之后才把 money * years 转换成 long 类型, 转换之前已经存在问题了
         System.out.println(total);
         System.out.println(total2);
 ?
         long total3 = money * ((long)years);//20000000000, 先把一个数转换为 long
         System.out.println(total3);
     }
 }

数字类型的运算规则:

1, 有多种类型的数据混合运算时, 系统首先自动将所有数据转换成容量最大的那种数据类型, 然后在进行计算. 数字类型的从小到大分别是 byte,short,int,long,float,double.

2, 数据类型的运算中, 多个相同类型变量参与的运算, 变量要先转换成相对应的数据类型的默认类型(比如连个 byte 类型的变量相加, 会先把两个 byte 类型的变量转换成默认的 int 类型之后再计算, 得到的结果是 int 类型). 这种情况适用于变量的数据类型的容量比默认类型的容量小,(比如 byte,short, 都比 int 小)

3, byte,short,char 之间不会相互转换, 它们三者在计算时首先转换为 int 类型.

Java 基础 06: 变量, 常量, 作用域

变量

变量是什么: 就是可以变化的量!

Java 是一种强类型语言, 每个变量都必须声明其类型.

Java 变量是程序中最基本的存储单元, 其要素包括变量名, 变量类型和作用域.

type varName [=value] [{,varName[=value]}];
 // 数据类型  变量名 = 值; 可以使用逗号隔开来声明多个同类型变量.(不建议在一行里面定义多个值, 这样看起来很麻烦)
public class Demo06 {
     public static void main(String[] args){
         //int a,b,c;
         //int a = 1, b = 2, c = 3;// 这样写不好
         // 尽量写成以下这样, 有利于程序可读性
         int a = 1;
         int b = 2;
         int c = 3;
 ?
         String name = "LengGuang";
         char x = 'x';
         double pi = 3.14;
     }
 }

注意事项

每个变量都有类型, 类型可以是基本类型, 也可以是引用类型.

变量名必须是合法的标识符.

变量名是一条完整的语句, 因此每一个声明都必须以分号结束.

变量作用域

类变量

实例变量

局部变量

public class Variable{
     static int allClicks = 0;   // 类实例
     String str = "hello world";     // 实例变量
     public void method(){
         int i = 0;  // 局部变量
     }
 }
public class Demo07 {
 ?
     // 类变量   static
     static double salary = 2000;
 ?
 ?
     // 属性: 变量
 ?
     // 实例变量: 从属于对象(也可以说它从属于这个类(Demo07)); 在实例变量中, 如果不自行初始化, 将使用这个类型的默认值
     // 所有数值类型初始化都是 0 或者 0.0
     // 布尔值: 默认是 false
     // 除了基本类型, 其余的默认值都是 null
     String name;
     int age;
 ?
     //main 方法
     public static void main(String[] agrs){
 ?
         // 局部变量: 必须声明和初始化值(只在自己在的方法内可以用)
         int i = 10;
         System.out.println(i);
 ?
         // 变量类型  变量名字 = new Demo07();
         Demo07 demo07 = new Demo07();
         System.out.println(demo07.age);
         System.out.println(demo07.name);
 ?
         // 类变量   static
         System.out.println(salary);
 ?
     }
 ?
      // 其他方法
     public void add(){
 ?
     }
 }

变量的概念:

>内存中的一个存储区域

>该区域有自己的名称 (变量名) 和类型(数据结构)

>Java 中每个变量必须先声明, 后使用

>该区域的数据可以在同一类型范围内不断变化

使用变量注意:

>变量的作用域: 一对 {} 之间有效

>初始化值

定义变量的格式: 数据类型 变量名 = 初始化值(第一次给变量赋值就是初始化值)

Java 中变量的定义: 数据类型 变量名 = 变量的值, 例如: int i = 1

变量是通过使用变量名来访问这块区域的

注意: 声明变量过程中的这个 =, 不是数学意义上的 =, 在 Java 编程中代表赋值(赋予变量值)

常量

常量 (Constant): 初始化(initialize) 后不能再改变值! 不会变动的值.

所谓常量可以理解成一种特殊的变量, 它的值被设定后, 在程序运行过程中不允许被改变.

final 常量名 = 值;

final double PI = 3.14;

常量名一般使用大写字符

public class Demo08 {
 ?
     // 修饰符, 不存在区分先后顺序
     //static final   double PI = 3.14;
     final static double PI = 3.14;
 ?
     public static void main(String[] args) {
         System.out.println(PI);
     }
 }

变量的命名规范

所有变量, 方法, 类名: 见名知意

类成员变量: 首字母小写和驼峰原则: monthSalary 除了第一个单词以外, 后面的单词首字母大写, 例如 lastname-->lastName

局部变量: 首字母小写和驼峰原则

常量: 大写字母和下划线: MAX_VALUE

类名: 首字母大小写和驼峰原则: Man,GoodMan

方法名: 首字母小写和驼峰原则: run(),runRun()

Java 中的名称命名规范:

包名: 多单词组成时所有字母都小写: xxxyyyzzz

类名, 接口名: 多单词组成时, 所有单词的首字母大写: XxxYyyZzz

变量名, 方法名: 多单词组成时, 第一个单词首字母小写, 第二个单词开始每个单词首字母大写: xxxYyyZzz

常量名: 所有字母都大写. 多单词时每个单词用下划线连接: XXX_YYY_ZZZ

变量的类型: 声明的变量的数据类型就是变量的类型

Java 基础 07: 基本运算符

运算符

Java 语言支持如下运算符

算数运算符:+,-,*,/,%, +,--

赋值运算符:=

关系运算符:>,<,>=,<=,==,!= instanceof

逻辑运算符:&&(与)我和你的意思, 两个都存在,||(或)我或者你, 其中一个,!(非)非你即我, 非黑即白不是黑就是白

位运算符:&,|,^,~,>>,<<,>>>(了解!!!)

条件运算符:?:

扩展赋值运算符:+=,-=,*=,/=

package operator;
 ?
 public class Demo01 {
     public static void main(String args[]){
         // 二元运算符
         //Ctel + D : 复制当前行到下一行
         int a = 10;
         int b = 20;
         int c = 25;
         int d = 25;
 ?
         System.out.println(a + b);
         System.out.println(a - b);
         System.out.println(a * b);
         System.out.println(a / (double)b);
     }
 }
package operator;
 ?
 public class Demo02 {
     public static void main(String[] args) {
         long a = 123123123123123L;
         int b = 123;
         short c = 10;
         byte d = 8;
 ?
         System.out.println(a + b + c + d);//long
         System.out.println(b + c + d);//int, 自动升型默认结果为运算中的最高类型
         System.out.println(c + d);//short 自动升型默认结果为运算中的最高类型
         //Java 程序不知道具体的这个变量在做完运算后会不会超出当前这个变量的范围, 所以会先把变量转换为一个更大长度
     }
 }

运算符是一种特殊的符号, 用以表示数据的运算, 赋值和比较等.

l 算术运算符

l 赋值运算符

l 比较运算符(关系运算符)

l 逻辑运算符

l 位运算符

l 三元运算符

1, 算术运算符

++ 和 - 分别是加 1 和减 1 的运算,++ 或者 - 符号在变量之前, 先对变量进行 运算然后再取变量的值; 如果这个 ++ 或者 - 符号在变量之后, 就先取变量的值, 再对变量进行运算.

算术运算符的注意问题:

l 如果对负数取模(取余), 可以把模数负号忽略不记, 如: 5%-2=1. 但被模数是负数则不可忽略. 此外, 取模运算的结果不一定总是整数.

l 对于除号 "/", 它的整数除和小数除是有区别的: 整数之间做除法时, 只保留整数部分而舍弃小数部分. 例如: int x=3510;x=x/1000*1000;x 的结果是?

l "+" 除字符串相加功能外, 还能把非字符串转换成字符串. 例如: System.out.println("5+5="+5+5);// 打印结果是? 5+5=55

l 以下二者的区别:

? System.out.println(''+'\t'+'');char 类型数据是可以做数学运算的, 在做数学运算的时候把字符转化为 ACSII 码进行计算.

? System.out.println(""+'\t'+''); 字符串与其它数据类型相加时, 实际上是把其他的数据转换为字符串, 然后做字符串的拼接.

2, 赋值运算符:

l 符号:=

? 当 "=" 两侧数据类型不一致时, 可以使用自动类型转换或使用强制类型转换原则进行处理.(例如: int i=1;shrot s=2;i=s;// 自动类型转换 s=(short)i; 强制类型转换)

? 可以连续赋值, 什么叫做连续赋值呢? 比如 int i0 = 0;int i1 = 0; int i2 = 0; 然后我想给他们赋值为 1, 就连续赋值 i0 = i1 = i2 = 1; 这样就可以连续赋值

l 扩展赋值运算符:+=,-=,/=,%=(比如 int i = 1;i = i + 2; 输出结果为 3, 那我们可以更简单一点, 用扩展赋值, int i = 1;i += 2; 输出结果也为 3, 加等于就是给 i 重新赋值, 赋值成它原来的值加上它后面的值. 说简单点就是 i+2 = 的结果, 省略简写了. 字符串怎么 +=?String str = "he";str +="llo"; 输出结果为 hello, 字符串的 += 就是字符串的拼接, 仅仅也只能用 += 的操作)

l 思考一:(1)和 (2) 有什么区别?

short s =2;

s=s+3;(1) 变量参与运算时候, Java 程序不知道具体的这个变量在做完运算后会不会超出当前这个变量的范围, 所以会先把变量转换为一个更大长度, 在这个例子中, short 是一个短整型数据, 会转化为默认的 int. 此处运算不能将 int 转换为 short, 只能强制转换, 语句为 s=(short)(s+3).

s+=3;(2) 在使用扩展赋值运算符时, 变量在参与运算时会把结果自动强制转换为当前变量的类型

3, 比较运算符

? 比较运算符的结果都是 boolean 型的, 也就是要么是 ture(是), 要么是 false(否).

? 比较运算符 "==" 不能误写成 "=".

4, 逻辑运算符:

& - 逻辑与(并且的关系) | - 逻辑或(有一个条件成立就成立, 就是或者) ! - 逻辑非(取反逻辑, 条件成立就取反成不成立)

&& - 短路与(两个条件成立它才成立) || - 短路或(a 和 b 只要有一个条件成立他就成立) ^ - 逻辑异或(a 和 b 一个成立, 一个不成立它才成立)

并且(比如说: 如果今天晴天并且没有事, 就去游泳), 或者(明天或者后天, 我都有时间去约会), 异或, 非

l 逻辑运算符用于连接布尔型表达式, 在 Java 中不可以写成 3<x<6, 应该写成 x>3&X<6.

l "&" 和 "&&" 的区别:

l 单 & 时, 左边无论真假, 右边都进行运算;

双 & 时, 如果左边为真, 右边参与运算, 如果左边为假, 那么右边不参与运算.(int i=1;int k=1;System.out.println(i != 0 & ++k == 2);// 单个的 & 时候, 两边都要参与运算

System.out.println(i != 0 && ++k == 2);//2 个 & 的时候, 如果左边为 ture, 右边就参与运算; 如果左边为 flase, 右边就不参与运算.)

l "|" 和 "||" 的区别同理,|: 左边无论真假, 右边都进行运算;|| 表示: 当左边为真, 右边不参与运算.(在不需要逻辑运算两边都参与运算的时候, 尽量使用 && 或 ||)

l 异或 (^) 与或 (|) 的不同之处是: 当左右都为 true 时, 结果为 false.

理解: 异或, 追求的是 "异"! 追求的是不同.

if(boolean 值){代码}, 当前其中的 boolean 值是 true 的时候会执行大括号里面的代码, flase 时不执行大括号里面的代码.

5, 位运算符:

l 位运算是直接对二进制进行运算

二进制, 逢 2 进 1 0+1=1 1+1=10 10+1=11 11+1=110

十进制(1,2,3,...9,10, 逢 10 进 1),10 进制的意思就是逢几进 1,10 进制的计算 1+8=9 9+1=10

进制计算机内部表示数的字节单位是定长的, 如 8 位, 16 位, 或 32 位. 所以, 位数不够时, 高位补零. 以 15 为例(负数以 - 15 为例)15 的二进制: 00000000 00000000 00000000 00001111(因为 int 是 32 位数, 所以补上了 0)-15 的二进制: 11111111 11111111 11111111 11110001 计算过程: 补码(负数的二进制)= 反码 + 1 反码: 11111111 11111111 11111111 11110000 补码(即加一):11111111 11111111 11111111 11110001 也就是 - 15 的二进制.(正数二进制 à 反码 à 加 1(补码)à 负数二进制) (负数二进制 à 减 1à 反码 à 原码 à 正数二进制)

有符号的右移>>: 正数左右移补 0, 负数右移前面位是 0 就补是 1 就补 1.(有符号的右移是看右移之后的首位是 0 还是 1, 是 0 前面空位补 0, 是 1 就补 1)

>>>(无符号右移): 正数的>>>与>>是一致的, 负数不一致. 移动之后不管首位是 0 还是 1, 空位都是直接补 0.

&(与)运算: 同位 & 运算的时候, 都是 1 结果为 1, 其他情况都为 0.

|(或)运算: 同位 | 运算时, 都是 0 结果为 0, 其他情况都为 1.

^(异或)运算: 同位 ^ 运算时, 都是 0 或者都是 1 的时候结果是 0, 其他的情况下都是 1(相同值为 0, 其他情况为 1)

~(反码)运算: 就是把二进制的同位反转, 也就是 1 变 0,0 变 1.

位运算符的总结:

来源: http://www.bubuko.com/infodetail-3682120.html