JAVA_chap02

第二章： Identifiers, Keywords and Types(40-63)

目标： 1. 标识符、关键字和类型介绍；

           2. 如何构建类?

------------------------------------------------------------

java.lang.Object 是所有java类的父类

1. 注释

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

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

类型：

1) 单行注释：

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

2) 多行注释：

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

/**/多行注释，可以出现在任意位置(包括[]的内部),但是不能出现在关键字的中间e.g main—>ma/*test*/in 这是不允许的。

3) 文档注释：

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

                            javadoc-d doc src/CommonTest.java

                            javadoc:生成文档命令

                            －d: 后面跟的内容 表示将来生成的文档位于路径

                            doc:生成的文档位于doc目录中

                            src/CommonTest.java编译的源文件的路径

                            如果想要生成的文档包含author和version需要

                            在javadoc 命令后面添加-version-author选项

                            需要注意该选项不能紧跟在-d后面 －d只能制定路径

                            @version和@author不能位于方法之上,只能位于

                            class的外面

2. 分号

1) 每个语句短语以;结束 ;

2) 代码段以{}结束;所有的逻辑语句必须出现在{}中间

3) 空白处（空格、tab键、新行和回车（几个语句短语连接在一起））是无关紧要的。

3. 标识符：类、方法和变量的名字

1) java标识符以字母、_和$开头，不能以数字开头，后跟字母、数字、“_”和“$”的组合;

2) 大小写敏感

3) 没有长度限制。

 

                 举例：  合法标识符                               非法标识符

                         try                      try#

                         GROUP_7               7GROUP

                         openDoor               open-door

                         boolean1               boolean

4. 关键字

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

       . 类和接口的声明——class, extends, implements(实现), interface

       . 包引入和包声明——import, package

       . 数据类型——boolean布尔, byte, short, char, int,float, long, double

       . 某些数据类型的可选值——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的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中.

         java中的 native 修饰符表示被修饰的方法由本地语言(C)实现

                   例如:java.lang.System.gc() 这个方法。

                        native hashCode()

                   它就是一个用 native修饰的方法：

                   publicstatic native void arraycopy（）

                   简单地说就是防止编译器对代码进行优化.( volatile)

                   对外部硬件而言，上述四条语句分别表示不同的操作，会产生四种不同的动作，但是编译器却会对上述四条语句进行优化，认为只有XBYTE[2]=0x58（即忽略前三条语句，只产生一条机器代码）。

                   如果键入volatile，则编译器会逐一的进行编译并产生相应的机器代码（产生四条代码）.

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

                . 所有关键字都是小写；

        . friendly, sizeof不是Java语言的关键字，这有别于C++；

         . 程序中标识符不能以关键字命名；

5. 基本类型：

程序的基本功能是处理数据

程序用变量来表示数据；

程序中必须能使用；

   定义变量是指设定变量的数据类型和变量的名字，定义变量的基本语法为：

                 数据类型  变量名；

                 Java语言把数据类型分为基本类型和引用类型。

                ------------------------------------------------------------

                 基本类型         数值类型         浮点数类型        

                   默认带有小数的数据类型是double

                   e.gint i = 10.0 此时10.0是double类型需要

                       转换类型 int i =(int)10.0 

                       float f = 10.0 此时10.0是double类型需要

                       转换类型 float f= (float)10.0或者

                        floatf = 10.0f   

                            boolean类型的取值只能是true或者false

                   位数

                   boolean 布尔类型

                   byte(8位)<short=char(16位)<int=float(32位)< long = double (64位)

                   窄范围转换成宽范围,自动转换

                   宽范围转换成窄范围,需要强制类型转换

                 ------------------------------------------------------------   

                 引用类型         引用             类类型

                                                  接口类型

                                                  数组类型

6. boolean类型

位置                                               boolean类型变量取值  

------------------------------------------------------------  

Java源程序             只能是true或false

class文件              用int或byte表示boolean 0 非0

虚拟机中               用整数0来表示false, 有任意一个非零整数表true

强调，在Java源程序中不允许把整数或null赋给boolean类型的变量，这是有别于其它语言(如c语言)的地方. 例：

                 boolean isMarried = 0;          //编译出错，提示类型不匹配

                 boolean isMarried = null;       //编译出错，提示类型不匹配

