java学习技能总结整理

　　目录的大小跟文件的大小有关，跟目录里的文件(目录)数量无关。

　　一行多个命令的话，中间用分号分开。如：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.设置环境变量。[U1]

　　#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程序[U2] 。

　　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字节) -int[U3] (在内存中占4个字节)-long(8个字节)

　　小数：float(4个字节，单精度浮点型) - double(8个字节，双精度浮点型)

　　字符：char(一个字符=2个字节):只能表示一个字。 如：char c=‘中‘; c存的是‘中‘这个字的编码。

　　布尔：boolean(true,false),不能用0和非0表示。

　　String[U4] (字符串)复杂数据类型(类)

　　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语句，将其他包的内容导入到本文件中，如：引入包com.kettas.common包中的SystemIn类

　　import com.kettas.common.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(var[U5] ){

　　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++){< p="">

　　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中的对象[U6] ：对现实对象的抽象(获得有用的，舍弃没用的)。

　　存储空间中的一块数据区域，用于存数据。如：人(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)：编译时多态。[U7]

　　在一个类的内部，方法名相同形参数不同的方法，对返回类型不要求，这种现象称之为重载;

　　编译器会自动选择使用的方法。体现了一个编译时多态。

　　好处：对使用者屏蔽因为参数不同造成方法间的差异。

　　找方法时如果没有合适的，采取自动向上扩展原则。

　　调用时形参之间的区别一定要明确。

　　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.可维护性

　　访问控制修饰符：public(公开的)，protected(受保护的，1，本包内可见;2，其他包的子类可见)

　　default(默认，本包内可见)，private(私有的，类内部可见)

　　访问控制修饰符 (可以范围) (可修饰)下面的类(指外部类)

　　private 本类 方法，属性

　　default 本包 类，方法，属性

　　protected 本包+子类 方法，属性

　　public 到处可见 类，方法，属性

　　1，属性：隐藏所有属性，用private。隐藏后属性只能在类以内访问 。程序可以根据需要提供get和set

　　2，方法(函数)：该公开的公开，该私有的就私有。(视情况而定)

　　3，公开方法的功能，隐藏方法的实现细节。

　　二，继承(inheritance)：抽象出不变性。

　　从一般到特殊的关系，可以设计成继承

　　特点：共性写在父类里面，特性写在子类

　　所有类的总父类是 Object (Object是类的祖先)

　　父类里写的是共性，子类里写的是特性。

　　父类中用private修饰的属性和方法不能被子类继承;

　　但是父类里的属性子类都有，如果子类有特殊属性的话，就要在子类里定义

　　且在创建该子类对象的时候初始化属性(包括父类所有属性和该子类所有属性);

　　什么样的功能和属性可以继承到子类?

　　对于父类里的属性和方法，子类有权访问的，我们称为可以继承;

　　用new创建子类对象，JVM执行的过程：Dog d=new Dog(); 为d申请空间。 class Dog extends Animal{}

　　(1)申请空间;(把值放到空间里，再把空间的地址给引用变量。)

　　(2)看本类构造方法的第一句

　　(3)默认的创建父类对象：

　　执行顺序：子类(2)---> 父类(2-->3-->4-->5)---> 子类(4-->5)，

　　新建一个对象空间只申请一次(该空间存放所有父类和子类)。)

　　(4)初始化本类的实例变量(该类的所有属性);

　　(5)执行本类的构造方法，(构造方法只会在创建一个对象的时候被执行一次)

　　(创建是先执行父类的构造方法，在执行子类的构造方法，访问时先访问子类自己的特殊属性和方法再访问父类的属性和方法)

　　用super调用父类被子类覆盖的普通方法和遮盖的属性，

　　指代的是在创建子类对象过程中，由JVM自动创建的那个父类，如：super.方法名()/属性

　　用super调用父类的构造方法;必须出现在子类构造方法的第一句。如：super(形参);

　　1，在子类的构造方法里如果没有指明调用哪一个父类的构造方法(就是子类中没有super(形参)语句;)，

　　JVM会默认调用父类的无参构造方法，跟本类构造方法的形参没有关系。

　　2，显示的写super，JVM会根据参数调用相应的父类构造方法。

