Java核心基础之基础知识介绍

Java核心基础之基础知识介绍

Java 是第一大编程语言和开发平台。它有助于企业降低成本、缩短开发周期、推动创新以及改善应用服务。如今全球有数百万开发人员运行着超过 51 亿个 Java 虚拟机， Java 仍是企业和开发人员的首选开发平台。

    

课程内容的介绍

1. 关键字

2. 标识符

3. 注释

4. 常量与变量

5. 基本数据类型和转化

6. 运算符

7. 表达式

  

一、关键字

Java 关键字：是 Java 语言保留供内部使用的，比如 class 用户与定义类。关键字也可以称为保留字，他们的意思是一样的。

public class HelloWorld{
    public static void main(String[]){
        System.out.println("HelloWorld...");
    }
}

关键字是 Java 语言事先定义的，有特殊的意义的标识符，简而言之就是在高级记事本或者 IDE 中颜色会改变的单词就是关键字。

注意：不需要刻意的去背！后面我们会慢慢的接触到每个关键字的用法。

  

关键字的特点

1. 关键字基本都是由小写字母组成的。

2. Java 语言规定关键字是不能作为标识符。

3. 目前 Java 中共有 50 个关键字。

其中 "const" 和 "goto" 这两个关键字在 Java 中是没有具体的含义的，预留的关键字。在其他的编程语言中"const" 和 "goto" 都是关键字。

  

课堂小案例：

判断一下单词哪些是关键字：

class HelloWorld public static void main String System out println

  

class: 类名

public: 共有的

static: 静态的

void: 没有返回结果

  

二、标识符

标识符：等同于现实生活中的取名字， Java 中对包、类、方法、参数和变量等要素命名的时候使用的字符序列称为标识符。 简而言之就是给类，接口，方法等起名字。

  

1.标识符的命名规则

规则：一定要遵守的，如果违反那么编译会报错

1. 是由字母、数字、下划线 _ 、美元符 $ 组成。

2. 不能以数字开头。

3. 区分大小写。

4. 不能使用 Java 中的关键字。

  

2.标识符的命名规范

规范：大家相互约定，都会遵守，如果不遵守编译不会报错。

1. 驼峰命名法 (schoolName)。

2. 见名知意 ( 使用有意义的英文单词 )。

3. 命名的长度不要超过 31 个字符。

  

3.开发中标准的规范

针对开发中对 包、类、抽象类、接口和实现类、变量、方法、常量的命名规范。

3.1 包

也就是文件夹。

1. 一般都是用公司域名的反写。

2. 所有的单词使用 "." 隔开。

3. 每个单词都是小写的。

// www.bobo.com
com.bobo.www
com.bobo.oa

   

3.2 类(抬头骆驼)

1. 所有的单词的首字母大写，其他字母小写。

2. 见名知意。

eg: HelloWorld IdentifiedDemo

  

3.3 接口(抬头骆驼)

1. 所有的单词的首字母大写，其他字母小写 interface。

2. 一般会在第一个单词的前面添加一个大写的 "I"。

eg: IStudent IPerson IUserService

  

3.4 接口的实现类(抬头骆驼)

1. 所有的单词的首字母大写，其他字母小写。

2. 一般我们会在最后一个单词后面追加 "Impl" implements。

eg: StudentImpl PersonImpl UserServiceImpl

  

3.5 抽象类(抬头骆驼)

1. 所有的单词的首字母大写，其他字母小写。

2. 在单词的开头一般都会加上 "Abs" Abstract。

eg: AbsStudent AbsPerson

  

3.6 变量(低头骆驼)

1. 第一个单词首字母小写，其他单词首字母大写。

2. 一般都是名词。

eg: studentName studentAge score totalScore

  

3.7 方法(低头骆驼)

1. 第一个单词首字母小写，其他单词首字母大写。

2. 一般是动词。

eg: getTotalScore getAvgScore getMaxScore getMinScore

  

3.8 常量

1. 所有的单词都是大写。

2. 每个单词间都有 "_" 分割。

eg: MAX_VALUE MIN_VALUE

  

面试题：说一说你对 Java 规范的理解。

   

