Java super关键字用法源代码
？extendsT和？superT的使用
extendsT和？superT的使⽤阿⾥规范中有⼀个12.【强制】泛型通配符<? extends T>来接收返回的数据，此写法的泛型集合不能使⽤ add ⽅法，⽽<? super T>不能使⽤ get ⽅法，两者在接⼝调⽤赋值的场景中容易出错。
具体的分析可以看下如下：最终PECS (Producer Extends Consumer Super ) 原则频繁往外读取内容的，适合⽤上界Extends。
经常往⾥插⼊的，适合⽤下界Super。
<? extends T> 和 <? super T> 是Java泛型中的“通配符（Wildcards）” 和 “边界（Bounds）”的概念<? extends T> 是指 “上界通配符（Upper Bounds Wildcards）”<? super T> 是指 “下界通配符（Lower Bounds Wildcards）”1. 为什么要⽤通配符和边界？使⽤泛型的过程中，经常出现⼀种很别扭的情况。
⽐如，我们有Fruit类，和它的派⽣类Apple类。
class Fruit {}class Apple extends Fruit {}然后有⼀个最简单的容器：Plate类。
盘⼦⾥可以放⼀个泛型的“东西”。
我们可以对这个东西做最简单的“放”和“取”的动作：set()和get()⽅法。
public class Plate<T> {private T item;public Plate(T t) {this.item = t;}public T get() {return item;}public void set(T item) {this.item = item;}}现在我定义⼀个“⽔果盘⼦”，逻辑上⽔果盘⼦当然可以装苹果。
Plate<Fruit> p=new Plate<Apple>(new Apple());但实际上Java编译器不允许这个操作。
js中super的用法
js中super的用法在JavaScript中，super关键字用于调用父类的方法或属性。
当子类继承了父类时，可以使用super关键字来访问父类的方法或属性。
在子类中，使用super关键字调用父类的方法或属性时，可以使用以下两种方式：1. 调用父类的构造函数当子类需要访问父类的构造函数时，可以使用super关键字来调用父类的构造函数。
在子类的构造函数中，调用super()方法即可。
例如：class Parent {constructor(name) { = name;}}class Child extends Parent {constructor(name, age) {super(name); // 调用父类的构造函数this.age = age;}}const child = new Child('Lucy', 18);console.log(); // 'Lucy'console.log(child.age); // 18在上述代码中，子类Child调用了父类Parent的构造函数，并且在调用时传递了参数name。
2. 调用父类的方法或属性当子类需要访问父类的方法或属性时，可以使用super关键字来调用父类的方法或属性。
在子类中，使用super关键字调用父类的方法或属性时，需要通过.运算符来访问。
例如：class Parent {sayHello() {console.log('Hello');}}class Child extends Parent {sayHello() {super.sayHello(); // 调用父类的sayHello方法console.log('World');}}const child = new Child();child.sayHello(); // 'Hello' 'World'在上述代码中，子类Child重写了父类Parent的sayHello方法，并且在重写时调用了父类的sayHello方法。
Java中的两个关键字——super、this
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型参数的构造⽅法。
super函数的用法
super函数的用法Super函数的用法Super函数是Python内置的一个函数，它可以用于调用父类的方法。
在多重继承中，如果子类需要调用父类的方法，就可以使用super函数。
一、super函数的基本语法super(type[, object-or-type])type：表示子类所在的类。
object-or-type：可选参数，表示当前对象所属的类型或对象。
二、使用super函数调用父类方法1. 单继承情况下使用super函数单继承情况下，我们可以直接使用父类名称来调用父类方法。
但是，在多重继承中，如果多个父类都有同名方法，则需要使用super函数来选择其中一个。
示例代码：class Parent:def __init__(self): = "Parent"def say_hello(self):print("Hello from Parent!")class Child(Parent):def __init__(self):super().__init__() = "Child"def say_hello(self):super().say_hello()print("Hello from Child!")child = Child()child.say_hello()输出结果：Hello from Parent!Hello from Child!2. 多重继承情况下使用super函数在多重继承中，如果子类需要调用某个父类的方法，就可以使用super函数。
当然，在多重继承中，可能存在多个同名方法，此时需要指定要调用哪个父类的方法。
示例代码：class Parent1:def say_hello(self):print("Hello from Parent1!")class Parent2:def say_hello(self):print("Hello from Parent2!")class Child(Parent1, Parent2):def say_hello(self):super(Parent1, self).say_hello()super(Parent2, self).say_hello()print("Hello from Child!")child = Child()child.say_hello()输出结果：Hello from Parent1!Hello from Parent2!Hello from Child!三、super函数的使用注意事项1. 调用父类方法时，需要确保父类方法的参数和返回值与子类中的相同。
java语言程序设计(一)第三章补充
专接本辅导java第三章《面向对象编程基础》补充0.类变量与实例变量区别（类方法与实例方法的区别见习题解答第12题改错）java类的成员变量有两种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
例如，对于下面的程序，无论创建多少个实例对象，只在类被第一次装置时初始化一次staticVar变量和sum变量，并且每创建一个实例对象，就会执行一次构造函数；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
public class类变量与实例变量{public static int staticVar = 0;//类变量初始化，只会在类装载时进行一次！！public int instanceVar = 0;//实例变量初始化public static int sum=1;public类变量与实例变量()//构造方法{staticVar++;instanceVar++;sum=sum+5;System.out.println("staticVar = "+staticVar+",instanceVar="+instanceVar);System.out.println("sum = "+sum);}public static void main(String []args){类变量与实例变量对象1=new类变量与实例变量();类变量与实例变量对象2=new类变量与实例变量();类变量与实例变量对象3=new类变量与实例变量();}}运行结果：staticVar = 1,instanceVar=1sum = 6staticVar = 2,instanceVar=1sum = 11staticVar = 3,instanceVar=1sum = 16再如下面的程序，涉及static块：class Value{static int c=0;static int d;Value(){c=15;d=65;}Value(int i){c=i;d=c-1;}static void inc(){c++;}}public class Count {Value v0=new Value();//调用无参构造函数建立Value类非静态对象v0，类Count和类Value是has-a关系Value v=new Value(10);//调用有参构造函数建立Value类非静态对象vstatic Value v1,v2;//声明Value类的static对象v1,v2//static Value v1=new Value(),v2=new Value();//声明v1、v2并引用新建立的Value类对象static{//★声明static块，其初始化工作会先于任何其它非static块及非static变量而不管其在源程序书写中出现的先后次序！System.out.println("static块中println语句执行结果:"+"\n"+"v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v1=new Value(30);//对象v1引用新建立的Value类对象System.out.println("static块中执行完“v1=new Value(30)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v2=new Value(15);//对象v2引用新建立的Value类对象System.out.println("static块中执行完“v2=new Value(15)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);System.out.println("特别说明：因此时还没有建立Count类对象（Count 类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！"+"\n");}public static void main(String[] args) {Count ct1=new Count();//建立Count类（外部类）对象Count ct2=new Count();System.out.print("在main方法中，现在建立Count类（外部类）对象，");System.out.println("ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！"+"\n"+"以下是main方法体中println语句执行结果：");System.out.println("v0是无参构造内部类非静态对象，ct1.v0.c="+ct1.v0.c+" ct1.v0.d="+ct1.v0.d+" ct2.v0.c="+ct2.v0.c+"ct2.v0.d="+ct2.v0.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v是有参构造内部类非静态对象，ct1.v.c="+ct1.v.c+" ct1.v.d="+ct1.v.d+" ct2.v.c="+ct2.v.c+" ct2.v.d="+ct2.v.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v1是有参构造内部类静态对象，Count.v1.c="+Count.v1.c+" count.v1.d="+Count.v1.d);//静态内部类对象可以通过外部类名访问System.out.println("v2是有参构造内部类静态对象，Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Value.inc();//通过类名调用类方法System.out.println("调用类方法inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Count.v2.inc();//通过类名调用类方法，这种写法不妥！System.out.println("调用类方法v1.inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法v1.inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);ct1.v0.c++;//this.v0.c++;//错误，★不能在静态上下文中使用this关键字:！因为Value是Count的内部类，只能使用其外部类的对象ct2.v0.c++;System.out.println("顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c="+ct1.v0.c+" ct2.v0.c="+ct2.v0.c);// 非静态内部类对象只能通过外部类对象名访问}}上面这个程序的行动结果如下：static块中println语句执行结果:v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c=0 v2.c=0 v1.d=0 v2.d=0static块中执行完“v1=new Value(30)之后：”v1.c=30 v2.c=30 v1.d=29 v2.d=29static块中执行完“v2=new Value(15)之后：”v1.c=15 v2.c=15 v1.d=14 v2.d=14特别说明：因此时还没有建立Count类对象（Count类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！在main方法中，现在建立Count类（外部类）对象，ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！以下是main方法体中println语句执行结果：v0是无参构造内部类非静态对象，ct1.v0.c=10 ct1.v0.d=9 ct2.v0.c=10 ct2.v0.d=9v是有参构造内部类非静态对象，ct1.v.c=10 ct1.v.d=9 ct2.v.c=10 ct2.v.d=9 v1是有参构造内部类静态对象， Count.v1.c=10 count.v1.d=9v2是有参构造内部类静态对象， Count.v2.c=10 count.v2.d=9调用类方法inc()之后 Count.v1.c=11 Count.v1.d=9调用类方法inc()之后 Count.v2.c=11 count.v2.d=9调用类方法v1.inc()之后 Count.v1.c=12 Count.v1.d=9调用类方法v1.inc()之后 Count.v2.c=12 count.v2.d=9顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c=14 ct2.v0.c=14以上运行结果中，有五点值得注意：一是static变量和static块是在类第一次装载时被初始化一次，并供类的所有对象共享，故static变量和static块中内容最先被初始化（早于main方法）。
java中super.ondestroy用法 -回复
java中super.ondestroy用法-回复Java中的super.onDestroy用法在Java中，super.onDestroy是用于调用父类的onDestroy方法。
onDestroy方法是Android生命周期中的一个回调方法，当一个活动被销毁时，Android系统会自动调用该方法。
通过调用super.onDestroy，我们可以实现在子类中重写父类的onDestroy方法，并在子类的销毁逻辑中添加一些额外的操作。
本文将详细解释super.onDestroy的用法，并提供一些示例代码来演示其使用方式。
一、super.onDestory的基本用法在子类中重写父类的onDestroy方法时，可以通过调用super.onDestroy来实现对父类onDestroy方法的调用。
super关键字是Java中的一个特殊关键字，它可以用于调用父类的方法。
通过调用super.onDestroy，可以确保父类中的onDestroy方法得到执行，从而保证子类的销毁逻辑与父类的销毁逻辑可以共存。
下面是一个简单的示例代码，演示了如何在子类中使用super.onDestroy来调用父类的onDestroy方法：javapublic class MyActivity extends Activity {Overrideprotected void onDestroy() {子类销毁逻辑super.onDestroy(); 调用父类的onDestroy方法}}当调用super.onDestroy时，程序会先执行子类中的销毁逻辑，然后再执行父类的销毁逻辑。
这样可以确保子类的销毁逻辑在父类的销毁逻辑之前执行，从而避免误删重要资源或造成其他问题。
二、为什么要使用super.onDestory在Android开发中，Activity的生命周期是非常重要的。
当一个Activity被销毁时，系统会调用其onDestroy方法来清理资源和释放内存。
java中的this和super的作用和异同和C++中调用父类的构造函数
java中的this和super的作⽤和异同和C++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到this和super，这⾥就做了⼀点总结，与各位共同交流，有错误请各位指正~thisthis是⾃⾝的⼀个对象，代表对象本⾝，可以理解为：指向对象本⾝的⼀个指针。
this的⽤法在java中⼤体可以分为3种：1.普通的直接引⽤这种就不⽤讲了，this相当于是指向当前对象本⾝。
2.形参与成员名字重名，⽤this来区分：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17class Person {private int age = 10;public Person(){System.out.println("初始化年龄："+age);}public int GetAge(int age){this.age = age;return this.age;}}public class test1 {public static void main(String[] args) {Person Harry = new Person();System.out.println("Harry's age is "+Harry.GetAge(12)); }}运⾏结果：初始化年龄：10Harry's age is 12可以看到，这⾥age是GetAge成员⽅法的形参，this.age是Person类的成员变量。
3.引⽤构造函数这个和super放在⼀起讲，见下⾯。
supersuper可以理解为是指向⾃⼰超（⽗）类对象的⼀个指针，⽽这个超类指的是离⾃⼰最近的⼀个⽗类。
super也有三种⽤法：1.普通的直接引⽤与this类似，super相当于是指向当前对象的⽗类，这样就可以⽤super.xxx来引⽤⽗类的成员。
2.⼦类中的成员变量或⽅法与⽗类中的成员变量或⽅法同名12 3 4 5 6 7 8 9 10 11 12 13class Country {String name;void value() {name = "China";}}class City extends Country {String name;void value() {name = "Shanghai";super.value(); //调⽤⽗类的⽅法 System.out.println(name);13 14 15 16 17 18 19 20 21 System.out.println(name);System.out.println();}public static void main(String[] args) { City c=new City();c.value();}}运⾏结果：ShanghaiChina可以看到，这⾥既调⽤了⽗类的⽅法，也调⽤了⽗类的变量。
Java程序设计精编教程5-8章知识点
b) 如果变量名由多个单词组成，从第 2 个单词开始的每个单词的首字母要大写。
方法
方法的定义包括两部分：方法声明和方法体。一般格式为：
方法声明部分 {
方法体的内容
}
方法声明
方法声明包括返回值类型、方法名和参数。
double getArea() { //返回值类型为 double，无参数。
…
}
方法的返回值类型可以是 Java 中的任意数据类型。如果一个方法不返回数据，返回值类型必须是 void。
2. 有一个类 Singleton，为该类设计单例模式（该类只能有一个实例，且不能在类的外部 new 对象），只能通过该类 的静态方法 getInstance()获取该类的唯一对象。在主类 Homework2 中测试单例模式的有效性。
b) 在实例方法中，不仅可以调用实例方法，也可以调用类方法。 2) 类名调用类方法
a) 在类方法中，只能调用类方法、操作类变量。 b) 也可以通过对象调用类方法。 c) 如果一个方法不需要操作实例变量就可以实现某种功能，可以考虑将其声明为类方法。（例 5-8） 5.7 方法重载与多态 Java 中有两种多态：重载（overload）和重写（override）。 方法重载（overload）：一个类中可以有多个名字相同的方法，但这些方法的参数必须不同，或者参数的个数不同， 或者参数的类型不同。方法的返回值类型与重载无关。
5.8 this 关键字 this 只能出现在实例方法和构造方法（也属于实例方法）中，表示调用该方法的当前对象。 一般情况下，方法中 this.实例变量的 this 可省略、类名.类变量的类名可省略，但当局部变量与成员变量同名时，
this 或类名不能省略。 5.9 包
包是 Java 语言管理类的一种机制，类似于操作系统中的目录，使用包名可以有效区分名字相同的类。 包语句
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
public class HelloWorld {
public static void main(String[] args) {
Dog d=new Dog();
d.shout();
d.printName();
}
}
class Animal{
String name="动物";
void shout() {
System.out.println("动物发出叫声");
}
}
class Dog extends Animal{
String name="犬类";
void shout() {
super.shout();//使用super关键字访问父类的成员方法}
public void printName() {
System.out.println("它的名字是name="+); //使用super关键字访问父类的成员变量
}
public class HelloWorld {
public static void main(String[] args) { Dog d=new Dog();
}
}
class Animal{
String name="动物";
public Animal(String name){
System.out.println("它是一只"+name);
}
void shout() {
System.out.println("动物发出叫声");
}
}
class Dog extends Animal{
String name="犬类";
public Dog() {
super("二哈");
void shout() {
super.shout();//super关键字访问父类的成员方法}
public void printName() {
System.out.println("它的名字是
name="+);//使用super关键字访问父类的成员变量}
}。