　　3，有this(形参)，在本类的构造方法之间调用，看被调用的那个构造方法的第一行。

　　三，多态[U8] (polymorphism)：多态只有方法多态，没有属性多态。

　　用父类类型屏蔽子类之间的差异

　　所有的子类对象都可以当父类对象来用，一个父类型的引用可能指向的是一个子类对象，

　　如：把狗(对象)看作动物(类型)。Animal a=new Dog(); 编译看前面，运行看后面。

　　(编译时类型) (运行时类型)

　　1，运行时对象不会改变(对象是客观存在的)，如：狗这个对象的属性和方法是不会改变的。

　　2，对一个引用，只能调用编译时类型里的已知方法。

　　如：编译器知道动物里已有的属性和方法，但不知道狗的属性和方法。

　　3，运行时会根据运行时类型自动寻找覆盖过的方法运行。

　　引用 instanceof 类名 //结果为boolean值，

　　引用所指向的对象和类名类型是否一致(对象是否属于类名类型)

　　类型的转换：转换编译时类型

　　Sub su= (Sub) s;

　　子类型的引用向父类型转换时，不需要强转

　　父类型的引用向子类型转换时，需要强转

　　Animal a=new Cat();

　　Dog d=(Dog)a; // 类型转换异常

　　引用 instanceof 类名 -----> boolean

　　引用所指向的对象和类名所代表的类型是否一致

　　a instanceof Animal -----> true a instanceof Cat----------> true a instanceof Dog----------->false

　　Employee e=new Manager();

　　e instanceof Employee ------>true

　　e instanceof Manager------> true

　　属性没有多态，属性只看编译时类型

　　编写程序的顺序：