三、注释

注释的概念：

为程序进行解释说明的，编译期不会对注释进行编译操作。

注释的好处：

1. 是代码的可读性提高。

2. 开发中工作项目交接更加顺畅。

3. 程序调试更方便。

  

单行注释： //

多行注释 : /* 在此处写我们的注释内容 */ 多行注释是不能嵌套的

文档注释 : /** */

  

注意：

1. 文档注释可以是 javadoc 工具来生成 API ，后续会介绍。

2. 初学者一定要养成良好的习惯，先写注释，再写代码。

3. 开发中的注释不能随便删除。

  

public class zhushi{
    /**
    * 我们的第一个main方法
    */
    public static void main(String[] args){
        // 声明一个变量 测试
        /*
        注释1
        注释2
        注释3
        */
        String userName = "张三";
    }
}

   

四、常量和变量

1.常量

1.1 什么是常量

在程序的执行过程中，值不会发生改变的量。

  

1.2 为什么要用常量

一周有 7 天

PI ： 3.1415926

一年有 12 个月

   

1.3 常量的分类

1.3.1 字面值常量

就是具体的值。

1.) 整数常量

大家要注意整数的进制。

1. 二进制 由 0 1 组成，常量表示二进制 0b 开头 0b010110。

2. 八进制 由 0~7 组成，由 0 开头 012。

3. 十进制 由 0~9 组成，默认就是十进制。

4. 十六进制 由 0~9 ABCDEF 组成，开头 0x。

2.) 小数常量

1. float 单精度小数 0.5F。

2. double 双精度 0.5D 默认。

float，double 后面会具体的来介绍这两个类型。

3.) 布尔型常量

用来表示 " 真 " " 假 ", 在程序中布尔型只有两个值 true false。

4.) 字符常量

什么是字符：字符串中的最小单位，包括字母，数字，运算符，标点符号和其他符号。

字符本质上还是数字。

针对有特殊含有的字符我们需要通过转义符来实现 "\"。

\t 制表 \n 换行 \r\n 换行 \R 换行 \' \"。

5.) 字符串常量

1. 由双引号包裹。

2. 里面可以有一个字符也可以有多个字符还可以没有字符。

public class ConstantDemo{
    public static void main(String[] args){
        // 整数 常量
        System.out.println(10);
        // 二进制常量 13
        System.out.println(0b01101);
        // 八进制 10
        System.out.println(012);
        // 十六进制 65535
        System.out.println(0xFFFF);
        System.out.println(5.5f);
        System.out.println(5.6D);
        System.out.println(true);
        System.out.println(false);
        // 字符 '' 单引号不能为空
        System.out.println('\'');
        // 字符串常量 必须写在一对 双引号之内
        System.out.println("HelloWorld");
        System.out.println("");
        // System.out.println(null);
    }
}

   

1.3.2 自定义常量

后面章节中会和大家介绍。

  

2.变量

变量的定义：在程序的执行过程中，其值可以发生改变的量。类似于数学中的未知数 X。

变量的本质：就是一个地址。

变量的三要素：

1. 声明

2. 赋值

3. 使用

public class VariableDemo{
    public static void main(String[] args){
        // 定义一个变量 租房子 我 我要租一个两室一厅的房子
        int a ;// 声明了一个变量
        a = 20; // 赋值操作 将一个常量赋值给了一个变量
        System.out.println(a); // 使用
        a = 50;
        System.out.println(a); // 使用
        int b = 100; // 声明和赋值一块执行
        System.out.println(b);
    }
}

    

注意点：

1. 变量一定要先声明再赋值在使用。

2. 变量的定义不能够重复。

3. 不能够连续定义变量 int x=y=z=123;。

4. 建议一行只写一条语句。

  

五、基本数据类型和转换

1.计算机单位

计算机能识别是只有二进制文件 0 和 1。

位：就是一个 0 或者 1。

  

1B: 1*8 位 字节： 8 位等于 1 字节 1B _ _ _ _ _ _ _ _ 0000 0000 -128~127

1KB: 1024*B

1MB=1024*1KB

1GB=1024*1MB

1TB=1024*1GB

。。。。

  

