面试题4

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
-------------------------------------------------------------------------------
5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整
数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换
为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都
不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich
语句中。

补充：面试题
switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?
可以,不可以,JDK7以后可以
-------------------------------------------------------------------------------
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
对于short s1 = 1; s1 = s1 + 1;
由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，
编译器将报告需要强制转换类型的错误。
对于short s1 = 1; s1 += 1;由于+=是java语言规定的运算符，
java编译器会对它进行特殊处理，因此可以正确编译。
-------------------------------------------------------------------------------
7、char型变量中能不能存贮一个中文汉字?为什么?
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所
以，char型变量中当然可以存储汉字啦。
-------------------------------------------------------------------------------
10、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的
内容还是可以改变的。例如，对于如下语句：
final StringBuffer a=new StringBuffer("immutable");
执行如下语句将报告编译期错误：
a=new StringBuffer("");
但是，执行如下语句则可以通过编译：
a.append(" broken!");
-------------------------------------------------------------------------------
11、"=="和equals方法究竟有什么区别？
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中
所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==
操作符。
记住，字符串的比较基本上都是使用equals方法。

补充：面试题
/* ==:
 * 		基本类型：比较的就是值是否相同
 * 		引用类型：比较的就是地址值是否相同
 * equals:
 * 		引用类型：默认情况下，比较的是地址值。
 * 		不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同
 */
public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("林青霞", 27);
		System.out.println(s1 == s2); // false
		Student s3 = s1;
		System.out.println(s1 == s3);// true
		System.out.println("---------------");

		System.out.println(s1.equals(s2)); // obj = s2; //false
		System.out.println(s1.equals(s1)); // true
		System.out.println(s1.equals(s3)); // true
		Student s4 = new Student("风清扬",30);
		System.out.println(s1.equals(s4)); //false
		
		Demo d = new Demo();
		System.out.println(s1.equals(d)); //ClassCastException

	}
}

class Demo {}
-------------------------------------------------------------------------------
补充：面试题
两个思考题(理解)
/*
思考题1：看程序写结果，然后分析为什么是这个样子的。并画图讲解。最后总结Java中参数传递规律。

Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响。
引用类型：形式参数的改变直接影响实际参数。
*/
class ArgsDemo {
public static void main(String[] args) {
	int a = 10;
	int b = 20;
	System.out.println("a:"+a+",b:"+b); //a:10,b:20
	change(a,b);
	System.out.println("a:"+a+",b:"+b); //*** a:10,b:20

	int[] arr = {1,2,3,4,5}; 
	change(arr);
	System.out.println(arr[1]); //*** 4
}

public static void change(int a,int b) { //a:10,b:20
	System.out.println("a:"+a+",b:"+b); //a:10,b:20
	a = b;	//a=20
	b = a + b; //b=40
	System.out.println("a:"+a+",b:"+b); //a:20,b:40
}

public static void change(int[] arr) { //arr={1,2,3,4,5};
	for(int x=0; x<arr.length; x++) {
		if(arr[x]%2==0) {
			arr[x]*=2;
		}
	}
	//arr={1,4,3,8,5};
}
}
 Java中的参数传递问题：
 Java中只有值传递（基本类型传递的是值，引用类型传递的是地址值，都叫值传递）。
 
一定要记住！！！
	基本类型传递的是值，别人拿这个值怎么变我这个变量保存的值不变，
			相当于把值复制了一份给你，你怎么变与我无关，我不变。
	引用类型传递的是地址值，两个拿的都是同一块堆内存，改变的都是同一块地址值，
			两个引用指向同一个堆内存。

基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参(两个拿的都是同一块堆内存地址)
-------------------------------------------------------------------------------
补充：面试题
final关键字(掌握)
(1)是最终的意思，可以修饰类，方法，变量。
	 /*
			继承的代码体现
			
			由于继承中方法有一个现象：方法重写。
			所以，父类的功能，就会被子类给覆盖调。
			有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
			这个时候，针对这种情况，Java就提供了一个关键字：final
			
			final:最终的意思。常见的是它可以修饰类，方法，变量。
		*/
		class Fu {
			public final void show() {
				System.out.println("这里是绝密资源,任何人都不能修改");
			}
		}
		
		class Zi extends Fu {
			// Zi中的show()无法覆盖Fu中的show()
			public void show() {
				System.out.println("这是一堆垃圾");
			}
		}
		
		class ZiDemo {
			public static void main(String[] args) {
				Zi z = new Zi();
				z.show();
			}
		}
(2)特点：
	A:它修饰的类，该类不能被继承（这个类叫最终类，没有子类）。
	B:它修饰的方法，该方法不能被重写。
	C:它修饰的变量，该变量只能被赋值一次，不能被重新赋值，因为这个变量变成了一个常量。
		常量： A：字面值常量"hello",10,true
			   B: 自定义常量final int x = 10; 
(3)面试相关：final修饰局部变量的问题
	A:局部变量
		a:基本类型： 基本类型的值不能发生改变
		b:引用类型： 引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
	 /*
			面试题：final修饰局部变量的问题
				基本类型：基本类型的值不能发生改变。
				引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。
		*/
		class Student {
			int age = 10;
		}
		
		class FinalTest {
			public static void main(String[] args) {
				//局部变量是基本数据类型
				int x = 10;
				x = 100;
				System.out.println(x);
				final int y = 10;
				//无法为最终变量y分配值
				//y = 100;
				System.out.println(y);
				System.out.println("--------------");
				
				//局部变量是引用数据类型
				Student s = new Student();
				System.out.println(s.age);
				s.age = 100;
				System.out.println(s.age);
				System.out.println("--------------");
				
				final Student ss = new Student();
				System.out.println(ss.age);
				ss.age = 100;
				System.out.println(ss.age);
				
				//重新分配内存空间
				//无法为最终变量ss分配值
				ss = new Student();
			}
		}
	B:初始化时机
		a:只能初始化一次。
		b:常见的给值
			  定义的时候。(推荐)
			  构造方法中。
	 /*
			final修饰变量的初始化时机
				A:被final修饰的变量只能赋值一次。
				B:在构造方法完毕前。(仅仅针对非静态的常量，静态的早就加载了)
		*/
		class Demo {
			//int num = 10;
			//final int num2 = 20;
			
			int num;
			final int num2;
			
			{
				//num2 = 10;
			}
			
			public Demo() {
				num = 100;
				//无法为最终变量num2分配值
				num2 = 200;
			}
		}
		
		class FinalTest2 {
			public static void main(String[] args) {
				Demo d = new Demo();
				System.out.println(d.num);
				System.out.println(d.num2);
			}
		}