　　class 类名{

　　private属性(有什么)

　　无参的构造方法(public类名(){｝)

　　有参的构造方法(作用：给属性赋值)

　　set和get(设置和获得属性)

　　业务方法(做什么)

　　｝

　　一，修饰符：static [U9]

　　static变量：如：static int index=2;

　　类的所有对象共同拥有的一个属性;可以用类名直接访问，又称为类变量，

　　类的所有对象共同拥有的一个变量;类第一次被加载时会初始化静态变量

　　(也就是会先执行static修饰的变量);

　　跟类创建了多少对象无关;任何对象对静态变量做的修改，其他对象看到的是修改后的值。

　　可以用作计数器，记录类创建对象的个数 ， static变量在类加载的时候只会被初始化一次，

　　static方法：如：public static void teach(){}

　　可以用类名直接去调用，不需要对象所以不能直接访问(在没有对象的情况下)实例变量，

　　在静态方法里不能出现this和super，类的所有对象共同拥有的一个方法;跟类创建了多少对象无关。

　　在继承里，父类的静态方法只能被子类的静态方法覆盖，且覆盖以后没有多态

　　(访问的是父类的静态方法);

　　static初始化块：如：class Teacher(){

　　static int index=4;

　　static{ //static初始化块

　　.........

　　}

　　}

　　静态初始华块：用static修饰类里面的一个独立的代码块，类第一次被JVM加载的时候执行，只被执行一次。

　　类加载：JVM在第一次使用一个类时，会到classpath所指定的路径去找这个类所对应的字节码文件，

　　并读进JVM保存起来，这个过程称之为类加载，一个线程一个jvm。

　　二，final (最后的，最终的)final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承

　　final类：如：final class Animal{}

　　表示该类不能被继承，意味着不能改变里面的代码;

　　对虚拟机的正常运行有重要作用的类通常用final修饰，如：String,System,Math ...等类

　　final方法：如：public final void sleep(){} 该方法不能被覆盖(修改)，但能被子类访问。

　　final变量：如：final (static) int index=4;

　　该变量是常量能被继承(访问);

　　final修饰的变量就是常量，通常和static一起连用，来声明常量;

　　final修饰引用类型数据，指的是引用(地址)不能变，但引用里的数据不受限制。

　　final修饰的变量，只要在初始化的过程中就可以赋值。

　　实例变量：声明的同时或构造方法里赋值;

　　静态变量：声明的同时或在静态代码块里赋值;

　　三，abstract

　　abstract类：如：abstract class Animal{}

　　抽象类，不能创建对象(如一些父类)，但是可以声明一个抽象类型的引用

　　(可以声明父类类型子类对象，编译时利用多态调用抽象方法)。

　　含有抽象方法的类一定是抽象类，但抽象类并不一定要有抽象方法;

　　抽象类一般是用来被继承的;子类继承自抽象类，就要实现里面的抽象方法，

　　如果不想让子类也是抽象类的话，必须实现父类里面所有的抽象方法。

　　抽象类有构造方法，有父类，也遵循单继承的规律。

　　abstract方法：如：public abstract void sleep();

　　抽象方法，只有方法名的定义，没有实现体(只定义了能做什么，没定义怎么做)，不能被调用，

　　用于被子类的方法覆盖或重新实现。只能放在抽象类中。

　　好处：允许方法的定义和实现分开。

　　public protected default private static final abstract

　　可以： public static

　　private static

　　public final

　　public static final

　　不可以：abstract final void eat();

　　private abstract void eat();

　　static abstract void eat();

　　abstract不能和final,private,static连用。

　　四，interface：是抽象类的变体，。在接口中，所有方法都是抽象的。如：interface M{

　　int num=3;

　　void eat();

　　}

　　理解为接口是一个特殊的抽象类，所以接口不能创建对象，且接口没有构造方法，

　　但可以声明一个接口类型的引用(m是接口类型实现类对象，如：M m=new N();)

　　接口存在的意义是被子类实现，如果不想让子类也抽象，

　　就要实现接口里面所有的抽象方法，实现过程中注意访问权限;

　　用 implements 关键字实现接口，如：class N implements M{

　　public void eat(){...}

　　}

　　接口里面的常量默认都是public static final的;

　　接口里面的方法默认都是public abstract的。

　　接口本身支持多继承，继承了父接口里功能的定义，如，interface A extends B,C,D{} //A，B，C，D都是接口;

　　类可以同时继承一个父类和实现接口(或多个接口)。

　　如：class AA extends BB implements CC,DD,EE{}//AA，BB 是类，CC，DD，EE是接口;

　　作用：1，用接口去实现多继承，接口是对类的共性进行再次抽象，抽象出类的次要类型。

　　如：蜘蛛侠，拥有人和蜘蛛的属性，但主要类型是人，次要类型(接口)是蜘蛛，

　　因为接口是次要类型，所以在类关系里不占一个节点，不会破坏类层次关系的树状结构，

　　2，标准(保证弱耦合)：一个接口就是一个标准(里面的属性不能改变，只定义了功能，

　　但没有被实现)， 接口将标准的制定者，标准的实现者以及标准的使用者分离开，

　　降低实现者和使用者的耦合。接口是java里一种重要的降低耦合的工具;

　　接口可以屏蔽不同实现类的差异，

　　当底层的实现类更换后，不会对上层的使用者产生影响，体现在参数和返回值。

　　写程序时，应该先写实现者再写使用者，如：Bank.java是实现者，View.java是使用者，

　　但是有了接口之后，就可以用接口回调的功能;

　　接口回调：先定义接口，然后写使用者和实现者的顺序随便(一般是先写使用者，

　　后写实现者);利用参数把实现者传给使用者(即：实现者是使用者的属性)，

　　使用者利用接口调用实现者相应的功能。

　　**接口和抽象类的区别 1一个类可以implements多个接口，而只能extends一个抽象类

　　2，一个抽象类可以实现部分的方法，而接口都是抽象的方法和属性

　　Object是Java里所有类的直接或间接父类，Object类里面的所有功能是所有java类共有的

　　1，JVM调用垃圾回收器回收不用的内存(没有引用指向的对象)前运行finalize()，给JVM用的方法。

　　程序显示的通知JVM回收没用的内存(但不一定马上就回收)：System.gc();或 Runtime.getRuntime().gc();

　　2，toString()返回对象的字符串表现形式，打印对象时，虚拟机会自动调用toString获取对象的字符串表现格式，

　　如：System.out.println(str.toString()); ==System.out.println(str);

　　如果本类不提供(覆盖)toString()，那么使用的是Object类里的相应方法，打印的就是地址。

　　如：public String toString(){

　　return ".....";

　　}

　　3，基本类型时“==“判断变量本身的值是否相等;引用类型时，判断的是地址是否相等。

　　equals判断的是对象内容是否相等。对于自己创建的类，应该覆盖Object类的equals()方法;

　　否则使用的是Object类里的equals()方法，比的是地址。

　　覆盖方法如下：

　　/*****************************************************

　　public boolean equals(Object o){

　　if(o==null) return false;

　　if(o==this) return true;

　　if(!(o.getClass()==this.getClass())) return false;

　　final Student s=(Student)o;

　　return this.name.equals(s.name) && this.age==s.age ; //比较原则;

　　}

　　******************************************************/

　　覆盖euqals()方法时遵循的原则：

　　自反性：a.quals(a); //true

　　对称性：a.equals(b);<==> b.equals(a); //true

　　传递性：a.equals(b);//true b.equals(c); //true

　　--->则：a.equals(c); //为true

　　封装类(Wrapper class)[U10] ：

　　OverLoading时，基本类型时采用向上匹配原则，

　　如果没有基本类型的话就向包装类转换，如果还没有就让这个基本类型在包装类里也采用向上匹配原则;

　　基本类型-转换到-->包装类

　　boolean----->Boolean

　　int-------->Integer //Integer是引用类型，

　　int-------->Ddouble //合法， 但Integer------>Double 非法

　　double------>Double

　　...... -------> ......

　　任何类型----->Object

　　基本数据类型int可以向double自动扩展，但是包装类型之间不能自动的相互转换，

　　基本类型数据--->包装类型

　　int i=3;

　　Integer it=new Integer(i); //手动转换;基本类型向包装类型转换。

　　int <----> Integer <----> String

　　转换时String类型必须为全数字字符串。如："2515" 不能为："abc265","aec"...等

　　String str=”123”; int it=Integer,parseInt(str);把字符串转换成数字。String str2=it+“”;把数字转化成字符串

　　==内部类============

　　定义在其他代码块(类体或者方法体)里的类称为内部类;

　　编译后每一个内部类都会有自己的独立的字节码文件，

　　文件名：Outer$Inner.class-->内部类也可以有父类和实现接口。也可以有抽象方法。

　　根本位置和修饰符的不同分为四种：

　　1，member inner class 成员内部类，当实例方法或变量一样理解。

　　1)定义的位置：类以内，方法之外，没有静态修饰符(static)。

　　2)本身能定义的属性和方法：只能定义非静态的属性和方法。

