1.重载
题目：
12． 以下对重载描述错误的是(B)
A) 方法重载只能发生在一个类的内部
B) 构造方法不能重载
C) 重载要求方法名相同，参数列表不同
D) 方法的返回值类型不是区分方法重载的条件
相关知识：
区分重载的方法是每个重载的方法都必须有一个独一无二的参数类型列表，甚至参数顺序的不同也足以区分两个方法。
只要编译器可以根据语境明确判断出语义，就允许某种重载。
以返回值区分重载：有时我们不关心返回值：f();Java无法判断该调用哪一个f().
涉及基本类型的重载：
基本类型能从一个”较小“类型自动提升至一个”较大“类型，传入的char类型如果无法找到恰好接受char参数的方法，会直接提升至int.
如果传入的实参类型”大于“重载方法声明的形参：需要手动类型转换执行窄化转换，否则编译器报错。
2.super与this关键字：
题目：
3． 在使用super 和this关键字时，以下描述正确的是(A)
A) 在子类构造方法中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过
B) super()和this()不一定要放在构造方法内第一行
C) this()和super()可以同时出现在一个构造函数中
D) this()和super()可以在static环境中使用，包括static方法和static语句块
相关知识：
this关键字:只能在方法内部使用，表示对”调用方法的那个对象"的引用，用于获取对当前对象的引用。
调用某对象的方法时编译器暗自把所操作对象的引用作为第一个参数传递给方法，用以区分该方法作用的不同对象。
this也可用于将当前对象传递给其他方法：
class Apple{
Apple getPeeled(){return Peeler.peel(this);}
}
使用this在构造器中调用构造器：
为this添加了参数列表，将产生对符合此参数列表的某个构造器的明确调用。
注意：1.不能调用两个，却必须将此调用置于最起始处，否则编译报错。
2.只能在构造器中这样调用，编译器禁止在其他任何方法中调用构造器。
super初始化基类：
在初始化子类时，其中的基类子对象必须确保被初始化。在有默认的基类构造器的情况下，Java会自动在子类的构造器中插入对基类构造器的调用。
如果没有默认的基类构造器，或者想调用一个带参数的基类构造器，就必须使用关键字super显式调用基类构造器，配以适当的参数列表。调用基类构造器必须放在子类构造器的第一行。
题目：
6． 以下程序的运行结果是(D)
class Person{
public Person(){
System.out.println(“this is a Person”);
}
}
public class Teacher extends Person{
private String name=”tom”;
public Teacher(){
System.out.println(“this is a teacher”);
super();
}
public static void main(String[] args){
Teacher teacher = new Teacher();
System.out.println(this.name);
}
}
A) this is a Person
this is a teacher
tom
B) this is a teacher
this is a Person
tom
C) 运行出错
D) 编译有两处错误
7． 以下说法错误的是(D)
A) super.方法()可以调用父类的所有非私有方法
B) super()可以调用父类的所有非私有构造函数
C) super.属性可以调用父类的所有非私有属性
D) this和super关键字可以出现在同一个构造函数中
3.final关键字
题目：
8． 以下关于final关键字说法错误的是(A,C)(两项)
A) final是java中的修饰符，可以修饰类、接口、抽象类、方法和属性
B) final修饰的类肯定不能被继承
C) final修饰的方法不能被重载
D) final修饰的变量不允许被再次赋值
相关知识：(接口和抽象类待查)
根据上下文环境，Java的关键字final含义存在细微的区别，但通常它指的是“这是无法改变的”。
1.final数据：编译期常量，可以代入任何可能用到它的计算式中(但不代表你在编译时就知道该值，比如可以初始化为Random产生的值，在运行时可知)Java中这类常量必须是基本数据类型，在进行定义时必须对其进行赋值。
static final数据：final说明它是一个常量，static则强调只有一份(不会因为对象不同而产生不同份的该数据)，一般用全大写命名。
空白final:声明为final但又未给定初值的域，但无论什么情况，编译器都确保空白final在使用前必须被初始化：在构造器中(这表现出空白final的灵活性：不同对象可以初始化其为不同的值)。
必须在域定义处或每个构造器中用表达式对final进行赋值，这正是final域在使用前总是被初始化的原因。
final对象引用：使引用恒定不变，但其指向的对象可变。这对数组也适用，因为数组不过是另一种引用。
final参数：Java允许在参数列表中以声明方式将参数指明为final,意味着你无法在方法中更改参数引用所指对象。
2.final方法：锁定该方法，以防任何继承类修改它，确保继承中该方法不变，并且不会被覆盖。(第二个原因效率，内嵌调用，用实际代码副本替代方法调用，已逐步淘汰)
final和private关键字：类中所有private方法都隐式指定为final的，由于无法取用，自然无法覆盖，对private添加final没有任何额外意义。
试图“覆盖”private:“覆盖”只有在某方法是基类接口的一部分时才会出现(那些向上转型为基类可以调用的方法)，而private方法并不是基类接口的一部分。如果在导出类以相同名称生成一个public,protected或包访问权限的方法，此时你并没有覆盖基类此同名private方法，而只是生成了一个新的方法。private方法无法触及并且能够有效隐藏，我们不需要在这些情形中考虑它。
3.final类：不允许被继承。由于该类禁止继承，其所有的方法都隐式为final的，因为无法覆盖它们。在final类中给方法添加final修饰词不会增添任何意义。
4.访问权限控制
题目：
9． 访问修饰符作用范围由大到小是(D)
A) private-default-protected-public
B) public-default-protected-private
C) private-protected-default-public
D) public-protected-default-private
题目和实际程序测试、分析：
13． 以下(BD)添加到ComputerBook中不会出错
class Book{
protected int getPrice(){
return 30;
}
}
public class ComputerBook extends Book{
}
A) protected float getPrice(){}
B) protected int getPrice(int page){}
C) int getPrice(){}
D) public int getPrice(){return 10;}
测试：
package cn.xbai.worktest;
class Book {
protected int getPrice() {
return 30;
}
}
class ComputerBook extends Book{
public int getPrice(){//这也是可以的，但调用验证一下看看：输出为1，这个做到了覆盖父类此方法，说明权限扩展是可以的，缩小不行！！
return 1;
}
/*protected float getPrice(){//false:The return type is incompatible with Book.getPrice()
return 1;//incompatible:不相容，说明编译器理解成了要覆盖，而没有做到形式完全一致！
}*/
/*int getPrice(){//false:Cannot reduce the visibility of the inherited method from Book
return 1;//构成覆盖，但权限不能缩小！！
}*/
protected int getPrice(int pri){//absolutely right,didn't report wrong!!
return pri;//这个是重载，是可以的！！！这个程序验证了：调用成功！！
}
}
public class HuaWei {
public static void main(String[] args){
ComputerBook cb=new ComputerBook();
System.out.println(cb.getPrice());//1
System.out.println(cb.getPrice(888));//888
}
}
QUESTION NO: 3
1. class A {
2. protected int method1(int a, int b) { return 0; }
3. }
Which two are valid in a class that extends class A? (Choose two)
A. public int method1(int a, int b) { return 0; }
B. private int method1(int a, int b) { return 0; }
C. private int method1(int a, long b) { return 0; }
D. public short method1(int a, int b) { return 0; }
E. static protected int method1(int a, int b) { return 0; }
测试：
package cn.xbai.worktest;
class A {
protected int method1(int a, int b) { return 0; }
}
class B extends A{
//static protected int method1(int a,int b){return 0;}//wrong:This static method cannot hide the instance method from A
//public short method1(int a,int b){return 0;}//wrong:The return type is incompatible with A.method1(int, int)
public int method1(int a,int b){return 1;}//这是可以的：经下面调用验证：输出结果1，覆盖
//private int method1(int a,int b){return 1;}//wrong,缩小了权限
private int method1(int a,long b){return 2;}//这是可以的，重载，权限无所谓了，内部调用验证：输出2，正确
public int test(){
return this.method1(1, (long)10);//注意这里强转才调用上方方法，否则调用基类同名方法输出0,或打开最上方方法输出1
}
}
public class HuaWei2 {
public static void main(String[] args){
B b=new B();
System.out.println(b.method1(3, 5));//1
System.out.println(b.test());//2
}
}
相关知识：
访问权限修饰词，从最大权限到最小权限依次为：public,protected,包访问权限(没有关键词)和private.
包访问权限：默认访问权限没有任何关键字，为包访问权限。当前包中所有其他类对此成员有访问权限，但对于这个包之外的所有类这个成员却是private.
一个编译单元，即一个文件，只能隶属于一个包，所以处于同一编译单元的包访问权限的所有类彼此自动可访问。
默认包：同一目录下的两个类都无包名，即使都没有声明为public类，彼此也可相互访问，因为同属于一个默认包。
包访问权限案例：
cn.xbai.p1.TestClass.java:
package cn.xbai.p1;
public class TestClass {
void test(){
System.out.println("Could you access me if you are not in my pacage?");
}
public void testOut(){
System.out.println("Could you access me if I am a public and you are not in my pacage?");
}
}
class TestClassIn {
void test(){
System.out.println("Could you access me if my boss is not public and you are not in my pacage?");
}
public void testOut(){
System.out.println("Could you access me if my boss is not public and I am a public and you are not in my pacage?");
}
}
class ClassInTheSamePacage{
static void testIn(){
TestClass tc=new TestClass();//同一包下的类可见
tc.test();
tc.testOut();
TestClassIn tci=new TestClassIn();//Same as upside
tci.test();
tci.testOut();
}
public static void main(String[] args){
testIn();
}
}
同一个包下其他.java文件编译的类：cn.xbai.p1.ClassThisPacage.java:
package cn.xbai.p1;
public class ClassThisPacage {
static void testIn(){
TestClass tc=new TestClass();//同一包下的类可见
tc.test();
tc.testOut();
TestClassIn tci=new TestClassIn();//Same as upside
tci.test();
tci.testOut();
}
public static void main(String[] args){
testIn();
}
}
同一.java文件或同一包下其他.java文件生成的类访问结果：
Could you access me if you are not in my pacage?
Could you access me if I am a public and you are not in my pacage?
Could you access me if my boss is not public and you are not in my pacage?
Could you access me if my boss is not public and I am a public and you are not in my pacage?
不同的包：
cn.test.p2.AccessTestClass.java:
package cn.test.p2;
import cn.xbai.p1.TestClass;
public class AccessTestClass {
static TestClass tc=new TestClass();
public static void main(String[] args){
//tc.test();//fucking wrong!It's pacage accessiable.
tc.testOut();//fine.It's public.
//TestClassIn tci=new TestClassIn();//It's not visible,totally.
}
}
不同包的类访问结果：
Could you access me if I am a public and you are not in my pacage?
protected访问权限:
继承自另一个包的某个类的子类，无法访问其包访问权限的成员。但如果基类该成员声明为protected,则子类可以访问。
案例：
package access.cookie2;public class Cookie {
public Cookie(){
System.out.println("Cookie constructor");
}
protected void bite(){
System.out.println("bite");
}
}
另一个包的类继承这个类，拥有bite方法，如果其为包访问权限，则子类不可访问，如果是protected,则子类可以访问：
package any.you.know;
import access.cookie2.Cookie;
public class ChocolateChip extends Cookie{
public ChocolateChip(){
System.out.println("ChocolateChip constructor");
}
public void chomp(){
//Accessing a method from base class!!!
bite();//If bite is pacage accessible,wrong.But if it's protected,it's OK.
}
public static void main(String[] args){
ChocolateChip x=new ChocolateChip();
x.chomp();
}
}
结果：
Cookie constructor
ChocolateChip constructor
bite
5.对象引用
方法参数传递：复制引用，复制的引用指向另一个对象，不会改变原引用的值(仍指向原来对象)
题目及上机测试：
QUESTION NO: 1
publicclassTest1 {
publicstaticvoidchangeStr(String str){
str="welcome";
}
publicstaticvoidmain(String[] args) {
String str="1234";
changeStr(str);
System.out.println(str);
}
}
测试：
package cn.xbai.worktest;
/**
* 经验：当你不确知一个知识或者不懂它的答案，上机测试它，想办法比对输出，看真实结果，看编译和运
行报出的错误原因，就没有不明白的！凡是可以亲自实践检验的东西都不会错，都不会不明白！！
* @author Administrator
*
*/
public class Test1 {
public static void changeStr(String str){
str="welcome";
System.out.println(str);//说明调用该方法的过程是复-制-引-用，因为字符串变量就是引用，这里指向从字符池中取出字符创建的不可更改的字符串对象
}
public static void main(String[] args) {
String str="1234";
changeStr(str);
System.out.println(str);
}
}
结果：
welcome
1234
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
