corejava_day2

目标：

1. 标识符、关键字和类型介绍
2. 如何构建类

---

标识符、关键字和类型介绍；如何构造类

1. 注释

作用：使部分内容只为程序员可见，不为编译器所编译、虚拟机所执行

位置：类声明前后、方法声明前后、属性声明前后、方法体中。几乎可以在一个源文件任意位置，但不能在一个关键字字符中插入注释

类型：

// 从//到本行结束的所有字符均作为注释而被编译器忽略
// text

// 从 /* 到 */ 间的所有字符会被编译器忽略
/* text */

// 从 /** 到 */ 间的所有字符会被编译器忽略。
// 当这类注释出现在任何声明（如类的声明、
// 类的成员变量的声明或者类的成员方法的声明）之前时，
// 会作为JAVADOC文档的内容；
/** text */ 

/**
    @author    类的作者
    @version   类的版本
    @since     从什么时候开始使用的
    @see       另外参照...
    @param     方法的参数
    @return    方法的返回类型
    @exception 方法掏出的异常
 */
 
 例如：
 
 package com.briup.ch02;
 
 /**
  * this is my CommentTest Class    
  * @author bing
  * @version 1.0
  * @since JDK1.8
  * */
  
  public class CommentTest {
      // 表示这个人的名字
      private String name;
      /**
       * this is a age of person
       * */
      private int age;
      
      /**
       * @param name：a name of person
       * @exception null
       * */
      public void setName(String name) {
          this.name = name;
      }
      /**
       * @return 没有返回类型
       * */
      public String getName() {
          return this.name;
      }
      public static void main(String[] agrs) {
          CommentTest ct = new CommentTest();
          ct.setName("Tom");
          String temp = ct.getName();
          System.out.println(temp);
      }
  }

使用javadoc进行编译：

javacdoc -d doc src/CommentTest.java

如果想显示出author和version

javadoc -d doc -author -version src/CommentTest.java

或者

