java--第三章：java语言基础2

不念不忘少年蓝@ 2023-06-06 08:13 17阅读 0赞

### 1 关键字 ###

**概念：**被java语言赋予特殊含义的单词

**特点：**组成关键字的字母全部小写

**注意事项：**goto和const作为保留字（目前只是保留，以后有可能作为关键字）存在，目前并不使用；类似Notepad++这样的高级记事本，针对关键字有特殊的颜色标记，非常好区分。

**常用的关键字：**

*  定义数据类型：class  interface  byte  short  int  long  float  double  char  boolean  void
 *  定义数据类型值：true  false  null
 *  定义流程控制：if  else switch case  default  while  do  for  break  continue  return  
 *  定义访问权限修饰符：private  protected  public
 *  定义类、函数、变量修饰符：sbstract  final  static  synchronized
 *  定义类与类之间的关系：extends  implements
 *  定义建立实例、引用实例及判断实例：new  this  super  instanceof  
 *  定义异常处理：try  catch  finally  throw  throws
 *  用于包：package  import 
 *  其他修饰符：native等

### 2 标识符（起名字时的标记） ###

**概念：**给类、接口、方法、变量等起名字时使用的字符序列

**组成规则：**英文大小写字母；数字字符；$和\_

**注意事项：**不能以数字开头；不能是java的关键字；严格区分大小写

**常见命名规则：（见名知意）**

1包：其实就是文件夹，用于把相同的类名进行区分

全部小写

单级：liuyi

多级：cn.itcast

2 类或者接口：

一个单词：单词的首字母必须大写，比如Student,Dog

多个单词：每个单词的首字母必须大写,比如HelloWorld，MakeName

3方法或者变量：

一个单词：单词的首字母小写，比如main

多个单词：从第二个单词开始，每个单词的首字母大写，比如studentAge

4常量：

一个单词：全部大写，比如PI

多个单词：每个字母都大写，用\_隔开，比如STUDENT\_MAX\_AGE

### 3 注释 ###

初学者一定要先写注释，再写代码

**概述：**用于解释说明程序的文字

**分类：**

单行注释：// 注释文字

多行注释：/\* 注释文字 \*/  （多行注释不可以嵌套使用，单行注释可以嵌套使用）

文档注释：/\*\* 注释文字 \*/（被javadoc工具解析生成一个说明书，面向对象部分讲解）

比如把HelloWorld.java这个案例写成带注释版的，我们可以像下面这么写

/*
        需求：写一个java程序，把"HelloWorld"这句话输出在控制台
    	
    	分析：
    		A：要写一个java程序，必须定义类
    		B：把数据能够输出，说明程序是可以独立运行的。而程序要独立运行，必须定义main方法。
    		C：把数据输出在控制台，必须使用输出语句
    		
    	实现：
    	    A：java语言提供了一个关键字：class用来定义类，后面跟的是类名
    		B：main方法的格式是固定的：
    			public static void main(String[] args){
    				
    			}
    		C:输出语句的格式是固定的：
    			System.out.println("HelloWorld")
    */
    
    class HelloWorld {
    	/*
    	   为了使程序能够独立运行，定义main方法
    	   main方法是程序的入口
    	   被jvm调用
    	*/
    	public static void main(String[] args){
    		//为了把数据显示在控制台，使用输出语句
    		System.out.println("HelloWorld");
    	}
    }

** 作用：**解释说明程序，提高程序的阅读性；可以帮助调试程序

### 4 常量 ###

**概述：**在程序执行的过程中，其值不可以发生改变

**分类：**

A：字面值常量

*  字符串常量：用双引号括起来的多个内容，例如"hello","world"
 *  字符常量：用单引号括起来的单个内容，例如'a','A'
 *  整数常量：所有的整数，例如100，200
 *  小数常量：所有的小数，例如10.23，110.11
 *  布尔常量：只有true和false
 *  空常量：null，后面讲

B：自定义常量（后面讲）

### 5 进制 ###

java针对整数常量提供了4种表现形式：二进制、八进制、十进制、十六进制

**进制概述：**就是进位制，人们规定的一种进位方法。对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位，二进制就是逢二进一，八进制就是逢八进一，十进制就是逢十进一，十六进制就是逢十六进一。

计算机电子原件的状态：开、关。那么，我们表达数据的时候，也是按照开、关的状态来表示的。

如果表达数据仅仅用这两种状态，那么能够表达的数据是很少的。而我们常见的数据：英文字母，数字，标点符号。这就很多了。两个状态是肯定不够的。为了能够表示更多的数据，国际化标准组织就规定：用8个这样的信号来表示一个数据，这个数据的单位叫：字节。

后来我们用数字1和0分别表示开和关。由1和0组成的数据就是二进制数据。

1byte=8bit

1k=1024byte

1m=1024k

1g=1024m

1t=1024g

但是，用二进制表达数据的表现形式有点长，所以我们应该简化一下。

如何简化呢？

把二进制的数据，从右开始，每三位一组合，最左边不够的时候，补0。然后分别计算出对应的十进制数值，最后再把每个十进制的数据组合起来，就是一个八进制数据。

