欢迎就这一部分各位朋友与我进行探讨，共同进步。

1、虽然有很多朋友可能进行了多年的java开发老手，但可能仍旧对某些点缺乏仔细探究。

2、去一些公司求职面试或笔试时的技术题目中，也往往会涉及到这里的一些内容。

所以，希望下边的这些总结能够对一些学习java或求职的朋友有些许帮助。

　 1、 关于java类中的缺省的构造器

如果一个java类没有显式定义没有参数的构造器，将有一个默认缺省的构造器。如果定义了一个有参数的构造器，那么原来的缺省的构造器将不在有效。

public class a{
}
此时如果用 new a(); java编译器将使用缺省的构造器。
public class a{
public a(int i){
}
}

如果此时用 new a(); 将产生一个编译错误，因为此时显式定义了，一个有参数的构造器。

2、java中的类名与文件名

1、在一个java文件中可以有多于一个类定义(更常见于某些组件的监听器类)，但只能有一个public class定义，且与文件同名。
2、如果一个java源文件中没有public类，那么每个类的名字没特殊规则，即不必与文件同名。
3、在编译后产生的class文件中，仍旧是多个单独分开的class文件。

3、import关键字

1、import语句必须定义在所有的class定义之前。
2、import语句只是为编译器指明了一个路径，并不像c或c++中的#include，所以用import .*并不影响性能

4、java中的几个特殊关键字

java中的关键字许多大家都比较熟悉，而有几个就不是很常用，如：
1、goto和const是保留关键字，在java中没使用
2、strictfp和volatile不常用； sizeof、zhen不是关键字。
3、true,false,null不是严格意义上的关键字，而是literals。

5、java方法中的传递值参

在java方法中传递参数，对于基本类型来讲传递的是值参数，相当于建立的一个参数的拷贝，不影响原来变量的值。

在引用方法中可以改变传递对象的内容，但对象引用(像a@5d87b2)从来不会改变。

public class tt{
public static void main (string args[]){
a aa = new a();
aa.num =5;
tt t = new tt();
system.out.println("11 aa="+aa + "num="+aa.num);
t.test(aa);
system.out.println("22 aa="+aa + "num="+aa.num);
}
void test(a a){
a ab = new a();
a = ab;
system.out.println("33 ab="+ab + "num="+ab.num);
}
}
class a{
int num;
}

6、变量初始化

java中的变量在使用之前必须被初始化，当创建一个对象的时候一些类的变量会自动初始化并赋予缺省值。

数字类赋值0；char类型赋值’\u0000’; boolean类型赋值false；引用对象赋值null;

注意的是在方法之外的类变量的值是自动赋初始值，而方法内的局部变量必须手工初始化。

class aa{
int num;
void test(){
int j;
j =5;//没有这一行则编译不会通过。
j = j+num;
}
}

7、switch语句

这个点经常在求职笔试题目中出现。default放在最上边编译没问题；碰到符合分支的，如果没有break会一直向下运行。

public class tt{
public static void main (string args[]){
tt t = new tt();
t.test(2);//可改变成3运行一下看一下结果
}
void test(int i){
switch (i){
default:
system.out.println("default");
case 1:
system.out.println("111");
break;
case 2:
system.out.println("222");
break;
}
}
}

8、关于java中的label使用

? break [label]
? continue[lbele]
? lable: statement; //这里的statement必须是一个loop循环
public class tt{
public static void main (string args[]){
tt t = new tt();
t.test();
}
void test(){
system.out.println("0000");
lb1:for (int i=0;i<10;i++){
lb2:for (int j=0; j<2; j++){
if (i==2) continue lb1;
system.out.println("i="+i +" j="+j);
}
}
system.out.println("111111");
}
}

9、类型转换校正

class employee
|
class manager

向上校正，总是允许的，manager直接使用父类employee的方法。
向下校正，必须用instanceof检验，才能将一个employee转换为manager对象。

public void test(employee e){
if (e instanceof manager){
manager m = (mnager)e;
...
}
}

10、方法重载(overloading)、方法覆盖(overriding)

方法重载(overloading)一定要求名字相同，参数不同，返回类型可以相同也可以不同

class a{
void test(int i){
}
}
class aa extends a{
int test(int i, int j){
return 5;
}
}

注：方法覆盖(overriding)要求名字，参数，返回类型全部必须相同，访问控制符可以不同，但必须大过父类的。因为如果名字和参数都已经相同了则一定要求返回类型相同，否则认为这是一个新的方法了，名字就必须不同了。

class a{
void test(int i){
}
}
class aa extends a{
public void test(int i){//若是换成private则编译不通过。
}
}

注：关于覆盖方法抛出异常的问题。如a是父类，b是继承a的子类。b中的方法meth()去覆盖父类a的此方法时，b中不能throws出新的异常，只能是父类抛出的异常或其子集。更甚至可以不抛出异常。

11、关于类的构造器重载问题

class a{
public a(int i){
}
}
class aa extends a{
public aa(){
int i = 5; // 这里出错，没有父构造器
}
}

由于父类a自定义了构造器，所以缺省的构造器就丢失了，当子类的构造器自动试图调用父类没参数的构造器时却没有，所以会编译出错。

12、关于static关键字总结：

