Java 语言编程基础

最新推荐文章于 2024-10-23 09:16:57 发布

weixin_46554863

最新推荐文章于 2024-10-23 09:16:57 发布

阅读量680

点赞数

分类专栏： java学习笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_46554863/article/details/106818435

版权

java学习笔记专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了Java编程的基础知识，包括标识符的命名规则、关键字和保留字的区分，数据类型的概述、分类及转换，以及运算符和表达式的使用，包括算术、关系、赋值和逻辑运算符。此外，还讲解了变量和常量的定义与分类，以及循环语句的基本结构和控制跳转语句的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

标识符与关键字

标识符命名规则

标识符：程序员在写代码的过程中自定义的一些名称即为标识符，如变量名，类名，函数名，接口名…
（就是标识万事万物的符号）
由标识符的组成：26个英文字母（大、小写），数字，下划线，美元符号$
Java标识符严格区分大小写，长度无限制
标识符不能用数字开头
为了提高标识符的可读性，尽量起有意义的名字，一般都是用英文单词表示
不要使用关键字和Java中的自带类名称做标识符

命名方式

大驼峰命名法：如果一个标识符是由多个单词组成的，那么所有单词的首字母大写
举例：TaoBao TianMao
应用：变量名、函数名等
小驼峰命名法：如果一个标识符是由多个单词组成的，那么除了第一个单词首字母小写外，其他单词首字母大写
举例：taoBao tianMao
应用：类、接口等
全大写命名法：如果一个标识符是由多个单词组成的，那么每一个单词都要大写，单词与单词之间用_连接
举例：MAX_VALUE DEFAULT_SIZE
应用：定义常量等

关键字和保留字

JAVA关键字

JAVA编程语言中，事先定义的，有特殊含义和用途的单词。
如：目前接触到的public、static、void等。

JAVA保留字

JAVA编程语言中，暂时还没有被定义的，但以后有可能会用到的单词，目前JAVA的保留字有goto和const。

注意

JAVA中没有sizeof、goto、const，且sizeof既不是关键字也不是保留字。

数据类型

概述

在这里插入图片描述

八大基本数据类型

类型名称	类型定义	取值范围
boolean	布尔值，作二元判断	true, false
byte	8位有符号整数	-128 ~ 127
short	16位有符号整数	-32768 ~ 32767
int	32位有符号整数	-2147483648（-231）~ 2147483647（231-1）
long	64位有符号整数	-263~ (263-1)
float	32位浮点数	1.4E-45 ~ 3.4028235E38
double	64位浮点数	4.9E-324 ~ 1.7976931348623157E308
char	16位Unicode字符	0 ~ 65535

注意：

(1)Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的“E+数字”表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。
(2)Java语言中，默认的整数类型是int类型，声明long类型的时候，后面必须要加个l(字母L的小写)或者L，建议使用大写L，防止和数字1混淆，如：30L；
(3)Java语言中，默认的浮点数类型是double，声明float类型的时候，后面必须添加字母f或者F，如3.14F，3.14f；
(4)Java语言中，char类型为16位Unicode字符，Unicode字符中的取值不存在负数范围，所以它的取值范围为 0 ~ 65535，—— 有点类似 “无符号数”；
(5)类型转换都是小范围向大范围转换，大范围往小范围转化需要用到强制转换；
例如：(1)int a=12;double b=a;(2)double a=3.0;int b=(int)a;

数据类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
- 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
- byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
- boolean类型不能与其它数据类型运算。
- 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。
强制类型转换
- 强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：

double x = 9.997;
int nx =（int）x;

如果运算符得到一个值，其类型与左侧操作数的类型不同，发生就会强制类型转换速。例如，如果X是一个整型，则以下语句

int x = 0;
x + = 3.5;

是合法的，将把x设置为（int）（x + 3.5）。

如果是下面这种赋值方式，则会报错

 double d = 2.0;
 int i = 0;
 i = i+d;//Type mismatch: cannot convert from double to int

数据类型的书写语法

