java从入门到精通全过程笔记.doc

Java 从入门到精通笔记整理

包含内容
Unix
Java 基础，
数据库（Oracle jdbc Hibernate pl/sql），
web，
JSP，
Struts，
Ajax
Spring，
Ejb，
java和模式

张巍峰 编辑
20009.10

Linux/Unix笔记

216

inode ：存储编号（地址）
ls -k：查看磁盘分区
ls -li：显示当前文件的inode号。
目录的大小跟文件的大小有关，跟目录里的文件（目录）数量无关。
一行多个命令的话，中间用分号分开。如：pwd;cal;date
last | grep pts/13 表示查看pts/13登陆服务器的记录。
find . -mtime -10 -print
-10：表示10天以内的，
+10：表示10天以前的，
.：表示当前路径
-mtime：最后一次修改时间。
-print:表示输出到显示器（可有可没有）。
-user 0:表示UID是0。
size+400:表示大于400*0.5K ，-400表示小于400*0.5K
-atime:表示最后一次访问时间。
grep:在文件里查找符合要求的那一行。通常用在管道（｜）后面，表示对 | 前面的输出做查找。
如：cat /etc/passwd | gred liu | sort
sort:表示排序。
进程是作业，作业是进程。
前台就是终端，后台就是服务器。
当杀掉父进程，前台子进程会消失，，后台作业不依赖于任何终端，会继续运行
LINUX常用命令（基础）
1. man 对你熟悉或不熟悉的命令提供帮助解释
eg:man ls 就可以查看ls相关的用法
注：按q键或者ctrl+c退出，在linux下可以使用ctrl+c终止当前程序运行。
2. ls 查看目录或者文件的属*，列举出任一目录下面的文件
eg: ls /usr/man ls -l
a.d表示目录(directory)，如果是一个"-"表示是文件，如果是l则表示是一个连接文件(link)
b.表示文件或者目录许可权限.分别用可读(r)，可写(w)，可运行(x)。
3. cp 拷贝文件
eg: cp filename1 filename2 //把filename1拷贝成filename2
cp 1.c netseek/2.c //将1.c拷到netseek目录下命名为2.c
4. rm 删除文件和目录
eg: rm 1.c //将1.c这个文件删除
5. mv 移走目录或者改文件名
eg: mv filename1 filename2 //将filename1 改名为filename2
mv qib.tgz ../qib.tgz //移到上一级目录
6. cd 改变当前目录 pwd 查看当前所在目录完整路径
eg: pwd //查看当前所在目录路径
cd netseek //进入netseek这个目录
cd //退出当前目录
7. cat，more命令
将某个文件的内容显示出来。两个命令所不同的是:cat把文件内容一直打印出来，而 more则分屏显示
eg; cat>1.c //就可以把代码粘帖到1.c文件里，按ctrl+d 保存代码。
cat 1.c 或more 1.c //都可以查看里面的内容。
gcc -o 1 1.c //将1.c编译成.exe文件，我们可以用此命编译出代码。
8.chmod 命令 权限修改 用法：chmod 一位8进制数 filename。
eg: chmod u+x filenmame //只想给自己运行，别人只能读
//u表示文件主人， g 表示文件文件所在组。 o 表示其他人 ;r 表可读，w 表可写，x 表可以运行
chmod g+x filename //同组的人来执行
9. clear，date命令
clear:清屏，相当与DOS下的cls;date:显示当前时间。
10. mount 加载一个硬件设备
用法:mount [参数] 要加载的设备 载入点
eg: mount /dev/cdrom
cd /mnt/cdrom //进入光盘目录
11. su 在不退出登陆的情况下，切换到另外一个人的身份
用法: su -l 用户名(如果用户名缺省，则切换到root状态)
eg:su -l netseek (切换到netseek这个用户，将提示输入密码)
12.whoami，whereis，which，id
//whoami:确认自己身份
//whereis:查询命令所在目录以及帮助文档所在目录
//which:查询该命令所在目录(类似whereis)
//id:打印出自己的UID以及GID。(UID:用户身份唯一标识。GID:用户组身份唯一标识。每一个用户只能有一个唯一的UID和 GID)
eg: whoami //显示你自已登陆的用户名
whereis bin 显示bin所在的目录，将显示为：/usr/local/bin
which bin
13. grep，find
grep:文本内容搜索;find:文件或者目录名以及权限属主等匹配搜索
eg: grep success * 　　 /*查找当前目录下面所有文件里面含有success字符的文件
14. kill 可以杀死某个正在进行或者已经是dest状态的进程
eg; ps ax
15. passwd 可以设置口令
16. history 用户用过的命令
eg: history //可以显示用户过去使用的命令
17. !! 执行最近一次的命令
18. mkdir命令
eg: mkdir netseek //创建netseek这个目录
19. tar 解压命令
eg: tar -zxvf nmap-3.45.tgz //将这个解压到nmap-3.45这个目录里
20. finger 可以让使用者查询一些其他使用者的资料
eg: finger //查看所用用户的使用资料
finger root //查看root的资料
ftp上传下载ftp 192.168.1.100
用户：xiangf Pwd xiangf
Put mput上传多个Get mget下载多个
在linux下Jdk的安装
1. 先从网上下载jdk(jdk-1_5_0_02-linux-i586.rpm) 
进入安装目录
#cd /home
#cp jdk-1_5_0_02-linux-i586.rpm /usr/local
#cd /usr/local
给所有用户添加可执行的权限
#chmod +x jdk-1_5_0_02-linux-i586.rpm.bin
#./jdk-1_5_0_02-linux-i586.rpm.bin
此时会生成文件jdk-1_5_0_02-linux-i586.rpm，同样给所有用户添加可执行的权限
#chmod +x jdk-1_5_0_02-linux-i586.rpm
安装程序
#rpm -ivh jdk-1_5_0_02-linux-i586.rpm
出现安装协议等，按接受即可
2.设置环境变量。

#vi /etc/profile
在最后面加入 
#set java environment
JAVA_HOME=/usr/java/jdk-1_5_0_02
CLASSPATH=.:＄JAVA_HOME/lib.tools.jar
PATH=＄JAVA_HOME/bin:＄PATH
export JAVA_HOME CLASSPATH PATH
保存退出。
3.检查JDK是否安装成功。
#java -version
如果看到JVM版本及相关信息，即安装成功！
bash-profile是配置文件，配置java-home，path，classpath等
。空格。bash-profile 从新启动
Vim 。bash-profile编辑
Javac 把.java编译成。Class java运行。Class文件
java –d.按包的名字自动生成相对应的
Core Java笔记
人－－－＞源文件－－－＞编译器－－－＞程序－－－＞CPU
编译器：
1，编译执行:源文件－－－＞可执行代码。如：C／C＋＋语言。
执行效率高。可移植性差。－－－－＞开发成本的增加。
2，解释执行：源文件－－－＞体系结构中立的中间代码( .class)－－－ ＞解释器 －－－＞机器指令。 如 ：java语言
执行效率低。 可移植性好。－－－－＞ 对硬件要求高。
JAVA语言：
（源文件）－－－＞（编译器javac.exe）－－－＞中间码－－－＞（虚拟机java.exe）－－－＞机器指令－－－＞CPU
（编译） （解释）
.java ----> .class ---> 可执行文件
PATH：指定可执行程序（命令）在哪个目录。不同目录用（：）分开。－－－＞SHELL
JAVA_HOME：指定JDK的安装目录。给其它应用程序看的。
CLASSPATH：指定（jar文件）中间字节码文件在什么地方。由多个目录组成的集合。－－－＞
让虚拟机可以找到中间字节码文件。就是可以找到.class文件
服务器上csh:.cshrc
bsh:.profile
客户端上。bash:.bash_profile
1 # .bash_profile
3 # Get the aliases and functions
4 if [ -f ~/.bashrc ]; then
5 . ~/.bashrc
6 fi //if的结尾。
8 # User specific environment and startup programs //#代表注释。
9 JAVA_HOME=/opt/jdk1.5.0_15 JDK 安装路径--- JDK = JRE {JVM(硬件)+编译器（ 软件）} +编译器工具+类库
10 PATH=$JAVA_HOME/bin:$PATH:$HOME/bin ／／系统定义的＄PATH 启动命令
11 CLASSPATH=.:java/jar/servlet-api.jar:/java/jar/jsp-api.jar //类路径
12
13 export PATH CLASSPATH JAVA_HOME ／／使三个变量变成全局变量。。
Source .bash_profile：只能经过这条命令之后，才会让修改的变量生效。（csh）
. .bash_profile。 只能经过这条命令之后，才会让修改的变量生效。 （bash）
java -version:查看虚拟机的版本号。

2.，编写第一个JAVA程序、一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以。必须只有一个类名与文件名相同。
。
1），以.java结尾的文件。
2），所有内容，都要写在一个类中（类名要和文件名想同，包括大小写在内）
pbulic class HelloWorld{......}
3），main函数是程序执行的入口，程序从main函数的第一条语句开始执行，执行到main函数结束为止。
public static void main(String argvs[]){
}
4），输出语句：System.out.println( );
5），每条语句以（；）结尾
先指定到源程序存放的目录，然后进行以下步骤运行。
编译：javac命令。如：javac -d . HelloWorld.java －－＞生成HelloWorld.class类文件
启动虚拟机(java)，运行类文件。如：java com.work.core.HelloWorld
后面的.class省略，无需写成java com.work.core.HelloWorld.class

包（package):
1，package com.kettas.corejava; ／／包声明。
2，必须保证类文件一定放在相应的目录结构中，HelloWorld.class放在com/kettas/corejava目录中。
3，运行时，一定在顶层包的同级目录下运行java命令，
例如:com（shell界面里运行）java com.kettas.corejava.HelloWorld
（如果顶级包所在的目录已经被配置到CLASSPATH中的话可以在任意目录中启动 java命令）
1，类文件太多，不好管理。
2，解决重名。
javac -d . HelloWorld.java (不仅能够编译类文件，同时还能创建包结构)
运行命令java xxxx 类的名字--- 启动虚拟机
（一）语言：适合于internet
1，跨平台的 （属于解释执行的语言）
2，更容易开发出安全的程序：
1）垃圾回收器，（帮助程序员管理内存）
2）取消了指针，对数组越界进行检查
3）安全检查机制，（对生成的字节码检测,如：包结构检测）
Hash算法，，只要加密的源是一样的。经过Hash运算之后，Hash值都一样。
加密的源如果不一样了，经过Hash运算之后，值都不一样。

（二）变量：
如： 学生，姓名，性别，age
帐户，ID，password，balance，username
内存：没记忆，容量小，成本高，存储变量数据，最小逻辑单位：byte（字节）=8bit（位）
外存（硬盘）：有记忆，容量大，成本低，存储文件数据
1，变量声明：给变量起名，是给变量选择一种数据类型。如：int age;
不同的变量，
1）参与的运算是不同的，
2）存储的值是不同的，
3）需要的存储空间的大小也不同，

java数据类型：
简单数据类型（原始数据类型）
数字： 整数：byte(1字节)－short(2字节) －int25、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1; （s1+1 运算结果是int 型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
(在内存中占4个字节)－long（8个字节）
小数：float(4个字节，单精度浮点型) － double（8个字节，双精度浮点型）
字符：char(一个字符＝2个字节):只能表示一个字。 如：char c='中'; c存的是‘中‘这个字的编码。
布尔：boolean（true,false）,不能用0和非0表示。
String4、String 和StringBuffer 的区别
JAVA 平台提供了两个类：String 和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String 类提供了数值不可改变的字符串。而这个StringBuffer 类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer 。典型地，你可以使用StringBuffers 来动态构造字符数据。
（字符串）复杂数据类型（类）
String 类提供了数值不可改变的字符串 String s=new String(“abc”);创建了两个对象1，在字符串池中创建一个对象（此对象是不能重复的）2，new出一个对象。Java运行环境有一个字符串池，由String类维护。执行语句String s="abc"时，首先查看字符串池中是否存在字符串"abc"，如果存在则直接将"abc"赋给s，如果不存在则先在字符串池中新建一个字符串"abc"，然后再将其赋给s。执行语句String s=new String("abc")时，不管字符串池中是否存在字符串"abc"，直接新建一个字符串"abc"（注意：新建的字符串"abc"不是在字符串池中），然后将其付给s。
2，初始化 (局部变量而言，必须初始化才能使用) 如：age=10；
3，通过变量的名字对变量进行操作，如：age=other;
赋值时，左＝右
1）数据性质是否一样。
2）所占用的内存空间上考虑 （左＞右）不用类型转换。（左＜右）要类型强制转换，
如：int age=1;
long l=10;
age=(int)l;
符号位：0代表正数，1代表负数。
BigDecimal比double更精确，一般用于处理高精度运算。
&和&&的区别。
&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）
Java中的标识符的要求:
1，只能是字母，数字，＿，＄。 2，数字不能作为标识符的开头。
3，大小写敏感。 4，没有长度限制。如：ArrayOutOfBoudleException
5，标识符不能是关键字。

一般来说，类的名字以大写字母开头。
方法和变量的名字以小写字母开头。
标识符的名字应当具有含义，如 age , name

表达式：1，由运算符和变量组成。2，都会有返回值。
简单表达式：a/b; 复合表达式："a/b="+(a/b);

作业，打印润年,
1，能被4整除，但不能被100整除
2，能被400整除。

自增（++），自减（－－）运算符。
前＋＋：++a;先对a+1，再返回a+1之后的值。
后＋＋：a++;先返回a的值，然后对a进行+1。
前＋＋，后＋＋共同的特点：a本身的值都会+1；
区别在于表达式的返回值是不一样；用返回值来参与计算。

？ ： －－＞（boolean express）? A : B;如：char ch=(5>2)?'Y':'N';
？前面的布尔表达式如果为真就执行A，否则执行B。
（‘：‘左右两侧的返回类型要一致，且与ch的返回类型也一样）

java打包（压缩包 .zip .rar .tar .gz .jar）。

root/
yesq/
|-com/
|-work/
|-core/
|-VarTest.class
|-RunNian.class
. . . . . .
压缩命令： jar -cvf abc.jar dir
解压命令：jar -xvf abc.jar
abc.jar为生成压缩包的名字
dir为被打包的文件目录下的东西
c：是做压缩。v：为压缩过程的信息。f：指定压缩文件的名字。x：是做解压
打包一般从顶层包开始打。如：[java@localhost yesq]$ jar -cvf first.jar com
//当前目录（yesq）下的com文件夹开始打

1，获得别人提供的jar文件
2，将jar文件的名字以及他的绝对路径配置到CLASSPATH中
3，使用import语句，将其他包的内容导入到本文件中，如：引入包mon包中的SystemIn类
import mon.SystemIn;

－－－－－－ java中的流程控制 －－－－－
1，顺序
2，条件（代码是否执行，依赖于一个特定的条件）
if(boolean express){
XXXXXX; //如果布尔表达式为真就执行XXXXXX。
XXXXXX;
}else{
XXXXXX; //如果布尔表达式为假就执行XXXXXX。
XXXXXX;
}
3，循环（相同的代码，被重复的执行多次）
a,初始化循环条件。b，确定循环条件。c，确定循环变量在循环体中的变化。

(1) a;
while(boolean express){
XXXXXXXXX; //如果布尔表达式为真就执行XXXXXX
XXXXXXXXX;
c;
}
（2） for(a;b;c){

}
（3） do{
XXXXXXXXXX; //循环体至少执行一次；
XXXXXXXXXX;
}while(boolean express);

while(XXX){
XXXXXX;
XXXXXX;
bread; //或者continue；
XXXXXX;
}
break ：用在循环或分支里，用于退出整个循环或分支

continue ：用在循环里，用于结束本次循环。接着开始下一次循环
4，分支
switch(varvar：是一个整数表达式。因此传递给 switch 和 case 语句的参数应该
是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
){
case 1 : XXXXXX;
break;
case 2 : xxxxxx;
break;
........
default : xxxxxxx; // default后面可以不用break；
}
函数（方法）：是由一些相关代码组成的集合，目的是为了解决一个特定的问题，或者实现某个特定的功能。
函数（方法）一定有一个自己的名字，通过函数的名字执行函数中的代码。
2，在java中如何定义函数：
a,声明：public static void printMenu(int a,double b){.....}
b,编写函数体：

如： public static void printMenu(int a,double b){
XXXXXXXXXXX;
XXXXXXXXXX;
}
函数（方法）里面不允许再有其它的函数（方法），函数（方法）的位置必须是并列的。
3，调用函数：
通过函数名，如pirntMenu(a,b);
public static void main(String argv[]){
XXXXXXXXXXXX;
printMenu(a,b);
XXXXXXXX;
}
调用者－原数据－＞函数
return 作用：1，结束本方法。2，返回结果。
一个函数返回的值只能有一个。

4，值传递。传递的是实参的值，
被调函数使用的数都是实参的拷贝。
是否改变实参，要看被调函数的设计。

数组：一维数组－－＞：三种声明方式
一，（1）首先要声明。如：int[] array;或int array[];
（2）申请内存空间如：array=new int［2];
array代表数组array[]的首地址（引用：引用就是C＋＋里的指针。）；当参数传递时，只要用数组的首地址就可以。
1，数组中的元素类型要一致。
2，数组长度不能缺省，不能改变，但可以删了重建。
3，内存空间连续，有索引下标值（从0开始，最大length-1）
优缺点：查询快，增删慢（链表，查询慢，增删快）

只要有new在，就要为变量分配内存。 array.length //表示数组array的长度。
array存的是array数组首变量的地址。
二，数组的显示初始化：int[] array={1,2,3,4,5,6};
三，int[] array=new int[]{1,2,3,4,5,6,7};

数组的拷贝：
public static int[] expand(int[] a){
int[] b=new int[a.length*2];
/* for(int i=0;i<a.length;i++){
b[i]=a[i];
}
这段代码等于下面那条代码
*/
// 从a数组下标为0的位置开始拷贝，到b数组下标为0 的位置开始粘贴。
// a.length为粘贴的个数。（一般为a数组的长度）。
System.arraycopy(a,0,b,0,a.length);
return b; //返回扩展后的数组b。b是代表数组b的首地址。
}

