java中super关键字的三种用法

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关键字来引用父类的方法。

java的super用法
Java的super是一个引用，它指向当前子类对象所属父类的实例。

它可以使子
类使用自己继承的父类的方法和属性。

下面总结了Java中使用super的：
一、实现父类的构造函数
1. 调用父类的无参构造函数
super() 是子类的构造函数的默认第一行，子类可以使用super（）显式调用父类的
无参构造函数；
2. 调用父类的有参构造函数
通过super关键字，可以调用父类指定的有参构造函数；
二、使用super调用父类的成员变量和成员方法
1. 调用父类的成员变量
super.变量名可以用来访问父类中声明过的成员变量；
2. 调用父类的成员方法
super.方法名（参数），可以用来调用父类中声明过的成员方法；
三、重写父类的方法时使用super
当子类重写了父类的方法时，要在子类中想调用父类的重写方法时使用super关键字；
以上就是Java中使用super的三种情况，super可以使子类使用父类中定义的
变量或方法，使子类在重写父类方法时调用父类方法，也可以调用父类的构造函数。

使用super关键字，能体现出面向对象的思想，能够有效的隔离模块，代码更加易
于维护和管理。

Java中super关键字是什么？⽤来⼲什么？super 关键字含义super : 超级的含义：在Java中代表当前对象的直接⽗类对象的引⽤⽤法分类super.super(实际参数)1、super(实际参数)super():代表调⽤⽗类⽆参的构造super(参数)：调⽤⽗类有参的构造作⽤：在⼦类构造⽅法中调⽤⽗类的构造⽅法特点：1.如果⼦类构造⽅法中的第⼀⾏没有this（）或者this（参数），也不是super（参数）默认是super(),构造⽅法的第⼀⾏不是this(...)就是super（...）2.super()和super（参数）只能在构造⽅法的第⼀⾏注意： super()和super(参数)只能⽤在⼦类的构造⽅法中案例：package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}// 定义⼀个⽗类class Super{int a;int b;//将构造public Super(){System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {System.out.println("我是⽗类有参数的构造⽅法");this.a = a;this.b = b;}//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super(11,22);System.out.println("我是⼦类的⽆参数的构造⽅法");}public Sub(int c, int d) {super(11,22);System.out.println("我是⼦类的有参数的构造⽅法");this.c = c;this.d = d;}}案例2:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}// 定义⼀个⽗类class Super{int a;int b;//将构造public Super(){System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {System.out.println("我是⽗类有参数的构造⽅法");this.a = a;this.b = b;//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super();System.out.println("我是⼦类的⽆参数的构造⽅法");}public Sub(int c, int d) {this();System.out.println("我是⼦类的有参数的构造⽅法");this.c = c;this.d = d;}}案例3:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {//Sub sub = new Sub();Sub sub = new Sub(10,20);// 在定义⼀个类的时候如果已经定义了有参构造在开发中⼀般要将⽆参数的构造⽅法补出来 }}class YeYe{public YeYe(){System.out.println("我是yeye的构造⽅法");}}// 定义⼀个⽗类class Super extends YeYe{int a;int b;//将构造public Super(){super();System.out.println("我是⽗类⽆参数的构造⽅法");}public Super(int a, int b) {}//定义⼀个⼦类class Sub extends Super{int c;int d;//构造⽅法public Sub(){super();System.out.println("我是⼦类的⽆参数的构造⽅法"); }public Sub(int c, int d) {this();System.out.println("我是⼦类的有参数的构造⽅法"); this.c = c;this.d = d;}}2、super .作⽤：区分直接⽗类中和⼦类中重名的成员(成员变量和成员⽅法)案例：package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {Sub sub = new Sub();sub.m();}}class YeYe{int b = 1;}// 定义⼀个⽗类class Super extends YeYe{int b = 10;public int m1(){return super.b;}}int b = 20;public void m(){int b = 30;//System.out.println(b);//System.out.println(this.b);System.out.println(super.b);//super 指代当前⼦类的直接⽗类对象的引⽤ System.out.println(super.b);int i = m1();System.out.println(i);}}案例2:package com.ujiuye.day09;public class Demo10 {public static void main(String[] args) {Sub sub = new Sub();sub.m2();}}// 定义⼀个⽗类class Super{public void m1(){System.out.println("我是⽗类中的m1⽅法");}}//定义⼀个⼦类class Sub extends Super{// sub中有3个 b 成员变量@Overridepublic void m1(){System.out.println("我是⼦类重写⽗类的m1⽅法");}public void m2(){//this.m1();//this.m1()super.m1();}}总结super: 当前类的直接⽗类对象的引⽤1. 只能⽤在构造⽅法中2. 只能是构造⽅法的第⼀条有效语句3. 如果⼀个构造⽅法的第⼀⾏不是 this() / this(实参) / super(实参),默认是super()2、super. : 当⼦类中存在和⽗类同名的成员变量,需要使⽤super 指定⽗类的重名的成员变量.。

