第一篇：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基础搞定了！有了基础学习还是好，万事开头难这句话说的太对了，学计算机语言我觉得记忆好的方法就是多打代码，课前预习，课堂上认真听讲，把现学的方法把以前所做的作业用最简便的方法再一次巩固，创新最重要，在后续的学习中，得要加倍努力学习。
其实学java有不懂，要先自己思考。想清楚这句代码是什么意思。为什么要写在这，等等之类的。等你真的搞不明白的时候，就一定要向老师咨询，不要感到有什么丢人的。因为不会是很正常的事。并不是每个人都是天才，一学就会，一学就能运用自如的。学java有一点是非常重要的，就是练习。一段代码要不停的敲，多敲几遍，尤其是自己不熟悉或者不熟练的代码，更要敲。不要感觉到厌烦，其实我感觉敲代码挺好玩的，并不是一件很枯燥的事。
老师平常布置的课后上机练习题一定要做，课后的练习题能够让你把新学到的知识巩固一遍，能够加深记忆，不会让你在以后做题的时候感到没一点思路。
当感觉到不会的时候，千万不要气馁，因为这很正常，现在的学习就是为了培养你有一个逻辑思维，为了以后开发软件的时候有个完整，清晰的思路。
其实，总体来说。学习java很快乐。尤其是当你遇到一道自己不会的题，然后，又通过自己的努力解决了，那时候，那种心情不是用言语来表达的。就好像你遇到一个数学难题，自己解决了之后那种成就感一样。
学java的时候一定要，放松心情，轻轻松松的来学，随时让自己快乐着，这样能够让你能够更快的接受java，千万不要有什么心理负担，因为java的特点之一就是--简单易懂。只要自己努力到了，就一定能够学好java。
学完了JAVA今天我们用项目案例：迷你DVD管理器来巩固了我们所学的所有内容，通过这项目的操练，首先，1、项目用到了会使用顺序、分支、循环、跳转语句编写程序，2、要会使用数组、操作字符串，3、会使用带参的方法；
4、会定义类、创建和使用对象，看到这些脑袋里一片迷茫啊！不知道怎样写，然后想到早写晚写都一样，就照着书上写起来了，到现在还是弄不懂的就是那个对象数组，不知道怎样去理解，抽象的把我抽晕了，有望老师来给我们补补这一章，在实现DVD的业务处理时，计算时差还是不懂，照着书上打了一遍，可还是得不到想要的结果，经过网上的搜寻与老师讲解，现在已略懂一二了，在做完这项目后，真不知道当时是怎样敲出来的，难道这就是所说的灵感！感觉很高兴，现在已习惯了代码报错，其实代码报错是一件值得鼓励的事，因为没有错就觉得自己什么都懂了，在学习中相信每一个人都遇到过挫折吧！但一定要想方法战胜挫折！我的战胜挫折方法就是不懂思考后还不懂就问，懂了以后就笔记本记下当时的解决方案！学习刚开始！后面的路很长，慢慢的去磨炼了！总结完毕！
第三篇：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.处理流：相当于包装流，套在节点流上，方便数据处理。相关一些用法，具体参考最后一次实验。
第四篇：Java个人总结参考
1、Java中取消指针运算防止了内存泄露的可能性。Java中的引用其实就是指针。JAVA语言不支持C++友元方法或友类。
2、编写完java源代码后，首先将其编译为一种中间状态字的字节码，然后Java虚拟机上的解释器来解释执行，“一次编程，到处运行”，Java是文本文件，编辑代码。
3、Window系统对于DOS命令中字符大小写不敏感；Java编译器和解释器对大小写敏感；保存源文件时，文件名一定要和源文件中公开类的类名一致。
4、习惯上，变量名以小写字母开头，类名以大写字母开头，常量名中所有的字符均大写。
5、final常量：初始化后不再重新赋值，在类继承时不允许子类覆盖。
6、类实例化就成为对象。
7、类继承：继承父类的属性和方法（关键字extends）
定义抽象类：关键字abstract
类声明：P62
类成员：P63
8、Java接口中声明了一组抽象方法，它构成了实现该接口的不同类共同遵守的约定。在类的定义中可以用关键字implements来指定其实现的接口。
9、Java接口与类的重要区别：Java接口中不存在构建器。
10、包的作用（P105）；Java中类的访问控制符（P77）；操作符优先级（P38）
11、包的命名：网络域名的逆序
包的使用：关键字import
12、异常处理（P119.120.125）：FileNotFoundException：代表文件未找到；SQLException：代表有关JDBC的异常；NullPointerException：表示试图引用null对象的方法或属性；IndexOutOfBoundException：表示数组越界的异常。
13、框架的默认关闭程序：f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14、setIconImage用于设定框架的图标；setLocation用于设定框架在屏幕上的位置。
15、取得框架的内容窗格：Container contentPane=f.getContnetPane();
16、面板的默认布局管理器是FlowLayout。setBownds(x,y,w,h)设置x，y坐标以及宽和高
17、内容窗格的默认布局管理器是边框布局（BorderLayout）
18、网格布局（GridLayout）将容器划分为大小相同的网格。
19、网格袋布局（GridBagLayout）是最灵活，也是最复杂的布局管理器。20、对话框 P180
showMessageDialog：消息对话框
showInputDialog：输入对话框
showConfirmDialog：确认对话框
showOptionDialog：选项对话框
21、类File有三种常用构建器：
File（String fileName）
File（String directory ,String fileName）File（File directory ,String fileName）
22、位于java.io包中的类包含两组独立的类层次结构：一个用于读取字节，成为字节流；一个用于读写字符，称为字符流。区别在于它们处理数据的方式，字节流按字节（一个8位组）来处理。字节流（P243）字符流（P245）
23、System.in 表示系统标准输入流，指向键盘输入；System.out 表示系统标准输出流，指向屏幕输出；System.err 表示系统标准错误输出流，指向屏幕输出；
24、文件的读写工作包括三个步骤：①、打开文件输入流或输出流；②、文件读或写操作；③、关闭文件输入流或输出流；
25、定制线程类：①、继承线程类Thread；②、实现Runnable接口；
#约定俗成的命名规则#
1、类名首字母必须大写
2、方法和属性必须小写
3、由多个单词组成的类名或方法必须采用驼峰标识
如：类名：StudentAdmin 方法或属性：studentName
*Equal 匹配
*equalIgnoreCase 匹配时忽略大小写 *Indexof 包含
*getMetaDate 获取元数据 *精度转换
*面向对象三大特性：封装、继承、多态 *界面逻辑、业务逻辑、数据逻辑 *三层架构总结：
1、开发人员可以只关注整个结构中的其中某一层
2、可以很容易用新的实现来替换原有层次的实现
3、可以降低层与层之间的依赖
4、有利于标准化
5、利于各层逻辑的复用
第五篇：Java笔记总结
1、Java是一种可以编译 跨平台、面向对象的高级计算机语言。
2、Java语言的特点：简单、安全、跨平台、面向对象、支持多线程。
3、Java的三个技术平台分别是 JavaSE、JavaEE、JavaME。
4、Java程序的运行环境简称为 JDK。
5、编译Java程序需要使用 javac 命令。
6、javac.exe和java.exe这两个可执行程序存放在JDK安装目录的bin目录下。
7、PATH环境变量用来存储Java的编译和运行工具所在的路径；CLASSPATH环境变量 则用来保存Java虚拟机要运行的“.calss”文件。
8、.class文件在 java.exe 文件启动的JVM中运行。
9、JRE与JDK之间的区别：
a)JRE（Java Runtime Environment）提供java程序运行所需要的基本条件（如JVM）和许多基础类。
b)JDK（Java Development Kit）是Java程序开发工具包——包含编译工具、解释工具、打包工具等开发工具。
10、JVM——Java虚拟机，相当于一个虚拟的操作系统，负责运行javac.exe生成的 字节码（二进制）文件。java.exe执行”.class”，就是java.exe启动JVM运行”.class”文件。
11、标识符命名规则：
a)包名所有字母一律小写。
b)类名和接口名每个单词首字母大写。
c)常量名所有字母都大写，单词之间用下划线分开。
d)变量名和方法名的第一个单词小写，之后的每个单词首字母大写。
12、强制类型转换：
a)格式：目标类型 变量名 =（目标类型）值
b)int类型转换成byte类型 很容易造成 精度丢失。因为int类型变量是32位，byte类型只有8位，所以在转换过程中会丢失int类型的高3位字节。
c)在用”双字符“型运算符（+=、-=之类的）运算时，强制类型会自动完成，不用程序显示的声明。
13、三元运算符：判断条件？表达式1：表达式2；——若条件成立，执行表达式1，否则执行表达式2。
14、跳转语句：
a)break：
i.用于switch语句，终止某case并跳出switch结构。ii.用于循环语句，跳出循环语句，执行后面的程序。
b)continue——只用于循环语句中：终止本次循环，执行下一次循环。
15、方法重载：
a)2个条件：方法名相同、参数个数或参数类型不同。b)与返回值类型无关。
16、数组：
a)定义数组：
i.类型[ ] 数组名 = new 类型[ 数组长度 ] //这种定义方式只指定了长度，元素的初值由系统自动赋0。（动态初始化）
ii.类型[ ] 数组名 = new 类型[ ]{元素，元素，......} iii.类型[ ] 数组名 = {元素，元素，......} //这2种称为 静态初始化。
17、冒泡排序：
a)若有n个元素，则进行n-1轮排序（n-1次外循环）
b)第1轮排序，元素之间进行n-1次比较；第2轮排序进行n-2次排序......最后1轮只进行1次比较。c)外循环条件：i < arr.length d)内循环条件：j < arr.length1
18、二维数组：
a)定义方式1：类型[ ][ ] 变量名 = new 类型[ 几行 ][ 几列 ];b)可理解为数组的 数组——例arr[0][1]-->数组名arr[0]，第二个元素[1];c)二维数组的 长度 由”[ 几行 ]“确定！
d)定义方式2：类型[ ][ ] 变量名 = new 类型[ 几行 ][ ];//行数确定，列数不确定——每行可以随便 赋值。
e)定义方式3：类型[ ][ ] 变量名 = { { ,...,...,...}，{ }，{ }，......} //这种行数、列数都不确定。大括号 内的每个 大括号 代表 一行 的元素，每行有多少个元素 取决于 内大括号 中元素的个数。
19、面向对象的特点：封装性、继承性、多态性。
20、在创建变量后，JVM运行程序时，会自动初始化变量。引用型变量 为 null。
21、垃圾对象——没有变量引用的对象。
22、类的封装：将类中的属性 私有化。外界访问私有属性时 只能通过该属性的 getxxx（）方法。
a)//择Generate getter and setter--> 自动生成
set和get方法。
23、构造方法：实例化对象。
a)可以用 带参数的构造方法 在实例化对象时就 给私有属性 赋值。b)好的程序员 应该为每个类 写一个 无参构造方法。c)定义构造方法的条件：
i.方法名与类名相同。ii.没有返回值的 声明。
iii.方法中 不能有return 返回值。
24、this关键字
a)this指代 该类实例化的 对象。所以可以用 this.xx的方式调用 成员。b)在成员方法中使用this关键字，避免参数名与属性名相同。c)用this关键字调用 构造方法
i.只能在构造方法中 用this调用其他构造方法； ii.此时this语句必须位于第1行，并且只能出现一次 iii.不能在一个类的两个构造方法中互相调用。
25、static关键字
a)静态变量：
i.用static修饰的变量 ii.静态变量被所有实例共享
iii.可以使用“类名.变量名”的形式来访问。iv.只能修饰 成员变量 b)静态方法
i.希望在不创建对象的情况下也能条用 类中的 某个方法，那就用static关键字休息这个方法 ii.静态方法 只能访问 静态成员！
//因为非静态成员 必须先创建对象才能访问，而静态方法在被调用的时候可以 不创建对象——那么就没有非静态成员可供访用。
c)静态代码块
i.当类被加载时，静态代码会执行一次。而类只会被加载一次，所以静态代码块只会被执行一次。
ii.通常会用静态代码块对类的成员变量进行初始化。d)单例模式
i.private static 类名 INSTANCE = new 类名();量——自己创建一个对象。private 类名(){};
//私有的 构造方法，只能内部访问
}
//私有成员变public static 类名 getInstance(){ return INSTANCE;//定义静态方法，返回自己的实例对象。ii.第二种单例模式创建方法。
1.Private 类名(){} 调用。
2.public static fianl 类名 INSTANCE = new 类名();的不能被修改的 静态成员对象。
26、内部类——定义在类里面的 类
a)成员内部类
i.相当于成员方法，可以访问外部类的所有成员；
ii.因为成员内部类相当于 成员方法，所以想要创建内部类对象时，必须得用外部类的对象 去创建内部类对象：
1.外部类名.内部类名 变量名 = new 外部类名().new 内部类名();b)静态内部类
i.用static修饰的成员内部类，也相当于静态方法。只能访问外部类的静态成员。
ii.因为静态，所以在创建内部类对象时，可以不用先创建外部类对象：
1.外部类名.内部类名 变量名 = new 外部类名.内部类名();iii.静态内部类中 可以定义静态成员，非静态内部类则不可。c)方法内部类
i.在方法中定义的类，只能在当前方法中被使用。
27、当一个对象被当成垃圾从内存中释放时，它的 finalize（）方法会被自动调用。
//公有
//私有的 构造方法，只能在类的内部被
28、继承
a)继承关键字：extends。b)格式：Class A extends B{} c)单继承——一个类只能有一个直接父类。
29、重写父类方法
a)条件：方法名、参数、返回值类型 3个都相同。
b)重写之后，子类调用被重写的方法时，就是调用自己写的方法。c)重写应用：
i.应用对象 是父类的 公有方法。重载 应用的对象是 类本身的 方法。ii.重写父类 不适合子类的 方法 iii.实现接口。
30、super关键字
a)调用父类成员变量和成员方法：
i.super.成员变量;ii.super.成员方法（参数1,参数2,...）;b)调用父类的构造方法
i.super（参数1,参数2,...）;ii.必须位于子类的构造方法的第一行，且只能出现一次。
iii.在实例化子类时，系统会在 子类的构造方法中 调用
父类的构造方法——如果子类的构造方法中 没有调用 父类的构造方法，系统会自动调用父类的无参构造方法。所以 每个类的 无参构造方法 一定不要漏了！子类也可以显示的调用 父类的有参或无参构造法方法。c)解决 重写了父类方法之后，不能调用父类方法的问题。
31、final关键字
a)final修饰的类 不能被继承 b)final修饰的方法 不能被子类重写
c)final修饰的变量 是常量，不能被修改，且必须在定义时 为变量赋值。
32、抽象类
a)关键字 abstract b)抽象方法：abstract void shout（）{}；——没有方法体。
c)包含抽象方法的类必须声明为 abstract类：abstract class Animal{} d)抽象类可以 不包含任何抽象方法，只需用abstract修饰。e)抽象方法不能直接实例化，只能让 子类实例化。
33、接口
a)定义关键字：interface——interface Animal{} b)接口中的方法 被默认修饰为：public abstract——抽象方法。c)接口中的变量 被默认修饰为 :public static final —— 全局常量
i.所以变量最好用
全大写
表示。
d)因为方法都是抽象的，所以必须定义一个类 来实现（implements）接口——Class A implements B{} e)接口之间可以继承——interface C extends B{} f)一个类可以实现多个接口，接口直接间用逗号隔开。g)一个类可以在继承一个类的同时，实现其它的接口。
h)如果一个类去实现接口的话，那么这个类必须实现接口中所有的方法。
34、多态
a)方法上的多态
i.类内部方法的重载 ii.子类对父类方法的重写 b)对象上的多态性
i.假设父类：A；子类B B b = new B();ii.对象的自动向上转型：A a = b;//子类对象，变成了父类对象。
1.虽然a指向A的对象，但是如果B重写了A的方法，那a调用的还是B中的方法。
iii.对象的强制向下转型
1.若 A a = new A();2.B b =(B)a;
//父类对象变成了 子类对象。3.这时对象b调用的是 子类的重写的方法。
4.注意：对象发生强制向下转型之前，必须保证已经发生了向上转型，否则会出异常。
35、异常
a)异常类分为：编译时异常、运行时异常 b)异常处理机制： i.try...catch...finally 1.try代码包含可能发生异常的Java语句，catch块中包含针对一场进行处理的代码。
2.当发生异常时，系统将异常信息封装成一个异常对象传递给catch代码块。所以catch需要定义1个对应的异常类 变量。3.finally代码块包含，无论发生什么异常都要执行的代码。常用于关闭系统资源。
ii.throws关键字声明抛出异常，调用者对其处理。这种方法能通过编译，但是发生异常后就会终止运行。
c)自定义异常
i.首先定义 一个继承Exception异常的 异常类；异常类中 编写一个无参构造方法（调用父类无参构造方法），再编写一个 带String参数的构造方法（也调用父类的带Stirng参数的构造方法）。ii.再定义一个 测试类，定义要调用的方法，并在此方法后面用 throws关键字 声明抛出自定义异常；再在 方法体 内判断什么时候 用throw new 自定义异常（“要打印的信息”）。//声明自定义异常对象。
iii.最后在 测试类的main 方法中，iv.try{...}
catch(...){ System.out.printlan(e.getMessage)}
finally{...}
36、线程的创建： a)继承Thread类，并重写run（）方法。然后new Thread（）.start;开启线程。
b)实现Runnable接口，重写run（）方法。然后new Thread（new myRunnable）.start开启线程。
37、两种实现多线程的比较——实现Runnable接口的方法更好
a)可以让多个线程共享资源。——售票系统需要。b)避免单继承。38、36、
点击咨询 