Java 从入门到进阶之路(二)

  • 时间:
  • 浏览:1
  • 来源:极速快3_快3走势_极速快3走势

但是的文章让当让我们 介绍了一下用 IDEA 编辑器创建另另十个 Java 项目并输出 HelloWorld,本章让当让我们 来看一下 Java 中的变量和基本数据类型。

在这但是让当让我们 先来看一下 Java 中的关键字,哪些关键字不要能被用作变量名称。

类别关键字说明
访问控制 private 私有的
protected 受保护的
public 公共的
类、妙招和变量修饰符 abstract 声明抽象
class
extends 扩充,继承
final 最终值,不可改变的
implements 实现(接口)
interface 接口
native 本地,原生妙招(非 Java 实现)
new 新,创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失
线程控制一段话 break 跳出循环
case 定义另另十个 值以供 switch 选泽
continue 继续
default 默认
do 运行
else 但会
for 循环
if 不可能
instanceof 实例
return 返回
switch 根据值选泽执行
while 循环
错误出理 assert 断言表达式是是否是为真
catch 捕捉异常
finally 有如此异常都执行
throw 抛出另另十个 异常对象
throws 声明另另十个 异常不可能 被抛出
try 捕获异常
包相关 import 引入
package
基本类型 boolean 布尔型
byte 字节型
char 字符型
double 双精度浮点
float 单精度浮点
int 整型
long 长整型
short 短整型
变量引用 super 父类,超类
this 本类
void 无返回值
保留关键字 goto 是关键字,但不要能使用
const 是关键字,但不要能使用
null

Java注释

例如于 C/C++、Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略。

 1 package com.demo;
 2 /** 这是第另另十个



Java线程
 3  * 这是另另另十个



行注释的示例
 4  */
 5 public class HelloWorld {
 6     public static void main(String[] args) {
 7         // 这是单行注释的示例
 8         /* 例如也是单行注释的示例 */
 9         System.out.println("Hello World");
10     }
11 }

Java语言提供了八种基本类型。六种数字类型(十个 整数型,另另十个 浮点型),例如字符类型,还有例如布尔型。

int 

int 数据类型是32位、有符号的以二进制补码表示的整数,占另另十个 字节;

  • 最小值 -2,147,483,648(-2^31),
  • 最大值 2,147,483,647(2^31 - 1),
  • 整数直接量默认为 int 型,不要能超范围,但会 会编译错误,
  • 另另十个 整数相除,结果还是整数,小数位无条件舍弃,
  • 运算时超出范围会趋于稳定溢出
 1 package com.demo;
 2 
 3 public class HelloWorld {
 4     public static void main(String[] args) {
 5         // int a = "123"; 编译错误
 6         // int a = 123.123; 编译错误
 7         // int a = 2147483648; 编译错误,超出最大值 2147483647
 8         // int a = -2147483649; //编译错误,超出最大值 -2147483648
 9         int a = 1;  // 声明变量 a 为整数 1
10         int b = 2147483647;
11         int c;
12         c = 1 + b;
13         System.out.println(c); // -2147483648,运算超出范围趋于稳定溢出
14         c = 2 + b;
15         System.out.println(c); // -2147483647,运算超出范围趋于稳定溢出
16     }
17 }

long 

long 数据类型是 64 位、有符号的以二进制补码表示的整数,8个字节;

  • 最小值是 -9,223,372,036,854,775,1508(-2^63)
  • 最大值是 9,223,372,036,854,775,1507(2^63 -1)
  • 长整型直接biang为在数字后面 加 l 或 L
  • 算数运算时有不可能 超范围,建议在第另另十个 数字后加 l 或 L
  • System.currentTimeMillis( ) 用于获取自 1970.1.1 零时至此时此刻所经历的毫秒数,用 long 存储。
 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // long a = "123"; 编译错误
 4         // long a = 123.123; 编译错误
 5         // long a = 92233720368547751508L; //编译错误,超出最大值 92233720368547751507
 6         // long a = -92233720368547751509L; //编译错误,超出最大值 -92233720368547751508
 7         long a = 1150L;  // 声明变量 a 为长整数 1150
 8         long b = 92233720368547751507L;
 9         long c;
10         c = 1 + b;
11         System.out.println(c); // -92233720368547751508,运算超出范围趋于稳定溢出
12         c = 2 + b;
13         System.out.println(c); // -92233720368547751507,运算超出范围趋于稳定溢出
14         long d = System.currentTimeMillis();
15         System.out.println(d); // 当前时间毫秒数 1558516383355
16     }
17 }

byte

byte 数据类型是8位、有符号的,以二进制补码表示的整数;占另另十个 字节

  • 最小值是 -128(-2^7);
  • 最大值是 127(2^7-1);
  • 默认值是 0;
  • byte 类型用在大型数组中节约空间,主要代替整数,不可能 byte 变量占用的空间不要能 int 类型的四分之一;
  • byte类型运算的但是自动转换为int类型
 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // byte a = "123"; 编译错误
 4         // byte a = 123.123; 编译错误
 5         // byte a = 128; 编译错误,超出最大值 127
 6         // byte a = -129; //编译错误,超出最大值 -128
 7         byte a = 1;  // 声明变量 a 为byte 1
 8         byte b = 127;
 9         // b = 1 + b;
