java中super的用法总结,下列选项中关于java中super关键字
这篇文章给大家带来了一些关于java的知识，包括对super关键字的初步了解，super(实参)的用法，当super。不能省略等。下面就来看看吧，希望对你有帮助。
如何解决写爬虫IP受阻的问题？立即使用。
super
super初步理解
例1：父类和子类都是无参构造
公共类Test01{
公共静态void main(String[] args){
//按照无参数构造方法创建一个对象，它一定会调用无参数构造方法！
//对象一创建就调用构造函数，先调用父类的构造函数，再调用子类的构造函数。
new B()；
}
}
A级
public(){//无参数构造方法
调用A的无参数构造函数！);
}
}
B类扩展了A{
public(){//无参数构造方法
//super()；//默认有一个super()通过子类调用父类的无参数构造函数；可以省略！
System.out.println(调用B的无参数构造函数！);
}
}
//结果：我们只创建B对象；因此，首先调用类A的构造函数，然后调用类B的构造函数。
/*
调用A的无参数构造方法！
调用B的无参数构造方法！
*/例2：父类是有参构造、子类是无参构造
公共类Test01{
公共静态void main(String[] args){
//按照无参数构造方法创建一个对象，它一定会调用无参数构造方法！
new B()；
}
}
A级
//如果一个类没有手动提供任何构造函数，系统默认会提供一个无参数的构造函数。
//如果手工为类提供构造方法，无参数构造系统将不再提供。
public A(int I){///参数化构造方法
调用A的参数化构造函数！);
}
}
B类扩展了A{
public(){//无参数构造方法
//父类是参数化构造方法，默认为super()会有问题，
因为super()只能调用父类的无参数构造函数。
//所以此时的super不能省略；并在写入时写入参数，
调用父类的参数化构造方法，例如：super(100)
超级(100)；
System.out.println(调用B的无参数构造函数！);
}
}
//结果：我们只创建B对象；因此，首先调用类A的构造函数，然后调用类B的构造函数。
/*
调用的参数化构造方法！
调用B的无参数构造方法！
*/例3：this()和super()不能共存(重点理解)
公共类Test01{
公共静态void main(String[] args){
//按照无参数构造方法创建一个对象，它一定会调用无参数构造方法！
new B()；
}
}
Class A{ //默认继承Object类，Class A扩展Object。
//建议手工写出类的无参数构造方法。
public(){//无参数构造方法
//这里默认也有super()，调用Object的无参数构造方法
调用A的无参数构造函数！);
}
public A(int I){///参数化构造方法
//这里默认也有super()，调用Object的无参数构造方法
调用A的参数化构造函数！);
}
}
B类扩展了A{
public(){//无参数构造方法
//通过这个调用B的参数化构造方法；而且B的参数构造方法默认也有super()！
这个(‘张三’)；
System.out.println(调用B的无参数构造函数！);
}
Public B(字符串名){///参数构造方法
//默认情况下还有super()，用来调用的无参数构造。
System.out.println(调用B的参数化构造函数！);
}
}
//最终结果
/*
调用A的无参数构造方法！
调用B的参数化构造方法！
调用B的无参数构造方法！
*/例4：套娃例题理解
公共类超级测试02{
公共静态void main(String[] args){
new C()；
}
}
//-对于父类A，将实际调用祖先对象类的无参数构造。
/*
类对象{
公共对象(){
}
}
*/
A类{//A类扩展对象
Public () {//-最后一个调用的；先结束！
system . out . println(“1”)；//1
}
}
B类扩展了A{
公共B(){
system . out . println(“2”)；
}
公共B(字符串名称){
//super()；默认情况下。
system . out . println(“3”)；//2
}
}
C类扩展了B{
Public () {//-第一个调用的；终于结束了！
这个(‘张三’)；
System.out .普里
公共c(字符串名称){
这个（名字，20);
系统。出去。println( 5 )；//4
}
公共c C(字符串名称，整数){
超级（名);
系统。出去。println( 6 )；//3
}
}
super(实参)的用法
公共类超级测试03{
公共静态void main(String[] args){
信用账户CA1=新信用账户()；//调用无参构造
系统。出去。println(CA1。getactno()，
ca1.getBalance()， ca1。get credit())；//空，0.0,0.0
信用账户Ca2=新信用账户( 1111 ，10000.0，0.999)；//调用有参构造
系统。出去。println(Ca2。getactno()，
ca2.getBalance()， ca2。get credit())；//1111,10000.0,0.999
}
}
//账户
类别帐户扩展对象{
//属性
私有字符串actno
私人双平衡；
//构造方法
公共帐户(){ //对于无参构造，默认会调用super()；并且给实列变量赋上缺省初始值
//super()；
//这个。actno=null
//这个。余额=0.0；
}
公共账户（字符串actno，双余额){
//super()；
this.actno=actno
this.balance=余额
}
//setter和吸气剂
public void setActno(String actno){
this.actno=actno
}
公共字符串getActno(){
返回actno
}
公共无效setBalance(双余额){
this.balance=余额
}
public double getBalance(){
返回余额；
}
}
//信用账户
类别信用账户扩展帐户{
//属性：信誉度（诚信值)
//子类特有的一个特征，父类没有。
私人双重信用；
//重点在这里-写上有参构造方法
//分析以下程序是否存在编译错误？
公共信用账户（字符串actno，双余额，双信用){
//直接访问不行，继承过来的私有的属性，只能通过作曲者和吸气剂方法进行访问
/*
this.actno=actno
this.balance=余额
*/
//以上两行代码在恰当的位置，正好可以使用：super(actno，balance)；
//通过子类的构造方法调用父类的构造方法。
超级(actno，balance)；//调用父类的构造方法
this.credit=信用
}
//提供无参数的构造方法
公共信用帐户(){ //对于无参构造，默认会调用super()；并且给实列变量赋上缺省初始值
//super()；
//这个。信用=0.0；
}
//setter和吸气剂方法
公共作废setCredit(双重信用){
this.credit=信用
}
public double getCredit(){
返还信用；
}
}内存图（重点掌握）
super.使用
公共类超级测试04{
公共静态void main(String[] args){
Vip v=新Vip(张三);
五、购物();
}
}
类别客户{
字符串名称；
公共客户(){}
公共客户（字符串名称){
super()；
this.name=name
}
}
贵宾级扩展客户{
公共Vip(){}
公共Vip(字符串名称){
超级（名);
}
//超级和这都不能出现在静态方法中。
公共空的购物(){
//这个表示当前对象。
System.out.println(this.name 正在购物!);
//超级表示的是当前对象的父类型特征（超级是这指向的那个对象中的一块空间。)
System.out.println(super.name正在购物！);
System.out.println(name 正在购物!);
}
}内存图
super.什么时候不能省略(掌握)
公共类超级测试05{
公共静态void main(String[] args){
Vip v=新Vip(张三);
五、购物();
}
}
类别客户{
字符串名称；//- 父类中也有名字
公共客户(){}
公共客户（字符串名称){
super()；
this.name=name
}
公共void doSome(){
系统。出去。println(这个。名字叫“做一些！”);
System.out.println(name do some！);
//错误：找不到符号-对象里面没有名字
//系统。出去。println(超级。名字叫“做一些！”);
}
}
贵宾级扩展客户{
//假设子类也有一个同名属性
//java中允许在子类中出现和父类一样的同名变量/同名属性。
字符串名称；//- 子类中也有名字
公共Vip(){
}
公共Vip(字符串名称){
超级（名);//给父类初始化了，子类并没有进行初始化是空
//这个。name=null
}
公共空的购物(){
/*
爪哇岛是怎么来区分子类和父类的同名属性的？
这个。名称：当前对象的名字属性
超级名称：当前对象的父类型特征中的名字属性。
*/
//- 默认访问的是当前对象的姓名；加极好的访问的是父类的名字
System.out.println(this.name 正在购物!);//null正在购物
System.out.println(super.name正在购物！);//张三正在购物
System.out.println(name 正在购物!);//null正在购物
}
}内存图
super使用时后面必须有一个.
公共类超级测试06 {
//实例方法
公共void doSome(){
系统。出去。println(这个)；//实际上调用的是this.toString()方法
//输出"引用"的时候，会自动调用引用的toString()方法。
//系统。出去。println(这个。tostring())；
//编译错误：需要.
//系统。出去。println(超级)；
}
//这个和极好的不能使用在静电静态方法中。
/*
public static void doOther(){
系统。出去。println(这个)；
系统。出去。println(超级。XXX)；
}
*/
//静态方法，主方法
公共静态void main(String[] args){
super test 06 ST=new super test 06()；
ST . do some()；
}
}
使用super调用父类方法
公共类超级测试07{
公共静态void main(String[] args){
/*
猫步！
猫步！
动物行动！
*/
Cat c=new Cat()；
c。yidong()；
}
}
动物类{
public void move(){ //父中有
System.out.println(动物移动!);
}
}
类别猫扩展动物{
//对移动进行重写。
public void move(){ //子中也有
System.out.println(Cat move！);
}
//在子类的实例方法当中调用父类的实例方法
public void yiDong(){
这个。move()；//猫动！-调用自己的
move()；//猫动！-调用自己的
//超级。不仅可以访问属性，也可以访问方法。
超级棒。move()；//动物移动！-调用父类的
}
}推荐学习： 《java视频教程》 以上就是爪哇中极好的关键字的用法详解的详细内容，更多请关注我们其它相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。