这种表现形式还不是最简单的，还有更简单的。

把二进制的数据，从右开始，每四位一组合，最左边不够的时候，补0。然后分别计算出对应的十进制数值，最后再把每个十进制的数据组合起来，就是一个十六进制数据。

**规则：**进制越大，表现形式越短。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70][]

**不同进制的数据组成：**

*  二进制：由0和1组成，以0b开头
 *  八进制：由0，1，...7组成，以0开头
 *  十进制：由0，1，...9组成，整数默认是十进制的
 *  十六进制：由0，1，...9,a,b,c,d,e,f(大小写均可)，以0x开头

class JinZhi {
    	public static void main(String[] args){
    		//十进制100
    		System.out.println(100);
    		
    		//二进制4
    		System.out.println(0b100);
    		
    		//八进制64
    		System.out.println(0100);
    		
    		//十六进制256
    		System.out.println(0x100);
    	}
    }

**十进制到其他进制的转换：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 1][]

**任意进制到十进制的转换：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 2][]

** 快速的进制转换法：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 3][]

## ##

###  6 原码反码补码 ###

为什么讲解这个知识点呢？因为计算机在操作的时候，都是采用数据对应的二进制的补码来进行计算的。

有符号数据表示法：

在计算机内，有符号数有3种表示方法：原码、反码和补码。所有数据的运算都是采用补码进行的。

**原码：**就是二进制定点表示法，即最高位为符号位，‘0’表示正，‘1’表示负，其余位表示数值的大小。

**反码：**正数的反码与其原码相同，负数的反码是对其原码逐位取反，符号位除外。

**补码：**正数的补码与其原码相同，负数的补码是在其反码的末位加1.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 4][]

### 7 变量 ###

**概述：**在程序执行的过程中，在某个范围内其值可以发生改变的量。

**定义格式：**

数据类型   变量名 = 初始化值

注意：格式是固定的

**组成规则：**

A：必须对其限定。用什么限定呢？数据类型

B：我们在运算的时候，不可能拿着空间去运算，真正运算时，使用的是该空间中的值，我们起名为 变量名

C：即使有数据类型和变量名了，但是如果没有值，这个空间也是一个垃圾空间，没有任何意义，所以我们需要 初始化值

**数据类型：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 5][]

数据类型分类：

A：基本数据类型

B：引用数据类型

基本数据类型：

A：整数                       占用字节数

byte(字节)                        1

short(短整型)                   2

int(整型)                           4

long(长整型)                     8

B：浮点数

float(单精度)                    4

double(双精度)                8

C：字符

char                                 2

D：布尔

boolean                           1

整数默认为int，小数默认为double，

长整型后缀用L或者l标记，建议用L。

单精度浮点型数后缀用F或者f标记，建议用F。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 6][]

**定义不同数据类型的变量：**

class DataType {
    	public static void main(String[] args){
    		
    		//定义一个字节变量
    		byte b = 10;
    		System.out.println(b);
    		
    		//定义一个短整型
    		short s = 100;
    		System.out.println(s);
    		
    		//定义一个整型
    		int i = 1000;
    		System.out.println(i);
    		
    		//定义一个长整型(后缀名加一个L)
    		long l = 1000000000L;
    		System.out.println(l);
    		
    		//定义单精度浮点类型
    		float f = 12.345F;
    		System.out.println(f);
    		
    		//定义双精度浮点类型
    		double d = 12.345;
    		System.out.println(d);
    		
    		//定义字符类型
    		char ch = 'a';
    		System.out.println(ch);
    		
    		//定义布尔变量
    		boolean flag = true;
    		System.out.println(flag);
    	}
    }

**使用变量的注意事项：**

A：作用域：变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。

B：初始化值：没有初始化值不能直接使用。只要在使用前给值，不一定非要在使用的时候立马给值。推荐在定义的时候给值。

定义变量的格式：

a：数据类型  变量名 = 初始化值；

b：数据类型  变量名；

变量名 = 初始化值；

C：在一行上建议只定义一个变量：可以定义多个，但是不建议。

class DataType2 {
    	public static void main(String[] args){
    		//定义变量
    		int x = 100;
    		
    		//错误，不能有同名的。
    		//int x = 200;
    		
    		//定义变量必须在使用前给值
    		//int y;
    		//System.out.println(y);
    		
    		//在一行上定义多个变量
    		int a = 10;int b = 20;int c = 30;
    		//上面的写法可以，但是不建议
    		
    		//下面的写法也不报错，但是不建议这么写
    		int d,e;
    		d = 40;
    		e = 50;
    		
    		//下面的写法会报错
    		//int d,int e;
    	}
    }

**数据类型转换之默认转换：**

\+是一个运算符，做加法运算的。

一般来说，我们在做运算的时候，要求参与运算的数据类型必须一致。

注意：boolean类型不能转换为其他的数据类型。

默认转换：（从小到大的转换）

A：byte,short,char--int--long--float--double