　　3)能直接访问的什么：能访问外部类的所有静态和非静态的属性或方法。

　　4)怎么创建对象：在外部类内的方法内：Outer.Inner inner=new Outer().new Inner();

　　在外部类外的类的方法内：Outer.Inner inner=new Outer().new Inner();或

　　在Outer类里提供一个getInner()方法,返回内部类的对象，这样在外部类外的类的方法内也可以用该成员内部类。

　　2，static inner class 静态内部类(嵌套内部类)，当静态方法或变量一样理解。

　　static只能修饰内部类，不能修饰外部类。

　　1)定义的位置：类以内，方法之外，有静态修饰符(static)。一般写在外部类的属性下面。

　　2)本身能定义的属性和方法：可以定义静态和非静态的属性或方法。

　　3)能直接访问的什么：只能访问外部类的静态属性和方法。

　　4)怎么创建对象：在外部类内的方法里： Outer.Inner inner=new Outer.Inner();

　　在外部类外的类方法里： Outer.Inner inner=new Outer.Inner();

　　3，local inner class 局部内部类 当局部变量一样理解。

　　1)定义的位置：方法里面的类，前面不能用public或static修饰。

　　2)本身能定义的属性和方法：只能定义非静态的属性和方法。

　　3)能直接访问的什么：能访问方法内用final修饰的局部变量(不能与该类内的变量名相同)。

　　能访问外部类的所有静态和非静态的属性或方法。

　　4)怎么创建对象：只能在方法内创建对象，如：Inner inner=new Inner(); 对象的作用范围只在方法内。