二维数组（数组的数组）－－＞：三种声明方式

二维数组的第二个［］在声明时可以留空，如：int[][] array=new int[4][];
//留空说明该二维数组的列是以行的数组下标为数组名，再成为新的数组。

一，声明：int[][] array=new int[3][4]; //声明一个三行四列的整型二维数组。
二，int[][] array={{1,2,3},{2,3,4},{2,5,7},{2,3,6}};
三，int[][] array=new int[][]{{1,2,3},{2,3,4},{2,5,7},{2,3,6}};
1，找对象（客观存在的事物）；
2，利用对象的功能。就是让对象干点什么；
3，对象的属性可以是其他对象。
4，对象还可以通过调用其他对象的函数产生联系。
5，简单的对象构成复杂的系统。

有什么：属性-------》 实例变量
做什么：方法-------》函数
对象的属性可以是其他对象
对象还可以通过调用其他对象的函数产生联系
简单的对象构成复杂的系统

思想：解决问题的过程，

总纲（优势）
1，符合人的思维过程。
2，编写出来的代码比较合理。如：可扩展性，可维护性，可读性等等。（存在就是合理），（贴近生活）
3，弱耦合性，
4，可扩展性
5，可复用性。 不要重复制造轮子。
6，更尽所能，更施其职。

＝========＝类：＝＝＝＝＝＝＝＝＝＝＝＝＝＝
面向过程：是代码的容器。
面向对象：对象所共有的功能和属性进行抽像，成为了类。客观事物在人脑中的主观反映。在程序里类是创建对象的模板。

