[笔记]Java-2 Java语言编程基础

最新推荐文章于 2024-10-06 20:16:20 发布

Shiroki 1.0

最新推荐文章于 2024-10-06 20:16:20 发布

阅读量99

点赞数

分类专栏：初号机1.0 文章标签： java

本文链接：https://blog.csdn.net/m0_54255201/article/details/119991803

版权

初号机1.0 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

Java语言编程基础：变量&数据类型

2.1 变量（非常重要）

**变量的概念**：当需要在程序中==记录单个数据内容==时，则`声明一个变量`即可，而声明变量的本质就是`在内存中申请一个存储单元`，由于该存储单元中的数据内容可以发生改变，因此得名为"变量"。由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在 Java语言中使用数据类型加以描述，为了便于下次访问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。

变量的声明方式

数据类型 标识符（变量名） = 初始值;

其中=初始值可以省略，但;不可以省略

变量的注意事项

Java是强类型语言，变量在使用前必须声明来指明其数据类型。
变量在使用之前必须初始化。
变量不能重复声明

备注：
初始化是一个C系编程语言术语，就是把变量赋为默认值，把控件设为默认状态，把没准备的准备好。但是如果是整个系统初始化那就不一样了。在汇编语言中，为变量分配空间时，初始化过的变量的初值位于可执行文件代码段数据后，会占用一定空间，不必要的初始化会造成磁盘空间的浪费。在C语言等高级语言中，为每一个变量赋初值被视为良好的编程习惯，有助于减少出现Bug的可能性。
初始化在计算机编程领域中指为数据对象或变量赋初值的做法，如何初始化则取决于所用的程序语言以及所要初始化的对象的存储类型等属性。用于进行初始化的程序结构则称为初始化器或初始化列表。初始化和变量声明是有明显区别的，而且变量声明也先于初始化进行，但两者在实践中仍常被混淆。

标识符命名法则

由数字、字母、下划线以及$等组成，其中数字不能开头（后面讲到）。
不能使用Java语言的关键字，所谓关键字就是Java语言用于表示特殊含义的单词。
区分大小写，长度没有限制但不宜过长。
尽量做到见名知意，支持中文但不推荐使用。
标识符可以给类/变量/属性/方法/包起名字。

案例1：提示用户从键盘输入自己的姓名和年龄信息并打印出来
步骤：

import java.util.Scanner    //导入java目录中util目录中的Scanner类
public class VarIOTest{

    public static void main(String[] args) {

        //1.声明两个变量，用于记录姓名和年龄
        String name;
        int age;

        //2.提示用户从键盘输入姓名和年龄信息并放入到变量中
        System.out.println("请输入姓名和年龄信息：");
        //创建一个扫描器来扫描键盘输入的内容，system.in代表键盘输入
        Scanner sc = new Scanner(System.in);
        //通过扫描器读取一个字符串数据放入变量name中
        name = sc.next();
        //通过扫描器读取一个整数数据放入变量age中
        age = sc.nextInt();

        //3.打印变量的数值
        System.out.println("name = " + name);
        System.out.println("age = " + age);
    }
}

优化代码

import java.util.Scanner    //导入java目录中util目录中的Scanner类
public class VarIOTest{

    public static void main(String[] args) {

        //1.提示用户从键盘输入姓名和年龄信息并放入到变量中
        System.out.println("请输入姓名和年龄信息：");
        //创建一个扫描器来扫描键盘输入的内容，system.in代表键盘输入
        Scanner sc = new Scanner(System.in);
        //2.通过扫描器读取一个字符串数据放入变量name中，同时声明name
        String name = sc.next();
        //通过扫描器读取一个整数数据放入变量age中，同时声明age
        int age = sc.nextInt(); //随使用随声明，比上面更好

        //3.打印变量的数值
        System.out.println("name = " + name + ", age = " + age);  //避免重复代码
    }
}

官方库的使用

JDK中带有大量的API类, 是有Java系统带来的工具库, 这些工具数以万计，是Java官方程序员的技术积累。
使用这些类可以大大简化编程, 提高开发效率。
具体的API类功能, 可以参阅Java的参考手册。

2.2 数据类型

数据类型的分类

在Java语言中数据类型主要分为两大类：
（1）基本数据类型（记住）
byte、short、int、long、float、double、boolean、char
（2）引用数据类型（了解）
数组、类、接口、枚举、标注

常用进制

