第一篇：java实用总结
java是一种解释型语言，但它的源文件要编译成java字节码即.class文件,然后在java虚拟机里运行.jsp是一种WEB开发技术，它在特定的WEB容器里运行,WEB容器先把jsp转化成Servlet文件(即.java文件)，然后编译成.class文件然后在java虚拟机里运行。javascript是一种浏览器脚本语言,它被浏览器解释执行.这三种语言都采用java的语法。
java包含三大分支:
1.J2SE--java standard edition--标准版本,这个是下面两个的基础!一般是位于客户端的应用;
2.J2ME--java Micro edition--一般位于嵌入式应用,例如手机游戏
3.J2EE--java Enterprise Editon--一般为服务器端程序的应用:例如JSP站点!
现在就知道J2EE是做什么的了吧
首先java它对开发基于Web的多层{即是J2EE}应用提供了功能上的支持。它包含13种核心技术规范：
（1）Java Database Connectivity(JDBC)以一种统一的方式来对各种各样的数据库进行存取
（2）Java Naming and Directory Interface(JNDI)用于名字和目录服务，它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统等
（3）Enterprise Java Beans(EJB)提供了一个框架来开发和实施分布式商务逻辑，显著地简化了具有可伸缩性和高度复杂的企业级应用的开发
（4）JavaServer Pages(JSPs)用以创建动态网页（5）Java servlets提供的功能大多与JSP类似，不过实现的方式不同
（6）Remote Method Invocation(RMI)在远程对象上调用一些方法，使用了连续序列方式在客户端和服务器端传递数据
（7）Interface Description Language(IDL)将Java和CORBA集成在一起
（8）Java Transaction Architecture(JTA)可以存取各种事务
（9）Java Transaction Service(JTS)规定了事务管理器的实现方式
（10）JavaMail 用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类
（11）JavaBeans Activation Framework(JAF)JavaMmail利用JAF来处理MIME-编码的邮件附件,MIME的字节流可以被转换成JAVA对象，或者转换自JAVA对象
（12）Java Messaging Service(JMS)是用于和面向消息的中间件相互通信的应用程序接口(API)（13）Extensible Markup Language(XML)XML是一种可以用来定义其它标记语言的语言
所以你说的JSP是Java在web上面[一般来说java的web应用成为J2EE]的应用的一个分支而已!
现在你也就知道JSP了哈!
很多初学习者对JavaScript、Java、Jsp、J2ee之间的关系与区别总是感到很困惑，为了帮助大家快速理解几者之间的关系，我们进行了如下解释说明：
1.JavaScript用于编写嵌入在网页文档中的程序,它由浏览器负责解释和执行，可以在网页上产生动态的显示效果和实现与用户交互的功能，譬如，让一串文字跟着鼠标移动，让一个图标在网页漂浮移动，验证用户输入的信用卡号的格式正确与否，等等特效网页功能。2.Java则是一种基础性的语言，学习jsp,j2ee都要有java的基础。无论你是想成为诗人，还是小说家，还是散文家，甚至就是当记者，你都要学习语文吧，Java就相当于语文、Jsp、J2ee则相当于小说、散文等。
学好了语文，你能否就会有一份好的职业呢？不见得吧，但至少机会要多多了，语文学得越好，就更容易成为小说家，或是记者等等了。要想成为记者、散文家等等，没有语文是怎么都不行的。
3.jsp用于让www服务器产生出内容可以变化的网页文档和对用户提交的表单数据进行处理，例如，显示留言内容，留言内容总是在增加的，所以，传递给用户浏览器的网页文件内容是需要改变的，这就是jsp来实现的。将用户留言插入到数据库中，也是jsp来实现的。
4.j2ee用于开发大型的商业系统，例如，你在各个银行之间的取款，存款，银行之间要互通有无，执行存取款的记录操作，还要进行安全性检查，不能谁都可以来查帐，还要考虑网络断线等问题。
使用j2ee，你就不用编写这些底层的细节程序代码了，而将精力集中到应用的业务流程设计上。
第二篇：java总结
将数据成员声明为静态的，那么每次调用的时候，静态成员的值并不会因之而改变。
如果想在主函数调用函数（不是有对象进行调用），比如while（test（）），那么test（）必须声明为静态的。
构造器，在c++中叫构造函数，也可以叫做构造方法，每当创建一个对象的时候，就会调用构造器。
构造器可以分为默认构造器和带参数的构造器，默认构造器就是无参的构造器，构造器的作用是使类中的成员初始化。
。构造器的互相调用可以使用this，主要就是在构造器内使用this（参数），里面的参数个数和类型决定调用什么构造器。
java中初始化的顺序，首先是创建一个对象，如果是创建的静态的对象和非静态的对象，先调用静态的对象，然后系统就会在堆中给他分配内存空间，如果在静态对象的类中有静态的成员类和非静态的成员类，先初始化静态的成员类，然后在调用非静态的成员类，最后调用自己的构造函数，如果在主函数创建的是非静态的对象，如果创建的类中有静态成员类，不进行初始化，只进行非成员类的初始化，最后执行自己的构造函数。
引进类库的时候要注意如果引进的是同名的类或者方法，在不使用的情况下，系统不会报错，但是，一不小心就会有错误。，但是，如果类中的私有方法不能被继承，在向上转型的时候就会出错，所以多态并不适合私有方法。而final不能被覆盖，所以在运行的时候也会出错。如果使用static，父类的静态方法会被子类的静态方法隐藏，而父类是静态，子类不是静态的，则会编译出错。
空白final增加了程序的灵活性，但必须在构造器中给他赋值（可以是有参的构造器，也可以是无参的构造器），你可以定义一个final类，里面的属性是可以引用改变它。
抽象类，如果父类是抽象类，则需要把父类的方法在子类中全部实现，如果父类不是抽象类，而父类的父类是抽象类，不需要将方法实现。如果方法是抽象的，那么就需要把类也定义成抽象的。
如果抽象类有final，static定义的方法，则子类中的方法不需要实现的。私有的更没法实现了。因此，当我们实现一个接口的时候，就需要将接口的方法实现，是因为接口就是抽象的，在接口中所有的方法都没有实例化。
在java中存在着内部类，就是在类中定义类，这跟内部成员类是有区别，内部类可以将方法和属性在这个类中实现初始化形如A.a a=t.new a()的形式。当然也有匿名内部类等。下面说下容器也叫集合。
容器有set list queue和map
你可以声明一个容器来保存一个对象或多个对象，通常我们add方法和get方法将某个对象加入容器和得到加入容器的对象，如果父类添加到
容器的对象，那么子类也可以加入到容器中，但是，如果是子类的子类，那么你就需要提示当前的是什么类型的，否则的话，编辑器将会报错，下面来讨论下加入容器中的顺序与重复值的问题，list必须按照顺序添加元素，而set不能有重复元素。
刚刚我们讨论add方法每次加一个元素到容器中，那么是否可以天健一组元素到容器中那，那么，使用我们可以（容器对象）。addall方法
运行速度相对较快，我们还可以使用Collections.addall（），把一些值赋给某个对象，而这种方法似乎方便的多。
还有许多排序方法，当然，你可以再实践中检验当前的排序问题。
下面有 continous，indexof remove等一些方法，还是需要在实践中检验。
迭代器是个好东西，他可以使容器的类型发生多用，要首先见对象转换成iterator类型，那么就需要调用iterator()方法，下面就需要检验它是否
有下一个值，如果有的话，就把它的下一个值传给当前容器的对象，本质上传的应该是引用，下面就可以输出当前的引用，但是你可以赋给toString方法
使他可以传进一个对象进来。对象的getfirst()和element（）方法传的是当前对象的头对象，如果为空，则抛出异常，peek（）方法，如果列表为空，则
返回null。remove和removefirst（）如果列表为空，则返回异常，否则，返回移除当前的对象，poll（）方法当列表为空时，返回null，addfirst和add和addlast
一样都是把对象加到列表的尾部。
栈是先进后出或后进先出的容器就像子弹夹一样。模拟下?? 就是addfirst（）不断的将元素加到列表的末尾，然后，removefirst将的第一个元素去掉。
set元素的键 值相对，键使用的是keyset方法，值是value是方法。要想键值相对，只需要使用两个for循环。
queue是先进先出的容器??? 使用offer方法将对象依次向后排，然后使用removefirst就可以发现队列的性质。
java异常
异常通常来捕捉错误，这些错误，分为Error错误，这些错误如 内部内部错误和资源耗尽错误，通常是不可预知的，我们似乎通知用户，无能为力，第二种是运行错误，在运行错误中，如果是文件操作，你不捕捉异常，系统将会报错，而令一个错误就是语法，这种错误你可以尽可能的避免，但是有些错误，在编程的时候还需要提醒用户，而且尽可能的捕捉。
在异常处理的过程中如果在try{}中加入return语句，那么finally中的语句也会被执行，抛出异常后，try{}下面的语句将不会被执行，finally中的语句一定被执行，但是如果finally语句
放在try{}和catch{}之间，那就悲剧了，可能会发生异常丢失，在构造器中尽量不要捕捉异常。通常情况下，你知道怎样捕捉异常才会去捕捉异常。
java
IO系统
javaIO系统通常进行的文件的操作和网络的操作和内存的操作。有输入流和输出流，输入流就是把文件或者网络中的东西写到内存，输出流就是把东西输入到文件等。
输入流通常使用的是write（）方法将数据写到文件。输出流通常是通过read（）方法将数据读出来。在文件的外面可以加上缓冲流? 或者dateoutputstream来对整数，double等进行
操作。加入缓冲流可以提高速度，可以1行1行的读。对文件进行处理通常是字节和字符，有时候我们可以讲字节转化成字节。还有对压缩文件的读取等等。
java 线程
所谓线程? 就是一个程序有多个任务在执行，每个任务都需要使他启动，通常情况下需要将线程与集合联系在一起，但在集合中有安全的和不安全的。那么线程将同步运行。但是有时候我们通过start（）方法来运行线程是相当消耗系统资源的，因此，java se5提供了一中
新的方法来启动线程，我们可以通过限制线程的数目来减小资源的浪费，如果我们想每次只启动一个线程，而且把这个线程结束，那么
就可以限制线程的数目为一。
当然如果我们想加入一个线程，通常情况下，我们可以通过加入join（）的方法，他会在某个线程结束之后，启动join（）加入的线程，这个线程是可选的，如果这个线程被打断了，通常这个线程会抛出异常，然后，join（）方法加入的线程会立刻被执行。
下面的就是图形界面了。
可以添加按钮，文本框，密码框，和各种布局管理器。以及如何实现监听等等。感觉太没意思了
下面就说下坦克大战如何实现的。也就是多线程，图形界面，各种类，监听，集合等构成的像放电影一样的由你操作的游戏。当我们从键盘中进行前进或者退后的操作时，那么面板中必须不断重新画出这个坦克，才能使我们感觉坦克在移动，那么以前的坦克哪里去了，那他肯定是垃圾了，所以一定会被回收，当然画出子弹的状况也是如此。
而敌人的坦克也是这样画的，只不过是个死循环。
第三篇：Java学习总结
8月份学习总结
目录一、二、1)
2)
3)
4)
5)
6)
7)
三、前言..........................1 主要知识点概括....................2 初识Java.........................2 变量、数据类型和运算符.........................2 运算符和基本选择结构......................3 复杂选择结构........................3 循环结构
（一）....................4 循环结构
（二）....................4 数组..........................5 学习体会.........................5一、前言
在青鸟将近2个月的学习生活当中，从计算机基础学到了Java程序基础，个人感到在青鸟的学习十分的充实。不仅掌握了必须的理论基础，也通过实践巩固了各种程序基础。同时，在这段学习期间，我也逐步融入了171班这个大家庭。使用Java理解程序逻辑这门课程将近上了一半，主要学习了以下7个内容：
初识Java
变量、数据类型和运算符
运算符和基本选择结构
复杂选择结构
循环结构
（一） 循环结构
（二） 数组
二、主要知识点概括
1)初识Java
主要知识点
① Java应用程序开发基本步骤。
② Java程序的结构、编写规范以及注释。
重点关注
① 源程序.java文件编译后变成.class文件，通过控制台使用命令“javac 空格 文件名.java”对源程序进行编译。再通过“java 空格 文件名”命令运行编译后的class文件。
② public修饰的类的名称必须与Java文件同名。
③ main（）方法中的void不可少。
④ Java对大小写敏感。
⑤ 每个完整的语句都要以“;”结束。
⑥ println语句中用于输出字符串的引号必须是英文的引号。
2)变量、数据类型和运算符
主要知识点
① 常用数据类型。
② 变量的声明与赋值。
③ 赋值运算符与算术运算符。
④ 数据类型转换。
⑤ 调用Scanner类实现从控制台获取键盘输入信息。
重点关注
① 自动类型转换的条件：(1)两种类型需兼容；(2)目标类型大于源类型。
② 输入公式需注意数据类型，如双精度变量degreeCel 和degreeFah。不管degreeFah为何数，经过degreeCel = 5/9*(degreeFah-32)运算后，degreeCel 始终为0.0，没有
得到想要的结果。是由于5/9的结果为整形，运算结果为0，乘以(degreeFah-32)后始终为0，需把9改为9.0。
③ 声明变量后养成变量赋初值习惯。
④ 使用Scanner input语句需记得在程序开头调用Scanner类。
3)运算符和基本选择结构
主要知识点
① boolean类型变量。
② 使用关系运算符比较返回boolean类型结果。
③ if选择结构与if else选择结构
重点关注
① 优先级：++、--、!>算术运算符>比较运算符>&&>||。
② 逻辑&&和逻辑||具有判断短路特点。
③ if语句后面的条件判断可以放置boolean类型变量或返回boolean类型结果的表达式。④ if语句执行的代码块需用大括号括起来。
⑤ char类型变量与字符比较可以用‘== ’，String类型变量与字符比较用.equals(“ ”)。
4)复杂选择结构
主要知识点
① 多重if选择结构、嵌套if选择结构。
② switch选择结构。
③ 用户输入信息判断。
重点关注
① 先确定将要实现功能的逻辑结构，从而选择合适的if结构实现代码。
② switch结构只能处理等值条件判断，且条件必须是整形变量或字符型变量，而多重
if结构没有此限制。
③ 通过input.hasNext()==true语句进行用户输入信息类型判断。获取用户输入信息的语句需处于input.hasNext()==true的判断结构内。
④ 多个分支的输出内容含有大部分相同字眼时，可把不同的字眼放入字符串变量内。
然后在选择结构内判断输出的字符串，选择结构外统一输出所有内容，实现程序优化。
5)循环结构
（一） 主要知识点
① while循环语句的使用。
② do while 循环语句的使用。
③ 程序调试。
重点关注
① 编写循环结构代码时需注意循环变量的初值，循环操作中对循环变量值的改变和循
环条件三者间的关系需合乎逻辑，确保循环次数正确以及不出现死循环。
② while循环的特点是先判断，后执行；do-while循环的特点是先执行后判断。根据要
实现的功能判断使用何种循环语句。
③ 当循环体内存在循环监控控制台输入信息体系时，可通过设置标志flag去控制输出
不同的输入提示。
④ My eclipse中调试程序设置断点后按F5单步跳入，F6单步跳过，F7用于单步跳入后的返回。
6)循环结构
（二） 主要知识点
① for循环语句的使用。
② break与continue语句的使用。
重点关注
① for语句的语法格式：for(参数初始化；条件判断；参数值改变){循环体}。
② 循环次数确定时选用for循环结构。
③ break语句实现直接跳出循环体，去执行循环块下一条语句。
④ continue语句实现终止执行当前循环continue语句后的语句，且进入下一次循环。⑤ break语句和continue语句除了可用于for循环体外，也适用于while与do while循
环中。
7)数组
主要知识点
① 数组的定义。
② 数组元素的访问。
③ 数组的输入与输出。
④ 数组元素升序排列。
⑤ 基本数据类型与引用数据类型。
重点关注
① 数组的下标是从0开始的。
② 数组元素的录入可以通过嵌入循环体内进行动态初始化，数组的输出可以使用一个
循环动态输出数组元素。
③ 利用Arrays类提供的sort()方法对数组元素进行升序排序。
④ int、double、char、boolean类型是基本数据类型，String和数组是引用数据类型。
基本数据类型变量声明后会赋予一个默认值。
⑤ 数组引用赋值需注意引用数组的赋值将会同步改变被引用数组的原值。
三、学习体会
首先，想成为一个专业的程序员，英文词汇量首先要足够的庞大。就拿变量声明来讲，变量命名应该做到顾名思议，若词汇量的匮乏，变量的命名很难达到要求。因此，需要更多的时间去积累英文知识。
另外，通过这一个月以来的学习发现编程思想十分重要。每个程序实现之前
都需要构建明确的编程思路。编程思路主要体现在：（1）算法确定。实现最终的算法，可以有多个路径选择。不同的编程思路会影响程序的大小以及运行效率；
（2）语句选择。比如实现特定功能，却只有一种语句是最适合；（3）程序结构。对于要实现一个较为庞大的体系，需要明确每个功能实现的先后，每个功能实现的先决条件。不然后续工作将变得十分混乱，代码冗余。
第四篇：java总结
调用父类构造方法
在子类的构造方法中可使用super(argument_list)语句调用父类的构造方法
如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错
1public class Person {
3private String name;
4private int age;private Date birthDate;
7public Person(String name, int age, Date d){ 8this.name = name;
9this.age = age;
10this.birthDate = d;
11}
12public Person(String name, int age){ 13this(name, age, null);
14}
15public Person(String name, Date d){ 16this(name, 30, d);
17}
18public Person(String name){
19this(name, 30);}
21// ……
22}
1public class Student extends Person {
2private String school;
4public Student(String name, int age, String s){ 5super(name, age);
6school = s;
7}
8public Student(String name, String s){
9super(name);
10school = s;
11}
12public Student(String s){ // 编译出错: no super()13school = s;
14}
15}
对象构造和初始化细节
分配存储空间并进行默认的初始化
按下述步骤初始化实例变量
1.绑定构造方法参数
2.如有this()调用，则调用相应的重载构造方法，然后跳转到步骤5
3.显式或隐式追溯调用父类的构造方法(Object类除外)
4.进行实例变量的显式初始化操作
5.执行当前构造方法的方法体
==操作符与equals方法
==操作符与equals方法的区别：
引用类型比较引用；基本类型比较值；
equals()方法只能比较引用类型，“==”可以比较引用类型及基本类型；
特例：当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个实例；
用“==”进行比较时，符号两边的数据类型必须一致(可自动转换的基本数据类型除外)，否则编译出错；
由装箱引发的——Integer比较的来龙去脉
前置知识： 众所周之，java是保留了int，char等基本数据类型的，也就是说int类型的并不是对象，然而有些方法却需要object 类型的变量，所以java使用了装箱机制，我们可一自豪的这样声明一个整型变量：Integer a = new Integer(10);那么整型的a也就是对象了，那这句是什么意思呢：Integer a= 10;java中可以这样声明一个对象吗？当然不是，从jdk1.5后，java实现了自动装箱，也就是自动将Integer a =10 中的int类型的10转化为了 Integer类型。好，有了前面的只是我们且先看一个题目：
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a==b);
System.out.println(c==d);
答案是什么呢？ 如果您回答true，false，那么很遗憾的告诉你，哈哈，其实你答对了！！
那我们晕了就相差1的两个数为啥走向了“反目成仇”的地步呢？凭啥127等于127，我128就不等于128呢？且听我慢慢道来，Integer a =127,Integer a=128。
127，128应该不会造成什么差异吧，难道是自动装箱的过程有猫腻？找下源码看看：
private static class IntegerCache {
private IntegerCache(){}
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i128);
}
这是用一个for循环对数组cache赋值，cache[255] = new Integer(255-128),也就是newl一个Integer(127),并把引用赋值给cache[255],好了，然后是Integer b= 127,流程基本一样，最后又到了cache[255] = new Integer(255-128),这一句，那我们迷糊了，这不是又new了一个对象127吗，然后把引用赋值给cache[255]，我们比较这两个引用（前面声明a的时候也有一个）,由于是不同的地址，所以肯定不会相等，应该返回false啊！呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象
来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！，那么我们进行比较a==b时，由于是同一个对象的引用（她们在堆中的地址相同），那当然返回true了！！
然后我们在看Integer c = 128;Integer d = 128;这两句。现在不用我说就应该能明白了吧，当数据不再-128到127之间时，是不执行return
IntegerCache.cache[i + offset];这句的，也就是不会返回一个static的引用，而是执行了return new Integer(i);于是当 Integer d = 128 时，又会重新返回一个引用，两个不同的引用
在做c==d 的比较时当然返回false了！
下面附上本程序的字节码以供喜欢底层的读者参考：
Compiled from “CompareInteger.java”
public class CompareInteger extends java.lang.Object{
public CompareInteger();
Code:
0:aload_0
1:invokespecial#1;//Method java/lang/Object.“
public static void main(java.lang.String[]);
Code:
0:bipush 127
2:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
5:astore_1
6:bipush 127
8:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
11: astore_2
12: sipush 128
15: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
18: astore_3
19: sipush 128
22: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
25: astore 4
27: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
30: aload_1
31: aload_2
32: if_acmpne39
35: iconst_1
36: goto40
39: iconst_0
40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
46: aload_3
47: aload4
49: if_acmpne56
52: iconst_1
53: goto57
56: iconst_0
57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return
}
评论：呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！
呵呵，博主我被你这句话小小的误导了一下，其实你这里说的原理没错，但是把位置说错了，这段代码只是初始化cache：
static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i-128);
}
但真正让cache[i]为static变量的是这句代码：
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];
第五篇：Java总结
Java实验
1.调试HelloWorld程序
2.this,super,get ,set,把课本90页程序4.7中的name改成私有变量
3.继承，重写，父类引用指向子类对象
4.验证数组Arrays类和Collection类
5.编写一个自己的异常类并捕获之。
6.编写一个类，将该类的几个对象装入TreeSet容器中，并将该容器的内容通过输出流写入文件中。
前三章重点
0.java的数据类型：四类八种-（1）布尔类型Boolean;(2)字符类型char;(3)整数byte,short,int,long;(4)浮点类型：float,double;1.面向对象的3个基本特征：封装，继承，多态。
2.构造方法和普通方法的区别：对构造方法而言，它有以下特性---（1）方法名必须与要创建对象的类名相同。（2）不允许声明返回类型，即使声明为void也不被允许。
3.this关键字:是一个引用，this引用指向的是其本身所在方法的当前对象。this的使用方法:(1)调用成员变量；（2）可以用this()调用其他构造函数。
4.java中只对类成员变量进行自动初始化，而方法内部的局部变量在使用前必须手动初始化。
5.static 关键字：可用来修饰类的成员变量和成员方法，需要注意两点--（1）静态方法不能调用类的非静态方法，不能访问类的非静态变量。（2）静态方法和静态变量（非私有的）可以有两种调用方式，一是实例对象调用，二是类名直接调用。
6.类成员访问控制修饰符public、private、default(可不写，即缺省状态)、protected的使用：public-公用的；private-私有的，只在定义它的类内部使用；default-可以被同一包中的类访问；protected-既可以被同一包中的类访问，也可以被不在同一包中的子类访问。
7.方法的重载：指方法名相同，而方法的参数列表不相同。参数列表不同有三层意思：（1）参数类型不同。（2）参数顺序不同。（3）参数个数不同。另外需注意，在同一个类中，当方法名和参数列表都相同时，访问控制修饰符或方法返回类型不相同并不是方法的重载，而且这种情况在java中是不被允许的。
第四五章重点
1.继承：需使用关键字extends.在使用继承时需注意--（1）每个子类只能定义一个超类（父类），即extends后面应且仅应跟一个类名作为该类的父类。（2）父类中的私有属性和私有方法不能被继承。
2.方法的重写：即子类对超类中的方法保持方法名、返回类型和参数列表不变，重写了方法体，使子类和超类完成不同的工作。重写需注意下面几个关键点：（1）超类中的私有方法不能被重写。（2）访问限制符强度由低到高依次是：public、protected、default、private,在重写过程中，如果子类和父类中方法的返回值、方法名及方法的参数列表都相同，这时，要求子类中该方法的访问限制符强度不能超过父类的。即如果父类中为public时，子类也只能为public,而不能是余下的三种。
3.重载（overload）和覆盖（override）的区别：(1)重载—发生在一个类的内部或子类与父类之间，要求方法名相同而参数列表不一样。（2）覆盖—只能发生在继承过程中，要求子类方法的返回类型，方法名和参数列表同父类的都相同，而方法体不一样。
4.构造器的调用顺序：先祖先，再客人，最后自己。
5.多态：指在类继承中子类和父类中可以有同名但意义或实现方式不同的属性和方法。分为：覆盖和重载。多态的优点：因为多态，可以在程序中对类进行扩展，而不需改变那些操作基类接口的方法。
6.动态绑定：指在代码执行期间，判断所引用对象的实际类型，根据其实际类型调用相应方法。动态绑定存在的三个必要条件--（1）要有继承；（2）要有重写（覆盖）；（3）父类引用指向子类对象（向上转型）。
7.Object中常用的方法总结：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，尽可能记几个，以防老师让咱们列举）注：java中Object类是所有类的父类，即java中所有的类都有上述9种方法。
8.对象的比较：注意关键字instanceof的使用。
9.抽象类：
抽象方法—用关键字abstract修饰的方法，该方法只需方法的声明，而不需方法的实现（即无方法体）。
抽象类——至少包含一个抽象方法的类，也用abstract关键字声明。（注：（1）抽象类中可以有一些具体方法。（2）抽象类不能实例化。（3）子类继承抽象类必须实现其抽象方法。）
10.接口：
（1）可以看成是高度抽象的抽象类，但是接口不是类。
（2）用关键字interface来声明接口，用关键字imlpements来实现接口。
（3）接口不能有具体方法，不能有实例数据，但可以定义常量。
（4）实现接口的非抽象类必须实现接口的所有方法。
（5）每个类可以实现多个接口，这些接口用逗号隔开，同时，一个接口可以被多个类实现。
第六章：重点看一下实验四
1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必须保持元素的特定顺序，常见的实现类有ArrayList和LinkedList；Set不能有重复元素,常见的实现类有HashSet和TreeSet。
Map——一组成对的“键值对”对象，即其元素是成对的对象，常见的实现类有HashMap和TreeMap。
第七章 1.异常类的根类是Throwable类，它的两个直接子类是Error类和Exception类。
2.异常中常用的5个关键字为：try,catch,finally,throw,throws.其中，try和catch:用于捕获异常；finally:无论try块中的异常是否抛出，finally中的代码块总能被执行；throw:抛出异常；throws：声明异常。
3.“未被检查的异常（Unchecked Exceptions）”和“受检查的异常(Checked Exceptions)”——
Unchecked Exceptions :编译器不检查方法是否处理或抛出的异常，即不做处理，编译时不报错。
Checked Exceptions：受编译器检查的异常，即不做处理编译时通不过。
4.常见的几种Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(尽可能的记几个吧，以防不测)第八章
1.流--字节流和字符流；
流--节点流和处理流。
2.所有的输入流都是从抽象类InputStream和Reader继承而来。所有输出流都是从抽象类OutputStream和Writer继承而来。3．字节流：InputStream和OutputStream;字符流：Reader和Writer；
4.节点流：直接与文件等底层打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.处理流：相当于包装流，套在节点流上，方便数据处理。相关一些用法，具体参考最后一次实验。
点击咨询 