java中的对象垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机
进行垃圾回收？
对于GC 来说，当程序员创建对象时，GC 就开始监控这个对象的地址、大小以及使用情况。通常，GC
采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些
对象是"不可达的"。当GC 确定一些对象为"不可达"时，GC 就有责任回收这些内存空间。可以。程序
员可以手动执行System.gc()，通知GC 运行，但是Java 语言规范并不保证GC 一定会执行。
：对现实对象的抽象（获得有用的，舍弃没用的）。
存储空间中的一块数据区域，用于存数据。如：人（nama sex age）
属性：实例变量（定义在类以内，方法之外）
1.默认的初值
2.实例变量的使用范围至少是类以内
3.实例变量调用必须有对象，实例变量和局部变量重名，局部优先。

例：
public class Test{
public static void main(String[] args){

//新建对象stu；stu存的是新建对象stu的地址。stu的专业术语：引用／对象变量／引用变量／实例变量
Student stu=new Student();
stu.name="tom"; //给对象stu的name属性赋值。
}}
class Student{ //用类声明的数据（str）为引用类型，如：Student str;

//实例变量：定义在方法之外，类以内的，没有static修饰的变量
//实例变量会有一个默认的初始值。初始值与变量定义时的类型有关。
//实例变量（成员变量）－－－＞属性。可通过新建对象的引用来访问类的实例变量。如，stu.name;
String name;
int age;
String sex;
}
实例变量和局部变量的区别：
1，位置：局部变量定义在方法里面。实例变量定义在类以内方法之外。
2，使用的范围：局部变量只能在定义他的方法里面使用，直接调用变量名就可以了。
实例变量至少可以在定义他的整个类内使用，使用时必须用对象去调用。只有跟对象一起实例变量才有意义。
3，局部变量使用之前必须初始化。实例变量不需要赋初值，系统会给默认的初值。