2.数据类型

Java 是一门强类型的语言。针对于每一种数据都提供的对应的数据类型。

  

2.1 基本数据类型

  

2.2 引用数据类型

后面专门介绍

1. 类 (class)

2. 接口 (interface)

3. 数组 ([])

  

3.数据类型转换

数据类型转换的依据：取决于数据的取值范围

byte --> short --> int --> long --> float --> double

char[0~65535]

注意： boolean 类型的数据是不能参与类型转换。

   

3.1 自动类型转换

我们将取值范围小的数据保存到取值范围大的数据类型中的时候是可以自动转换类型的。

public class DataTypeConvertDemo{
    public static void main(String[] args){
        // 自动类型转换
        byte by1 = 20;
        int i = by1; // 将 byte 类型的变量赋值给了 int 类型的变量
        System.out.println(i);
    }
}

   

3.2 强制类型转换

我们将取值访问比较大的变量赋值给取值范围比较小的变量，那么此时会出现数据的丢失，所以此时我们需要强制类型转换。

// 强制类型转换
float f1 = 9.9; // 浮点类型 默认的就是 double类型
System.out.println(f1);

  

编译的时候会出现如下的错误。

   

此时为了避免这个错误，我们需要强制类型转换

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

// 强制类型转换
//float f1 = 9.9; // 浮点类型 默认的就是 double类型
//System.out.println(f1);
// 目标类型 变量名 = (目标类型) 被转换的类型;
float f1 = (float)9.9;
// 数据的溢出
short s1 = (short)123456;
// 数据的精度丢失
int i2 = (int)3.3;
System.out.println(f1);
System.out.println(s1);
System.out.println(i2);

   

做数据类型的强制转换的时候会有 数据溢出 和 数据丢失 的可能 . 所以在做数据的强制类型转换的时候一定要谨慎！

  

3.3 类型转换的特例

在 byte 、 short 、 char 在转换的时候系统会帮助我们做一些处理，我们在赋值给 byte，short，char 时，如果赋予的值在对于类型的范围之内，系统会帮助我们自动完成转换，次场景下我们不需要强制内容转换。

// 特例
byte by2 = 100;
//byte by3 = 129;
//short short1 = 32768;
char c1 = 65536;
System.out.println(c1);

   

3.4 byte/short和char转换，都需要强制类型转换

byte 类型和 char 类型转换及 short 类型和 char 类型相互转换都是需要强制类型转换的。

// short和byte类型 同 char类型转换的时候都需要强制类型转换
byte by4 = 120;
char c2 = (char)by4;
System.out.println(c2);
char c3 = 'd';
byte by5 =(byte) c3;
System.out.println(by5);
short s2 = 666;
char c4 = (char)s2;
System.out.println(c4);

   

3.5 表达式类型提升

当表达式运算符两边的类型不一致的时候，结果的类型会自动向高类型转换。

// 表达式类型的提升
double d = 2.67;
int i3 = 50;
int i4 = d + i3; // double 和 int 会提升到 double
System.out.println(i4);

解决方式

int i4 = (int)d + i3; // double 和 int 会提升到 double
int i4 =(int)(d + i3);

   

3.6 byte,short,char之间参与运算

当 byte,short,char 之间参与运算的时候，底层都会转换为 int 类型来计算。

char c5 = 'a';
short s3 = (short)(c5 + 1); // c5 + 1 得到的结果的类型是int
System.out.println(s3);
char c6 = 'A';
byte b6 = 1;
short s4 = (short)(c6 + b6);
System.out.println(s4);

   

3.7 布尔型不能参与运算和转换的

在 Java 中 boolean 是不能参与运算和转换的。

boolean bool1 = false;
System.out.println(bool1 + 1);
short s5 = bool1;

   

3.8 字符串运算的时候拼接

当字符串类型的数据和其他数据做加法运算的时候都是之间拼接的。

String ss = "HelloWorld";
System.out.println(ss + 2.5);
// 20101010
System.out.println(10 + 10 + "10" + 10 + 10);

   

3.9 变量和常量计算的问题

如果表达式是变量组成的，那么我们说讲的特例是不生效的，特例只针对常量。