int 直接书写，即为int型int i = 100;
long 后面要加后缀L或者l（为了区别视觉歧义建议大写）long i = 100L；
byte 和 short 无法直接表示，我们可以通过前面所讲的表示范围，可以看出byte和short表示范围内的数，我们都可以赋值给int和long，所以它是无法直接表示的。
我们需要注意的就是long类型后面需要加后缀L
结合前面博文补充个知识点：不同进制的表示，不明白的可以点下连接跳转下：进制转换
整数int 类型127在不同进制下的表示：
- 2进制 int a = 0b01111111;
- 8进制 int b = 0377;
- 10进制 int c = 127;
- 16进制 int d = 0x7F；
【16进制下的字母不区分大小写】
整数long类型127在不同进制下的表示：
- 2进制 int a = 0b01111111L;
- 8进制 int b = 0377L;
- 10进制 int c = 127L;
- 16进制 int d = 0x7FL；
浮点类型的书写语法：（只能使用十进制）
- float （必须加后缀F或f，推荐F）
- float f = 100F；
- float f = 3.14F；
- double（后缀D或d，推荐D）
- double a = 100D
- double a = 3.14；//小数默认为double类型，后面可不加
- double a = 3.14D；
说到浮点类型我们就要讲到浮点数的科学计数法表示，科学计数法知识补充：科学计数法百科
E4（相当于乘以10的4次方）
- float类型31415.926F
- 3.1415926E4F或3.1415926e4F
- double类型31415.926
- 3.1415926E4或3.1415926e4
- 3.1415926E4D或3.1415926e4D

变量和常量

变量的定义

变量是内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），Java中每个变量必须先声明，后使用，该区域的数据可以在同一类型范围内不断变化。
标识符：在计算机高级语言中，用来对变量、符号常量名、函数、数组、类型等命名的有效字符序列统称为标识符。简单地说，标识符就是一个对象的名字。

变量的分类

按数据类型
- 对于不同的数据类型，在内存中分配了不同大小的内存空间
- 数据类型分为基本数据类型和引用数据类型，引用数据类型有类（class）、接口（interface）、数组，基本数据类型有布尔型（boolean）、字符型（char）、数值性【整数类型（byte、short、int、long）、浮点类型（float、double）】

按声明的位置

  在方法体外，类体内声明的变量称为成员变量；在方法体内部声明的变量称为局部变量

在这里插入图片描述

.声明格式

 定义变量的格式：数据类型 变量名 = 初始化值

变量在内存中的区域:
在这里插入图片描述

常量

常量是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变，一般用大写字符
```
    语法：final 常量名 = 值;如：final String LOVE = ‘java‘;
```
注意：必须要在常量声明的时候就对其进行初始化，否则会出现编译错误。常量一旦初始化后就无法再改动
常用的常量有以下几类：
- （1）整型常量。如1000，1234，0，-345等都是整型常量。
- （2）实型常量。有两种表示形式：
  - a、十进制小数形式，由数字和小数点组成。如：123.456，0.345，-56.79，0.0，12.0等。
  - b、指数形式，如12.34e3（代表12.34×10e3），-346.87e-25（代表-346.87×10e-25）,0.145E25（代表0.145×10e-25）等。由于在计算机输入或输出时，无法表示上角或下角，故规定以字母e或E表示以10为底的指数。但应注意：e或E之前必须有数字，且e或E后面必须为整数。如不能写成e4，12e2.5.
- （3）字符常量。有两种形式的字符常量：
  - a、普通字符，用单撇号括起来的一个字符，如：‘a’，‘Z’，‘3’，’?’，’#’。不能写成’ab’或’12’。请注意：单撇号只是界限符，字符常量只能是一个字符，不包括单撇号。'a’和’A’是不同的字符常量。字符常量存储在计算机存储单元中时，并不是存储字符（如a,z,#等）本身，而是以其代码（一般采用ASCII代码）存储的，例如字符’a’的ASCII化代码是97，因此，在存储单元中存放的是97（以二进制形式存放）。
  - b、转义字符，除了以上形式的字符常量之外，C还允许用一种特殊形式的字符常量，就是以字符\开头的字符序列。例如，前面已经遇到过的，在printf函数中的’\n’它代表一个“换行”符。’\t’代表将输出的位置跳到下一个tab位置，一个tab位置为8列。这是一种在屏幕上无法显示的“控制字符”，在程序中也无法用一个一般形式的字符来表示，只能采用这样的特殊形式来表示。
