第二章 Java基础

第一节：关键字

1. 第一个Java程序

• 编写程序框架(类)

  public class Test{}

• 编写main()方法的框架

  • 主程序入口

  • 一个程序只能有一个main()方法

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

• 

public class Test {
     public static void main(String[]args)
       {
        System.out.println("Hello Word！");  //控制台输出 Hello Word！
         }
 }

2. 概念

类名，变量名，方法名都被称为关键字。

常用的关键字如下图示：

            

3. 注意点

• 所有的标识符都应该以字母（A-Z或者a-z），美元符号（$）,下划线（_）开始

• 首字母之后可以是字母（A-Z或者a-z），美元符号（$）,下划线（_）或数字的任何字符组合

• 辅助记忆口诀：字下美人

• 不能使用关键字作为变量名或方法名

• 标识符是大小写敏感的

• 合法的标识符举例：age $salary _value......

• 非法标识符举例：123abc -salary #abc......

public static void main(String[]ages){
    String name = "张三";
    String name1 = "李四";
    System.out.print(name);    //控制台输出张三
    System.out.print(name1);   //控制台输出李四
}

第二节：数据类型

1. 强类型语言

要求变量的使用要严格符合规定，所有变量都必须先定义才能使用

2. 弱类型语言

• 基本类型：（primitive type）

• 引用类型：（reference type）

//整型
int num1 = 10;
byte num2 = 20;
short num3 = 30;
long num4 = 40L; //Long类型要在数字后加个L

//整数拓展:进制 二进制(0b~)  八进制(0~)  十进制  十六进制(0x~)
int i1 = 10;
int i2 = 010;
int i3 = 0x10; //0~9 A~F
int i4 = 0x11;
System.out.print(i1); //输出 10
System.out.print(i2); //输出 8
System.out.print(i3); //输出 16
System.out.print(i4); //输出 17


//浮点型
float num5 = 44.6F; //float类型要在数字后面加个F
double num6 = 3.141592653589;

//浮点型拓展 银行业务怎么表示钱？
/*
使用 BigDecimal 数学工具类
------------------------
eg1: 
float f1 = 232233333f;
float f2 = f1 +1;
System.out.print(f1 == f2); //输出true

eg2:
 float f1 = 0.1f;
 double f2 = 1.0/10;
 System.out.print(f1 == f2); 输出结果： false

float 有限 离散 舍入误差 大约 接近但不等于
注意：最好不要完全使用浮点型进行比较

*/

//字符
char sex = '男';

//字符拓展 :
        //1.所有的字符本质就是数字
        char s1 = 'a';
        char s2 = '中';
        System.out.println(s1); //输出 a
        System.out.println((int)s1); //输出 97 强制类型转换
        System.out.println(s2); //输出 中
        System.out.println((int)s2); //输出 20013 强制类型转换

        System.out.println("-------------------------------------");
        //2. 编码问题 unicode：可以处理各种语言的文字 占2个字节 (0~65532个字节)
        //eg: 97代表 a  65代表 A
        //转义
        char s3 = '\u0061';
        System.out.println(s3); //输出 a

        System.out.println("-------------------------------------");
        //转义符
        /*
        \t 空格
        \n 换行
         */
        System.out.println("你好\t哈哈");
        System.out.println("你好\n哈哈");

//字符串
String name = "张三"; //注意：String不是基本数据类型，属于引用类型。是类。

//布尔类型
boolean flag = true;
boolean flag2 = false;

第三节：类型转换

由于Java是强类型语言，所以要进行有些运算时需要用到类型转换

              

1. 强制转换

由 高 ---> 低进行转换

语法 ：（数据类型）表达式；

int a = 128;
byte b = (byte)a;
System.out.println(a); //输出 128
System.out.println(b); //输出 -128 会引发内存溢出问题

2. 自动类型转换

由 低 ---> 高进行转换

int a = 10;
double b = a;
System.out.println(a);//输出 10
System.out.println(b);//输出 10.0

注意点：

1. 不能对布尔值进行转换；

2. 不能把对象类型转换为不相干的类型；

3. 在将高容量转换到低容量时，进行强制类型转换；

4. 在转换时可能存在内存溢出问题，或者损失精度问题。