4，局部变量在同一方法里不能重名。局部变量和实例变量可以重名，在方法里采用就近原则。

＝＝方法：＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
包括：
方法:
做什么：方法的定义
修饰符 返回类型 方法名（参数列表） 异常
怎么做：方法的实现 {******}
修饰符（如：public） 返回类型（如：int） 方法名/函数名 （参数表－－形参）
如：
public void eat(String fish){ //eat(),吃的功能。
//怎么做.
}
使用实例方法时也需要用对象去调用。如：stu.eat("fish");
方法重载（overloading）：编译时多态。方法的重写
Overriding 和重载Overloading 是Java 多态性的不同表现。重写Overriding 是父类与
子类之间多态性的一种表现，重载Overloading 是一个类中多态性的一种表现.我们说该方法被重写 (Overriding)。子类的对象使用这个方法
时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个
同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
Overloaded 的方法是可以改变返回值的类型。

在一个类的内部，方法名相同形参数不同的方法，对返回类型不要求，这种现象称之为重载；
编译器会自动选择使用的方法。体现了一个编译时多态。
好处：对使用者屏蔽因为参数不同造成方法间的差异。
找方法时如果没有合适的，采取自动向上扩展原则。
调用时形参之间的区别一定要明确。
1. 形参的个数不同
2. 形参的类型不同
3. 形参的顺序不同
4. 形参的名字相同

