目标： 1. 标识符、关键字和类型介绍；
2. 如何构建类?
javadoc注释以"/**"开始，以"*/"结束，里面可以包含普通文本、HTML标记和javadoc标记。javadoc只处理源文件中在类/接口定义、方法、域、构造器之前的注释，忽略位于其他地方的注释
public boolean sendMessage() {
return false;
}
boolean:false true
如果方法有返回类型,需要在方法添加return关键字,return 后面跟方法返回值(该值的类型必须与方法返回类型一致)
java API:java的帮助文档 帮助用户可以快速开发java相关的软件
javaSE:java标准版本，所有后期学习的相关java高级应用都来自于javase
javaEE:enterprese 企业及应用 主要用来开发javaWEB项目 类似于网站系统开发
javaME:mobile 移动互联应用 主要用来开发安卓等一些相关手机应用
api: 左边 第一部分 相关包 第二部分 该包下面包含相关的类(class) 接口(interface)
枚举(enum),异常(exception) 错误(error) 注释信息(annocation)
右边 点击左边的类 右边显示该类所拥有的详细信息(方法,属性....)
java.lang.Object 是所有java类的父类
第二章： Identifiers, Keywords and Types(40-63)
目标：1. 注释
作用：使部分内容只为程序员可见，不为编译器所编译、虚拟机所执行；
位置：类声明前后、方法声明前后、属性声明前后、方法体中。几乎可以在一个源文件任意位置，但不能在一个关键字字符中插入注释。
类型：1) 单行注释：
//text——从"//"到本行结束的所有字符均作为注释而被编译器忽略
2) 多行注释：
/*text*/——从"/*"到"*/"间的所有字符会被编译器忽略
/**/多行注释，可以出现在任意位置(包括[]的内部),
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的外面
火狐乱码:浏览器最上方找到查看view－－－>编码格式character——>unicode
view—>character encoding—>unicode
2. 分号、块和
1) 每个语句短语以;结束 ;
2) 代码段以{}结束;
所有的逻辑语句必须出现在{}中间
3) 空白处（空格、tab键、新行和回车（几个语句短语连接在一起））是无关紧要的。
e.g String name; public static void main(String args[]){}
String 和 name之间必须有空格,空格个数没有限定
main 和 （）之间可以没有空格也可以有空格 () 和 {}之间可以没有空格,或者有空格
Swap file ".GrammerTest.java.swp" already exists!
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, 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的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前
添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中
java 中的 native 修饰符表示被修饰的方法由本地语言(C)实现
例如: java.lang.System.gc() 这个方法。
native hashCode()
它就是一个用 native 修饰的方法：
public static native void arraycopy（）
如果键入volatile，则编译器会逐一的进行编译并产生相应的机器代码（产生四条代码）.
Java语言的保留字是指预留的关键字，它们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
. 所有关键字都是小写；
. friendly, sizeof不是Java语言的关键字，这有别于C++；
. 程序中标识符不能以关键字命名；
5. 基本类型：
程序的基本功能是处理数据
程序用变量来表示数据；
程序中必须能使用；
定义变量是指设定变量的数据类型和变量的名字，定义变量的基本语法为：
数据类型 变量名；
Java语言把数据类型分为基本类型和引用类型。
------------------------------------------------------------
基本类型 数值类型 浮点数类型
默认带有小数的数据类型是double
e.g int i = 10.0 此时10.0是double类型需要
转换类型 int i = (int)10.0
float f = 10.0 此时10.0是double类型需要
转换类型 float f = (float)10.0或者
float f = 10.0f
boolean类型的取值只能是true或者false
位数
boolean 布尔类型
byte(8位)<short=char(16位)<int=float(32位)<double=long(64位)
窄范围转换成宽范围,自动转换
宽范围转换成窄范围,需要强制类型转换
double 64位 1字节 ＝ 8位
float 32位
整数类型 byte 8位
short 16位
int 32位
long 64位
字符类型 char 16位
------------------------------------------------------------
引用类型 引用 类类型
接口类型
数组类型
------------------------------------------------------------
二进制数(仅4位的2进制数)= 十进制数 = 16进制数
0*2^0+0*2^1+0*2^2+0*2^3
0000 = 0 = 0
0001 = 1 = 1
0010 = 2 = 2
0011 = 3 = 3
0100 = 4 = 4
0101 = 5 = 5
0110 = 6 = 6
0111 = 7 = 7
1000 = 8 = 8
1001 = 9 = 9
1010 = 10 = A
1011 = 11 = B
1100 = 12 = C
1101 = 13 = D
1110 = 14 = E
1111 = 15 = F
1*2^0+1*2^1+1*2^2+1*2^3 =15
十六进制表示方法：0xff 15*16^1+15*16^0=255(max) 0x00 = 0(min)
111111011010010110011011（这是一个2进制数)
转换成十六进制,十六进制再转换成十进制
先把它所包含的数字分成4个4个在一块，如下所示：
1111 1101 1010 0101 1001 1011
根据上述常用表可以得到
1111=F
1101=D
1010=A
0101=5
1001=9
1011=B
那么它所对应的16进制数就是“0xFDA59B”
接下来，我们主要关注基本数据类型，关注各种基本数据类型 有什么样的取值范围？占用多少内存空间？
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
char a = ‘a’ int i = a 此时i的值就是a字母对应的是十进制的值
但是 如果String—>int 不能直接转换 需要使用Integer.parseInt(String)方法进行转换
即使使用方法转换成功,如果String本来对应的值就不是数字类型 ,转换过去也不是数字类型
e.g
String s = “123” int ii = Integer.parse(s) ii时整数
String s = “name” int ii = Integer.parse(s) ii此时不是数字类型 返回false
字符串拼接 ：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字符编码
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字符编码 windows系统
对GB2312字符编码的扩展，收录了21886个字符(21003个字符+其它字符), 它与GB2312字符编码兼容。
e. Unicode字符编码：
由国际Unicode协会编制，收录了全世界所有语言文字中的字符，是一种跨平台的字符编码。
UCS(Universal Character Set)是指采用Unicode字符编码的通用字符集。
Unicode具有两种编码方案：
. 用2个字节(16位)编码，被称为UCS-2, Java语言采用;
. 用4个字节(32位)编码，被称为UCS-4;
f. UTF字符编码 unix操作系统使用
有些操作系统不完全支持16位或32位的Unicode字符编码，UTF(UCS Transformation Format)字符编码能够把
Unicode字符编码转换为操作系统支持的编码，常见的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) 转义字符
Java编程人员在给字符变量赋值时，通常直接从键盘输入特定的字符，而不会使用Unicode字符编码，因为很难记住各
种字符的Unicode字符编码值。
对于有些特殊字符，比如单引号，如不知道它的Unicode字符编码，直接从键盘输入编译错误：
char c = '''; //编码出错
为了解决这个问题，可采用转义字符来表示单引号和其他特殊字符：
char c = '\'';
char c = '\\';
转义字符以反斜杠开头，常用转义字符：
\n 换行符，将光标定位到下一行的开头；
\t 垂直制表符，将光标移到下一个制表符的位置；
\\ 反斜杠字符
\' 单引号字符
8. 整数类型
byte, short, int和long都是整数类型，并且都是有符号整数。与有符号整数对应的是无符号整数，两者的区别在于把二进制数转换为十进制整数的方式不一样。
有符号整数把二进制数的首位作为符号数，当首位是0时，对应十进制的正整数，当首位是1时，对应十进制的负整数。对于一个字节的二进制数, 它对应的十进制数的取值范围是-128 - 127。255
byte -128 127
八位 0111 1111(补码)== +127
1*2^6+1*2^5….+1*2^0 = 127
1000 0000(源码) -128
1000 0000(补码)
byte -129
源码 1000000000000…(24位)1000 0001(8位)
补码 1111111111111…(24位)0111 1111(8位)
byte(-129) 0111 1111(补码=源码) 127
byte 130
源码 0000000000000…(24位)1000 0010(8位)
补码 0000000000000…(24位)1000 0010(8位)
byte(130) 1000 0010(补码->源码) 1111 1110(源码) -126
源码 第一位是符号位 其他位是真值位 可以求出具体十进制的二进制表达式
反码 源码 除去符号位保留不变 其他位按位取反获得的二进制表达式
补吗 反码+1得到的二进制表达式
内存中按照补吗进行保存
正数 源码 反码 补吗相同
负数 源码—>取反(反码)+1—>补吗
byte b = (byte)129;
按照数字推算出的二进制表达形式是源码
129 000000000000000(24位) 1000 0001 (源码－－－》补吗)
1000 0001 (补吗——->源码)
取反+1 1111 1111(源码 -127)
byte b = (byte)-129
源码：1000000000000000(24位) 1000 0001
补码: 1111111111111111(24位) 0111 1111
0111 1111(正数补码 源码)
byte b = (byte)-130
-130 1000000000000000(24位) 1000 0010(源码->补码)
1111111111111111(24位)
0111 1110(补码->源码)
byte b = (byte)130
130 0000000000000000(24位) 1000 0010(源码—>补吗)
1000 0010(补吗—>源码)
取反+1
1111 1110 =
0x7E = 7*161+14*160=126
1000 0001== -1
1000 0000补吗 和
1000 0000源码 相同 ==-128
无符号:0~255~~~1111 1111
0000 0000
. 无符号整数把二进制数的所有位转换为正整数。对于一个字节的二进制数, 它对应的十进制数的取值范围是0 - 255。
在Java语言中，为了区分不同进制的数据，八进制数以“0”开头，十六制以“0x”开头。举例：
一个字节的二进制数 八进制数 十六进制数 有符号十进制数 无符号十进制数
————————————————————————————————————————————————
0000 0000 0000 0x00 0 0
二进制 3位 ＝ 八进制 1位 111(二进制) = 122+1*21+12^0 = 7
1111 1111将二进制进行分割 011 111 111 0377 0xFF
1111 1111 0377 0xFF -1 255
001 111 111
0111 1111 0177 0x7F 127 127
1000 0000 0200 0x80 -128 128
1 -
111 1111
+ 1
1000 0000 = 128 -128
二进制转十进制
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型整数；
long var = 100l; //整数100后面加上大写的后缀"l"，表示long型整数；
Java语言允许把八进制数(以"0"开头), 十六进制数(以"0x"开头)和十进制数赋给整数类型变量，例如：
int a1 = 012; //012为八进制数，变量a1的十进制取值为10
int a2 = 0x12; //0x12为十六进制数，变量a2的十进制取值为18
int a3 = 12; //12为十进制数，变量a3的十进制取值为12
int a4 = 0xF1; //0xF1为十六制数，变量a4的十进制取值为241
byte b = (byte)0xF1 //0xF1为十六制数，变量b的十进制取值为-15
9. 浮点类型
浮点类型表示有小数部分的数字。Java中有两种浮点类型：
. float: 占4个字节，共32位，称为单精度浮点数;
. double: 占8个字节，共64位，称为双精度浮点数；
双精度比单精度表示的位数大精确的位数多,简单地说, float表示的小数点位数少,double能表示的小数点位数多!
在默认情况下，小数及采用十进制科学计数法表示的数字都是double类型，可以把它直接赋值给double类型变量。
默认情况下,如果直接构建带有小数的数字,表示的是double类型
float接受需要进行强制类型转换.
e.g float f = (float)10.0;
double d1 = 1000.1;
double d2 = 1.0001E+3; 1.0001*10^3 //采用十进制科学计数法表示的数字，d2实际取值为1000.1
double d3 = 0.0011;
double d4 = 1.1E-3; 0.0011 //采用十进制科学计数法表示的数字，d4实际取值为0.0011
double d5 = 10e10; //转换成1E11,将e前面的数字也装换成科学计数
如果把double类型的数据直接赋给float类型变量，有可能会造成精度的丢失，因此必须进行强制类型的转换，否
则会导致编译错误，例如：
float f1 = 1.0 //编译错误，必须进行强制类型转换；
float f2 = 1; //合法，把整数1赋值给f2，f2的取值1.0;
float f3 = (float)1.0; //合法，f3的取值为1.0;
float f4 = (float)1.5E+55; //合法, 1.5E+55超出了float类型的取值范围，
f4的取值为正无穷大
System.out.println(f3); //打印1.0;
System.out.println(f4); //打印Infinity
----------------------------------------------------------------------------------------------------
Student student = new Student();
该表达式在内存中分为两步走
Student student; 在栈区的构建
new Student();在堆区的构建
=:栈区的引用指向堆区的地址
创建对象类型 对象的引用(任意指定) ＝ 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;
}
}
Student student = new Student();
Float.NaN 非数字
Float.POSITIVE_INFINITY 无穷大
Float.NEGATIVE_INFINITY 负无穷大
float f1 = (float)(0.0/0.0); //f1的取值为Float.NaN
float f2 = (float)(1.0/0.0); //f2的取值为Float.POSITIVE_INFINITY
float f3 = (float)(-1.0/0.0); //f3的取值为Float.NEGATIVE_INFINITY
System.out.println(f1); //打印NaN;
System.out.println(f2); //打印Infinity
System.out.println(f3); //打印-Infinity
Java语言之所以提供以上特殊数字， 是为了提高Java程序的健壮性，并且简化编程。当数字运算出错时，可以用浮
点数取值范围内的特殊数字来表示所产生的结果。否则，如果Java程序在进行数学运算遇到错误时就抛出异常，会影
响程序的健壮性，而且程序中必须提供捕获数学运算异常的代码块，增加了编程工作量。
10. 变量的申明和赋值
final public 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. 理解对象
面向对象的开发方法把软件系统看成各种对象的集合，对象就是最小的子系统，一组相关的对象能够组合成更复杂的
子系统。面向对象的开发方法将软件系统看成各种对象的集合，接近人的自然思维方式。
对象是对问题领域中事件的抽象。对象具有以下特性：
1) 万物皆为对象。问题领域中的实体和概念都可以抽象为对象。例如学生，成绩单、教师、课和教室。
2) 每个对象都是惟一的。正如世界上不存在一模一样的叶子。
3) 对象具有属性和行为。
例如小张，性别女，年龄22，身高1.6m, 体重40kg, 能够学习，唱歌。小张的属性包括姓名、性别、年龄、身高和
体重，行为包括学习、唱歌。
例如一部手机，牌子是诺基亚、价格是2000元，银白色，能够拍照、打电话和收发短信等。这部手机的属性包括品
牌类型type、价格price和颜色color，行为包括拍照takePhoto()，打电话call()，收发短信receiveMessage()和发短
信sendMessage().
4) 对象具有状态。状态是指某个瞬间对象的各个属性的取值。对象的某些行为会改变对象自身的状态，即属性的取值。
例如小张本来体重为40kg，经为减肥后，体重减到35kg.
肥胖状态: 40kg
|
| 减肥行为
|
肥胖状态: 35kg
5) 每个对象都是某个类的实例。小张和小王都属于学生类、中国和美国都属于国家类、中文和英文都属于语言类。
类是具有相同属性和行为的对象的集合。
同一个类的所有实例都有相同属性，但属性取值不一,事实上相同，但是它们的状态不一定相同。例如小张和小王都属
于学生类，都有姓名、性别、年龄、身高和体重这些属性，但是他们的属性取值不同。
同一个类的所有实例都有相同行为，意味着它们具有一些相同的功能。
13. 创建类
类是一组具有相同属性和行为对象的模板。面向对象编程的主要任务就是定义对象模型中的各个类。
package sample;
public class Teacher {
/**attributes of a teacher*/
private String name;
private int age;
private double salary;
/** Creates a new instance of Teacher */
public Teacher(String name, int age, double salary) {
this.salary = salary;
this.age = age;
this.name = name;
}
/**operations on properties */
/** get the name of this teacher */
public String getName() { return name; }
/**get the salary of this teacher */
public double getSalary() { return salary; }
/**get the age of teacher teacher */
public int getAge() { return age; }
……
}
代码解析：
public String toString() {
return “name:”+name+” age:”+age+” gender:“+gender;
}
toString方法:返回用户指定输出的字符串格式
可以使用class引用.toString()调用
如果直接写class引用实际也是调用toString()方法.
即使没有构建toString(),class引用默认也是调用
toString()方法.默认的toString()方法输出
当前对象位于的内存地址
如果自己构建toString()方法,执行自己的toString()方法
如果自己没有构建toString()方法,执行系统自带的默认toString()方法.
关键字this:表示当前类本身,输出toString()方法
e.g
Student student = new Student();
(this == student)
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 void main(String[] args) {
Teacher gzhu = new Teacher("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(对象引用) = new Student()(创建对象);
获得对象student后,可以使用student.name来获取student中
的name属性.
获取属性:class引用.属性名
获取方法:class引用.方法名
注：结合实例，并画内存分配图讲解。
15. 基本类型和引用类型的区别
1) 基本类型代表简单的数据类型，比如整数和字符。
引用类型代表复杂数据类型，引用类型所引用的实例包括操纵这种数据类型的行为。
通过"."运算符，就能访问引用变量所引用的实例的方法.
2) 基本类型Java虚拟机会为其分配数据类型实际占用的内存空间；
引用类型仅是一个指向堆区中某个实例的指针。
例：public class Counter {
int count = 13;
}
Counter counter = new Counter();
counter引用变量-------------> Counter实例
count变量(占4个字节,值为13)
counter引用变量的取值为Counter实例的内存地址。
counter引用变量本身也占一定的内存空间，到底占用多少内存空间取决于Java虚拟机的实现，这对Java程序是透明的。
注：counter引用变量到底位于Java虚拟机的运行时数据区的哪个区？取决于counter变量的作用域，如果
是局部变量，则位于Java栈区；
静态成员变量，则位于方法区；
实例成员变量，则位于堆区；
121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