- 常用的以“\”开头的特殊字符如下：
- （4）字符串常量。如“boy”，“123”等，用双撇号把若干个字符括起来，字符串常量是双撇号中的全部字符（但不包括双撇号本身）。注意不能错写成’CHINA’,‘boy’,‘123’。单撇号内只能包含一个字符，双撇号内可以包含一个字符串。
（5）符号常量。用#define指令，指定用一个符号名称代表一个常量。如
```
   #define PI 3.1416 //注意行末没有分号
```

运算符与表达式

常用运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。Java也提供了一套丰富的运算符来操纵变量，们可以把运算符分成以下几组：
算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符和其他运算符

算术运算符与表达式

算术运算符用在算术表达式中，其作用和数学中的运算符相同，一般用于数值运算，可对操作数进行加减乘除、取余、自增和自减操作。

自增自减运算符

自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
- 前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。
- 后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算实例：

public class Test {
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        // 拆分运算过程为: a=a+1=6; x=2*a=12
        int x = 2*++a;
        // 拆分运算过程为: y=2*b=2*5=10; b=b+1=6
        int y = 2*b++;
        System.out.println("a="+a+",x="+x); // a=6, x=12
        System.out.println("b="+b+",y="+y); // b=6, y=10
    }
}

关系运算符与表达式

关系运算符也是双目运算符，用于关系表达式。关系运算符对两个操作数进行比较，并返回比较结果，比较结果的值为一个布尔值（true或false）。

public class Test {
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     System.out.println("a==b : " + (a == b) ); // a==b : false
     System.out.println("a!=b : " + (a != b) ); // a!=b : true
     System.out.println("a>b : " + (a > b) ); // a>b : false
     System.out.println("a<b : " + (a < b) ); // a<b : true
     System.out.println("b>=a : " + (b >= a) ); // b>=a : true
     System.out.println("b<=a : " + (b <= a) ); // b<=a : false
  }
}

赋值运算符与表达式

赋值运算符是双目运算符，用在赋值表达式中。它的作用是将运算符右边操作数的值赋给运算符左边的变量。
赋值运算符分为两类，一类是简单赋值，一类是复合赋值。简单赋值是直接把运算符右边操作数的值赋给运算符左边的变量，运算符有“=”；复合赋值运算符复合赋值是先执行运算符指定的运算，然后再将运算结果赋值给运算符左边的变量。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b; // 30
        c += a ; // c = c+a = 30+10 = 40
        c -= a ; // c = c-a = 40-10 = 30
        c *= a ; // c = c*a = 30*10 = 300
        c /= a ; // c = c/a = 300/10 = 30
        c %= a ; //  c= c%a = 30%10 = 0      
        a = 10; 
        c = 15;
        c /= a ; // c = c/a = 15/10 = 1
        a = 10;
        c = 15;
        c %= a ; // c = c%a = 15%10 = 5
        c <<= 2 ; // c = c<<2 = 5<<2 = 20
        c >>= 2 ; // c = c>>2 = 20>>2 = 5
        c >>= 2 ; // c = c>>2 = 5>>2 = 1
        c &= a ; // c = c&a = 1&10 = (00000001 & 00001010=00000000) = 0
        c ^= a ; // c = c^a = 0^10 = (00000000 ^ 00001010=00001010) = 10
        c |= a ; // c = c|a = 10|10 = (00001010 | 00001010=00000000) = 0
    }
}

逻辑运算符与表达式

逻辑运算符连接两个关系表达式或布尔变量，用于解决多个关系表达式的组合判断问题，返回的运算结果为布尔值。

public class Test {
  public static void main(String[] args) {
     boolean a = true;
     boolean b = false;
     System.out.println("a && b = " + (a&&b)); // false
     System.out.println("a || b = " + (a||b) ); // true
     System.out.println("!(a && b) = " + !(a && b));  // true
  }
}

条件运算符与表达式

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
三元运算符格式：(关系表达式)？表达式1：表达式2

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b ); // 30
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b ); // 20
   }
}

位运算符与表达式

位运算符主要针对二进制，它包括了：“与”、“非”、“或”、“异或”。
Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。

（1）与运算符