Java中this和super的⽤法详解前⾔这次我们来回顾⼀下this和super这两个关键字的⽤法，作为⼀名Java程序员，我觉得基础是最重要的，因为它决定了我们的上限，所以我的⽂章⼤部分还是以分享Java基础知识为主，学好基础，后⾯的知识我想学起来就变得简单。

废话不多说，进⼊正⽂。

thisthis 关键字只能在⽅法内部使⽤，表⽰对调⽤⽅法的那个对象的引⽤。

其实简单来说 this 关键字就是表⽰当前对象，下⾯我们来具体介绍 this 关键字在Java中的⽤法。

1、调⽤成员变量在⼀个类的⽅法内部，如果我们想调⽤其成员变量，不⽤ this，我们会怎么做？public class ThisTest {private String name = "xiaoming";public String getName() {return name;}public void setName(String name) {name = name;}}看上⾯的代码，我们在ThisTest类中创建了⼀个name属性，然后创建了⼀个setName⽅法，注意这个⽅法的形参也是String name，那么我们通过name = name这样赋值，会改变成员变量name的属性吗？public static void main(String[] args) {ThisTest thisTest = new ThisTest();thisTest.setName("xiaoma");System.out.println(thisTest.getName());}打印结果是xiaoming，⽽不是我们重新设置的xiaoma，显然这种⽅式是不能在⽅法内部调⽤到成员变量的。

因为形参的名字和成员变量的名字相同，setName⽅法内部的name = name，根据最近原则，编译器默认是将这两个name属性都解析为形参name，从⽽导致我们设值操作和成员变量name完全没有关系，当然设置不了。

java中super关键字的用法一、什么是super关键字super关键字是java语言的一个关键字。

它可以被用来访问一个对象的父类中的字段、构造器和方法。

它在子类中和this关键字很类似，但是this只能用于访问它所在的类中的成员，而super可以访问父类中的成员。

二、super关键字的用法1、super用于调用父类的构造器：当子类构造器需要调用父类构造器时，可以使用super语句。

