java笔记(super关键字的使用)

super 关键字调用父类的构造方法与方法的用法和注
意事项
在Java中，使用关键字`super`可以调用父类的构造方法和方法。

下面是关于使用`super`关键字的一些用法和注意事项：
1. 调用父类的构造方法：
- 当子类创建对象时，会自动调用父类的默认构造方法（如果父类有无参构造方法）。

- 如果父类没有无参构造方法，或者希望调用父类的其他构造方法，可以使用`super`关键字来显式调用父类的构造方法。

- 使用`super(参数列表)`来调用父类的构造方法，其中参数列表需要与父类构造方法的参数列表相匹配。

2. 调用父类的方法：
- 在子类中，可以使用`super`关键字来调用父类的被覆盖（重写）的方法。

- 使用`super.方法名(参数列表)`的方式来调用父类的方法。

注意事项：
- `super`关键字只能在子类中使用，用于引用父类的成员。

- `super`关键字必须放在子类的构造方法或方法的第
一行。

- 如果子类覆盖了父类的方法，在子类中使用`super.方法名()`可以在调用父类的方法之前执行一些额外的逻辑。

- 当存在多级继承时，可以使用`super`关键字依次调用父类的构造方法和方法。

使用`super`关键字可以方便地在子类中访问和调用父类的成员，实现代码的复用和扩展。

java中this和super的用法
一、this的用法
1、当this表示当前对象时：
在类的方法中，this表示当前对象，它总是指向调用该方法的对象，这就是说，在类的方法中，“this”永远指向当前对象。

2、局部变量和属性
当一个局部变量或者成员变量名字相同时，this可以用来区分这两个变量，指明属性，要么this引用实例的属性，要么就是方法的局部变量。

3、用this调用构造函数
有时可以使用this调用同一类中其他构造函数，如：
public class A{
public A(){
}
public A(int a){
this();
}
}
4、强调调用成员变量
当this.x和x表示同一个成员变量时，可以使用this.x来强调x是成员变量，而不是局部变量。

二、super的用法
1、调用父类的构造函数
每个子类构造函数默认都会调用父类的默认的无参数的构造函数，可以使用super来调用父类有参数的构造函数。

2、调用父类的成员函数
子类可以调用自己不具备的父类函数，或者重写父类函数，重写时也可以使用super来调用父类函数。

3、调用父类的成员变量
由于子类不能直接访问父类的成员变量，需要使用super来访问父类的成员变量。

Java中的super()方法是用来调用父类的构造方法的关键字。

在面向对象编程中，父类和子类之间的关系非常重要，而super()方法就是在子类中调用父类的构造方法的一种方式。

1. super()方法的作用在Java中，当创建子类的实例时，通常会调用父类的构造方法来初始化父类中的成员变量和方法。

而使用super()方法可以在子类的构造方法中显式地调用父类的构造方法，以便完成对父类成员变量的初始化工作。

2. super()方法的语法在子类的构造方法中使用super()方法的语法非常简单，只需要在子类构造方法的第一行代码中使用super()即可。

例如：```javapublic class SubClass extends SuperClass {public SubClass() {super();// other initialization code}}```在这个例子中，SubClass是子类，SuperClass是父类，super()方法用来调用SuperClass的构造方法。

3. super()方法的参数在使用super()方法时，还可以传递参数给父类的构造方法，以便完成更为复杂的初始化工作。

例如：```javapublic class SubClass extends SuperClass {public SubClass(int param) {super(param);// other initialization code}}```在这个例子中，SubClass的构造方法接受一个参数param，然后通过super(param)调用父类的构造方法，将参数传递给父类的构造方法。

4. super()方法与this()方法的区别在Java中，this()方法用来调用同一个类中的其他构造方法，而super()方法用来调用父类的构造方法。

它们的主要区别在于this()方法是针对当前类的构造方法，而super()方法是针对父类的构造方法。