与运算符用符号“&”表示，其使用规律为，两个操作数中位都为1，结果才为1，否则结果为0，例如下面的程序段。

public class data13 {

	public static void main(String[] args)
	{
		int a=129;
		int b=128;
		System.out.println("a 和b 与的结果是："+(a&b));
	}
}

运行结果
a 和b 与的结果是：128

下面分析这个程序：
- “a”的值是129，转换成二进制就是10000001，而“b”的值是128，转换成二进制就是10000000。根据与运算符的运算规律，只有两个位都是1，结果才是1，可以知道结果就是10000000，即128。

（2）或运算符

或运算符用符号“|”表示，其运算规律为，两个位只要有一个为1，那么结果就是1，否则就为0，下面看一个简单的例子。

public class data14 {
	
	public static void main(String[] args)
	{
		int a=129;
		int b=128;
		System.out.println("a 和b 或的结果是："+(a|b));
	}
}

运行结果
a 和b 或的结果是：129

下面分析这个程序段：
- a 的值是129，转换成二进制就是10000001，而b 的值是128，转换成二进制就是10000000，根据或运算符的运算规律，只有两个位有一个是1，结果才是1，可以知道结果就是10000001，即129。

（3）非运算符

非运算符用符号“~”表示，其运算规律如为，如果位为0，结果是1，如果位为1，结果是0，下面看一个简单例子。

public class data15 {
	
	public static void main(String[] args)
	{
		int a=2;
		System.out.println("a 非的结果是："+(~a));
	}
}

（4）异或运算符

异或运算符是用符号“^”表示的，其运算规律为，两个操作数的位中，相同则结果为0，不同则结果为1。下面看一个简单的例子

public class data16 {
	
	public static void main(String[] args)
	{
		int a=15;
		int b=2;
		System.out.println("a 与 b 异或的结果是："+(a^b));
	}
}

运行结果
a 与 b 异或的结果是：13

分析上面的程序段：
- a 的值是15，转换成二进制为1111，而b 的值是2，转换成二进制为0010，根据异或的运算规律，可以得出其结果为1101 即13。

Java 运算符的优先级

和数学中的运算符一样，Java运算符也存在优先级关系。在Java表达式中，优先级高的运算符先参与运算，优先级低的运算符后参与运算。

Java程序的流程控制语句

顺序结构

是最基本的流程控制语句，按照语句先后顺序，从上往下，依次执行，是程序中大部分代码的执行顺序

选择结构

if 语句

格式一

 if(比较表达式或boolean类型的值){
	语句体;
}

执行流程
先计算if后括号内的值，如果为true，则执行语句体，如果为false，则不执行语句体。
格式二

if(比较表达式或boolean类型的值){
 	语句体1;
 }else{
 	语句体2;
 }

执行流程
先计算if后表达式的值，如果为true，就执行语句体1，如果为false，就执行语句体2
格式三

if(比较表达式或boolean类型的值1){
  	 语句体1;
  }else if(比较表达式或boolean类型的值2){
   	 语句体2;
  }else if(比较表达式或boolean类型的值3){
	 语句体3;
  }
  ……
  else {
 	 语句体n+1;
  }

执行流程
先计算表达式1的值，如果是true就执行语句体1，if语句结束；如果是false就接着计算表达式2 ，如果是true，就执行语句体2，if语句结束，如果还是false，接着执行表达式3，如果是true，就执行语句体3，if语句结束，如果……，如果都是false，就执行语句体n+1。
只要有一个条件满足，if语句就执行该条件下的语句体，if语句结束，如果都不满足，就执行else下的语句体。
案例

//        键盘输入一个x，求y的值
//        x >= 3        y = 2 x + 1;
//        -1<= x < 3    y = 2 x;
//        x< -1         y = 2 x –1;

 public static void main(String[] args) {
      Scanner in = new Scanner(System.in);
        System.out.println("请输入x:");
        double x = in.nextDouble();
        if (x >= 3) {
            System.out.println("y的值是：" + (2 * x + 1));
        } else if (x >= 1 && x < 3) {
            System.out.println("y的值是：" + (2 * x));
        } else {
            System.out.println("y的值是：" + (2 * x - 1));
        }
    }

switch语句

格式