　　4，annonymous inner class 匿名内部类 如： Teacher tc=new Teacher(){

　　1)没有名字的类，没有构造方法。是一个特殊的局部内部类， public void teach(){...}

　　可以实现一个接口， 或者一个类， }

　　生命周期里只能产生一个对象(tc)，也就是说只能被一个对象(tc)调用，

　　2)除了没有名字外，看匿名内部类所在的位置，他的定义和访问将和成员内部类、静态内部类、局部内部类一样。

　　一般像局部内部类的定义和访问比较多。

　　3)当试图创建接口或者抽象类对象的时候，用匿名内部类。

　　表示类体的{...}紧跟在抽象实例(接口)之后，表示实现该抽象实例(接口)。

　　调用匿名内部类的方法只能用写类时创建的那个对象(tc)。

　　作用：1，不破坏访问权限的情况下，内部类可以使用外部类的私有成员变量和方法。

　　2，将接口公开，将实现类(实现公开的接口)作成内部类隐藏起来，强制要求使用者使用接口，强制降低偶合度。

　　3，Java通过接口和内部类两种机制来实现多继承。在类内部可以建立本类的实例，然后调用本类内的其他方法。

　　Exception(异常)：运行时的概念。

　　1，Throwable：运行时可能碰到的任何问题的总称;

　　1)Error：指非常严重的错误，系统不要求程序员处理，也处理不了。如：硬件坏了.....等。

　　2)Exception：从代码的角度是程序员可以处理的问题;

　　UncheckedException(RuntimeException 的子类) (未检查异常)如果是RuntimeException(或子类)就是为检查异常，其他就是已检查异常

　　程序员小心谨慎完全可以避免的异常，系统不要求程序员处理(可以不管,运行会提示错误)，

　　如：3/0 数组下标越界。

　　CheckedExcepiton (已检查异常)

　　系统要求必须处理异常。

　　2，异常处理：异常是相对于方法来说的。

　　1)声明抛出异常(消极的处理)

　　throws(抛弃)：写在方法名的定义上，后面跟要抛弃的异常类型。

　　如：public void m1() throws Exception{.}

　　异常产生时，责任可能并不在当前方法，向外抛弃(把异常抛弃，留给调用者处理)可以让异常找到一个最佳的位置处理

　　抛弃过程中可以对异常类型进行扩展，但是不能缩小。

　　throw(抛出)：一般出现在方法实现里，用来抛出异常对象(或者是产生异常)，

　　如：throw new FileNotFoundException();

　　当代码出现异常时，代码不会向下执行，JVM会将异常封装成相应的异常类的对象，

　　然后向外抛出。之后这个方法里剩下的代码就不会再执行了。

　　对于一个方法的返回值：

　　1)正常运行时，要求方法必须返回定义的类型的值。

　　2)如果运行不正常(出现异常)，方法返回的是异常对象

　　方法覆盖：名相同，参数相同，返回类型相同，访问权限不能更小，子类抛弃的异常不能比父类更多。

　　2)try....catch(积极的处理)：

　　一个try语句后可以跟多个catch语句;catch时异常子类放上面，异常父类放下面。

　　如果没有父子关系，先后无所谓;

　　---方法---( ){

　　try{

　　//可能会出现异常的代码

　　xxxxxxxxxx; (1)

　　xxxxxxxxxx; (2)

　　}catch(Exception1 e1){

　　//当try代码块出现异常时,执行catch代码块。

　　xxxxxxxxx; (3)

　　}catch(Exception2 e2){

　　xxxxxxxxx; (4)

　　}finally{

　　//不管有没有异常出现都要执行的代码。

　　xxxxxxxxx; (5)

　　xxxxxxxx; (6)

　　1)如果(1)，(2)没产生异常，(2)执行后直接执行(5)，然后执行(6)。

　　2)如果(1)产生异常，(2)不会被执行，直接跑出try{..},匹配catch，和catch里定义的类型一致，

　　执行catch完了后，直接跳到(5)执行，最后再执行(6),如果异常类型都不一致，将导至语法问题。

　　3)自定义异常类型(业务异常)：

