关于java:Java-从入坑到放弃No-3-变量与数据类型

前情回顾

1. No 1. 搭建 Java 开发环境
2. No 2. 玩转 IDEA

在之前的文章中，咱们曾经介绍了如何搭建 Java 开发环境以及如何应用 IDEA，当初就开始正式学习 Java 语言的相干语法吧！😎

本文内容预报如下：

1. 变量
2. 数据类型
3. 变量作用域
4. 常量

变量

什么是变量？

所谓变量，就是用来命名一个数据的标识符，在 Java 中，变量又能够分为两种：

• 根本类型的变量
• 援用类型的变量

// 根本类型的变量
int id = 1;
// 援用类型的变量
String name = "村雨遥";

其中 int 是根本数据类型，示意这是一个整型数；而 String 则是援用类型，示意这是一个援用类型；

id 和 name 则是标识符，也就是咱们所说的 变量；

= 则是赋值操作符，而 1 则是根本类型的值，村雨遥 则是援用类型的值；

变量的特点

变量的最重要的一个特点就是能够从新赋值；

public class Main {public static void main(String[] args) {
        // 定义 int 类型变量 id，并赋予初始值 1
        int id = 1; 
        // 打印该变量的值，察看是否为 1
        System.out.println(id); 
         // 从新赋值为 2
        id = 2; 
        // 打印该变量的值，察看是否为 2
        System.out.println(id); 
    }
}

变量命名规定

变量命名也是一门学识，并不是咱们想怎么命名就怎么命名，日常开发中最常见的变量命名规定次要有如下几条：

1. 强制 ：变量命名只能应用 字母（大小写均可）、数字、$、_；
2. 强制：变量名不能应用关键字（就是 Java 中内置的一些关键字，如 int、for、long…）；
3. 强制：变量第一个字符不能应用数字，只能用字母、$、_；
4. 更多命名规定举荐参考阿里巴巴推出的《Java 开发手册》，下载链接：https://github.com/cunyu1943/…

常见关键字

这是一种当时定义好的，有特定意义的标识符，也叫做保留字。对于 Java 编译器有着非凡意义，用来示意一种数据类型，或者示意程序的构造等。此外，关键字不能用作变量名、办法名、类名、包名和参数名。常见的关键字能够分为如下几类，具体的关键字如下图所示：

• 访问控制类
• 类、办法及变量修饰符类
• 程序控制类
• 错误处理
• 包相干
• 根本类型
• 变量援用
• 保留字

数据类型

根本数据类型

Java 中，共有 8 中根本数据类型，由 Java 语言预约好的，每个数据类型都属于关键字，而且每种根本变量都有其对应的封装类，这 8 中根本数据类型别离是：

• 整型（4 种）
• 浮点型（2 种）
• 字符型（1 种）
• 布尔型（1 种）

留神：

1. boolean 个别用 1 bit 来存储，然而具体大小并未规定，JVM 在编译期将 boolean 类型转换为 int，此时 1 代表 true，0 代表 false。此外，JVM 还指出 boolean 数组，但底层是通过 byte 数组来实现;
2. 应用 long 类型时，须要在后边加上 L，否则将其作为整型解析，可能会导致越界；
3. 浮点数如果没有明确指定 float 还是 double，对立按 double 解决；
4. char 是用 单引号 '' 将内容括起来，只能寄存一个字符 ，相当于一个整型值（ASCII 值），可能加入表达式运算；而 String 是用 双引号 "" 将内容括起来，代表的是一个地址值；
5. Java 在内存中是采纳 Unicode 示意，所以无论是一个中文字符还是英文字符，都能用 char 来示意；

那么如何个一个根本类型变量赋值呢？

在 Java 中，根本数据类型属于 Java 的一种内置的非凡数据类型，不属于任何类，所以能够间接对其进行赋值；给根本类型的变量赋值的形式就叫做 字面值；

float score = 89.0f;
int age = 26;

援用数据类型

常见援用数据类型

而对于援用数据类型，咱们常常是须要 new 关键字来进行赋值，然而援用类型中的 接口是不能被实例化的，咱们须要对其进行实现；

// 初始化一个对象
Pet dog = new Pet();
// 初始化一个数组
int[] arr = new int[10];

String

对于援用数据类型中的 String，咱们须要特地关注。

String 不同于 char，它属于援用类型，而 char 属于根本数据类型。用双引号 "" 括起来示意字符串，一个字符串可能保留 0 个到任意个字符，它一旦创立就不能被扭转。

