Java入门－－系统Java基础知识部分总结

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

　　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则编译不通过。 　　}

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