在日常生活中采用十进制进行数据的描述，逢十进一，十进制权重是：10^0、101、10^2、…
在计算机的底层采用0和1组成的二进制序列进行数据的描述，逢二进一，二进制的权重是2^0、21、2^2、…
二进制中的最高位（最左边）用于代表符号位，若该位是0则表示非负数，若该位是1则表示负数。
八进制和十六进制其实都是二进制的简写。

进制转换

正十进制转换为二进制的方式
a.除2取余法，使用十进制整数不断地除以2取出余数，直到商为0时将余数逆序排序。

b.拆分法，将十进制整数拆分为若干个二进制权重的和，有该权重下面写1，否则写0。
权重是什么

进制之间的转换

正二进制转换为十进制的方式
a.加权法，使用二进制中的每个数字乘以当前位的权重再累加起来。
负十进制转换为二进制的方式
a.先将十进制的绝对值转换为二进制，然后进行按位取反再加1。
负数的需要补码：按位取反，再加1.

eg：找 -9 的二进制数

1.利用“除2取余法，余数逆序排列”，得到原码。
即将-9的绝对值9除于2，取每次的余数，逆序排列后得到原码为：0000 1001（以8位为例）。
2.将上一步骤得到的原码取反（1取0，0取1），得到反码。对应反码为：11110110。
3.在反码的基础上，加1得到补码。对应的补码为：11110111。

负二进制转换为十进制的方式
a.先减1再按位取反，合并为十进制整数后添加负号。

eg：将11101101转换成十进制

1.将二进制数减1，得到：11101100
2.将减1后的代码取反操作，得到：00010011
3.将取反后的代码换算成十进制，得到19。
注意，在计算结果19的基础上要加上-号，得到-19才是要求的最终结果

单个字节表示的整数范围（重要）

补充：字节，位，字长的相关定义
字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，也表示一些计算机编程语言中的数据类型和语言字符。
字节是二进制数据的单位。一个字节通常8位长。
Byte是从0-255的无符号类型，所以不能表示负数。
1.B与bit：数据存储是以“字节”（Byte）为单位，数据传输大多是以“位”（bit，又名“比特”）为单位，一个位就代表一个0或1（即二进制），每8个位（bit，简写为b）组成一个字节（Byte，简写为B），是最小一级的信息单位。
2.字（Word）：在计算机中，一串数码作为一个整体来处理或运算的，称为一个计算机字，简称字。字通常分为若干个字节（每个字节一般是8位）。在存储器中，通常每个单元存储一个字。因此每个字都是可以寻址的。字的长度用位数来表示。

3.字长：计算机的每个字所包含的位数称为字长，计算的字长是指它一次可处理的二进制数字的数目。一般地，大型计算机的字长为32-64位，小型计算机为12-32位，而微型计算机为4-16位。字长是衡量计算机性能的一个重要因素。

在计算机中单个字节表示八位二进制位，其中最高位(最左边)代表符号位，
使用0代表非负数，使用1代表负数，具体表示的整数范围如下：
非负数表示范围：0000 0000 ~ 0111 1111 => 0 ~ 127 => 0 ~ 2^7-1
负数表示范围：1000 0000 ~ 1111 1111 => -128 ~ -1 => -2^7 ~ -2^0
单个字节表示的整数范围是：-2^7 ~ 2^7-1，也就是-128 ~ 127.

整数类型

Java语言中描述**整数数据**的类型有：byte、short、int、long，荐int类型.
其中byte类型在内存空间中占1个字节，表示范围是：-2^7 ~ 2^7-1.
其中short类型在内存空间中占2个字节，表示范围是：-2^15 ~ 2^15-1.
其中int类型在内存空间中占4个字节，表示范围是：-2^31 ~ 2^31-1.
其中long类型在内存空间中占8个字节，表示范围是：-2^63 ~ 2^63-1.
在Java程序中直接写出的整数数据叫做直接量/字面值/常量，默认为int类型。若希望表达更大的直接量，则在直接量的后面加上l或者L，推荐L。

浮点类型

Java语言中用于描述小数数据的类型：float 和 double，推荐double类型
其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位
有效数字，范围：-3.403E38~3.403E38。
其中double类型在内存空间占8个字节，叫做双精度浮点数，可以表示15
位有效数字，范围：-1.798E308~1.798E308。
Java程序中直接写出的小数数据叫做直接量，默认为double类型，若希望
表达float类型的直接量，则需要在直接量的后面加上f或者F.

布尔类型

Java语言中用于描述真假信息类型有：boolean，数值只有：true 和 false。
布尔类型在内存空间中所占大小没有明确的规定，可以认为是1个字节。

字符类型