switch(表达式){
	case值1:
		语句体1;
		break;
	case值2:
	        语句体2;
  		break;
  	case值3:
  		语句体3;
  		break;
  		……
  		default:
  			语句体n+1;
  			break;
  	}

执行流程
先计算表达式的值，然后逐次和case后的值进行比较，如果相等，就执行该case内的语句，遇到break结束；如果都匹配不到，就执行default后的语句。
注意
case后的值只能是常量，不能是变量，且多个case后的值不能相等；switch语句碰到break关键字就会结束，如果一个case语句下的语句体执行完后没有碰到break，那么就会接着执行下一个case中的语句体，直到遇见break或全部语句体执行完，switch语句结束。
案例
键盘录入月份，输出对应的季节

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    System.out.println("请输入月份，我们将为你输出对应的季节");
    int month = in.nextInt();
    switch (month) {
        case 3:
        case 4:
        case 5:
            System.out.println(month + "月对应的是春天");
            break;
        case 6:
        case 7:
        case 8:
            System.out.println(month + "月对应的是夏天");
            break;
        case 9:
        case 10:
        case 11:
            System.out.println(month + "月对应的是秋天");
            break;
        case 12:
        case 1:
        case 2:
            System.out.println(month + "月对应的是冬天");
            break;
        default:
            System.out.println("你输入的月份有误！");
            break;
    }
}

当要比较某些点值时，switch 语句比较好用，比如月份、星期等；当要比较某个区间的值时，用 if 比较合适。

循环语句

for 循环

在满足循环条件的情况下，反复执行某一段代码的结构称为循环结构，被重复执行的代码叫做循环体，循环结构需要一个条件结束循环，不然就会形成死循环。
for 循环结构

for(初始化表达语句;判断条件语句;控制条件语句){
	循环体语句;
}

执行流程
- 进行初始化表达语句
- 执行判断条件语句，如果为true，继续执行；如果为false，跳出循环，循环结束
- 为true执行循环体语句
- 执行控制条件语句
- 执行判断条件语句，为true继续执行循环体语句，为false跳出循环，循环结束
- 为true执行循环体语句
- 执行条件判断语句
  ……
注意：初始化表达语句只执行一次
案例
需求：求出1-100之间偶数和

public static void main(String[] args) {
    int sum = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 2 == 0) {
            sum = sum + i;
        }
    }
    System.out.println(sum);
}

while循环

while循环结构

初始化条件语句;
while(判断条件语句) {
	循环体语句;
	控制条件语句;
}

执行流程
- 执行初始化条件语句
- 执行条件判断语句，若为true，继续执行循环体语句；若为false，结束循环
- 执行循环体语句
- 执行控制循环语句
- 执行条件判断语句，若为true，继续执行循环语句；若为false，结束循环
  ……
案例
求和: 求1-100之和

public static void main(String[] args) {
    int sum = 0;
    int i = 1;
    while (i <= 100) {
        sum += i;
        i++;
    }
    System.out.println(sum);
}

do while循环

do while循环语句格式

初始化条件语句;
do {
	循环体语句;
	控制条件语句;
}while(判断条件语句);

执行流程
- 执行初始化条件语句
- 执行循环体语句
- 执行控制条件语句
- 执行判断条件语句，若为true，继续循环；若为false，跳出循环
- 若为true，执行循环体语句
- 执行控制条件语句
  ……
案例
- 请在控制台输出数据1-10

public static void main(String[] args) {
 int i = 1;
 do {
     System.out.println(i);
     i++;
 } while (i <= 10);
}

for、while、do while 三种循环的区别

do while 循环至少执行一次，而 for 和 while 可以一次也不执行
如果已知循环次数，用for循环方便；如果只知道循环结束条件，用while循环
如果想在循环过后继续使用控制条件变量，用while循环，否则用for循环
建议优先使用for循环，再是while循环，最后是do while循环
注意：一定要注意控制循环的变量，不然容易造成死循环
- 练习：在控制台输出九九乘法表

public static void main(String[] args) {
    for (int i = 1; i <= 9; i++) {
        for (int j = 1; j <= i; j++) {
            System.out.print(j + "*" + i + "=" + (j * i) + "\t");
        }
        System.out.println();
    }
}