super()用于调用父构造函数吗? 请解释super()。
super()是用来调用父构造函数吗?
是的。
请解释一下超级()。
Super()是Super关键字的一种特殊用法,用于调用无参数的父构造函数。通常,super关键字可用于调用被重写的方法、访问隐藏字段或调用超类的构造函数。
下面是官方教程
是的,super()(小写)调用父类的构造函数。可以包含参数:super(foo, bar)
还有一个超级关键字,您可以在方法中使用它来调用超类的方法
“Java super”的快速谷歌会导致这样的结果
Super()不带参数地调用父构造函数。
它也可以与参数一起使用。例如super(argument1),它将调用接受一个argument1类型形参的构造函数(如果存在的话)。
它还可以用于从父类调用方法。即super.aMethod ()
更多信息和教程在这里
来源文章:Java:调用super()
是的。Super(…)将调用超类的构造函数。
说明:
独立的例子:
class Animal {
public Animal(String arg) {
System.out.println("Constructing an animal: " + arg);
}
}
class Dog extends Animal {
public Dog() {
super("From Dog constructor");
System.out.println("Constructing a dog.");
}
}
public class Test {
public static void main(String[] a) {
new Dog();
}
}
打印:
Constructing an animal: From Dog constructor
Constructing a dog.
这是正确的。Super用于调用父构造函数。假设你有这样一个代码块
class A{
int n;
public A(int x){
n = x;
}
}
class B extends A{
int m;
public B(int x, int y){
super(x);
m = y;
}
}
然后你可以给成员变量n赋一个值。
一些事实:
Super()用于调用直接父节点。 Super()可以用于实例成员,即实例变量和实例方法。 可以在构造函数中使用Super()来调用父类的构造函数。
好,现在让我们实际实现super()的这些点。
检查程序1和程序2之间的区别。这里,程序2证明了Java中super()的第一个语句。
程序1
class Base
{
int a = 100;
}
class Sup1 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup1().Show();
}
}
输出:
200 200
现在检查程序2,试着找出主要的区别。
项目2
class Base
{
int a = 100;
}
class Sup2 extends Base
{
int a = 200;
void Show()
{
System.out.println(super.a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup2().Show();
}
}
输出:
100 200
在程序1中,输出只是派生类。它既不能打印基类的变量,也不能打印父类的变量。但是在程序2中,我们在输出变量a时使用了super(),它打印的不是派生类变量a的值,而是基类变量a的值。因此,它证明了super()是用来调用直接父节点的。
好,现在看看程序3和程序4的区别。
项目3
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup3 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup3().Show();
}
}
输出:
200
这里输出是200。当我们调用Show()时,派生类的Show()函数被调用。但是,如果我们想调用父类的Show()函数,应该怎么做呢?请查看程序4以获得解决方案。
项目4
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup4 extends Base
{
int a = 200;
void Show()
{
super.Show();
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup4().Show();
}
}
输出:
100 200
这里我们有两个输出,100和200。当调用派生类的Show()函数时,它首先调用父类的Show()函数,因为在派生类的Show()函数内部,我们通过将super关键字放在函数名之前调用父类的Show()函数。
构造函数 在构造函数中,可以使用它而不带点来调用另一个构造函数。Super调用父类中的构造函数;调用该类中的构造函数:
public MyClass(int a) {
this(a, 5); // Here, I call another one of this class's constructors.
}
public MyClass(int a, int b) {
super(a, b); // Then, I call one of the superclass's constructors.
}
Super在父类需要初始化自身时很有用。这允许您只在一个构造函数中编写一次所有硬初始化代码,并从所有其他更容易编写的构造函数调用它,这很有用。
方法 在任何方法中,都可以使用它和一个点来调用另一个方法。Super.method()调用超类中的方法;this.method()调用该类中的一个方法:
public String toString() {
int hp = this.hitpoints(); // Calls the hitpoints method in this class
// for this object.
String name = super.name(); // Calls the name method in the superclass
// for this object.
return "[" + name + ": " + hp + " HP]";
}
super在某些情况下是有用的:如果你的类和你的超类有相同的方法,Java会假设你想在你的类中使用这个方法;Super允许你请求父类的方法。这只在提高代码可读性时有用。
super关键字可用于调用超类构造函数和引用超类的成员
当您使用正确的参数调用super()时,实际上调用了构造函数Box,它通过使用相应参数的值来初始化变量width、height和depth。你只剩下初始化它的增值权重。如果有必要,现在可以将类变量Box设为私有。放在Box类私有修饰符的字段中,并确保您可以毫无问题地访问它们。
在超类中可以有多个重载版本的构造函数,因此可以使用不同的参数调用方法super()。程序将执行与指定参数匹配的构造函数。
public class Box {
int width;
int height;
int depth;
Box(int w, int h, int d) {
width = w;
height = h;
depth = d;
}
public static void main(String[] args){
HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
}
}
class HeavyBox extends Box {
int weight;
HeavyBox(int w, int h, int d, int m) {
//call the superclass constructor
super(w, h, d);
weight = m;
}
}
只是超级();Alone将调用默认构造函数,如果类的超类中存在默认构造函数。但是必须自己显式地编写默认构造函数。如果你不这样做,Java会为你生成一个没有实现的,保存super();,引用通用超类对象,并且不能在子类中调用它。
public class Alien{
public Alien(){ //Default constructor is written out by user
/** Implementation not shown…**/
}
}
public class WeirdAlien extends Alien{
public WeirdAlien(){
super(); //calls the default constructor in Alien.
}
}
例如,在selenium自动化中,你有一个PageObject,它可以像这样使用它的父类构造函数:
public class DeveloperSteps extends ScenarioSteps {
public DeveloperSteps(Pages pages) {
super(pages);
}........
调用无参数的超级构造函数只是浪费屏幕空间和程序员时间。编译器生成的代码完全相同,不管你写不写。
class Explicit() {
Explicit() {
super();
}
}
class Implicit {
Implicit() {
}
}
Super是一个关键词。在子类方法定义中使用它来调用父类中定义的方法。父类的私有方法不能被调用。只有public和protected方法可以被super关键字调用。类构造函数也使用它来调用父类的构造函数。
点击这里查看进一步的解释。
如前所述,在默认构造函数内部,在构造函数的第一行调用隐式super()。
这个super()自动调用从类层次结构顶部开始的构造函数链,并向下移动层次结构。
如果程序的类层次结构中有两个以上的类,顶层类的默认构造函数将首先被调用。
下面是一个例子:
class A {
A() {
System.out.println("Constructor A");
}
}
class B extends A{
public B() {
System.out.println("Constructor B");
}
}
class C extends B{
public C() {
System.out.println("Constructor C");
}
public static void main(String[] args) {
C c1 = new C();
}
}
以上将输出:
Constructor A
Constructor B
Constructor C
我愿意与代码分享我所了解的一切。
java中的super关键字是一个引用变量,用于引用父类对象。它主要用于以下情况:-
1. super与变量的使用:
class Vehicle
{
int maxSpeed = 120;
}
/* sub class Car extending vehicle */
class Car extends Vehicle
{
int maxSpeed = 180;
void display()
{
/* print maxSpeed of base class (vehicle) */
System.out.println("Maximum Speed: " + super.maxSpeed);
}
}
/* Driver program to test */
class Test
{
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}
输出:
Maximum Speed: 120
super with的使用方法:
/* Base class Person */
class Person
{
void message()
{
System.out.println("This is person class");
}
}
/* Subclass Student */
class Student extends Person
{
void message()
{
System.out.println("This is student class");
}
// Note that display() is only in Student class
void display()
{
// will invoke or call current class message() method
message();
// will invoke or call parent class message() method
super.message();
}
}
/* Driver program to test */
class Test
{
public static void main(String args[])
{
Student s = new Student();
// calling display() of Student
s.display();
}
}
输出:
This is student class
This is person class
3.super与构造函数的使用:
class Person
{
Person()
{
System.out.println("Person class Constructor");
}
}
/* subclass Student extending the Person class */
class Student extends Person
{
Student()
{
// invoke or call parent class constructor
super();
System.out.println("Student class Constructor");
}
}
/* Driver program to test*/
class Test
{
public static void main(String[] args)
{
Student s = new Student();
}
}
输出:
Person class Constructor
Student class Constructor
我们可以用SUPER做什么?
访问超类成员
如果你的方法覆盖了它的一些超类的方法,你可以通过使用关键字super来调用被覆盖的方法,比如super. methodname ();
调用超类构造函数
如果构造函数没有显式调用超类构造函数,Java编译器会自动插入对超类的无参数构造函数的调用。如果超类没有无参数构造函数,则会得到编译时错误。
看看下面的代码:
class Creature {
public Creature() {
system.out.println("Creature non argument constructor.");
}
}
class Animal extends Creature {
public Animal (String name) {
System.out.println("Animal one argument constructor");
}
public Animal (Stirng name,int age) {
this(name);
system.out.println("Animal two arguments constructor");
}
}
class Wolf extends Animal {
public Wolf() {
super("tigerwang",33);
system.out.println("Wolf non argument constructor");
}
public static void main(string[] args) {
new Wolf();
}
}
When creating an object,the JVM always first execute the constructor in the class of the top layer in the inheritance tree.And then all the way down the inheritance tree.The reason why this is possible to happen is that the Java compiler automatically inserts a call to the no-argument constructor of the superclass.If there's no non-argument constructor in the superclass and the subclass doesn't explicitly say which of the constructor is to be executed in the superclass,you'll get a compile-time error.
类的构造函数,在上面的代码中,如果我们想成功地创建Wolf对象 类必须执行。在这个过程中,Animal中的双参数构造函数 类被调用。同时,它显式地调用同一个参数中的单参数构造函数 类和单参数构造函数隐式调用生物中的非参数构造函数 类和非参数构造函数再次隐式调用Object中的空构造函数 类。
The super keyword in Java is a reference variable that is used to refer to the immediate parent class object.
Java超级关键字的使用
Super可用于引用直接父类实例变量。 Super可用于调用直接父类方法。 Super()可用于调用直接父类构造函数。
还有其他一些用途。
引用继承接口的默认方法:
import java.util.Collection;
import java.util.stream.Stream;
public interface SkipFirstCollection<E> extends Collection<E> {
@Override
default Stream<E> stream() {
return Collection.super.stream().skip(1);
}
}
还有一种很少使用的情况,在实例化静态子类时,使用限定的超类为超类构造函数提供一个外部实例:
public class OuterInstance {
public static class ClassA {
final String name;
public ClassA(String name) {
this.name = name;
}
public class ClassB {
public String getAName() {
return ClassA.this.name;
}
}
}
public static class ClassC extends ClassA.ClassB {
public ClassC(ClassA a) {
a.super();
}
}
public static void main(String[] args) {
final ClassA a = new ClassA("jeff");
final ClassC c = new ClassC(a);
System.out.println(c.getAName());
}
}
然后:
$ javac OuterInstance.java && java OuterInstance
jeff
推荐文章
- URLEncoder不能翻译空格字符
- Java中的super()
- 如何转换JSON字符串映射<字符串,字符串>与杰克逊JSON
- 使用Java在原语数组中查找最大/最小值
- 如何自动生成N“不同”的颜色?
- 如何从java应用程序创建一个windows服务
- 好的Java图算法库?
- 将字符串转换为Uri
- jUnit中的字符串上的AssertContains
- 将JSON转换为映射
- 在Java8中使用lambda仅在不为空时筛选值
- Java反射中的getFields和getDeclaredFields有什么区别
- 如何检查一个文件夹是否存在?
- 错误:无法在intelliJ IDE中找到或加载主类
- 如何创建Android Facebook密钥哈希?