Java03——变量与常量

啊橙
417 阅读12分钟

1、基本数据类型

image.png

Java 的两大数据类型:

  • 内置数据类型：byte、short、int、long、float、double、boolean、char
  • 引用数据类型

1.1 内置数据类型

Java语言提供了八种基本类型。有六种数字类型（四个整数型，两个浮点型），一种字符类型，一种布尔型。

byte：【用于定义整数】

  • 数据类型是8位、有符号的，用于定义整数
  • 最小值是： -128（-2^7）；最大值是： 127（2^7-1）
  • 默认值是： 0
  • 作用：主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一
  • 例子：byte a = 100，byte b = -50

short：【用于定义整数】

  • short 数据类型是 16 位、有符号的，用于定义整数
  • 最小值是： -32768（-2^15）；最大值是： 32767（2^15 - 1）
  • 默认值是 0
  • 作用：节省空间。一个short变量是int型变量所占空间的二分之一
  • 例子：short s = 1000，short r = -20000

int：【用于定义整数】

  • 数据类型是32位、有符号的
  • 最小值是 -2,147,483,648（-2^31）；最大值是 2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为 int 类型
  • 默认值是 0 
  • 例子：int a = 100000, int b = -200000

long：【用于定义整数】

  • 数据类型是 64 位、有符号的
  • 最小值是 -9,223,372,036,854,775,808（-2^63）；
  • 最大值是 9,223,372,036,854,775,807（2^63 -1）；
  • 这种类型主要使用在需要比较大整数的系统上；
  • 默认值是 0L；
  • 例子： long a = 100000L，Long b = -200000L。
    "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：【用于定义浮点数】

  • 数据类型是单精度、32位
  • float 在储存大型浮点数组的时候可节省内存空间
  • 默认值是 0.0
  • 浮点数不能用来表示精确的值，如货币
  • 例子：float f1 = 234.5f

double：【用于定义浮点数】

  • 数据类型是双精度、64 位
  • 浮点数的默认类型为 double 类型
  • double类型同样不能表示精确的值，如货币
  • 默认值是 0.0
  • 例子：
    double   d1  = 7D ;
    double   d2  = 7.; 
    double   d3  =  8.0; 
    double   d4  =  8.D; 
    double   d5  =  12.9867;

7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

boolean：

  • 只有两个取值：true 和 false
  • 默认值是 false
  • 例子：boolean one = true

char：字符

  • 只能使用单引号 ''
  • char 类型是一个单一的 16 位 Unicode 字符
  • 默认值：'u0000'
  • 取值范围：
    • 十进制 0 ~ 65535;
    • Unicode：\u0000 ~ \uffff
  • char 数据类型可以储存任何字符
  • 例子：char letter = 'A';

这应该其他的数据类型 他是一个类

String：字符串

  • String字符串和char字符不同，char使用单引号，只能表示一个字符，
  • String是个类。这个类使用final修饰，所以这个类是不可以继承扩充和修改它的方法的。String类又特别常用，所以在对String对象进行初始化时，它可以不像其它对象一样，必须使用new关键字构造对象。Java提供了一种简化的特殊语法。

使用String对象存储字符串：

String s = "有志者事竟成";
String s1 = "dasdasdasd";
// 当然我们也还是可以像以前使用new关键字的。
String s = new String("有志者事竟成");

1.2 引用数据类型

引用类型的变量非常类似于C的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。

  • 对象、数组都是引用数据类型
  • 所有引用类型的默认值都是：null
  • 一个引用变量可以用来引用任何与之兼容的类型
  • 例子：Site site = new Site("Runoob")

2、常量

常量就是在程序中固定不变的值。一般常量用大写英文表示

在Java中，常量包括整型常量、浮点数常量、布尔常量、字符常量等。

2.1 整型常量

整型常量是整数类型的数据，具体表示形式如下：

二进制：由数字0 和1 组成的数字序列。在JDK7.0中允许使用字面值来表示二进制数，前面要以0b或0B开头，目的是为了和十进制进行区分，如：0b01101100、0B10110101。

八进制：以0开头并且其后由0 ~7范围（包括0和7）内的整数组成的数字序列，如：0342。

十进制：由数字0~9范围（包括0和9）内的整数组成的数字序列。如：198。整数以十进制表示时，第一位不能是0，0本身除外

十六进制：以0x或者0X开头并且其后由09、AF(包括0和9、A和F)组成的数字序列，如0x25AF。

2.2 字符常量

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号（' '）引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。具体示例如下：

'a' , '1' , '&' , '\r' , '\u0000'

上面的示例中，'\u0000'表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示是因为，Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为'\u0000'。

2.3 字符串常量

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号（" "）引起来，具体示例如下："helloworld","lalala"

2.4 布尔常量

布尔常量即布尔型的两个值true和false，该常量用于区分一个事物的真与假。

2.5 null 常量

null常量只有一个值null，表示对象的引用为空

写法：

public class demo1{
  public static void main(String[] args){

    // 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。 
    final float MONTH = 12.56f;
    final double YEAR = 151545.485;
    int num = 100;

    System.out.println(MONTH);  // 12.56
    System.out.println(YEAR);  // 151545.485

  }
}