而针对字符串，如果咱们要打印一些非凡的字符，比方字符串原本就蕴含 "，那么这个时候就须要借助于转义字符 \，最常见的转义字符次要有：

那多个字符串之间或者字符串和其余类型数据之间，该如何进行连贯呢？

Java 编译器中，对于字符串和其余数据类型之间，能够应用 + 进行连贯，编译器会主动将其余数据类型主动转换为字符串，而后再进行连贯；

String 既然是不可变，那有什么长处呢？

1. 用于缓存 hash 值

因为 String 的 hash 值被频繁应用，它的不可变性使得 hash 值也不可变，此时只须要进行一次计算；

1. 字符串常量池（String Pool）的须要

如果一个 String 对象曾经被创立过，那么就会优先从字符串常量池中获取其援用，其不可变性确保了不同援用指向同一 String 对象；

1. 安全性

咱们常常用 String 作为咱们办法的参数，其不变性可能保障参数不可变；

1. 线程平安

String 的不可变性让它天生 具备线程平安，可能在多个线程中方便使用而不必思考线程平安问题。

String、StringBuilder、StringBuffer 比照，该如何抉择？

通过 new String(“xxx”) 创立字符串的两种状况？

应用 new 的形式创立字符串对象，会有两种不同的状况：

1. String Pool 中不存在“xxx”

此时会创立两个字符串对象，“xxx”属于字符串字面量，因而在编译期会在 String Pool 中创立一个字符串对象，用于指向该字符串的字面量“xxx”；而后 new 会在堆中创立一个字符串对象；

1. String Pool 中存在“xxx”

此时只须要创立一个字符串对象，因为 String Pool 中曾经存在指向“xxx”的对象，所以间接在堆中创立一个字符串对象；

数据类型转换

对于根本数据类型，不同类型之间是能够互相转换的，然而须要满足肯定的条件；

从小到大主动转，从大到小强制转。

即就是，对于低精度的数据类型，如果要转换为高精度的数据类型，间接将低精度的值赋给高精度的值即可；

但对于高精度的数据类型，如果想要转换为低精度的数据类型，则须要采纳 强制转换 的伎俩，但此时须要承当精度失落的危险，就像从一个大杯子往一个小杯子里倒水，你要做好小杯子可能装不下溢出的状况；

int a = 110;
long b = 113;
// 低精度转高精度，因为 long 的范畴比 int 大，所以能够主动转
b = a;
// 高精度住哪低精度，因为 long 的范畴比 int 大，所以须要强制转
a = (int)b;

隐式转换（主动类型转换）

当满足如下条件时，如果将一种类型的数据赋值给另一种数据类型变量时，将执行主动类型转换：

1. 两种数据类型彼此兼容；
2. 指标数据类型的取值范畴大于源数据类型；

一般而言，隐式转换的规定是从低级类型数据转换为高级类型数据，对应规定如下：

• 数值类型：byte -> short -> int -> long -> float -> double
• 字符类型转整型：char -> int

显式转换（强制类型转换）

那既然满足上述两个条件时会产生隐式转换，那不满足同时咱们又想进行数据类型转换时，咱们该怎么办呢？

这个时候就须要咱们的 显式转换 退场了，其语法格局如下：

(type) variableName;

咱们举个 🌰 来说下：

int num = 3;
double ans = 5.0;
// 要将 double 类型的值赋值给 int，则须要强制转换
num = (int)ans;

留神：强制转换可能会导致精度失落，所以个别状况下尽量能不必就不必。

常见数据类型转换方法

1. 字符串与其余类型之间的转换

• 其余类型 -> 字符串

1. 调用类的串转换方法：X.toString()；
2. 主动转换："" + X；
3. 利用 String 的办法：String.valueOf(X)；

// 办法 1
String str1 = Integer.toString(int num);
String str2 = Long.toString(long num);
String str3 = Float.toString(flaot num);
String str4 = Double.toString(double num);
// 办法 2
String str = "" + num ; // num 是 int、long、float、double 类型

// 办法 3
String str1 = String.valueOf(int num);
String str2 = String.valueOf(long num);
String str3 = String.valueOf(float num);
String str4 = String.valueOf(double num);

• 字符串 – > 其余类型

1. 调用 parseXXX 办法，比方 parseLong、parseFloat、parseDouble...；
2. 先调用 valueOf()，办法，而后再调用 xxxValue() 办法；