System.out.println((int)23.4); //输出 23
System.out.println((int)-44.56f); //输出 -44

char c = 'a';
int d = a + 1;
System.out.println(d); //输出 98 自动转换
System.out.println((char)d); //输出 b 强制转换 

//当操作比较大额的数时，注意内存溢出问题
//JDK7新特性：数字之间可以使用下划线分割
int money = 10_0000_0000;
int years = 20;
int total = money * years;
 System.out.println(total); //输出 -1474836480
//如何解决？
long total2 = money*((long)years); //先把一个数据转换为long类型
System.out.println(total2); //输出 20000000000

第四节：变量

1. 概念

• 可以变化的量

• Java是强类型语言，每一个变量都必须声明类型

• Java变量是存储数据的一个基本单元

• 例：

2. 变量声明及使用

• 声明变量，给变量命名

  • 语法： 数据类型 变量名；

• 给变量赋值 （将数据存储至对应的内存空间）

  • 语法：变量名 = 值；

• 整合语法：数据类型 变量名 = 值；

• 调用变量

3. 变量命名规则

遵循驼峰命名法,见名知意原则

序号	条件	合法变量名	非法变量名
1	变量必须以字母（A-Z或者a-z），美元符号（$）,下划线（_）开始	_myCar	*myName
2	变量可以包括数字，但不能以数字开头	score1	1_Age
3	除了"_"和""符号以外，变量名不能包含任何特殊符号 | mySchool	my_Name	a+b
4	不能使用Java关键字，如 int，class，public 等	myName1_1	My Sex

常见错误：

1. 变量未赋值先使用

2. 使用非法变量名

3. 变量重名

4. 变量作用域

• 类变量

• 实例变量

• 局部变量

public class Admin{
    static int age = 10; //类变量
    String name = "李四"; //实例变量
    //实例变量：从属于对象，如果不进行初始化，会直接调用默认值
    //布尔值 ：默认是false
    //除了基本数据类型，其余的默认值都为"null"
    public void method(){
        //局部变量
        //必须声明和赋初始值
        int count = 0; 
    }
}

5. 常量

1. 固定不变的值

2. 常量（constant）：初始化（initialize）后不能再改变值！

3. 常量名一般使用大写

4. 语法

final 数据类型 常量名 = 值；
//示例
final double SCORE = 86.5;

第五节：运算符

1. 算术运算符

• （ + ） 加

• （ - ） 减

• （ * ） 乘

• （ / ） 除

• （ % ） 取模

• （ ++ ）自增

• （ -- ） 自减

 //二元运算符
int a = 10;
int b = 20;
int c = 25;
int d = 25;
System.out.println(a+b); //输出 30
System.out.println(a-b); //输出 -10
System.out.println(a*b); //输出 200
System.out.println(a/(double)b); //输出 0.5

long a = 1231231231231L;
int b = 123;
short c = 10;
byte d = 8;
System.out.println(a+b+c+d); //当有多个参数中，有一个数为long，那么结果集为long类型
System.out.println(b+c+d); //int
System.out.println(c+d); //int

// % 取余/模运算
int a = 10;
int b = 22;
System.out.println(b % a);  //输出 余数2

// ++ 自增  -- 自减  一元运算符
int a = 3;
int b = a++;  //执行完这行代码后，先给b赋值，再自增
// a=a+1
System.out.println(a);
// a=a+1
int c = ++a;  //执行完这行代码前，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);

//幂运算拓展：使用工具类来操作
double pow = Math.pow(2,3);
System.out.println(pow);

2. 赋值运算符

• ( = ) 赋值

//把右边的值赋值个左边的变量 
int b = 123;
short c = 10;

3. 关系运算符

• （ > ）大于

• （< ）小于

• （ >= ）大于等于

• （ <= ）小于等于

• （ == ）等于等于

• （ != ） 不等于

//关系运算符返回的结果：布尔类型（true/false）
int a = 10;
int b = 20;
System.out.println(a == b); //输出 false
System.out.println(a > b);  //输出 false
System.out.println(a < b);  //输出 true
System.out.println(a != b); //输出 true

4. 逻辑运算符

• （ && ）与 and

• （ || ）或 or

• （ ！） 非/取反 not