类型转换

                   char—>int  直接转换

                   e.g

                   chara = ‘a’ int i = a   此时i的值就是a字母对应的是十进制的值

但是 如果String—>int 不能直接转换  需要使用Integer.parseInt(String)方法进行转换

         即使使用方法转换成功,如果String本来对应的值就不是数字类型,转换过去也不是数字类型

字符串拼接：java中字符串都可以使用+进行拼接,不能使用－来构建新的字符串

                 String、StringBuffer与StringBuilder之间区别

                   1.三者在执行速度方面的比较：StringBuilder>  StringBuffer  > String

　　                   3.StringBuilder与StringBuffer

　　　　                            StringBuilder：线程非安全的

　　　　                            StringBuffer：线程安全的

            对于三者使用的总结：

                           1.如果要操作少量的数据用 =String

　　　　　　　　　　        2.单线程操作字符串缓冲区下操作大量数据 = StringBuilder

                            3.多线程操作字符串缓冲区下操作大量数据 = StringBuffer

7. 文本数据类型——char和String

1) 字符编码

Java语言对文本字符采用Unicode字符编码。由于计算机内存只能存取二进制数据，因此必须为各个字符进行编码。所谓字符编码，是指用一串二进制数据来表示特定的字符。常见的字符编码包括：

a. ASCII字符编码

    一个字节的7位，一共表示128个字符。

d. GBK字符编码 windows系统

e. Unicode字符编码：

                       Unicode具有两种编码方案：

                       . 用2个字节(16位)编码，被称为UCS-2,Java语言采用;

                       . 用4个字节(32位)编码，被称为UCS-4;

f. UTF字符编码 unix操作系统使用

常见的UTF字符编码包括UTF-8,UTF-7和UTF-16.

2) char的几种可能取值

                    Java语言采用UCS-2字符编码，字符占2个字节(1个字节8位)

                    字符a的二进制数据形式为0000 0000 0110 0001

                         十六进制数据形式为0x0061

                           十进制数据形式为 97

以下4种赋值方式是等价的：

char c = 'a';

char c = '\u0061';      //设定"a"的十六进制数据的Unicode字符编码

char c = 0x0061;        //设定"a"的十六进制数据的Unicode字符编码

char c = 97;            //设定"a"的十进制数据的Unicode字符编码

3) 转义字符

    转义字符以反斜杠开头，常用转义字符：

                    \n           换行符，将光标定位到下一行的开头；

                    \t           垂直制表符，将光标移到下一个制表符的位置；

                    \\           反斜杠字符

                    \'           单引号字符

8. 整数类型

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

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

源码第一位是符号位其他位是真值位 可以求出具体十进制的二进制表达式

反码源码除去符号位保留不变其他位按位取反获得的二进制表达式

补码反码+1得到的二进制表达式

内存中按照补吗进行保存

正数源码反码补码相同

负数源码—>取反(反码)+1—>补码

byte b = (byte)129;

按照数字推算出的二进制表达形式是源码 

                       无符号:0~~~255

                       0000 0000~~~~~1111 1111

    .无符号整数把二进制数的所有位转换为正整数。对于一个字节的二进制数, 它对应的十进制数的取值范围是0 - 255。

在Java语言中，为了区分不同进制的数据，八进制数以“0”开头，十六制以“0x”开头。

                       二进制转十进制

                      Integer.valueOf("0101",2).toString()

                       另外还有

                       十进制转成十六进制：

                       Integer.toHexString(int i)

                       十进制转成八进制

                       Integer.toOctalString(int i)

                       十进制转成二进制

                       Integer.toBinaryString(int i)

                       十六进制转成十进制

                      Integer.valueOf("FFFF",16).toString()

                       八进制转成十进制

                       Integer.valueOf("876",8).toString()

     如果一个整数值在某种整数类型的取值范围内，就可以把它直接赋给这种类型的变量，否则必须进行强制类型的转换。

        long var = 100L;         //整数100后面加上大写的后缀"L"，表示long型整数；

9. 浮点类型