B：byte,short,char相互之间不转换，他们参与运算首先转换为int类型。

class DataType3 {
    	public static void main(String[] args){
    		//直接输出的方式做加法
    		System.out.println(3 + 4);
    		
    		//两int类型做加法
    		int x=3;
    		int y=4;
    		
    		int z=x + y;
    		System.out.println(z);
    		
    		//定义一个byte类型，一个int类型，做加法
    		byte a = 3;
    		int b = 4;
    		System.out.println(a + b);
    		
    		//可能损失精度
    		//byte c = a + b;
    		
    		int c = a + b;
    		System.out.println(c);
    	}
    }

byte类型和int类型数据相加，会转换为int类型。所以如果把相加的结果赋值给一个byte类型的话，系统会提示：可能损失精度。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 7][]

**数据类型转换之强制转换：（从大的数据类型到小的数据类型）**

目标类型  变量名=(目标类型)(被转换的数据)

注意：不要随意的去使用强制转换，因为它隐含了精度损失问题。

class DataType4{
    	public static void main(String[] args){
    		byte b = 3;
    		int a = 4;
    		
    		//这个是有问题的
    		//byte c = a + b;
    		
    		//用强制类型转换
    		byte c = (byte)(a + b);
    		System.out.println(c);
    	}
    }
    
    /*
       思考题1：请问下面这个有没有问题
           double d = 12.345;
           float f = d;
       思考题2：看看下面两定义有没有区别呢？
           float f1 = (float)12.345;
    	   float f2 = 12.345f;
    	   
    	   f1其实是通过一个double类型转换过来的，
    	   而f2本身就是一个float类型。
    */
    
    
    class DataType5{
    	public static void main(String[] args){
    		//解决思考题1
    		double d = 12.345;
            float f = (float)d;
    		
    		//看看下面两定义有没有区别呢？
    		float f1 = (float)12.345;
    		float f2 = 12.345f;
    	}
    }

**变量相加和常量相加的区别面试题：**

//面试题1:哪句是编译失败的呢？为什么？
    /*
    byte b1 = 3,b2 = 4,b;
    b = b1 + b2;
    b = 3 + 4;
    */
    
    //面试题2:下面这句有没有问题？如果我想赋值正确，可以怎么做？结果是多少？
    /*byte b = 130;*/
    
    class DataType6 {
    	public static void main(String[] args){
    		//面试题1
    		byte b1 = 3,b2 = 4,b;
    		//b = b1 + b2;//变量相加，首先看类型问题，这个是类型提升，所以有问题
    		
    		b = 3 + 4;//常量相加，先把结果计算出来，然后看是否在赋值的数据类型范围内，如果在就不报错
    		
    		
    		//面试题2
    		//byte b3 = 130;
    		//因为byte的范围是-128到127，而130不在范围内，所以报错
    		
    		//我们可以强制类型转换
    		byte b3 = (byte)130;
    		System.out.println(b3);//-126
    		
    		/*
    		    分析过程：我们想知道结果是什么，应该知道如何进行计算的。
    		    而我们又知道计算机中数据的运算都是补码进行的。
    		    而要得到补码，首先要计算出数据的二进制。
    		  
    		    A:获取130这个数据的二进制
    			  00000000 00000000 00000000 10000010
    			  这是130的原码，也是反码，还是补码
    			B:做截取操作，截成byte类型的了
    			   10000010
    			   这个结果是补码
    			c:已知补码为10000010，求原码
    			  结果为-126
    			
    		*/
    		
    	}
    }

** 字符参与运算：**

通过字符和一个整数相加，我们给出一张表，ASCII码表

看完这张表，我们需要记住三个值：

‘a’  ----   97

‘A’  ----   65

‘0’  -----  48

class DataType7{
    	public static void main(String[] args){
    		//直接输出一个字符
    		System.out.println('a');//a
    		
    		//输出一个字符和一个整数做加法
    		System.out.println('a'+1);//98
    		
    		/*字符串数据和其他数据做加，结果是字符串类型，
    		  这里的+不是加，而是字符串连*/
    		System.out.println("hello"+'a'+1);//helloa1
    		
    		System.out.println('a'+1+"hello");//98hello
    		
    		System.out.println("5+5="+5+5);//5+5=55
    		
    		System.out.println(5+5+"=5+5");//10=5+5
    	}
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70]: /images/20230601/8e0ed321391742ab93a8cca9699f42a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 1]: /images/20230601/b10be7bef62f4462827bc21404f0fd31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 2]: /images/20230601/f496e06f09f8407b8fd2f2cf81d03163.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 3]: /images/20230601/632769e5d0004044b6cd9e5ebdf0dc41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 4]: /images/20230601/76cac3a9036f432193d351560b61d902.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 5]: /images/20230601/4dcf51b00a23403dbb011466f4705864.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 6]: /images/20230601/d3a111df5f884bd882128908e5af9d27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xlbW9udHJlZV9mdQ_size_16_color_FFFFFF_t_70 7]: /images/20230601/5eadac32b8a14b8bb932861c7a17699c.png