boolean a = true;
boolean b = false;
System.out.println(a && b); //逻辑与：当两个变量都为true，结果才为true;反之为false
System.out.println(a || b); //逻辑或：当两个变量有一个为true，结果就为true
System.out.println(!(a && b)); //取反：结果为true，则变为false;结果为false，则变为true

5. 位运算符

• ( & ) 按位与

按位与的运算规则

操作数1	0	0	1	1
操作数2	0	1	0	1
按位与	0	0	0	1

规则总结：只有两个操作数对应位同为1时，结果为1，其余全为0. （或者是只要有一个操作数为0，结果就为0）。

• ( | ) 按位非

按位或的运算规则

操作数1	0	0	1	1
操作数2	0	1	0	1
按位或	0	1	1	1

规则总结：只有两个操作数对应位同为0时，结果为0，其余全为1.（或者是只要有一个操作数为1，结果就为1）。

• ( ^ ) 按位异或

按位异或的运算规则

操作数1	0	0	1	1
操作数2	0	1	0	1
按位异或	0	1	1	0

规则总结：异：1.

• ( ~ ) 按位异或

按位非的运算规则

操作数	0	1
按位或	1	0

在求负数的源码中使用过。

• ( >> ) 按右移

将一个整数的二进制位向右平移指定的位数，由于是右移就相当于是缩小了数值，并且每移动一位，相当于缩小了二倍。

①移出的低位将被丢弃

②若为正数，高位补0

③若为负数，高位补1

//eg:
System.out.println(24>>2); //输出 6
System.out.println(16>>4); //输出 1

• ( << ) 按左移

将一个整数的二进制位向左平移指定的位数，由于是左移就相当于是扩大了数值，并且每移动一位，相当于扩大了二倍。

①移出的高位将被丢弃

②右侧补零

//eg:
System.out.println(6<<3);  //输出 48
System.out.println(16<<2); //输出 64

                          

• ( >>> ) 无符号右移,高位补0

低位溢出，高位补0。

注意，无符号右移（>>>）中的符号位（最高位）也跟着变，无符号的意思是将符号位当作数字位看待。如：-1>>>1结果为2147483647。这个数字应该比较熟悉，看两个输出语句就知道是什么了：

System.out.println(Integer.toBinaryString(-1>>>1));

System.out.println(Integer.toBinaryString(Integer.MAX_VALUE));

//输出结果为：
//1111111111111111111111111111111
//1111111111111111111111111111111

6. 三元运算符

用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行。

语法：

(条件表达式) ? 表达式1 : 表达式2；

运算规则：

a) 判断条件表达式，结果为一个布尔值。

b) true，运算结果为表达式1

c) false，运算结果为表达式2

int score = 92;
String type = (score >= 90) ? "优秀" : "不优秀";
System.out.println(type); //输出 优秀

7. 赋值运算符

• （+=）

• （-=）

• （*/）

• （/=）

int a = 10;
int b =20;
a+=b; //a=a+b
a-=b; //a = a-b
System.out.println(a); //输出 10

//字符串拼接拓展：
System.out.println(a+b);  //输出 30
System.out.println(""+a+b); //输出 1020 若字符串在前，则会拼接
System.out.println(a+b+""); //输出 30   若字符串在后，则会运算

8. 优先级

                   

第六节：包机制

• 为了更好的组织类，Java提供了包机制，用于***区别类名的命名空间

• 包机制的语法格式

package pkg1[.pkg2[.pkg3_]];

• 一般利用公司域名倒置作为包名；

• 为了能够使用某一个包，需要在Java中导入该包，关键字为“import”

import package1[.package2].(className | *);

第七节：JavaDoc

• JavaDoc命令是用来生成自己API文档的

• 参数信息

  • @author 作者名

  • @version 版本号

  • @since 指明需要最早使用的jdk版本

  • @param 参数名

  • return 返回值情况

  • @throws 异常抛出情况

• 如何生成JavaDoc文档？

//1.通过Doc命令生成JavaDoc文档
//javadoc -encoding UTF-8 -charset UTF-8 Doc.java

//2.通过IDEA软件生成JavaDoc文档
//找到工具栏tools --> Gencrate JavaDoc…打开