浮点类型表示有小数部分的数字。Java中有两种浮点类型：

        . float: 占4个字节，共32位，称为单精度浮点数;

        . double: 占8个字节，共64位，称为双精度浮点数；

         双精度比单精度表示的位数大精确的位数多,简单地说, float表示的小数点位数少,double能表示的小数点位数多!

         在默认情况下，小数及采用十进制科学计数法表示的数字都是double类型，可以把它直接赋值给double类型变量。默认情况下,如果直接构建带有小数的数字,表示的是double类型

float接受需要进行强制类型转换.

                   e.gfloat f = (float)10.0;

    如果把double类型的数据直接赋给float类型变量，有可能会造成精度的丢失，因此必须进行强制类型的转换，否则会导致编译错误，例如：

loat f1 = 1.0                   //编译错误，必须进行强制类型转换；

引用类型

                  Student student = new Student();

                     该表达式在内存中分为两步走

                     Student student; 在栈区的构建

                     newStudent();在堆区的构建

                     =:栈区的引用指向堆区的地址

创建对象类型  对象的引用(任意指定)  ＝ new(创建) 对象的构造方法:真正创建对象

                     无参数的构造方法，类自动构建

                     对象的引用.属性 可以调用属性(赋值 取值)

                     对象的引用.方法 可以调用方法(处理数据)

                     对象构建:通过使用new 可以构建对象.new 对象的构造方法

public void setName(String name) {

         this.name= name;

}

如果方法参数中包含的变量名称和当前类中的变量名称相同时

需要使用this.name = name 来给当前类中的变量赋值

this.name:表示当前类中name属性

name:表示当前方法中的name属性

如果方法参数中包含的变量名称和当前类中的变量名称不相同

时,可以直接进行赋值操作,不需要使用this关键字.

e.g public void setName(String name2) {

         name= name2;

    }

this:表示当前类对象

如果对象的构造方法有参数,new的对象必须和构造方法的参数类型一样.

构造方法:必须public修饰没有返回类型方法名必须和当前类名称相同

         参数可有可无.没参数称之为无参构造器,如果类中有参数,并且构造方法的参数和类中的参数一模一样(数量，类型)此时构造器称之为全参构造器(构造方法)

                    e.g

                           class Student {

                              String name;

                            int age;

                              //构造方法

                          public Student() {}

                           public Student(String name,int age) {

                                         this.name =name;

                                     this.age= age;

                           }

                           }

                            Studentstudent  = new Student();

10. 变量的申明和赋值

                   finalpublic static int MAX_ROW = 100;

                  final修饰变量都是不可改变的称之为常量

                   static修饰变量一开始就被加载到内存,不依赖当前类,称之为静态变量

                   同时final和static修饰的变量称之为静态常量

       

程序的基本功能是处理数据

       程序用变量来表示数据；

       程序中必须先定义变量才能使用；

       定义变量是指设定变量的数据类型和变量的名字，定义变量的基本语法为：

                  数据类型  变量名；

                  Java语言要求变量遵循先定义，再初始化，然后使用的规则。变量的初始化是指自从变量定义以后，首次给它赋初始值的过程。例：

 

                  int a;          //定义变量a

                  a = 1;          //初始化变量a

                  a++;            //使用变量a

                  int b=a;        //定义变量b, 初始化变量b, 使用变量a;

                  b++;            //使用变量b

11. 推荐命名规则

                  1) 类名以大写字母开头；

                  2) 接口名以大写字母开头；

                  3) 方法名以小写字母开头；

                  4) 变量名以小写字母开头；

                  5) 常量名全部大写，多个单词以"_"连接；

                     

12. 理解对象

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

同一个类的所有实例都有相同属性，但属性取值不一,事实上相同，但是它们的状态不一定相同。同一个类的所有实例都有相同行为，意味着它们具有一些相同的功能。

13. 创建类