byte b7 = 20 + 30;
System.out.println(b7);
byte b8 = 30;
short s6 = 50;
byte b10 = (byte)(b8 + s6);
System.out.println(b10);
byte b9 = 10;
byte b11 = (byte)(b8 + b9);
System.out.println(b11);

   

六、运算符

1.算术运算符

+ ， - ， * ， / 、 % 、 ++ 、 --

   

1.1 +号

1. 正数

2. 加号

3. 连接符号

System.out.println(+20); // 表示 正数
System.out.println(3+4); // 两数相加
System.out.println("Hello"+666); // 拼接

   

1.2 - * / %

System.out.println(5-3); // 2
System.out.println(-3); // -3
System.out.println(5*3); // 15
System.out.println(5/3); // 1
System.out.println(5%3); // 2
System.out.println(2%4); // 2
System.out.println(5/(double)3); // 1.666667
System.out.println((double)5/3); // 1.666667

   

1.3 ++/--

++ -- 属于单目运算

++ 表示自增 1

-- 表示自减 1

  

1.3.1单独使用

表示自增或者自减，没有任何的区别。

public static void main(String[] args){
    int a = 10;
    int b = 20;
    // a = 10 b = 20
    System.out.println("a = " + a + " b = " + b);
    //a ++;
    //b --;
    // a = 11 b = 19
    //System.out.println("a = " + a + " b = " + b);
    ++ a ;
    -- b ;
    // a = 11 b = 19
    System.out.println("a = " + a + " b = " + b);
}

  

1.3.2 参与运算

1. 如果 ++ 放在操作数的左边，就表示先自增再参与运算。

2. 如果 ++ 放在操作数的右边，就表示先参与运算然后在自增 1 或者自减 1。

// ++ -- 参与运算
int a1 = 3;
int a2 = 4;
int result = (a1++)/3 + (--a2)*2 -(a1--)%6 + (a2++)*3 - (a2--);
/*
a 3 4 3
b 4 3 4 3
result 3/3 + 3*2 - 4%6 + 3*3 - 4 = 1 + 6 -4 + 9 - 4 =8
*/
System.out.println("a1=" + a1 + " a2="+a2 + " result="+result);

   

1.3.3 课堂练习：

1. int x = 3; int res = (x++)%(++x) 请推断 res 的值，及 x 此时的值。

2. int n = 5; n=++n + ++n 求 n 的值。

3. int n = 3; n= ++n + n ++; 求 n 的值。

   

2.赋值运算符

普通的 =

扩展的 += -+ *= /= %=

public static void main(String[] args){
    // 赋值运算符 这个不是==赋值语句
    int a = 10 ; // 表示将常量10赋值给变量a地址所对应的内存区域中
    a += 3; //等价于a = a + 3
    System.out.println(a);
    a -= 3; // 等价于 a = a - 3;
    System.out.println(a);
}

   

面试题 1: short s1 = 1 ; ? s1 = s1 + 1; 有什么错？

short s1 = 1; s1 += 1; 又有什么错？

short s1 = 1;
//s1 = s1 + 1; // 变量时 特例没有效果 需要强制类型转换 编译报错
s1 += 1; // 使用扩展赋值运算符系统会自动帮助我们强制类型转换 没有问题，能够正常执行
System.out.println(s1);

   

面试题 2 ：如何交换两个数 ?

int x = 10;
int y = 20; // 互换x和y的值

  

解决方案：定义一个中间变量即可。

  

3.关系运算符

> < >= <= != ==

关系运算符得到的结果都是 boolean 类型的数据 (true 和 false) 。

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

   

4.逻辑运算符

连接多个 boolean 类型的表达式。

boolean 类型的表达式 1 boolean 类型的表达式 2 boolean 类型的表达式 3 boolean 类型的表达式4。

  

4.1 安位逻辑运算符

& 按位与

| 按位或

^ 异或