10         // System.out.println(b); // 编译错误,byte 参与运算自动转为 int
11 
12         // 要能转换为 byte 型数据
13         b = (byte) (1 + b);
14         System.out.println(b); // -128,超出运算范围趋于稳定溢出
15     }
16 }

short

short 数据类型是 16 位、有符号的以二进制补码表示的整数,占另另十个 字节

  • 最小值是 -32768(-2^15);
  • 最大值是 32767(2^15 - 1);
  • 默认值是 0
  • short 数据类型要要能像 byte 那样节省空间。另另十个 short 变量是int型变量所占空间的二分之一;
  • short 类型运算的但是自动转换为int类型
 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // short a = "123"; 编译错误
 4         // short a = 123.123; 编译错误
 5         // short a = 32768; 编译错误,超出最大值 32767
 6         // short a = -32769; //编译错误,超出最大值 -32768
 7         short a = 1;  // 声明变量 a 为short 1
 8         short b = 32767;
 9         // b = 1 + b;
10         // System.out.println(b); // 编译错误,short 参与运算自动转为 int
11 
12         // 要能转换为 short 型数据
13         b = (short) (1 + b);
14         System.out.println(b); // -32768,超出运算范围趋于稳定溢出
15     }
16 }

double,float

double 浮点型数据,数据类型是双精度、64 位

float 浮点型数据,数据类型是单精度、32位

  • 浮点数的默认类型为 double 类型;
  • 表示 float 型数据的直接量时需加 f 或 F 后缀。
  • double 类型的精度值是 float 类型的两倍
  • 大多数场合使用 double 表示浮点型
  • float 在储存大型浮点数组的但是可节省内存空间
  • 浮点数运算时,不可能 会趋于稳定摄入误差
  • 浮点数不要能用来表示精确的值,如货币
 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // float a = "123"; 编译错误
 4         // double a = "123"; 编译错误
 5         float a = 5.0F;
 6         a = a - 4.3F;
 7         System.out.println(a); // 0.6999998
 8 
 9         double b = 5.0;
10         b = b - 4.3;
11         System.out.println(b); // 0.7000000000000002
12     }

boolean 

布尔型,不要能取值为 true 或 false,占另另十个 字节,默认为 false

1 public class HelloWorld {
2     public static void main(String[] args) {
3         // boolean a = "111"; // 编译错误
4         boolean a = true;
5         System.out.println(a); // true
6         boolean b = false;
7         System.out.println(b); // false
8     }
9 }

char

char类型是另另十个 单一的 16 位 Unicode 字符;

  • 最小值是 \u0000(即为0);
  • 最大值是 \uffff(即为65,535);
  • char 数据类型要能储存任何字符;
  • 任意单字符需加单引号 ' ' 
 1 public class HelloWorld {
 2     public static void main(String[] args) {
 3         // char a = "123"; 编译错误
 4         // char a = 123.123; 编译错误
 5         // char a = 65536; 编译错误,超出最大值 65535
 6         // char a = -1; //编译错误,超出最小值 0
 7         // char a = '197'; //编译错误 不可能

有单引号,表示是字符,只允许放单个字符。
 8         // char a = 'a' + b; //编译错误 不可能

b是另另十个



赋值的变量。
 9         // char a = '中' + '国' + '国' + '国'; //报错 int转char有损失。不可能

结果不可能

超出char类型的范围。
10         // char a = '中' + "国"; //报编译错误 String无法转换为char。
11         char a='1';  //任意单个字符,加单引号。
12         char a='中'; //任意单个中文字,加单引号。
13         char a = 'a' + 'b'; //Ã  char类型相加,提升为int类型,输出对应的字符。
14         int a = 'a' + 'b'; //195 195如此超出int范围,直接输出195。
15         char a = 197; //Ã 输出字符编码表中对应的字符。
16         char a = 'a' + 1; //b 提升为int,计算结果98对应的字符是b。
17         char a = '中' + '国';//42282。
18         int a = '中' + '国' + '国' + '国'; //86820
19         char a = '中' + 1; ////1是int,结果提升为int,输出对应的字符。
20 
21         System.out.println('中' + "国"); //中国 如此变量附值的过程。String与任何字符用“+”相连,转换为String。
22     }
23 }

不同的基本类型要能直接相互转换

  • 自动转换(隐式转换):从小类型到到类型要能自动完成,类型的大小关系:byte -> short -> int -> long -> float -> double,其中 char -> int 单独。

  • 强行转换:从大类型到小类型时需强制转换符:(时需转换的类型)变量。但可是转换不可能 会造成精度损失不可能 溢出。

在后面 的示例代码中不可能 演示过强转了,这里就找不到举例了。

隐含强制类型转换

  • 1. 整数的默认类型是 int。

  • 2. 浮点型不趋于稳定例如清况 ,不可能 在定义 float 类型时时需在数字后面 跟上 F 不可能 f。