类是一组具有相同属性和行为对象的模板。面向对象编程的主要任务就是定义对象模型中的各个类。

                  package sample;

                 public class Teacher {

                      /**attributes of ateacher*/

                      private String name;

                      private int age;

                      private double salary;

                     

                       /** Creates a new instance of Teacher*/

                      public Teacher(Stringname, int age, double salary) {

                          this.salary = salary;

                          this.age = age;

                          this.name = name;

                      }

                      /**operations onproperties */

                      /** get the name of thisteacher */

                      public String getName() {return name; }

                      /**get the salary of thisteacher */

                      public double getSalary(){ return salary; }

                      /**get the age of teacherteacher */

                      public int getAge() {return age; }

                      ……

                  }

 

                  代码解析：

 

                            publicString toString() {

                                     return“name:”+name+” age:”+age+” gender:“+gender;

                            }

                            toString方法:返回用户指定输出的字符串格式

                            可以使用class引用.toString()调用

                            如果直接写class引用实际也是调用toString()方法.

                            即使没有构建toString(),class引用默认也是调用toString()方法.

默认的toString()方法输出当前对象位于的内存地址

                            如果自己构建toString()方法,执行自己的toString()方法

                            如果自己没有构建toString()方法,执行系统自带的默认toString()方法.

                            关键字this:表示当前类本身,输出toString()方法

1) package sample;

    包声明语句，将Java类放到特定的包中，便于类的组织、权限访问和区分名字相同的类。

2) public class Teacher {...}

    类的声明语句，类名为Teacher, public修饰符意味着这个类可以被公开访问；

    声明类的格式：

                     class 类名 {

                         类内容

                     }

3) private String name;

    类的属性(也称为成员变量)的声明语句；Teacher类有一个name属性，字符串类型，private修饰符意味着这个属性不能被公开访问。只能在当前类使用。

4) public String getName() { return name; }

    方法的声明语句和方法体。方法名为getName，不带参数，String表明返回类型为String。public表明这个方法可以被公开访问。getName后紧跟的大括号为方法体，代表getName的具体实现。

声明方法的格式：

                     修饰符 返回值类型 方法名 (参数列表) {

                         方法体

                     }

    返回值类型是方法的返回数据的类型, 如果返回值类型为void, 表示没有返回值。

       方法名是任意合法的标识符;

       参数列表可包含零个或多个参数，参数之间以逗号","分开。

       方法体每个语句用";"结束；

       方法体中使用return语句返回数据或结束本方法的执行；

14. 创建实例

                  public static voidmain(String[] args) {

                          Teacher gzhu = newTeacher("George Zhu", 30, 10000);

                         System.out.println("Teacher: " + gzhu.getName());

                         System.out.println("\tAge: " + gzhu.getAge());

                         System.out.println("\tSalary: " + gzhu.getSalary());

                  }

main()方法是Java应用程序的入口点，每个Java应用程序都是从main()方法开始运行的。作为程序入口的main()方法必须同时符合以下几个条件：

       . 用public static修饰；

       . 返回类型为void;

       . 方法名为main;

       . 参数类型为String[];

       包含main方法的类又叫主程序类。

类创建好之后，通过new关键字创建具体对象。它有以下作用：

       . 为对象分配内存空间，将对象的实例变量自动初始化为其变量类型的默认值；

       . 如实例变量显示初始化，将初始化值赋给实例变量；

       . 调用构造方法；

       . 返回对象的引用；

                 Student student(对象引用) = newStudent()(创建对象);

                   获得对象student后,可以使用student.name来获取student中的name属性.

                   获取属性:class引用.属性名

                   获取方法:class引用.方法名

注：结合实例，并画内存分配图讲解。

15. 基本类型和引用类型的区别    

      1) 基本类型代表简单的数据类型，比如整数和字符。引用类型代表复杂数据类型，引用类型所引用的实例包括操纵这种数据类型的行为。通过"."运算符，就能访问引用变量所引用的实例的方法.

      2) 基本类型Java虚拟机会为其分配数据类型实际占用的内存空间；

        引用类型仅是一个指向堆区中某个实例的指针。

     例：publicclass Counter {

               int count = 13;

        }

        Counter counter = new Counter();

counter引用变量-------------> Counter实例

      count变量(占4个字节,值为13)

      counter引用变量的取值为Counter实例的内存地址。

      counter引用变量本身也占一定的内存空间，到底占用多少内存空间取决于Java虚拟机的实现，这对Java程序是透明的。

    注：counter引用变量到底位于Java虚拟机的运行时数据区的哪个区？取决于counter变量的作用域，如果是局部变量，则位于Java栈区；

               静态成员变量，则位于方法区；

                实例成员变量，则位于堆区；