方法覆盖（override）：运行时多态。
1，发生在父类和子类之间
2，方法名相同，参数相同，返回类型相同
3，子类方法的访问权限不能更严格，只能等于或更加宽松。

构造方法：
1，没有返回类型，方法名必须和类同名。
2，构造方法不能手动调用，它只用在创建对象在时候，只出现在new之后。
只要构造方法被调用运行，就一定有对象产生。
3，在一个对象的生命周期里，构造方法只能被调用一次。
4，类写好后一定有构造方法，
如果程序没有显示的提供构造方法，JVM会提供一个默认的构造方法，public classname(){}
如果程序显示提供，系统不再提供默认的
5，同一个类的多个构造方法一定重载。
6，创建对象的同时构造方法的代码块里还可以写需要运行的代码，还可以给属性（实例变量）赋值，
引用类型的属性赋值就是用new创建对象，然后调用构造方法。如：Student stu=new Student();
用new创建对象时JVM做的三件事：
如：Student stu=new Student();
1，申请空间；（把值放到空间里，再把空间的地址给引用变量。）－－－－创建父类对象
2，初始化实例变量；没显示声明值的话就用默认值。
3，执行构造方法，
因为实例变量在创建对象的过程中被初始化，所以使用实例变量前必须创建对象（要用对象去调用），否则实例变量根本不存在