Java语言中用于描述单个字符的数据类型：char类型。如：‘a’、'中’等。
其中char类型在内存空间中占2个字节并且没有符号位，表示的范围是：0 ~ 65535，由于现实生活中很少有数据能够被单个字符描述，因此以后的开发中更多的使用由多个字符串起来组成的字符串，使用String类型加以描述，如：“hello”、“奇点”等。
计算机的底层只识别0和1组成的二进制序列，对于字符’a’这样的图案来说不满足该规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就可以给该数据指定一个编号，然后将编号存储起来即可，该编号就叫做ASCII。
要求掌握的ASCII有：‘0’ - 48 ‘A’ - 65 ‘a’ - 97 空格 - 32 换行符 - 10
Java字符类型采用Unicode字符集编码。Unicode是世界通用的定长字符集，所有的字符都是16位。
要求掌握的转义字符有：" - " ’ - ’ \ - \ \t - 制表符 \n - 换行符

基本数据类型之间的转换
自动类型转换和强制类型转换

1.自动类型转换：小类型 → 大类型

2.强制类型转换：大类型 → 小类型
语法格式：

目标类型 变量名 = (目标类型)源类型变量名;

比如：

double a = 2.556;
int temp = (int)a;   //强制类型转换，将双精度浮点数转化为int整数
System.out.println("temp=" + temp);

强制转换是有风险的。

本节知识点

代码部分

/*
    编程实现布尔类型的使用
 */
public class BooleanTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个boolean类型的变量并初始化
		boolean b1 = true;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = true
		
		System.out.println("-------------------------------------------");
		// 3.修改变量b1的数值   = 赋值运算符，用于将=右边的数据赋值给=左边的变量，覆盖变量中原来的数值
		b1 = false;
		System.out.println("b1 = " + b1); // b1 = false
		
		System.out.println("-------------------------------------------");
		//b1 = 1; // 错误: 不兼容的类型: int无法转换为boolean
	}
}

/*
   编程实现字符类型的使用         
 */
public class CharTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个char类型的变量并初始化
		char c1 = 'a';
		// 2.打印变量的数值
		System.out.println("c1 = " + c1); // c1 = a   
		System.out.println("对应的编号是：" + (int)c1); // 表示将char类型的c1强制转换为int类型并打印   97 
		
		System.out.println("-------------------------------------------------------------------------");
		// 2.声明一个char类型的变量并初始化
		char c2 = 98;
		System.out.println("c2 = " + c2); // c2 = b   
		System.out.println("对应的编号是：" + (int)c2); // 98
		
		System.out.println("-------------------------------------------------------------------------");
		// 3.使用Unicode字符集来表示一下我的名字   奇点  对应的编号是： \u5947\u70b9
		char c3 = '\u5947';
		char c4 = '\u70b9';
		System.out.println("最终的结果是：" + c3 + c4); // 奇点
		
		System.out.println("-------------------------------------------------------------------------");
		// 4.特殊字符的使用   双引号本身有2个含义：a.字符串的开头和结尾标志    b.双引号自身    \ 转义就是转换原有的含义
		System.out.println("我想过过\"过过过过的生活！");   //  \"  - "
		System.out.println("我想过过\'过过过过的生活！");
		System.out.println("我想过过\\过过过过的生活！");
		System.out.println("我想过过\t过过过过的生活！");
		System.out.println("我想过过\n过过过过的生活！");
	}
}

/*
    编程实现浮点类型的使用
 */
public class DoubleTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个float类型的变量并初始化
		//float f1 = 3.1415926;   // 错误: 不兼容的类型: 从double转换到float可能会有损失   小数数据叫做直接量，默认为double类型
		float f1 = 3.1415926f;
		// 2.打印变量的数值
		System.out.println("f1 = " + f1); // f1 = 3.1415925     一般是7位有效数字
		
		System.out.println("---------------------------------------------------------");
		// 3.声明一个double类型的变量并初始化
		double d1 = 3.1415926;
		System.out.println("d1 = " + d1); // d1 = 3.1415926     一般是15位有效数字
		
		System.out.println("---------------------------------------------------------");
		// 4.笔试考点
		System.out.println(0.1 + 0.2);  // 0.30000000000000004  运算时可能会有误差，若希望实现精确运算则借助java.math.BigDecimal类型 
	}
}

/*
    编程实现整数类型的使用
 */
public class IntTest {
	