1、不能在static修饰的方法中引用this变量，只能引用一些静态变量或方法，或new新的对象(可以定义局部变量)。
简言之，静态方法或块中，只能引用静态的方法或变量。
2、类中的成员变量(static修饰)有缺省值，而类的定义的方法中的局部变量没有缺省值。
3、在类的构造器中，可以引用任何的静态或非静态的变量和方法，可以在非static方法中调用static方法。
4、static{}块中的代码在类装载中仅执行一次。
5、在7-7，a static method cannot be overridden but can be hidden. 不理解。
6、不能在无论非static方法中或static方法中定义static变量。

13、关于final关键字

1、不能继承final修饰的类，不能覆盖final修饰的方法。
2、final修饰的变量，若没赋值，必须在构造器中赋初始值。

class a{
final int j;
public a(){
j = 9;//若没有此行，则编译不通过。
}
}
3、final类型的方法参数可定义，但不能改变。
class a{
void m(final int i){ //这一行的声明i为一个final没问题。
i ++ ; //但在这里面，i的值不能再被改变。
}
}

14、interface接口关键字

1、接口中的变量
1、必须初始化其值。
2、默认修饰符为public+static+final,其他的修饰符不允许。
2、接口中的方法
1、默认为public+abstract
2、其它修饰符 static,private,protected,final,synchronized,native均不能有。

interface a{
void s();
}
class aa implements a{
void s(){ //编译器在这里提示由于接口中的方法s()修饰符默认是public，
//而这里的s()默认是protected，小于public所以不允许。
}
}

15、abstract抽象关键字

abstract class a{
private int i;
private void m();{}
}

抽象类中可以有私有的变量和私有属性，而接口就不行（原因如上），
这是因为java是按实例虚拟调用的，在生成某一个具体的对象可以有私有的属性或方法的。

abstract class a{
private int i;
private void m(){};
public abstract void n();//若是private则编译不通过。
}

抽象类中的抽象方法是让其他类继承的，如果本身都是私有的，就没有什么意义了

16、集合类型

以有无顺序，允许不允许重复区分
collections: 一组对象，无序集合，允许重复
set：无序集合，不允许重复
list：有序集合，允许重复

注意：在jdk1.1中定义的集合类型，都是线程安全的，所以都是“重量级”的。像hashtable,vector

而在java2中定义的一些新的集合类型如hashmap, arraylist不是线程安全的，是“轻量级”的，但速度快，性能好。这一点在许多公司面试试题都见过。

17、布局管理器

flowlayout,borderlayout,gridlayout,cardlayout
关于panel和frame默认的layout常在一些公司的面试试题中出现。
1、panel和applet类默认的布局管理器是flowlayout 一个一个的加上去
2、frame和window类默认的布局管理器是borderlayout 按东南西北加入
3、xylayout是borland公司开发的布局管理器。

18、面试试题中applet部分

1、使用代码

2、可以覆盖的方法init(),start(),stop(),destory(),paint(g)

19、面试试题中线程部分

1、基本实现方式两中，继承thread类和实现runnable接口
2、必须实现父类或接口中的run()方法。
3、有关线程方法，start()启动线程。
join()指在调用这个线程的方法或进程中，必须等待此线程运行结束才能继续其他进程。
4、线程中的同步synchronized,注意死锁。

20、对象串行化

1、仅仅对象类型的数据可以串行化。

2、标记为transient的数据不可以串行化。

存储一个对象到某种永久性存储叫persistence，如存储到磁盘、磁带或别的机器的内存中。

java.io.serializable接口没有定义方法要实现，仅仅是一个标记暗示实现了这个接口的类可以被考虑串行化。没有实现这个接口的对象不能保存或存储它们的状态。

当一个对象被串行化的时候，仅仅数据被保留，而方法和构造器不是串行化的部分。

一些对象类是不能串行化的因为他们代表的数据是经常变化的。如java.io.fileinputsream和java.langthread。如果串行化的对象包含了不可串行化的对象，整个串行化动作会失败，并抛出notserializableexception。

21、java中的网络通讯

一般的tcp/ip网络数据通信主要可分2种，tcp和udp

tcp：tcp是面向连接的通信协议，就像打电话，先要拨通建立连接，传送的数据不会丢失

java提供了serversocket和socket类。在server端，建立一个serversocket，并指定端口，并侦听连接。

服务器端代码

serversocket sc=new serversocket(1111);
socket socket1= sc.accept();
datainputstream s_in = new datainputstream(socket1.getinputstream());

客户端代码

socket socket2 = new socket("192.168.1.1",1111);

udp：udp非面向连接，就像写信，将传输的数据包成一个分组，可能有数据丢失

服务器端代码

datagramsocket server = new datagramsocket(1234);
datagrampacket in_packet =new datagrampacket(in_buf,2000);
server.recieve(in_packet);

客户端代码

datagramsocket client= new datagramsocket(1235);
datagrampacket out_packet=
new datagrampacket (out_buf,100,"192.168.1.1",1234);
client.send(outpacket);

22、string对象

一般讲来创建的两个对象如果用==来比较肯定是不等的，因为他们的引用地址是不同的，而==是对于对象来讲是比较对象地址的。但对于string对象来讲是一个例外，两个string对象如果值相同，==比较也是相同的。我想这可能与sun公司对string对象定义有关。

public class tt{
public static void main (string args[]){
tt t = new tt();
t.test(2);
}
void test(int i){
string s1 = "123";
string s2 = "123";
if (s1==s2)
system.out.println("111111");
else
system.out.println("2222222");
}
}

结果输出：111111