＝＝＝＝＝关键字：this＝＝＝＝＝＝＝
1，在普通方法里，指代当前对象引用（哪个对象调用该方法，this就指向该对象）
2，this不能出现在静态方法里。
3，在构造方法里，this用来指代本类的其他构造方法。在本类构造方法之间互相调用。如：this(形参);
使用时放在构造方法里的第一行。
4，不能写成死循环（不能递归调用）
＝＝＝＝＝关键字：super＝＝＝＝＝＝＝
（和this的用法类似）
1,调用父类的构造方法，在子类调用父类的构造方法必须出现在第一句，构造方法第一句可能出现的三种情况（调用父类的构造方法看子类构造方法的第一句）①super（）；②super（参数）注意传递的参数一定是实体，有值的。③this（），先在本类的构造方法间调用，再看调用那个构造方法的第一句是什么
2，super访问父类的变量和方法，及super代表父类的对象，super.name;super.setName();
＝＝＝＝＝＝参数传递＝＝＝＝＝＝＝＝
1，参数相当于局部变量
2，参数传递相当于赋值语句
3，基本类型数据传递的是本身的值，引用类型数据传递的是引用xx(Animal animal)（地址，对象变量本身的值）

面向对象的三大特性：

一，封装（Encapsulation）：一个系统以合理的粒度出现。
定义：封装就是将客户端不应看到的信息包裹起来。使内部执行对外部来看不一种不透明的、是一个黑箱，客户端不需要内部资源就能达到他的目的。(封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概
念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。)
1．事物的内部实现细节隐藏起来
2．对外提供一致的公共的接口――间接访问隐藏数据 3．可维护性  
访问控制修饰符：publ