下载文档原格式
Java考试复习题JAVA程序设计练习一、填空题1、目前Java运行平台主要分为下列3个版本是Java se ，Java ee ，Java me 。
2、SDK平台提供的Java编译器是javac.exe 和Java解释器java.exe 位于Java安装目录的bin 文件夹中。
3、Java运行环境JRE由Java虚拟机、Java的核心类以及一些支持文件组成。
4、一个Java应用程序必须有一个称为主类的类，该类含有public static void main （String args[ ]）方法。
5、在源文件的命名中如果源文件中有多个类，那么只能有一个类是public类；如果有一个类是public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是java；6、一个Java Applet源文件不再需要main方法，但必须有且只有一个类扩展了Applet类，我们把这个类称作Java Applet源文件的主类。
7、类是组成Java程序的基本要素。
类封装了一类对象的状态和方法。
8、创建一个对象包括对象的声明和为对象分配成员变量两个步骤，对象的声明的一般格式为：类的名字对象名字；使用new运算符和类的构造方法为声明的对象分配成员变量9、用关键字static修饰的成员变量称作静态变量或类变量，类变量不仅可以通过某个对象访问也可以直接通过类名访问。
10、一个类中的方法可以互相调用：实例方法可以调用该类中实例方法或类方法；类方法只能调用该类的类方法，不能调用实例方法。
11、实例方法可以操作实例变量或类变量；而类方法只能操作类变量不能操作实例变量。
12、this关键字出现在类的构造方法中，代表使用该构造方法所创建的对象；this 关键字出现在类的实例方法中，代表使用该方法的当前对象。
13、成员变量在整个类内有效，局部变量仅在方法内有效，如果在方法内部局部变量的名字与成员变量的名字相同，则成员变量被隐藏，此时若要使用成员变量，格式为：this.成员变量。
mockito super方法Mockito是一个Java框架，可以用于编写单元测试代码时对依赖对象进行模拟。
它提供了一系列的功能，方便我们创建、配置和验证模拟对象的行为。
在Mockito中，我们可以使用`super`关键字来模拟父类的方法调用。
当我们需要模拟一个方法时，可以使用`when`-`thenReturn`结构来设置对方法的调用的预期结果。
而当我们需要调用父类的方法时，可以使用`super`关键字来调用真正的父类方法。
在使用`super`方法进行模拟时，我们首先需要模拟一个父类的实例。
我们可以通过`mock`方法创建一个模拟对象，并指定父类的类型。
然后，我们可以使用`when`-`thenReturn`结构来设置对模拟对象方法的调用的预期结果。
例如，假设我们有一个父类`ParentClass`和一个子类`ChildClass`，子类`ChildClass`中重写了父类的某个方法`doSomething`，我们想要模拟`doSomething`方法，但同时又需要调用真正的父类方法。
我们可以通过以下代码来实现：```javaParentClass parentMock = Mockito.mock(ParentClass.class);ChildClass child = new ChildClass(;Mockito.when(parentMock.doSomething().thenCallRealMethod(;child.doSomething(;Mockito.verify(parentMock).doSomething(;```在这个例子中，我们首先创建了一个父类的模拟对象`parentMock`。
然后，我们使用`when`-`thenCallRealMethod`结构来设置对`parentMock.doSomething`方法的调用的预期结果，即调用真正的父类方法。
接下来，我们创建了一个子类的实例`child`，并调用了`child.doSomething`方法。
java中super的用法super关键字在Java中用于访问父类的成员变量和方法。
它可以用来调用父类构造方法，访问父类中被子类覆盖的方法和变量，以及在子类中显式地调用父类中的方法。
super关键字的一些常见用法包括：1. 调用父类的构造方法在子类中使用super关键字可以调用父类的构造方法。
这种方式通常用于子类构造函数中需要调用父类构造函数的场景。
例如：```public class Animal {int age;public Animal(int age) {this.age = age;}}public class Dog extends Animal {String name;public Dog(int age, String name) {super(age); = name;}}```在Dog类的构造函数中使用了super关键字来调用Animal类的构造函数。
2. 访问父类中被子类覆盖的方法和变量当子类覆盖了父类中的方法或者变量时，可以使用super关键字来访问父类中被覆盖的方法或者变量。
例如：```public class Animal {public void sayHello() {System.out.println('Animal says hello!');}}public class Dog extends Animal {@Overridepublic void sayHello() {super.sayHello();System.out.println('Dog says hello!');}}```在Dog类的sayHello方法中使用了super关键字来访问父类中的sayHello方法，从而实现了在子类方法中调用父类方法的效果。
3. 在子类中显式地调用父类中的方法子类中可以使用super关键字来显式地调用父类中的方法。
这种方式通常在需要在子类中扩展父类方法的同时，保留父类方法的实现逻辑时使用。
super()的用法一、什么是super()函数二、super()函数的基本用法1. super()函数的参数2. 使用super()函数调用父类方法3. 使用super()函数在多重继承中的应用三、示例：使用super()函数实现多层继承四、总结一、什么是super()函数在面向对象编程中，继承是一种重要的概念。
通过继承，子类可以获得父类的属性和方法，并且可以对其进行修改或扩展。
当子类需要调用父类的方法或属性时，通常使用`super()`函数来实现。
`super()`函数是Python内置的一个特殊方法，它允许子类调用父类的方法或属性。
通过`super()`，我们可以在子类中使用父类定义的方法，而不需要显式地指定父类。
这样做既能简化代码结构，又能保持程序的可读性和灵活性。
二、super()函数的基本用法1. super()函数的参数在使用`super()`函数时，通常需要传入两个参数：第一个参数表示当前子类所在的位置（即当前类），第二个参数表示当前子类的对象。
例如，在单重继承中，我们可以按以下方式使用`super()`函数：```class ChildClass(ParentClass):def __init__(self, arg1, arg2):super().__init__(arg1) # 父类的初始化方法self.arg2 = arg2```在上述例子中，`super().__init__()`将调用父类（`ParentClass`）的初始化方法，并传入参数`arg1`。
2. 使用super()函数调用父类方法除了在初始化方法中使用`super()`函数之外，我们还可以在子类中调用父类其他定义的方法。
例如：```class ChildClass(ParentClass):def child_method(self):super().parent_method()```在上述例子中，通过`super().parent_method()`，我们可以调用父类的`parent_method()`方法。
描述super关键字的功能与用法Super是一个重要的关键字，用于访问父类对象和方法。
基本上，它是一个指示编译器在继承关系中向上当前类superclass父类结构的语言元素。
super关键字在Java中用于以下几种情况：1. 在子类中引用父类中的成员变量或成员方法时，使用了super关键字来代表父类对象。
2. 如果子类覆盖了父类的方法，可以使用super关键字来调用父类的方法。
3. 如果子类定义了构造函数，则可以使用super关键字来调用父类的构造函数。
4. 在多层继承关系中，如果需要访问中间层或更高级别的超类，可以使用super关键字。
如果子类继承了父类中的成员变量或成员方法，而子类本身也定义了与父类同名的成员变量或成员方法，可以使用super关键字来访问父类中的成员变量和成员方法。
例如，如果有一个具有两个类的继承关系，子类B继承自父类A，B 定义了与A同名的成员变量或成员方法，那么可以使用super关键字来访问A类的成员变量或成员方法。
使用super关键字调用父类的方法时，可以使用两种方式：1. 调用父类的构造函数：在子类中调用super（）函数，该函数会调用父类的默认构造函数。
2. 在子类中调用带有参数的构造函数：使用super（arg1，arg2）来调用父类中与子类相匹配的构造函数。
super关键字的作用在于让开发者能够选择是否使用父类中已经存在的成员变量或成员方法，并且能够控制从哪个父类中获得成员变量或成员方法。
同样，使用它还可以提高代码的可读性，使继承关系更加清晰和易于维护。
总之，super关键字是Java编程中一个强大的工具，在多态和继承中发挥着重要的作用。
在实际编程中，我们必须理解这个关键字并正确地使用它，以便更好地管理继承关系和维护代码。
Java中的两个关键字——super、thisJava中的两个关键字——super、this ⼀、supersuper 是java中⽅的⼀个关键字，⽤它可以引⽤⽗类中的成员：super可⽤于访问⽗类中定义的属性super可⽤于调⽤⽗类中定义的成员⽅法super可⽤于在⼦类构造器中调⽤⽗类的构造器使⽤super关键字注意事项：1、当⼦类和⽗类都有同名的属性时，在⼦类中如果要使⽤⽗类的属性 super . 属性2、 super只能应⽤在成员⽅法和构造⽅法中，不能⽤在静态⽅法中（和this是⼀样的）3、如果在构造⽅法中使⽤必须放在第⼀⾏4、在构造⽅法中this()和super()不能同时出现super没有什么需要解释的地⽅，我们⽤代码来看看super具体的⼀些强⼤功能吧⽰例⼀、使⽤super调⽤基类的属性：public class Father { int num=20;}public class Child extends Father{ int num; public void print(){ num=10; super.num=30; System.out.println("num="+num); System.out.println("="+super.num); }}public class Test { public static void main(String[] args) { Child xm=new Child(); xm.print(); }}运⾏结果：⽰例⼆、使⽤super调⽤基类中的构造⽅法：public class Father { int num; public Father() { System.out.println("⽗类中的⽆参构造⽅法---"); } public Father(int num){ System.out.println("⽗类中的有参的构造⽅法----"+num); }}public class Child extends Father{ int num; public Child() { super(30); System.out.println("⼦类⽆参构造⽅法---"); } public Child(int num) { this.num = num; System.out.println("⼦类中的有参的构造⽅法---"+num); }}解释⼀下上⾯的这段代码：在Child类中的第⼀个构造函数⾥⾯，super(30);它会去调⽤⽗类中嗲有⼀个int型参数的构造⽅法。
在java中super的用途
在Java中，super是一个关键词，代表了父类对象的引用。
super可以在子类中使用，以调用父类的方法、构造函数和属性。
主要用途包括以下几个方面：
1. 调用父类的构造函数
在子类的构造函数中，可以使用super调用父类的构造函数。
这种情况通常发生在子
类需要在父类的基础上进行一些特定的初始化操作，或者需要传入一些父类的参数。
调用
父类的构造函数可以使用super()，并且必须是子类中的第一条语句。
3. 引用父类的属性
子类可以使用super来引用父类的属性。
这种情况通常发生在子类需要使用父类中的
某个属性作为基础，在此基础上进行一些特定的操作。
使用super的格式为super.属性名。
4. 提高程序的可维护性
使用super可以提高程序的可维护性，使得代码更加清晰简洁。
父类中的方法和属性
通常具有通用性和重复性，子类可以直接复用这些方法和属性，避免了重复的代码，并且
可以更加方便地进行程序的扩展。
5. 帮助实现多态
Java是一种面向对象的语言，多态是面向对象最重要的特征之一。
使用super可以帮助实现多态性。
当子类对象调用方法时，JVM首先在子类中查找方法，如果没有找到，就
会到父类中查找方法。
如果父类中也没有找到，那么会一直向上查找，直到找到Object类为止，这种机制就是多态性的体现。
案例4-1 super访问父类成员变量一、案例描述1、考核知识点编号：029004003名称：super关键字2、练习目标➢掌握使用super关键字访问父类成员变量的方法3、需求分析子类可以继承父类的非私有成员变量，如果在子类中修改了继承自父类的成员变量的值，再想要访问父类的该成员变量时，可以通过super.成员变量来实现。
为了让初学者熟悉super关键字的用法，本案例将分别设计Fu类及其子类Zi，并在Zi类的方法中使用super关键字访问Fu类的成员变量。
4、设计思路（实现原理）1）编写一个Fu类，在类中定义无参构造和一个初始值为20的num成员变量。
2）Zi类继承Fu类，在子类中对num值进行了修改，同时在子类中定义无参构造和一个无返回值的method()方法，method()方法中使用super关键字调用了Fu类的num成员变量。
3）定义测试类Example03。
二、案例实现1、编写Fu类及其子类Zi，在Zi类中使用super关键字调用Fu类成员变量，代码如下class Fu {Fu() {}int num = 20;}class Zi extends Fu {Zi() {}int num = 30;// 修改num的值void method() {System.out.println("method");// super关键字调用父类成员变量System.out.println("Fu类中num值为：" + super.num);System.out.println("Zi类中num值为：" + num);}}2、定义测试类Example03，代码如下：class Example03{public static void main(String[] args) {Zi z = new Zi();z.method();}}运行结果如图4-3所示。
java的继承super用法在Java中，继承是面向对象编程的一个重要概念。
它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。
在继承关系中，子类继承了父类的特性，并且可以添加自己的特性或覆盖父类的方法。
当子类继承父类时，super关键字经常被用来引用父类的属性和方法。
super关键字有多种用法，下面将详细介绍每一种用法。
1. super( 构造器在子类的构造器中，使用super(来调用父类的构造器。
这是因为子类继承了父类的属性，需要通过调用父类的构造函数来初始化这些属性。
super(的调用必须放在子类构造器的第一行。
如果没有显式地调用super(，那么Java会自动隐式调用父类的默认构造函数。
2. super 关键字引用父类属性在子类中，可以使用super关键字来引用父类的属性。
这常常用于解决子类和父类有同名字段的冲突问题。
通过super关键字，可以明确地指定引用的是父类的属性。
```public class AnimalString name;public Animal(String name) = name;public class Dog extends Animalint age;public Dog(String name, int age)super(name); //调用父类的构造器来初始化name属性this.age = age;}public void displaSystem.out.println( + " is " + age + " years old."); //引用父类的name属性}public static void main(String[] args)Dog dog = new Dog("Fido", 5);dog.display(; //输出 Fido is 5 years old.}```3. super 关键字引用父类方法子类可以通过super关键字来引用父类的方法。
1.子类的构造函数如果要引用super的话，必须把super放在函数的首位. class Base {
Base() {
System.out.println("Base");
}
}
public class Checket extends Base {
Checket() {
super();//调用父类的构造方法，一定要放在方法的首个语句
System.out.println("Checket");
}
public static void main(String argv[]) {
Checket c = new Checket();
}
}
如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super 之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。
那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。
2．在Java中，有时还会遇到子类中的成员变量或方法与父类（有时也称父类）中的成员变量或方法同名。
因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法，但是我们如果想要使用父类中的这个成员变量或方法，就需要用到super. class Country {
String name;
void value() {
name = "China";
}
}
class City extends Country {
String name;
void value() {
name = "Hefei";
super.value();//不调用此方法时，返回的是父类的成员变量的值null System.out.println(name);
System.out.println();
}
public static void main(String[] args) {
City c=new City();
c.value();
}
}
为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、和super.value(),若不调用super.value()时，返回父类
成员变量默认值null,调用此方法时，super.value()方法把成员变量name赋
值为China,再利用调用父类的成员变量的值。
另外，要注意的是调用的是成员变量的值，
class Country {
String name="xianfan";
String value(String name) {
name = "China";
return name;
}
}
class City extends Country {
String name;
String value(String name) {
name = "Hefei";
super.value("失败");//不调用此方法时，返回的是父类的成员变量的值
null
System.out.println(name);
System.out.println();
return name;
}
public static void main(String[] args) {
City c=new City();
c.value("成功");
}
}
结果为：Hefei
xianfan
此时，返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。
3．用super直接传递参数：
class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("A Person.");
}
Person(String name) {
prt("A person name is:" + name);
}
}
public class Chinese extends Person {
Chinese() {
super(); // 调用父类无形参构造方法（1）
prt("A chinese.");// (4)
}
Chinese(String name) {
super(name);// 调用父类具有相同形参的构造方法（2）
prt("his name is:" + name);
}
Chinese(String name, int age) {
this(name);// 调用当前具有相同形参的构造方法（3）prt("his age is:" + age);
}
public static void main(String[] args) {
Chinese cn = new Chinese();
cn = new Chinese("kevin");
cn = new Chinese("kevin", 22);
}
}
结果为：A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。
super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。
this后加参数则调用的是当前具有相同参数的构造函数，如3处。
当然，在Chinese 的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。
但这样似乎就有点画蛇添足的味道了。