public static void main(String[] args){
    int a = 10;
    int b = 20;
    // 按位 & 都为true 结果 true
    System.out.println((a > b ) & (a < b)) ; // false & true = false
    System.out.println((a < b ) & (a > b)) ; // true & false = false
    System.out.println((a < b ) & (a < b)) ; // true & true = true
    System.out.println((a > b ) & (a > b)) ; // false & false = false
    System.out.println("----------------------------");
    // 按位 | 有true 就为true
    System.out.println((a > b ) | (a < b)) ; // false | true = true
    System.out.println((a < b ) | (a > b)) ; // true | false = true
    System.out.println((a < b ) | (a < b)) ; // true | true = true
    System.out.println((a > b ) | (a > b)) ; // false | false = false
    System.out.println("----------------------------");
    // 按位 异或 相同为false 不同为true
    System.out.println((a > b ) ^ (a < b)) ; // false ^ true = true
    System.out.println((a < b ) ^ (a > b)) ; // true ^ false = true
    System.out.println((a < b ) ^ (a < b)) ; // true ^ true = false
    System.out.println((a > b ) ^ (a > b)) ; // false ^ false = false
}

   

按位符号也会运用在 位运算 ，位运算操作要比普通运算的效率要高很多。

&:有0取0，否则取1
1001 & 0110 = 0
1 0 0 1
& 0 1 1 0
----------
0 0 0 0

|:有1取1，否则取0
1001 | 0110 = 15
1 0 0 1
| 0 1 1 0
----------
1 1 1 1

^:相同为0 不同为1
1001 ^ 0110 = 15
1 0 0 1
^ 0 1 1 0
----------
1 1 1 1

   

4.2 短路逻辑运算符

&& 短路与

|| 短路或者

! 非

& 表示按位与，无论什么情况都会同时计算运算符两边的表达式。

&& 表示短路与，如果前面的表达式为 false ，那么无论后面的表达式结果如何，都不会去计算后面表达式的值。因为后面表达式的值不会影响结果。

同时注意：在实际使用中我们很少使用按位与，更多的是使用短路与。

   

！：取反

当 ! 的个数是奇数个的时候，结果相反。

当 ! 的个数是偶数的时候，结果不变。

   

面试题： & 与 && 的区别

1. & 表示按位与，无论什么情况都会同时计算运算符两边的表达式。

2. && 表示短路与，如果前面的表达式为 false ，那么无论后面的表达式结果如何，都不会去计算后面表达式的值。因为后面表达式的值不会影响结果。

3. && 开发中使用， & 基本不使用。

4. & 常用与位运算操作，效率高。

   

5.位运算符

位运算符：用来计算二进制的运算符

& | ^ ~

<< >> >>> 补码

   

6.条件运算符

条件运算符又称为 三目运算

格式： X ? Y : Z ;

X 表达式必须是 boolean 类型的表达式。

计算流程：

1. 首先计算 X 的值。

2. 如果 X 为 true ，那么整个表达式的结果就是 Y 的值。

3. 如果 X 为 false ，那么整个表达式的结果就是 Z 的值。

   

七、表达式

表达式的定义：符合一定的语法规则的 运算符 和 操作数 的序列。

运算符：算数运算符， 赋值运算符， 关系运算符， 逻辑运算符， 位运算符 ( 了解 )， 三目运算符。

操作数：变量或者常量。

a + b
a * 64 - 3
x ? y : z
(x > y) && (100 > z)

   

表达式的值：整个表达式的结果。

表达式的类型：整个表达式的结果的类型。

   

表达式的优先级：

i < 30 && i%10 !=0

优先级不用去背！！！

   

运算符的优先级：

1. 有括号先计算括号里面的。

2. 单目运算 > 双目运算 > 三目运算。

3. 算数运算符 > 关系运算 > 逻辑运算 > 条件运算 > 赋值运算。

4. 如果优先级相同，从左至右即可。

5. + 、 - > ++ -- !

( ) 可以显著的提高程序的可读性。

   

为了便于查询，以下列出 ASCII 码表：第 128 ～ 255 号为扩展字符（不常用 ）

ASCII 码表

GB2312 中文对 ASCII 的扩展 -- 》 GBK -- 》 GBK18030

BIG5

   

---> ISO( 国际标准化组织 ) ---> UNICODE --> UTF-8(1-4 个字节表示一个字符 )