　　如：class MyException extends Exception{

　　public MyException(String str);

　　super(str);

　　Exception异常总结：

　　1、如果程序用了System.exit(0);则不会执行finally里的程序

　　2、在程序return前执行finally里的程序

　　3、Java中异常分为两类：

　　1) checked Exception

　　处理方式一、继续抛出，消极做法，直到抛出到JVM

　　处理方式二、用try..catch

　　2) unchecked Exception (runtime exception)

　　throws ArithmeticException,IOException应该是出现这两种异常就向上抛吧。

　　什么情况下一个方法抛出几个异常?一般来说应该是会抛出几种异常，然后在一级调用这个方法时处理一下。

　　如果没有特殊需要的话要把可能出现的异常都截获并处理。

　　try{

　　method();

　　}catch(exception1 e1){

　　do something;

　　}catch(exception2 e2){

　　do something;

　　}……

　　e1的范围小于e2.

　　课外考题：12、final, finally, finalize 的区别。

　　final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

　　finally 是异常处理语句结构的一部分，表示总是执行。

　　finalize 是Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖

　　此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

　　Java高级部分=============================================

　　集合,常用的接口，Collection，List Set，SortedSet，Map，SortedMap

　　用来管理/容纳多个对象的对象(或称为容器);

　　面向对象可重用性的体现，对数组作了功能封装。

　　Collection是一个接口：是以对象为单位来管理元素的。

　　基本操作：add remove size，

　　遍历：迭代遍历

　　有两个子接口：List接口和Set接口

　　1，List接口：元素是有顺序(下标)，可以重复。有点像数组。可以用迭代器(Iterator)和数组遍历集合。

　　List接口里本身有自己的方法，还有从父接口Collection里继承的方法。

　　remove(int)删除某一位置的对象、add(int,Object)往某一位置插入对象 、get(int)查询某一位置上的元素。

　　遍历：迭代遍历、for遍历

　　Collections.sort(list); 引入list集合然后对list集合里的对象(如：Student类)进行排序时，

　　只要在让对象(类)实现Comparable接口，再覆盖接口里面的方法(compareTo()方法)，

　　在compareTo()方法里写出进行什么样的方式排序，

　　Public int compareTo(Object o){

　　Work w=(Work)o;

　　If(this.salary!=w.salary){return (int)w.salary-(int)this.salary;}

　　Else If(this.age!=w.age){return w.age-this.age;}else retuen this.name.compareTo(w.name);sss

　　然后在主函数里使用Collections.sort(list); ，就对list里的对象进行排序了，

　　而不用管Collections.sort()方法是怎么实现的，既不用管Collections.sort()方法的实现体。

　　排序规则：对象实现Comparable接口，覆盖compareTo()方法，Collections.sort(List);

　　1)ArrayList[U11] 集合类实现List接口，轻量级，底层是以数组实现的，查询快，增删慢，线程不安全，用get(int)方法多时，

　　Vector集合也实现List接口，底层也是以数组实现的。但这个类已经放弃了。重量级，查询慢，增删快，线程安全。(Vector和HashTable是线程同步的(synchronized)，所以线程安全。性能上，ArrayList和HashMap分别比Vector和Hashtable要好。)

　　2)LinkedList集合类实现List接口，他底层是以链表实现的，查询慢，增删快，

　　用remove(int)、add(int,Object)方法多时，

　　自己实现栈(stack)，并对栈里进行增删操作。

　　class MyStack{

　　private LinkedList list=new LinkedList();

　　public void push(Object o){

　　list.addFirst(o);

　　public void pop(Object o){

　　list.removeFirst();}}

　　2，Set接口：无顺序，不可以重复(内容不重复，而非地址不重复)。只能用迭代器(Iterator)遍历集合。

　　Set接口里本身无方法，方法都是从父接口Collection里继承的，

　　遍历：迭代遍历

　　实现类：保证元素内容不重复。

　　1)HashSet集合类实现Set接口，底层是以数组实现的。HashSet集合里不允许有重复对象

　　每向HashSet集合类里添加一个对象时，先使用HashSet集合类里add(o)方法，

　　再调用对象o的hashCode()方法算出哈稀码，保证相同对象返回相同的哈希码。

　　如果哈稀码一样，再调用对象o里的equals()方法对对象的属性进行比较是否相等，