Java中super关键字的⽤法和细节⽬录前⾔1.super关键字的⽤法2.super关键字的使⽤细节3.super和this关键字的⽐较总结前⾔ 因为西安疫情的原因在宿舍摆了⼀个⽉，最近在复习前⾯学过的知识的时候发现，⾃⼰在初学⾯向对象时对Super关键字的理解不够深刻，所以现在重新学习⼀下super关键字的⽤法和细节。

1. super关键字的⽤法 在Java中，super关键字共有三种⽤法，分别是:通过 super.属性名来访问⽗类中的成员变量通过super.⽅法名(参数列表) 来访问⽗类中的成员⽅法通过super(参数列表) 来访问⽗类的构造⽅法调⽤⽗类的成员变量:class Person {protected int age;}class Student extends Person{public void func(){int age = super.age; //通过super.属性名访问⽗类的成员变量}}调⽤⽗类中的成员⽅法:class Person {protected void func(){}}class Student extends Person{public void func(){super.func(); //通过super.⽅法名调⽤⽗类的成员⽅法}}调⽤⽗类的构造器:class Person {String name;public Person(String name) { = name;}}class Student extends Person{public Student(String name) {super(name); //通过super(参数列表)调⽤⽗类的构造⽅法}}注意:⼦类⽆法通过super关键字访问⽗类中private修饰的属性和⽅法，因为private修饰的属性和⽅法只能在当前类的内部进⾏访问在⼦类的构造器中通过super关键字调⽤⽗类的构造器时，super关键字必须出现在构造器的第⼀⾏且仅能出现⼀次2. super关键字的使⽤细节当我们查找⼦类中的⽅法时，调⽤规则如下:当⼦类中存在需要调⽤的⽅法时，直接调⽤即可如果⼦类中不存在该⽅法，则向上寻找⽗类，如果⽗类中存在该⽅法，则调⽤⽗类中的⽅法若⽗类中不存在该⽅法，那么向上寻找⽗类的⽗类，直到找到Object类提⽰:如果直到Object类依然没有找到该⽅法，那么会提⽰⽅法不存在，但如果向上找到了这个⽅法但没有权限访问(例如该⽅法被private修饰)，则会产⽣错误。

一、super()的概念在Java编程中，super()是一个关键字，用来调用父类的构造方法。

在子类中使用super()可以调用父类的构造方法，从而实现子类继承父类的属性和方法。

super()必须作为子类构造方法的第一条语句，如果不显式调用super()，则默认调用父类的无参构造方法。

二、super()的用法1. 调用父类的构造方法当子类实例化时，会先调用父类的构造方法，可以使用super()在子类构造方法中调用父类的构造方法。

例如：```javapublic class Parent {public Parent(){System.out.println("Parent类的构造方法");}}public class Child extends Parent {public Child(){super(); //调用父类的构造方法System.out.println("Child类的构造方法");}}在上述例子中，当实例化Child类时，会先调用Parent类的构造方法，然后再调用Child类的构造方法。

2. 访问父类的属性和方法在子类中使用super关键字可以访问父类的属性和方法。

例如：```javapublic class Parent {public String name = "parent";public void sayHello(){System.out.println("Hello, I'm "+ name);}}public class Child extends Parent {public String name = "child";public void sayHello(){super.sayHello(); //调用父类的sayHello方法System.out.println("My name is "+ name);}}在上述例子中，子类可以通过super关键字访问父类的属性和方法，实现对父类的继承和扩展。

java super 关键字调用父类的构造方法与方法的用法和注意事项一、背景介绍在Java中，super关键字是一个非常重要的关键字，它用于调用父类的构造方法和方法。

在面向对象的程序设计中，经常会遇到需要在子类中重写父类的方法或者调用父类的构造方法的情况。

而super关键字就是用来处理这些情况的。

二、什么是super关键字super关键字是Java中的一个关键字，它用来调用父类的构造方法和方法。

在子类中通过super关键字可以访问父类中的成员变量和方法，以及调用父类的构造方法。

三、调用父类的构造方法在Java中，当子类实例化的时候，其构造方法会自动调用父类的无参构造方法。

但如果父类没有无参构造方法，那么子类就需要通过super关键字来调用父类的有参构造方法。

例如：javapublic class Parent {public Parent(int num) {父类的有参构造方法}public class Child extends Parent {public Child(int num) {super(num); 调用父类的有参构造方法}}需要注意的是，super关键字在子类构造方法中必须是第一条语句，否则编译器会报错。

因为在实例化子类的时候，先要调用父类的构造方法，然后再执行子类的构造方法。

四、调用父类的方法除了调用父类的构造方法，super关键字还可以用来调用父类的方法。

在子类中可以使用super关键字来访问父类中的普通方法或者重写父类的方法。

例如：javapublic class Parent {public void method() {父类的方法}public class Child extends Parent {public void method() {super.method(); 调用父类的方法}}在这个例子中，子类重写了父类的方法，然后在子类方法中通过super关键字调用了父类的方法。

super 关键字的使用 super 关键字出现在子类中，主要功能就是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

super 调用父类中的构造方法：class Person{String name;int age;public Person(String name,int age){=name;this.age=age;}}class Student extends Person{String school;public Student(){super("张三",27);}}public class TestPersonStudentDemo{public static void main(String args[]){Student s=new Student();S.shchool=”北京”;System.out.println("我是:"++",今年:"+s.age+"岁,学校:"+s.school) ; }}输出结果为：我是张三，今年27岁，学校：北京本程序在子类的构造方法中明确地指明了调用的是父类中有两个参数的构造方法，所以程序在编译时不再去找父类中无参的构造方法。

用super 调用父类中的构造方法，只能放在子类的第一行。

通过super 调用父类的属性和方法：class Person 父类构造方法子类构造方法 调用父类构造方法{String name;int age;public Person(){}public String talk(){return "我是："++",今年："+this.age+"岁";}}class Student extends Person{String school;public Student(String name,int age,String school){//在这里用super 调用父类中的属性=name;super.age=age;//调用父类中的talk()方法System.out.print(super.talk());//调用本类中属性this.school=school;}}public class TestPersonStudentDemo3{public static void main(String args[]){Student s=new Student("张三",27,"北京");System.out.println(",学校："+s.school);}}输出结果为：我是：张三,今年：27岁,学校：北京限制子类的访问有些时候，父类并不希望子类可以访问自己的类中全部的属性或方法，所以需要将一些属性父类构造方法子类构造方法 父类一般方法与方法隐藏起来，不让子类去使用。

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键字可以在子类中调用父类的构造函数、属性和方法。

super键字的定义：super一个指向父类的特殊变量，它可以用来访问父类的属性和方法。

super键字有两个重要的用途：1.调用父类的构造函数；2.调用父类的属性和方法。

将来介绍 super这两个用法。

首先，我们看一个例子，让大家了解 super键字是如何工作的： class Parent {int propertyA;void methodA(){System.out.println(Parent class methodA()}}class Child extends Parent {int propertyB;void methodB(){System.out.println(Child class methodB()System.out.println(Parent class propertyA: +propertyA); methodA();}}上面的程序中，我们有一个 Parent，它有一个属性 propertyA 一个方法 methodA()。

Child继承自 Parent，它有一个属性propertyB一个方法 methodB()。

在 Child的 methodB()法中，我们使用 super键字来访问 Parent的属性 propertyA方法 methodA()。

调用父类构造函数：在子类中，可以使用 super用父类的构造函数，super键字必须位于子类构造函数的第一行，如果没有明确指定，编译器会默认调用父类的无参构造函数，如果没有无参构造函数，编译器将报错。

下面是一个示例：class Parent {int propertyA;Parent(int a) {propertyA = a;}}class Child extends Parent {int propertyB;Child(int a, int b) {super(a);propertyB = b;}}在上面的程序中，Child有两个构造函数，第一个构造函数接受两个参数，它首先调用父类的构造函数，传入一个参数，然后赋值给propertyB。

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 指定⽗类的重名的成员变量.。