javadoc -d doc -author -version src/*.java

---

2. 标识符

类、方法和变量的名字

1. 由字母、数字、下划线"_"、美元符号"$"组成，第一个字不能是数字
2. 不能是Java中的关键字
3. 大小写敏感
4. 没有长度限制

注：Java中标识符是可以使用中文的，但是一般不推荐这样做

举例：

合法标识符	非法标识符
try1	try#
GROUP_7	7GROUP
openDoor	open-door
boolean1	boolean
_int	int
$int	int

推荐常见的标识符命名规范

1. 类名以大写字母开头 Hello Person Teacher TypeTest
2. 接口名以大写字母开头 Eat Fly
3. 方法名以小写字母开头 say go doSomething
4. 变量名以小写字母开头 name age myName myAge
5. 常量名全部大写，多个单词以"_" 连接 FILE_TYPE PERSON_TITLE

分号、代码块和空格

1. 每个语句短语以分号(;)结束

类的声明最后不需要加;

public class Hello{ 
    ... 
}

方法的声明最后不需要加;

public class Hello {
    public void go() { 
        ...
    }
}

属性的声明最后一定要加;

public class Hello {
    int id;
    private String name;
    public int age;
    
    public void go() {
        ...
    }
}

2. 代码片段用{}括起来

常见的有： 类的声明后加{}、方法的声明后加{}

注意：代码的{}后面都不需要加;

3. 空白处

空格、tab键、换行和回车等是无关要紧不影响代码执行的。

---

3. 关键字

Java语言的关键字是程序代码中的特殊字符。包括：

类和接口的声明：class、extends、implements、interface

包引入和包声明：import、package

数据类型：boolean、byte、char、double、float、int、long、short

某些数据类型的可选值：false、true、null

流程控制：break、case、continue、default、do、else、for、if、return、switch、while

异常处理：catch、finally、throw、throws、try

修饰符：abstract、final、native、private、protected、public、static、synchronized、transient、volatile

操作符：instanceof

创建对象：new

引用：this、super

方法返回类型：void

Java语言的保留字是指预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中可能作为关键字：goto const

所有关键字都是小写，并且程序中标识符不能以关键字命名

---

4. 基本数据类型

Java语言中的数据类型分为基本类型和引用类型

基础类型：float、double、byte、short、int、long、char、boolean

引用类型：类类型、接口类型、数组类型

数据类型本身是描述程序中数据所具备的特点的，同时数据类型也可以用来定义变量，而变量又是用来接收和存储数据的。

所以Java中的变量也只有两大种类：基本类型变量和引用类型变量

计算机中：1字节 = 8位 0000 0001

基本数据类型又可以分为：整型、浮点类型、布尔类型、字符类型

整型：

byte	8	1字节
short	16位	2字节
int	32位	4字节
long	64位	8字节
flaot	32位	4字节
double	64位	8字节
boolean	8位	1字节
char	16位	2字节

注意：Java中采用unicode编码，用两个字节表示一个字符，但是在其他字符编码中可能不是使用两个字节表示一个字符

1. boolean

boolean类型数据的值为true或者false，在JVM中会转换位1或者0

注意：0代表的是false，1代表的是true

例如：

boolean flag = true;
boolean bool = false;

2. char

char是字符，String是字符串

String是类类型，而char是基本数据类型

一个String是由0个或者n个char组成的

2.1 字符编码

Java语言对文本字符采用Unicode编码。由于计算机内存只能存取二进制数据，因此必须为各个字符进行编码。

例如：a --> 编码 --> 0000 0000 0110 0001

2.2 常见的字符编码包括：

a. ASCII

ASCII–Amecian Standard Code for Information Interchange(美国信息交换标准代码). 主用于表达现代英语和其他西欧语言中的字符。它是现今最通用的单字节编码系统，它只用一个字节的7位，一共表示128个字符。

b. ISO-8859-1

又称为Latin-1, 是国际标准化组织(ISO)为西欧语言中的字符制定的编码，用一个字节(8位)来为字符编码，与ASCII字符编码兼容。所谓兼容，是指对于相同的字符，它的ASCII字符编码和ISO-8859-1字符编码相同。

c. GB2312

它包括对简体中文字符的编码，一共收录了7445个字符(6763个汉字+682个其他字符). 它与ASCII字符编码兼容。

d. GBK

对GB2312字符编码的扩展，收录了21886个字符(21003个字符+其它字符), 它与GB2312字符编码兼容。

e. Unicode

由国际Unicode协会编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
UCS(Universal Character Set)是指采用Unicode字符编码的通用字符集。
Unicode具有两种编码方案：
用2个字节(16位)编码，被称为UCS-2, Java语言采用;
用4个字节(32位)编码，被称为UCS-4;

f. UTF

有些操作系统不完全支持16位或32位的Unicode编码，UTF(UCS Transformation Format)字符编码能够把Unicode编码转换为操作系统支持的编码，常见的UTF字符编码包括UTF-8, UTF-7和UTF-16.

2.3 字符编码表

每一种字符编码都有一个字符编码表，例如在Unicode编码表中十六进制的数字6136对应的汉字是愶

例如：

char c = '\u6136';
System.out.println(c);

2.4 char值的形式

Java语言采用Unicode编码，字符占2个字节。

字符a

二进制数据形式为 0000 0000 0110 0001

十六进制数据形式为 0x0061

十进制数据形式为 97

char c = 'a';
// 设定'a'的十六进制数据的Unicode编码
char c = '\u0061';
// 设定'a'的十六进制数据的Unicode编码
char c = 0x0061;
// 设定'a'的十进制数据的Unicode编码
char c = 97;
// 设定'a'的八进制数据的Unicode编码
// 0开头的数字为八进制
char c = 0141;
注意：一个中文汉字就是一个字符
char c = '中';

2.5 转义字符

Java编程人员在给字符变量赋值时，通常直接从键盘输入特定的字符，而不会使用Unicode字符编码，因为很难记住各种字符的Unicode字符编码值。

对于有些特殊字符，比如单引号，如不知道它的Unicode字符编码，直接从键盘输入编译错误：

// 编译出错
char c = ''';

为了解决这个问题，可采用转义字符来表示单引号和其他特殊字符：

char c = '\'';
char c = '\\';

3. 整数类型

byte、short、int和long都是整数类型，并且都是有符号整数（负号）。与有符号整数对应的是无符号整数，两者的区别在于把二进制数转换为十进制整数的方式不一样。

有符号整数把二进制数的首位作为符号数，当首位是0时，对应十进制的正整数，当首位是1时，对应十进制的负整数。对于一个字节(byte)的二进制数，它对应的十进制数的取值范围是-128~127

无符号整数把二进制数的所有位转换位正整数。对于一个字节(byte)的二进制数，它对应的十进制数的取值范围是0~255

在Java语言中，为了区分不同进制的数据，八进制数以"0"开头，十六制以"0x"开头，JDK1.7还支持了二进制的直接表示，0b开头：

例如：

byte b1 = 97; // 十进制
byte b2 = 0141; // 八进制
byte b3 = 0x61; // 十六进制
byte b4 = 0b01100001; // 二进制
// 都是97打印出来
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);

整数类型的默认类型是int，对于给出一个字面值是99的数据，在没有指明这个数是什么具体的类型的情况下，那么Java默认认为是int类型。

例如：

// 编译报错
// a+1中a是byte类型，字面值1没有声明类型，那么默认是int
// byte是8位，int是32位，那么结果是32位的数字
// b只是一个byte类型的变量，那么只能接收8位的数字
// 修改为int b = a+1;就可以编译通过
byte a = 1;
byte b = a+1;

// 编译通过
// 虽然1+1中的1都是默认的int类型
// 但是这个两个1都是固定的字面值
// 编译器可以判断出其结果是否超出了byte表示的范围
// 上面例子中a+1不能判断出结果的原因是：
// a是变量，是有可能发生变化的
byte c = 1+1;

// 编译报错
// 编译器判断出其结果超出了byte的表示范围(-128~127)
byte d = 1+127;

// 编译报错
// 原因：32位的数据赋值给byte类型的变量
// 因为使用的1这些都是字面值，默认是int
// 所以它默认是前面补了24个0
byte e = 0b11111111;

// 编译通过
// 输出结果为255
// 因为1的前面补了24个0
int e = 0b11111111;

// 编译通过
// 输出结果为-1
byte f = (byte)0b11111111;

四种整数类型的声明

byte a1 = 1; (内存中占8位) 1字节
short a2 = 1; (内存中占16位) 2字节
int a3 = 1; (内存中占32位) 4字节
long a4 = 1L; (内存中占64位) 8字节

使用long类型数据的时候后面要加大写L或者小写l，建议加上大写的L，因为小写的1和数字1很相似。

四种整形类型的表示范围

byte 8位 范围：负2的7次方~2的7次方减1

short 16位 范围：负2的15次方~2的15次方减1

int 32位 范围：负2的31次方~2的31次方减1

long 64位 范围：负2的63次方~2的63次方减1

4. 浮点型

float和double都是Java中的浮点型，浮点型可以用来表示小数。

float是32位，1符号位+8指数位+23尾数位

double是64位，1符号位+11指数位+52尾数位

float和double的精度是由尾数的位数来决定的。

浮点数在内存中是按科学计算法来存储的。

float的精度为7位左右有效数字

double的精度为16位左右有效数字

两种浮点型数据的声明

// 后面加f或者F
float f = 10.5f;
// 后面加d或者D
double d = 10.5d;

浮点型的二进制形式

参考样例：

float f = 10.5f;
int b = Float.floatToIntBits(f);
System.out.println(Integer.toBinaryString(b));

浮点型的默认类型是double，对于给出一个字面值是10.8的数据，在没有指明这个数据是什么具体的类型的情况下，那么Java默认认为是double类型。

例如：

// 编译通过
// 字面值1.5默认类型是double
double d = 1.5;

// 编译报错
// 字面值1.5默认类型是double
// double和float的精确度不一样
float f = 1.5;

// f2编译通过，因为字面值1的类型是int
// f3编译报错，因为字面值1.5的类型是double
float f1 = 10.5f;
float f2 = f1+1;
flaot d3 = f1+1.5;

浮点型的精度丢失

例如：

System.out.println(1.0-0.66); // 0.33999999999999997

Java中的简单浮点数类型float和double不能够进行精确运算，因为大多数情况下是正常的，但是偶尔会出现如上所示的问题。这个问题其实不是Java的bug，因为计算机本身是二进制的，而浮点数实际上只是个近似值，所以从二进制转化为十进制浮点数时，精度容易丢失，导致精度下降。

要保证精度就要使用BigDecimal类，而且不能直接从double直接转BigDecimal，要将double转String再转BigDecimal。也就是不能使用BigDecimal(double val)方法，而是需要使BigDecimal(String val)方法。

例如：

BigDecimal d1 = new BigDecimal("1.0");
BigDecimal d2 = new BigDecimal("0.66");
double result = d1.subtract(d2).doubleValue();
System.out.println(result); // 0.34

---

5. 变量的声明和赋值

Java中的任意类型可以用来声明变量，包含八个基本类型和三个引用类型

// 变量的声明
int x;
// 声明多个类型相同的变量
int x,y;
相当于
int x;
int y;
// 先声明变量
// 再给变量赋值
int x;
x = 10;
// 声明变量的同时就赋值
int x = 10;

思考：变量在程序中的作用是什么？

变量的主要作用，就是用来存储信息，然后在计算机程序中使用这些信息。

---

6. 理解对象

Java是面向对象的编程语言(OOP)，面向对象的开发方法把软件系统看成各种对象的集合，这种方法也是接近人的自然思维方式。

世界上万事万物实在太多了，不能一概而论，所以要解决一个问题，必须是要把事物限定到一定的范围之内，那么这个范围就是我们要解决则之中，而不是针对全世界所有中学的教师管理规则。

对象是对问题领域中事物的抽象。对象具有以下特性：

1. 万物皆为对象。问题领域中的实体和概念都可以抽象为对象。例如学生、成绩单、教师、课和教室。
2. 每个对象都是唯一的。正如世界上不存在一模一样的树叶。
3. 对象具有属性和行为。

例如：

小张，性别女，年龄22，身高1.6m，体重40kg，能够学习，唱歌。
小张的属性包括姓名、性别、年龄、身高和体重
小张的行为包括学习、唱歌。

4. 对象具有状态。状态是指对象在某个时刻的属性取值。对象的某些行为会改变对象自身的状态。

例如：

小张本来体重为40kg，经为减肥后，体重减到35kg。

肥胖状态：40kg --> 减肥行为 --> 35kg

5. 每个对象都是某个类的实例

例如：

小张和小王都属于学生类的实例

中国和美国都属于国家类的实例

中文和英文都属于语言类的实例

类是具有相同属性和行为的对象的集合。

同一个类的所有实例（对象）都有相同属性名，但属性的取值不一定相同，例如：

小张和小王都属于学生类，都有姓名、性别、年龄、身高和体重这些属性，但是他们的这些属性取值都可能不同。

同一个类的所有实例（对象）都有相同行为，意味着它们具有一些相同的功能。

例如：

小张和小王都属于学生类，他们都能学习以及能唱歌

6. Java中的对象其实就是堆区中的一块内存空间

JVM管理的内存，被划分为了若干区域，其中有一个被称为堆区，Java运行过程生产的所有对象几乎都会在堆区中

垃圾回收器(gc)的工作主要也就是把堆区中把不再被使用的内存（也就是对象）进行回收。

new关键字就是向JVM申请内存空间以便接下来创建对象，这块内存地址就是所创建对象的内存地址，通过改地址也是内存中找到该对象的唯一方式。

---

7. 定义类

1. 分析学生都具备哪些特点以及行为

学生都有学号、姓名、性别

学生都可以说话、学习、跑步

2. 把学生这一群体抽象位一个Java类：Student

所以一个Java类是对某一类事物的整体描述

Student类是对整体学生的描述

3. 把学生的“特点”抽象为Student类中的“属性”

所以只要是属于这个Student类的对象都具有这些属性

4. 把学生的“行为”抽象为Student类中的“方法”

所以只要是属于这个Student类的对象都具有这些方法
5. 如果有需要，可以在类中添加对于的构造器，以便我们在创建对象的时候给对象的属性赋值，如果不添加构造器那么JVM会自动帮我们在类中添加一个无参构造器

定义一个学生类：Student

public class Student {
    // 属性
    public long id;
    public String name;
    public char gender;
    
    // 方法
    public void say() {
        System.out.println("I can say..");
    }
    public void study() {
        System.out.println("I can study..");
    }
    public void run() {
        System.out.println("I can run..");
    }
    
    // 无参构造器 创建对象的时候使用
    public Student() {}
    // 有参构造器 创建对象的时候使用
    public Student() {
        this.id = id;
        this.name = name;
        this.gender = gender;
    }
}

---

8. 创建类的实例

在Java代码中，需要把类进行实例化得到该类的对象后，再使用对象去访问对象中的属性以及调用到对象中的方法

形式：

对象.对象中的属性
对象.对象中的方法()
对象.对象中的方法(参数)
注1：首先要使用类进行实例化创建出这个对象
注2：对象调用方法时一定有小括号，对象访问属性时一定没有小括号

类中的属性和方法一般清空是不能直接使用的，类中的代码知识提供了一个创建对象的模版，根据这个模板创建出的对象才可以使用。

所以类只是创建对象的模板，对象才是调用方法、执行代码、完成功能这个过程中的关键点。

注意：类A中有什么属性和方案，那么该类的对象中就有什么属性和方法，因为该对象是根据类A这个模版创建出来的。

根据上面所编写的Student类，进行类的实例化，也就是创建对象。

1. 使用new+类中构造器 的形式创建出该类的对象

new Student();

或者

new Student(1L,"tom",'男');

这种方式可以直接给对象中属性赋值

2. 为了方便进一步使用这个对象，需要使用变量去接收这个对象

Student s = new Student();

Java是强类型编程语言，数据是什么类型的，那么接收数据的变量类型也要与之对象

3. 接下来可以使用对象方法其属性，也可以调用其方法

Student s = new Student();
// 对象访问其属性并且给该属性赋值
s.id = 2L;
s.name = "zhangsan";
s.gender = 'm';
// 打印出对象中的属性值
System.out.println("id：" + s.id);
System.out.println("name：" + s.name);
System.out.println("gender：" + s.gender);
// 对象调用其方式
s.say();
s.study();
s.run();

---

9. 基本类型变量和引用类型变量的区别

1. 基本类型变量指的是使用byte、short、int、long、float、double、boolean、char这八种类型声明出来的变量
2. 引用类型变量指的是使用任意一个类、任意一个接口、任意以恶搞数组所声明出来的变量
3. 基本类型的数据是一种比较简单的数据，不能包含其他类型的数据，也不能调用任何方法
4. 对象是一种比较复杂的数据，可以包含其他类型的数据，也可以调用方法

例如：对象s中包含了其他三个不同类型的数据

Student s = new Student(1L,“tom”,‘男’);

5. 基本类型变量接收的只能是一些比较简单的数据(8/16/32/64位)
6. 引用类型变量接收的只能是对象

Student s = new Student();

引用类型的变量可以简称为 引用

简称：引用 “指向” 对象

例如：

// 使用x不能访问任何属性也不能调用任何方法
int x = 1;
Student s = new Student();
// 使用s可以访问对象中的属性
s.name = "tom";
// 也可以调用对象中的方法
s.run();