例： class SuperClass { SuperClass(){ System.out.println('SuperClass构造器被调用'); } } class SubClass extends SuperClass { SubClass() { super(); // 调用父类的构造器 System.out.println('SubClass构造器被调用'); } } 2、super用于调用父类的方法：当子类的方法需要调用父类的方法时，可以使用super语句。

例： class SuperClass { void print() { System.out.println('调用父类的print方法'); } } class SubClass extends SuperClass { void print() { super.print(); // 调用父类的print方法System.out.println('调用子类的print方法'); } }3、super用于调用父类的字段：当子类中的字段和父类中的字段名称相同时，可以使用super关键字来区分。

例：class SuperClass { int x = 10; } class SubClass extends SuperClass { int x = 100; voidprint(){ System.out.println(super.x); // 调用父类的x } } 总结super关键字是java语言中的一个关键字，用于访问父类的字段、构造器和方法。

super是Java中的一个关键字，它在许多方面都有其特殊的用途。

这个关键字主要在三个地方使用：在构造函数中，实例方法中，以及静态方法中。

以下是关于super关键字详细用法的解析。

首先，让我们从构造函数开始。

在Java中，每个构造函数都必须显式或隐式地调用其超类（superclass）的构造函数。

如果你不显式地调用超类的构造函数，Java编译器会自动在构造函数的开始处插入一个无参数的super()调用。

但如果你显式地使用super关键字调用一个带有参数的构造函数，Java编译器就不会自动插入无参数的super()调用。

使用super关键字调用构造函数的主要目的是为了在子类构造函数中初始化超类的部分。

其次，super关键字也可以在实例方法中使用。

在实例方法中，你可以使用super关键字调用超类的实例方法。

这在覆盖（override）方法时特别有用，因为你可以使用super 关键字调用被覆盖的超类方法，从而在其基础上添加新的功能。

最后，尽管静态方法不能被覆盖，但是你仍然可以使用super关键字在子类的静态方法中调用超类的静态方法。

这主要是为了在子类的静态方法中访问超类的静态字段或方法。

此外，super关键字还有一个重要的用途，那就是访问超类的隐藏字段。

在Java中，如果子类和超类有同名的字段，那么子类的字段会隐藏超类的字段。

在这种情况下，你可以使用super关键字访问被隐藏的超类字段。

总的来说，super关键字在Java中的主要作用是在子类中访问超类的构造函数、方法和字段，从而实现代码的复用和扩展。

它体现了Java面向对象编程中的继承和多态的核心概念。

java中super的用法一、super关键字的概述在Java编程语言中，super关键字常用于子类中，用于引用父类的成员变量、方法和构造方法。

通过使用super关键字，子类可以直接访问并调用父类中被隐藏或重写的成员。

二、使用super关键字访问父类的成员变量和方法2.1 访问父类的成员变量子类继承了父类的所有非私有成员变量，在子类中可以直接访问继承而来的这些成员变量。

如果子类中定义了与父类同名的成员变量，则可以通过使用super关键字来区分并访问父类中的成员变量。

例如，下面是一个简单的示例代码：```javaclass Parent {int num = 10;}class Child extends Parent {int num = 20;void display() {System.out.println("Child num: " + num);System.out.println("Parent num: " + super.num);}}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}}```输出结果为：```Child num: 20Parent num: 10```可以看到，Child类中定义了一个与Parent同名的成员变量num，并且在display()方法中通过super.num来访问父类中的num变量。

2.2 调用父类的普通方法与访问父类的成员变量类似，子类可以使用super关键字来调用父类中的普通方法。

在子类中重写了父类的方法后，想要调用父类的方法可以使用super关键字。

例如，下面是一个简单的示例代码：```javaclass Parent {void display() {System.out.println("Parent display() called"); }}class Child extends Parent {@Overridevoid display() {super.display(); // 调用父类的display()方法 System.out.println("Child display() called"); }}public class Main {public static void main(String[] args) {Child child = new Child();child.display();}}```输出结果为：```Parent display() calledChild display() called```可以看到，在Child类中通过super.display()来调用父类中的display()方法。

1.this关键字：super代表父类对象。

this指对象本身。

this，super都不能放在静态方法里，因为他们时实例（对象）相关的。

注意，main 方法也是静态方法。

用法1：private int stuNo;public void setStuNo(int stuNo){this.stuNo=stuNo;}public int getStuNo(){return this.stuNo;}用法2：类的构造器可以相互调用，调用方式是使用this关键字来实现。

如：public Point(){this(0,0);相当于this.x=0;this.y=0;有this了，super就没有了。

不 } 执行super了。

public Point (double x,double y){//super();this.x=x;this.y=y;}在构造器中，super（）和this（0，0）；这样的，不能同时出现。

如：super();生成一个对象this(0,0)；又生成一个对象都显示就有问题，super构造与this构造不能同时出现。

☆：this代表的是对象的本身。

Java语言中，方法重载要求（ A ）A．采用不同的参数列表。

B．采用不同的返回值类型。

C．调用时，用类名或对象名做前缀。

D．在参数列表中使用的参数名不同。

this：构造器中指该构造器所创建的新对象。

方法中指调用该方法的对象。

顺序：比如创建Person p=new Person(); extends Animal首先执行构造方法中Super这时，先走Animal类的变量定义，有赋值的给变量赋值。

然后走Animal的构造方法，然后走person类的变量定义，然后走person的构造方法。

（这是一步步递归）。

2.初始化块：不管使用哪个构造器创建对象，它都会被首先运行，在成员运行之后，然后才是构造器的主体部分被执行。

如下面的初始化块：作用是给属性赋值。

super关键字的用法
super是一个关键字，用于调用父类的方法、构造函数和属性。

super是Java中的重要关键字之一，它可以在子类中使用，在子类中，我们可以使用super关键字来调用父类中的构造函数和方法。

这篇文章将介绍super关键字的用法。

一、调用父类的构造函数
在子类中通过super调用父类的构造函数，可以让子类继承父类的属性和方法。

在Java中，所有的类都会有一个默认的构造函数，如果我们不显式地定义构造函数，编译器会自动生成一个默认的构造函数。

但是，如果父类有多个构造函数，我们就需要使用super关键字来调用父类中的构造函数。

下面是一个例子：
```
class Parent {
Parent() {
System.out.println("Parent Constructor");
}
}
在上面的代码中，我们定义了两个类：Parent和Child。

Child继承了Parent。

在Child的构造函数中，我们使用super()来调用Parent的构造函数。

这样，当我们创建Child的实例时，就会先调用Parent的构造函数，然后再调用Child的构造函数。

输出结果如下：
```
Parent Constructor
Child Constructor
```
二、调用父类的方法
在子类中通过super调用父类的方法，可以让子类重载父类的方法，或者在父类的基础上增加额外的功能。

我们可以在子类中使用super来调用父类中的方法。

三、访问父类的属性
总结：。

super的用法java在Java中，"super" 是一个关键字，用于引用父类的成员，以便在子类中访问父类的属性和方法。

以下是一些使用"super"的常见用法：1. 调用父类的构造方法：当子类继承父类时，可以使用"super"关键字来调用父类的构造方法，以便在子类对象创建时初始化父类的属性。

例如：javapublic class Parent {public Parent(String message) {System.out.println("Parent: " + message);}}public class Child extends Parent {public Child() {super("Hello"); 调用父类的构造方法}}2. 调用父类的方法：子类可以使用"super"关键字来调用父类的方法。

这在子类需要重写父类方法，并且在子类方法中需要调用父类方法时特别有用。

例如：javapublic class Parent {public void showMessage() {System.out.println("Hello from Parent");}}public class Child extends Parent {@Overridepublic void showMessage() {super.showMessage(); 调用父类的showMessage方法System.out.println("Hello from Child");}}3. 引用父类的属性：在子类中，可以使用"super"关键字来引用父类的属性，以便在子类中使用或修改父类的属性。

例如：javapublic class Parent {protected int number;public Parent(int number) {this.number = number;}}public class Child extends Parent {public Child(int number) {super(number); 使用super引用父类的构造方法}public void updateNumber() {super.number = 10; 使用super引用父类的属性并修改}}总的来说，"super"关键字可以用于调用父类的构造方法、方法以及引用父类的属性，以便在子类中使用和修改。