Java基础知识小结

引用

小结Java学习中的一些知识点

JAVA中&&和||的区别

&&; 表示一个一个执行下去 结合性为从左到右,即先计算左边的操作数,当左边为false时,就不关心右边的数了,直接返回False,如果为True而再计算右边的操作数,当右边的也为True时,返回True,如果为False,则返回在False,即当全部为true才打印true ,如果有一个结果是  false则停止执行 打印false.

&&:即是,从左到右，先判断第一个，如果第一个为True时，再判断第二个，两个都为真(True)时,才为真.如果第一个为False，刚放弃判断第二个，返回False.

|| 表示一个一个执行下去 结合性为从左到右,即先计算左边的操作数,当左边为true时,就不关心右边的数了,直接返回true,如果为false而再计算右边的操作数,当右边的也为false时,返回True,如果为true,则返回true,即当全部为false才打印false 
   如果有一个结果是  true则停止执行 打印true
当全部为false 则打印false

&&:是找错的，一旦发现一个错就返回False，所以当发现第一个是错的时，便毫不犹豫的返回False，第一个为True时才去看第二个，如果第二个还是True，那么它就满意了，过关，返回True，否则返回False。

｜｜：是找对的，一旦发现一个对的，就返回true，当第一个为对的时，便毫不犹豫的返回true，当第一个为False时，再看第二个，如果还为False则返回false,如果有一个TRue那么，返回true。

&&：两个当中只要有一个是错的，就算错，除非两个都是对的，才算对;
||：两个当中只要有一个是对的，就算对，除非两个都是错的，才算错;

==和Equals的区别

==指的是它们的引用相同 
而equals指的是它们的内容是否相同 

equals比较的是两个东西的内容，如果相同则为true。

= =比较的是两个东西的内存地址,如果不是同一个对象的引用，那么就是 false。如上图中对S1和S2的比较（粉红色底线所示），因为S1和S2是两个对象，所以不是对一个对象的引用，所以比较的结果是false。但与之相反的S1与S3的比较，因为这里不是New出来的，所以是一个对象，S1和S3指向的都是同一个对象，所以S1与S3都是同一个对象的引用，结果就是True。

所以它们两个的用法是不一样的，如果要比较内容，当然是用equals

＆和＆＆的区别：

　＆是位运算符，而＆＆是逻辑运算符
　 
逻辑操作＆　｜和条件操作＆＆、｜｜的区别：
　条件操作只能操作布尔型，而逻辑操作不仅可以操作布尔型，还可以操作数值类型
　条件操作有短路，而逻辑操作不会产生短路。

int和Integer的区别：

 int 是原始类型，直接存数值，Integer是引用类型，是一个类。
　当用作某个类的实例数据时引用类型所指定的缺省值是null，而原始类型实例变量的缺省值与它们的类型有关
　引用类型和原始类型的行为完全不同且具有不同的特征和用法

Abstract和Interface的区别：

　接口是一种特殊的抽象类，但不是类，抽象类是未实现部分方法的类。
　接口能被多个不相关的类继承，一个类也可以继承多个不相关的接口。而抽象类只能继承一个类，且被一个子类继承。

　　
静态变量与实例变量的区别：

类变量也叫静态变量，也就是在变量前加了static 的变量； 
实例变量也叫对象变量，即没加static 的变量； 
类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；
"实例变量，它不需用static关键字来声明；只要对象被当作引用，实例变量就将存在。实例变量有时也被用作成员变量，因为它们是类的成员

String和StringBuffer的区别：
　

String 是不可变的，而StringBuffer是可变的；可以用StringBuffer来动态构建字符数据。

　

Abstract和Interface的区别：


接口是一种特殊的抽象类，但不是类，抽象类是未实现部分方法的类。
　接口能被多个不相关的类继承，一个类也可以继承多个不相关的接口。而抽象类只能继承一个类，且被一个子类继承。

final、finally、finalize有什么区别？　　

Final代表着不变的，固定的，Final修饰类，代表这个类是不可继承的，是项极类。修饰变量，代表这个变量只能被赋值一次，修饰方法，代表方法不能被重写。
　Finally是在try　Catch｛｝子句后，始终执行的一段程序。
　Finalize是指Java的自垃圾回收器。