字面量可以赋给任何内置类型的变量。例如：

byte a = 68;
char a = 'A'

3、变量类型

3.1 在Java语言中，所有的变量在使用前必须声明

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

3.2 Java语言支持的变量类型有：

  • 类变量（静态变量）：独立于方法之外的变量，用 static 修饰
  • 实例变量：独立于方法之外的变量，这些成员变量是对象中的成员。没有 static 修饰
  • 局部变量：类的方法中的变量
public class Variable{
  static int num = 0;  // 静态变量 或 类变量。随着类的加载而存在于方法区中 
  
  String str="hello world"; // 实例变量 或 成员变量，需要new一下。随着对象的创建而存在于堆内存中
  
  public void method(){     // 普通方法 或 实例方法

      int i =0;  // 局部变量
  }
  
  static void method2(){      // 静态方法

  }

}

3.3 Java局部变量

  • 局部变量声明在方法、构造方法或者语句块中；
  • 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
  • 访问修饰符不能用于局部变量；
  • 局部变量只在声明它的方法、构造方法或者语句块中可见；
  • 局部变量是在栈上分配的。
  • 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
public class Exam1 {
  static int allClicks = 1220; // 类变量
  String str = "hello world"; // 实例变量  需要new一下才能被访问
  float cc = 12.56f;
  
  // pupAge函数
  public void pupAge(){
    int age = 0;   // 局部变量
    age = age + 7;
    System.out.println("小狗的年龄是: " + age);
  }

  // 主函数
  public static void main(String[] args) {  
    Exam1 exam1 = new Exam1();   // 实例化对象赋值给exam1 用Exam引用类型来定义
    exam1.pupAge();   // 对象调用成员pupAge方法 打印7
    

    // 只要加了static的，可以不new，直接被类名调用
    System.out.println(Exam1.allClicks);  // 类名调用静态方法，也可对象调用静态方法（不推荐）
    System.out.println(exam1.allClicks);  // 对象调用静态方法（不推荐）
    
    System.out.println(exam1.cc);    // 打印实例变量 12.56
    
    // System.out.println(Exam1.str); // 实例变量无法直接通过类来调用
    System.out.println(exam1.str);   // 必须被实例后才能获取
    
  }
}

3.4 Java实例变量

  • 声明范围：在一个类中，但在方法、构造方法和语句块之外
  • 当一个对象被实例化之后，每个实例变量的值就跟着确定
  • 实例变量在对象创建的时候创建，在对象被销毁的时候销毁
  • 实例变量可以声明在使用前或者使用后；
  • 访问修饰符可以修饰实例变量；
  • 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  • 实例变量的默认值是：0
  • 布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
  • 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
// 实例变量
public class Exam1{
  public String name;   // 这个实例变量对子类可见 
  private double salary;  // 私有变量，仅在该类可见  其他class无法访问
  String nas;   // 默认会被加上public 

  // 构造方法不用写class
  public Exam1 (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){
    Exam1 empOne = new Exam1("啊橙"); // 传参
    empOne.setSalary(1000.0);
    empOne.printEmp();


    System.out.println("名字 : " + empOne.name ); // 获取实例变量必须new
    System.out.println("薪水 : " + empOne.salary);
  }
}

3.5 类变量（也称为静态变量）

  • 在类中以 static 关键字声明，但必须在方法之外
  • 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝
  • 静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变
  • 静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量
  • 静态变量在第一次被访问时创建，在程序结束时销毁
  • 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型
  • 默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化
  • 静态变量可以通过：ClassName.VariableName的方式访问
  • 类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致
public class Employee {
  private static double salary;   // salary是静态的私有变量
  public static final String DEPARTMENT = "开发人员";   // DEPARTMENT是一个常量
  
  public static void main(String[] args){
      salary = 10000;
      System.out.println(DEPARTMENT+"平均工资:"+salary);
  }
}

3.6 变脸的作用域

变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。

image.png

.

4、变量类型的转换

4.1 自动类型转换

转换前的数据类型的位数必须要低于转换后的数据类型的位数。从小转大

三种可以进行自动类型转换的情况，具体如下：

  • 整数类型之间可以实现转换：

    • 如byte类型的数据可以赋值给short、int、long类型的变量
    • short、char类型的数据可以赋值给int、long类型的变量
    • int类型的数据可以赋值给long类型的变量

  • 整数类型转换为float类型：

    • 如byte、char、short、int类型的数据可以赋值给float类型的变量。

  • 其它类型转换为double类型，如byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。

    char c1='a';  //定义一个char类型
    int aa = c1;  //char自动类型转换为int
    System.out.println("char自动类型转换为int后的值等于"+aa);

4.2 强制类型转换

  • 条件是转换的数据类型必须是兼容的
  • 格式：(type)value --> 'type'是要强制类型转换后的数据类型
  • 当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。
public class demo1{ 
    public static void main(String[] args){ 
        int num = 123; 
        byte b = (byte)num;//强制类型转换为byte 
        System.out.println("int强制类型转换为byte后的值等于"+b); 
    } 
}

4.3 隐含强制类型转换

  • 整数的默认类型是 int
  • 小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f
avatar
文章
阅读
粉丝