	public static void main(String[] args) {
		
		// 1.声明一个byte类型的变量并初始化
		byte b1 = 25;
		//byte b1 = 250;     // 错误: 不兼容的类型: 从int转换到byte可能会有损失  250这样直接写出的整数数据叫做直接量/常量/字面值 默认为int类型 
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 25
		
		System.out.println("---------------------------------------------");
		// 3.声明一个short类型的变量并初始化
		short s1 = 250;
		//short s1 = 250250;  // 错误：不兼容的类型：从int转换到short可能会有损失
		System.out.println("s1 = " + s1); // s1 = 250
		
		System.out.println("---------------------------------------------");
		// 4.声明一个int类型的变量并初始化
		int i1 = 250250;
		//int i1 = 2502505006; // 错误: 整数太大   默认为int类型，这个数据自身已经出错，无法表示
		//int i1 = 2502505006L;  // 错误：不兼容的类型：从long转换到int可能会有损失
		System.out.println("i1 = " + i1); // i1 = 250250
		
		System.out.println("---------------------------------------------");
		// 5.声明一个long类型的变量并初始化，若描述比long类型还大的数据则使用java.math.BigInteger类型
		long g1 = 2502505006L;
		System.out.println("g1 = " + g1); // g1 = 2502505006
		
		System.out.println("---------------------------------------------");
		// 6.请问下面的代码是否有错误？若有请指出并说明原因
		//int i2 = 25;
		//byte b2 = i2;  // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//System.out.println("b2 = " + b2);
		
	}
}

/*
    编程实现基本数据类型之间转换的使用
 */
public class TransformTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个变量并初始化
		byte b1 = 10;
		short s1 = 20;
		// 2.打印变量的数值
		System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 20
		
		System.out.println("----------------------------------------------");
		// 3.实现自动类型转换的使用
		// 表示将变量b1的数值赋值给变量s1，并覆盖变量s1中原来的数值，相当于从byte类型到short类型的转换，小到大  自动转换
		s1 = b1;
		System.out.println("b1 = " + b1); // b1 = 10
		System.out.println("s1 = " + s1); // s1 = 10
		
		System.out.println("----------------------------------------------");
		// 4.实现强制类型转换的使用
		// 表示将变量s1的数值赋值给变量b1，并覆盖变量b1中原来的数值，相当于从short类型到byte类型的转换，大到小  强制转换
		//b1 = s1;   // 错误: 不兼容的类型: 从short转换到byte可能会有损失
		s1 = 128;    // 故意加该行代码      128:0000 0000 1000 0000  => 1000 0000 => 0111 1111 => 1000 0000 => 128 => -128
		b1 = (byte)s1;
		System.out.println("b1 = " + b1); // b1 = 10   -128 
		System.out.println("s1 = " + s1); // s1 = 10   128
	}
}

/*
   编程实现变量的输入输出
 */

// 导入java目录中util目录的Scanner类
import java.util.Scanner; 
 
public class VarIOTest {
	
	public static void main(String[] args) {
		
		// 1.声明两个变量用于记录姓名和年龄信息
		//String name;
		//int age;
		
		// 2.提示用户从键盘输入姓名和年龄信息并放入到变量中   变量随使用随声明
		System.out.println("请输入您的姓名和年龄信息：");
		// 创建一个扫描器来扫描键盘输入的内容  System.in代表键盘输入
		Scanner sc = new Scanner(System.in);
		// 通过扫描器读取一个字符串数据放入变量name中
		String name = sc.next();
		// 通过扫描器读取一个整数数据放入变量age中
		int age = sc.nextInt();
		
		// 3.打印变量的数值     尽可能减少重复的代码
		//System.out.println("name = " + name);
		//System.out.println("age = " + age);
		System.out.println("name = " + name + ", age = " + age);
	}
}

/*
    编程实现变量的声明和使用
 */
public class VarTest {
	
	public static void main(String[] args) {
	
		// 1.声明一个变量并初始化   数据类型 变量名 = 初始值;
        int age = 18;
		// 2.打印变量的数值   + 字符串连接符  用于将两边的内容拼接/连接起来结果还是字符串
		System.out.println("age = " + age); // age = 18
		
		System.out.println("-----------------------------------------------------");
		// 3.使用变量的注意事项
		// 3.1 使用变量之前需要声明
		// System.out.println("name = " + name); // 错误: 找不到符号 
		// 3.2 使用变量之前需要初始化
		//String name;
		//System.out.println("name = " + name); // 错误: 可能尚未初始化变量name
		String name = "奇点";
		System.out.println("name = " + name); // name = 奇点
		// 3.3 变量不能重复声明
		//int age = 17; // 错误: 已在方法 main(String[])中定义/声明了变量 age
		int aGe = 17;
		int fjakjf3fjdlakjfa7987jfkdajlkf2427897fdjafjalkl89809fdjafjlj = 10;
		int 年龄 = 16;
	}
}