接口与抽象类的区别

 abstract class和interface在Java语言中都是用来进行抽象类定义的；
抽象类和接口都不能被实例化；
接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，没有变量和方法的实现。接口中只能定义抽象方法，
接口只包含常量和方法的定义，没有变量和方法的实现，绝不能含有实例域，也不能在接口中实现方法。而抽象类除了抽象方法之外，抽象类还可以包含具体数据和具体方法。
 abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系(因为Java不支持多继承 -- 转注)。但是，一个类却可以实现多个interface。也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。



Forward和SendRedirect有什么不同？

Forward将Request及Response一并传过去了，而SendRedirect只是实现了一种资源的重新定位。

　







指出下面程序的运行结果：

package test;
class A{
	static{
		System.out.println("1");
	}
	public A(){
		System.out.println("2");
	}
}

class B extends A{
	static{
		System.out.println("a");
	}
	public B(){
		System.out.println("b");
	}
}
public class Static1 {

	public static void main(String[] args) {
		A a=new B();
		a=new B();
		a=new A();
	}
}

运行结果是：1a2b


说出原因：

引用

★　New　子类时执行的操作：
　先定位子类构造（注意：这里是定位，并不是执行，也就是说从这里开始），先父后子，先this（）后Super()，先语句块后构造。
　先从父类执行，先找父类的构造，父类的构造又有构造，一直找到Object.
　找到父类后，先执行静态语句块的内容，按照先父后子的顺序，再找子类中静态语句块的内容，执行，也就是先父后子，先语句块，
　父类和子类的静态都执行完了以后，再来找构造方法，按照什么标准来找呢？还是先父后子，先this()后Super（）；即先执行父类中的构造，父类中的构造按先this（），后Super（）执行，然后再执行子类中的构造，同样按先this（），后Supter（）这样的顺序执行；

★在这里可以看到，实际上先父后子是一个贯穿始终的原则，我们可以这样来理解，在New+子类时，执行的操作是，先从父类找静态方法，执行完了以后再找子类的静态方法；（这里是一个先父后子）。父和子的都执行完了以后，接下来又返回，从父类中执行构造，在执行父类的构造的过程中，是按照先this（）后Super（）；来执行的，待执行完了父类的构造后，接下来再执行子类的构造，同样，按照先this（），后super（）的原则来执行。这就是整个过程。

指出以下代码的运行结果，并试分析原因：

package test;

public class Try {
	public static int testTry(int n){
		int r ;
		try{
			r=n*n;
			return r;
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(n=　=2);
		}
		return n;
	}

	public static void main(String[] args) {
		int a=Try.testTry(2);
		System.out.println(a);
	}

}

运行结果是：４

原因是：

引用

在Finally子句包含return语句时，将会出总想不到的结果。假设利用return语句从try语句中退出，在方法返回之前，finally语句块的内容将会被执行。如果Finally语句块中也包含一个return语句，那么这个返回的值将会掩盖原始的返回值。如下例：

如果将代码改为以下：

package test;

public class Try {
	public static int testTry(int n){
		int r ;
		try{
			r=n*n;
			return r;
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			if(n= =2);return 0;　//绿色部分为更改代码。
		}
//		return n;　　 //绿色部分为更改代码。
	}

	public static void main(String[] args) {
		int a=Try.testTry(2);
		System.out.println(a);
	}

}
如果Finally语句块中也包含一个return语句，那么这个返回的值将会掩盖原始的返回值。也就是说会返回finally中的return　中的值　即　０　。
class Trey{
	public static void test(){
		try{
			System.out.println("run");
			return;
//			System.exit(-1);
		}catch(Exception e){
			System.out.println("Exception");
		}finally{
			System.out.println("finally");
		}
	}
}
public class Test{
public static void main(String[] args) {
	int a=Try.testTry(2);
	System.out.println(a);
	Trey.test();
}
}

输出的结果是：

run
finally
如果将System.exit(1);打开，将Return注掉，
则运行结果为：
Run
原因是Syste.exit(1)；的意思是退出虚拟机。

待补充......

评论

1 楼 grandboy 2009-07-24  

finalize从来没有用过，我觉得也不好用。而需要释放资源的时候，总能找到一个合理的方案，而避开它。