Java基础篇(中)

2019-12-10 16:02:01来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Java基础篇(中)

4Java 关键字

下面列出了 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

 

5Java 变量类型

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

byte

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

最小值是 -128-2^7);

最大值是 1272^7-1);

默认值是 0

byte 类型用在大型数组中节约空间,主要代替整数,因为 byte 变量占用的空间只有 int 类型的四分之一;

例子:byte a = 100byte b = -50

short

short 数据类型是 16 位、有符号的以二进制补码表示的整数

最小值是 -32768-2^15);

最大值是 327672^15 - 1);

Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一;

默认值是 0

例子:short s = 1000short r = -20000

int

int 数据类型是32位、有符号的以二进制补码表示的整数;

最小值是 -2,147,483,648-2^31);

最大值是 2,147,483,6472^31 - 1);

一般地整型变量默认为 int 类型;

默认值是 0

例子:int a = 100000, int b = -200000

long

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

最小值是 -9,223,372,036,854,775,808-2^63);

最大值是 9,223,372,036,854,775,8072^63 -1);

这种类型主要使用在需要比较大整数的系统上;

默认值是 0L

例子: long a = 100000LLong b = -200000L

"L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。

float

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;

float 在储存大型浮点数组的时候可节省内存空间;

默认值是 0.0f

浮点数不能用来表示精确的值,如货币;

例子:float f1 = 234.5f

double

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;

浮点数的默认类型为double类型;

double类型同样不能表示精确的值,如货币;

默认值是 0.0d

例子:double d1 = 123.4

boolean

boolean数据类型表示一位的信息;

只有两个取值:true false

这种类型只作为一种标志来记录 true/false 情况;

默认值是 false

例子:boolean one = true

char

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

最小值是 \u0000(即为0);

最大值是 \uffff(即为65,535);

char 数据类型可以储存任何字符;

例子:char letter = 'A';

自动类型转换

整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。

转换从低级到高级。

 ------------------------------------>  

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

数据类型转换必须满足如下规则:

01.不能对boolean类型进行类型转换。

02. 不能把对象类型转换成不相关类的对象。

03. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

04. 转换过程中可能导致溢出或损失精度,例如:

int i =128;   

byte b = (byte)i;

因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。

05. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:

(int)23.7 == 23;        

(int)-45.89f == -45

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型,例如: short数据类型的位数为16位,就可以自动转换位数为32int类型,同样float数据类型的位数为32,可以自动转换为64位的double类型。

强制类型转换

01.条件是转换的数据类型必须是兼容的。

02.格式:(type)value type是要强制类型转换后的数据类型

隐含强制类型转换

01.整数的默认类型是 int

02.浮点型不存在这种情况,因为在定义 float 类型时必须在数字后面跟上 F 或者 f

Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:

type identifier [ = value][, identifier [= value] ...] ;

格式说明:typeJava数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

以下列出了一些变量的声明实例。注意有些包含了初始化过程。

 1 int a, b, c;         // 声明三个int型整数:a、 b、c
 2 
 3 int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
 4 
 5 byte z = 22;         // 声明并初始化 z
 6 
 7 String s = "runoob";  // 声明并初始化字符串 s
 8 
 9 double pi = 3.14159; // 声明了双精度浮点型变量 pi
10 
11 char x = 'x';        // 声明变量 x 的值是字符 'x'。

 

Java语言支持的变量类型有:

类变量:独立于方法之外的变量,用 static 修饰。

实例变量:独立于方法之外的变量,不过没有 static 修饰。

局部变量:类的方法中的变量。

实例

 1 public class Variable{
 2 
 3     static int allClicks=0;    // 类变量
 4 
 5     String str="hello world";  // 实例变量
 6 
 7     public void method(){
 8 
 9         int i =0;  // 局部变量
10 
11     }
12 
13 }

 

Java 局部变量

局部变量声明在方法、构造方法或者语句块中;

局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;

访问修饰符不能用于局部变量;

局部变量只在声明它的方法、构造方法或者语句块中可见;

局部变量是在栈上分配的。

局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

实例 1

在以下实例中age是一个局部变量。定义在pupAge()方法中,它的作用域就限制在这个方法中。

 1 package com.runoob.test;
 2 
 3 public class Test{
 4 
 5    public void pupAge(){
 6 
 7       int age = 0;
 8 
 9       age = age + 7;
10 
11       System.out.println("小狗的年龄是: " + age);
12 
13    }
14 
15    public static void main(String[] args){
16 
17       Test test = new Test();
18 
19       test.pupAge();
20 
21    }
22 
23 }

以上实例编译运行结果如下:

小狗的年龄是: 7

 

实例 2

在下面的例子中 age 变量没有初始化,所以在编译时会出错:

 1 package com.runoob.test;
 2 
 3 public class Test{
 4 
 5    public void pupAge(){
 6 
 7       int age;
 8 
 9       age = age + 7;
10 
11       System.out.println("小狗的年龄是 : " + age);
12 
13    }
14 
15    public static void main(String[] args){
16 
17       Test test = new Test();
18 
19       test.pupAge();
20 
21    }
22 
23 }

以上实例编译运行结果如下:

Test.java:4:variable number might not have been initialized

age = age + 7;

         ^

 

实例变量

实例变量声明在一个类中,但在方法、构造方法和语句块之外;

当一个对象被实例化之后,每个实例变量的值就跟着确定;

实例变量在对象创建的时候创建,在对象被销毁的时候销毁;

实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;

实例变量可以声明在使用前或者使用后;

访问修饰符可以修饰实例变量;

实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;

实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;

实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName

实例

Employee.java 文件代码:

import java.io.*;

public class Employee{

   // 这个实例变量对子类可见

   public String name;

   // 私有变量,仅在该类可见

   private double salary;

   //在构造器中对name赋值

   public Employee (String empName){

      name = empName;

   }

   //设定salary的值

   public void setSalary(double empSal){

      salary = empSal;

   }  

   // 打印信息

   public void printEmp(){

      System.out.println("名字 : " + name );

      System.out.println("薪水 : " + salary);

   }

   public static void main(String[] args){

      Employee empOne = new Employee("RUNOOB");

      empOne.setSalary(1000);

      empOne.printEmp();

   }

}

以上实例编译运行结果如下:

$ javac Employee.java

$ java Employee

名字 : RUNOOB

薪水 : 1000.0

 

类变量(静态变量)

类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。

无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。

静态变量除了被声明为常量外很少使用。常量是指声明为public/privatefinalstatic类型的变量。常量初始化后不可改变。

静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。

静态变量在第一次被访问时创建,在程序结束时销毁。

与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。

默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。

静态变量可以通过:ClassName.VariableName的方式访问。

类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是publicfinal类型,其命名方式与实例变量以及局部变量的命名方式一致。

实例:

Employee.java 文件代码:

 1 import java.io.*;
 2 
 3 public class Employee {
 4 
 5     //salary是静态的私有变量
 6 
 7     private static double salary;
 8 
 9     // DEPARTMENT是一个常量
10 
11     public static final String DEPARTMENT = "开发人员";
12 
13     public static void main(String[] args){
14 
15     salary = 10000;
16 
17         System.out.println(DEPARTMENT+"平均工资:"+salary);
18 
19     }
20 
21 }

以上实例编译运行结果如下:

开发人员平均工资:10000.0

注意:如果其他类想要访问该变量,可以这样访问:Employee.DEPARTMENT


原文链接:https://www.cnblogs.com/sudoit/p/12016946.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:小白的springboot之路(八)、继承Redis以及@Cacheable注解实现R

下一篇:【原创】002 | 搭上SpringBoot事务源码分析专车