// 办法 1
int num1 = Integer.parseInt(String str);
Long num2 = Long.parseLong(String str);
Float num3 = Float.parseFloat(String str);
Double num4 = Double.parseDouble(String str);

// 办法 2
int num1 = Integer.valueOf(String str).intValue();
Long num2 = Long.valueOf(String str).longValue();
Float num1 = Float.valueOf(String str).floatValue();
Double num1 = Double.valueOf(String str).doubleValue();

1. int、float、double 之间的转换

• float -> double

float num = 1.0f;
Float num1 = new Float(num);
double num2 = num1.doubleValue();

• double -> float

double num = 100.0;
float num1 = (float)num;

• double -> int

double num = 100.0;
Double num1 = new Double(num);
int num2 = num1.intValue();

• int -> double

int num = 200;
double num1 = num;

变量作用域

咱们曾经学会了如何定义变量，也晓得了应用各种数据类型来定义变量。然而还有一点不晓得大家有没有留神到，如果咱们的定义变量在不同的地位，其作用是不是雷同的呢？

这就波及到变量的作用域，个别依据其作用域的不同，能够分为：

• 成员变量：定义在办法体和语句块外，不属于任何一个办法，能在整个类中起作用；
• 局部变量：定义在办法或办法体中的变量，作用域是其所在的代码块；

成员变量

成员变量又能够分为 全局变量（又叫实例变量） 和 动态变量（也叫类变量），两者的区别如下：

public class Person {
    // 成员变量，全局变量
    String name; 
    // 成员变量，全局变量
    int age; 

    // 成员变量，动态变量
    public static final String wechatPublic = "公众号：村雨遥"; 
    // 成员变量，动态变量
    public static final String website = "http://cunyu1943.site"; 
}

局部变量

成员变量指定义在办法或办法体中的变量，作用域是其所在的代码块，能够分为如下三种：

• 形参

public class Main {
    // 办法中的参数
    public static void func(int num) {System.out.println("num =" + num);
    }

    public static void main(String[] args) {func(3);
    }
}

• 办法内定义

public class Main {public static void main(String[] args) {
        int num = 10;
        if (num > 5) {
            // 申明一个 int 类型的局部变量
            int tmp = 5; 
            System.out.println("tmp =" + tmp);
            System.out.println("num =" + num);
        }
        System.out.println("num =" + num);
    }
}

• 代码块定义

public class Main {public static void func() {
        try {System.out.println("Hello!Exception!");
        } catch (Exception e) { // 异样解决块，参数为 Exception 类型
            e.printStackTrace();}
    }

    public static void main(String[] args) {func();
    }
}

常量

简介

既然有变量，那就有与之绝对的常量（也就是值是固定的，不能再变）。

常量又叫做字面常量，是通过数据间接来示意的，在程序运行过程中不能产生扭转。通常咱们把 Java 中用 final 关键字所润饰的成员变量叫做常量，它的值一旦给定就无奈再进行扭转！

分类

Java 中应用 final 关键字来申明常量，其语法格局如下：

final 数据类型 常量名 = 常量初始值;

public class Main{public static void main(String[] args){
        // 申明一个常量并赋值
        final int num = 1024;
        
        // 再次赋值，将导致编译谬误
        num = 1943;
        
        // 申明一个常量但不赋值
        final int id;
        // 因为申明时未赋值，所以能够过程首次赋值
        id = 1;
        // 常量曾经赋值过了，再次赋值将导致编译谬误
        id = 2;
    }
}

常量能够分为如下 3 种类型：

• 动态常量：final 之前用 public staic 润饰，示意该常量的作用域是全局的，咱们不必创建对象就可能拜访它。
• 成员常量：相似于成员变量，然而最大的不同在于它不能被批改。
• 部分常量：作用相似于局部变量，不同之处也在于不能批改。

public class Main{
    // 动态变量
    public static final dobule PI = 3.14;
    
    // 成员常量
    final int num = 1024;
    
    public static void main(String[] args){
        // 局部变量
        final long count = 1000;
    }
}

PS：final 润饰变量后，该变量则变为常量。而 final 也还能够用来润饰类和办法，润饰办法时，示意这个办法不能被重写（但能够重载）；润饰类时，则表明该类无奈被继承。这些货色这时候你可能会感觉很生疏，不过等咱们后续学习了面向对象之后，你就会发现其实很简略。

总结

码字不易，如果感觉对您有所帮忙，能够点赞关注一波哦！🙏

博主程度无限，对于文中可能呈现的谬误，还请各位批评指正，来评论区一起聊天吧！