精华内容
下载资源
问答
  • 1.在子类的成员方法,访问父类的成员变量 2.在子类的成员方法,访问父类的成员方法 3.在子类的构造方法,访问父类的构造方法 下面有一些代码关于this和super在继承... System.out.println("super关键字的用法");

    1.在子类的成员方法中,访问父类的成员变量

    2.在子类的成员方法中,访问父类的成员方法

    3.在子类的构造方法中,访问父类的构造方法

    下面有一些代码关于this和super在继承中的一些用法

    package net.onest.demo2;
    
    public class Person {
    	
    	private String name;
    	private int age;
    	
    	
    	
    	public String getName() {
    		System.out.println("super关键字的用法");
    		return name;
    	}
    
    
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    
    
    	public int getAge() {
    		return age;
    	}
    
    
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    
    
    	public Person(String name) {
    		System.out.println("基类中的含参构造方法");
    	}
    	
    	public Person() {
    		System.out.println("基类中的无参构造方法");
    	}
    
    }
    
    
    package net.onest.demo2;
    
    public class Student extends Person{
    	
    	private String name;
    	
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Student(String name) {
    		super(name);
    		// TODO Auto-generated constructor stub
    		System.out.println("使用了super关键字");
    		
    	}
    	
    	public Student(){
    		this("123");
    		super.getName();
    		System.out.println("派生类的无参构造方法");
    	}
    	
    	public Student(int age) {
    //		this("张三");
    		this();
    		System.out.println("使用了this关键字调用其他的构造方法");
    	}
    
    	public static void main(String[] args) {
    		
    		Person a = new Student(18);
    		System.out.println();
    		Student b = (Student) new Person();
    		
    		
    	}
    
    }
    
    
    展开全文
  • super关键字 1. super.属性和super.方法 如下,有一父类Transport package test2; public class Transport { String typeOfVehicle="小汽车";//车辆类型 float speed=150.2f;//车速 public void run() { ...

    super关键字

    1. super.属性和super.方法
    如下,有一父类Transport

    package test2;
    
    public class Transport {
        String typeOfVehicle="小汽车";//车辆类型
        float speed=150.2f;//车速
        public void run() {
    		System.out.println(typeOfVehicle+"能跑"+speed+"KM/H");
    	}
        
    }
    

    有一个子类Car

    package test2;
    
    public class Car extends Transport {
       //方法的重写
    	public void run() {
    		System.out.println(super.typeOfVehicle+"的速度是"+super.speed);
    }
    }
    

    建立一个测试类

    package test2;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
           
           Car car=new Car();
           car.run();
    	}
    
    }
    

    执行结果如下:

    可以看到,对子类对象进行实例化后,子类的super关键字均调用了父类的属性和方法
    2.super关键字与构造方法的关系
    仍然以上述代码为例,作微小改动
    父类如下:

    package test2;
    
    public class Transport {
        String typeOfVehicle="小汽车";//车辆类型
        float speed=150.2f;//车速
        public void run() {
    		System.out.println(typeOfVehicle+"能跑"+speed+"KM/H");
    	}
        public Transport() {
        	System.out.println("父类构造方法被执行");
        }
        
    }
    

    子类如下:

    package test2;
    
    public class Car extends Transport {
       //方法的重写
    	public void run() {
    		System.out.println(super.typeOfVehicle+"的速度是"+super.speed);
    		super.run();
    }
    	public Car() {
    		//super();//此处super()可加可不加,初始化子类对象时,父类的构造方法首先执行
    		System.out.println("子类方法被执行");
    	}
    }
    

    Test类如下:

    package test2;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
           
           Car car=new Car();
           
    	}
    
    }
    

    运行结果如下:
    在这里插入图片描述
    从运行结果可看到,子类初始化过程中隐式的调用了父类初始化方法,即使用了super();但super可写可不写。如果不写,则默认调用父类无参的构造方法;如果写,必须在第一行。当父类有一个有参数的构造方法时,则编译器不会自动构建无参的构造方法,此时在子类中如果要调用父类的构造方法,则必须用super();且必须放在子类构造方法的第一行

    展开全文
  • super 表示使用它父类。super 可用于: 调用父类构造方法;调用父类方法(子类覆盖了父类方法时);访问父类数据域(可以这样用但没有必要这样用)。 调用父类构造方法语法: super(); 或 ...

    super 表示使用它的类的父类。super 可用于:

    • 调用父类的构造方法;
    • 调用父类的方法(子类覆盖了父类的方法时);
    • 访问父类的数据域(可以这样用但没有必要这样用)。

    调用父类的构造方法语法:

    super();  
    
       
    
    super(参数列表);

    注意:super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字,如果子类中没显式调用,则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。

    静态方法中不能使用 super 关键字。

    调用父类的方法语法:

    super.方法名(参数列表);

    如果是继承的方法,是没有必要使用 super 来调用,直接即可调用。但如果子类覆盖或重写了父类的方法,则只有使用 super 才能在子类中调用父类中的被重写的方法。


    展开全文
  • 原地址:http://www.cnblogs.com/java-class/archive/2012/12/20/2826499.html ...1)有人写了个很好初始化属性构造函数,而你仅仅想要在其中添加另一些自己新建属性初始化,这样在一个构造函数调用

     原地址:http://www.cnblogs.com/java-class/archive/2012/12/20/2826499.html

    昨天写this用法总结的时候,突然产生了一个问题,请教别人之后,有了自己的一点认识。还是把它写下来,为大家更好的认识提供一点思路。

    1)有人写了个很好的初始化属性的构造函数,而你仅仅想要在其中添加另一些自己新建属性的初始化,这样在一个构造函数中调用另外一个构造函数,可以避免重复的代码量,减少工作量;

    2)在一个构造函数中调用另外一个构造函数的时候应该用的是同一块内存空间,在默认的构造函数中先初始化变量,调用另一个的时候覆写已经初始化的变量的值;

    3)整个调用的过程和递归调用函数有点类似,不断充气球,直到整个气球膨胀起来,不断的深层递进,遇到停止标记,逐层的跳出来。

         写了段代码,解释我上面的叙述:

    复制代码
     1 class JavanTiger {
     2     int age;      // 年龄
     3     int hight;    // 身体高度
     4 
     5     public JavanTiger() {
     6         print();
     7         this.age=2;   //这里初始化 age 的值 ,但递归返回的时候,这个值会被覆写
     8     }
     9     
    10     public JavanTiger(int age) {
    11         this();      // 调用自己的第一个构造函数,下面的两个语句数不执行的
    12         this.age = age;
    13         print();
    14     }
    15 
    16     public JavanTiger(int age, int hight) {
    17         this(age);   // 调用自己第二个构造函数  ,下面的两个语句数不执行的
    18         this.hight = hight;
    19         print();
    20     }
    21 
    22     public void print() {  //打印函数
    23         System.out.println("I'am a " + age + "岁 " + hight + "尺高 tiger!");
    24     }
    25     public static void main(String[] args) {
    26         new JavanTiger(3,3);
    27     }
    28 }
    29 //output
    30 //I'am a 0岁 0尺高 tiger!
    31 //I'am a 3岁 0尺高 tiger!
    32 //I'am a 3岁 3尺高 tiger!  
    复制代码

          个人理解就是这样了,可能里面还有问题,比如构造函数递归调用和程序函数递归调用的机制是否似乎相同的?构造函数同对象一起产生,也就是同时会分配内存空间出来,那门这样的递归调用会不会打乱分配内存的顺序?希望看到的大牛们拍板,给个最好的解释。

         今天要总结的是 super 这个关键字的使用,super 在构造函数中出现的时候一般是当前这个类继承了其他的类,super 的出现就是为了调用父类的构造函数,贴段代码先

    复制代码
     1 class Tiger {
     2     int age; // 年龄
     3     int hight; // 身体高度
     4 
     5     public Tiger() {
     6         print();
     7     }
     8 
     9     public void print() {
    10         System.out.println("I'am a " + age + "岁 " + hight + "尺高 tiger!");
    11     }
    12 }
    13 public class JavanTiger extends Tiger {    
    14     public JavanTiger() {
    15         super();    // 调用父类无参数的构造函数
    16     }
    17     public static void main(String[] args) {
    18         new JavanTiger();
    19     }
    20 }
    复制代码

        其实在类JavanTiger 中的构造函数中的 super()可以不写,JAVA会默认调用父类的无参数的构造函数,但如果父类没有定义无参数的构造函数,没有语法错误,程序会自动退出,没有任何打印语句,这时候你需要手动调用其他父类的构造函数,贴段代码:

    复制代码
     1 class Tiger {
     2     int age; // 年龄
     3     int hight; // 身体高度
     4 
     5     public Tiger(int age) {
     6     this.age = age;
     7     print();
     8     }
     9     public void print() {
    10         System.out.println("I'am a " + age + "岁 " + hight + "尺高 tiger!");
    11     }
    12 }
    13 public class JavanTiger extends Tiger {    
    14     public JavanTiger() {
    15         super(1);    // 调用父类有参数的构造函数
    16     }
    17     public static void main(String[] args) {
    18         new JavanTiger();
    19     }
    20 }
    复制代码

          这段代码中的 super(1)必须要写进去,否则编译器会报错。所以我简单的总结了一下,“this()是调用自己其他的构造函数,super()是调用自己继承的父类的构造函数“,如果只想调用默认无参数的父类构造函数,不用在子类的构造函数当中写出来,但是实际编程的时候,总是会忽略这一点。

         那门这两个关键字能不能同时出现在子类的一个构造函数当中纳?答案肯定是不能。先说下自己的理解:

    1)在新建一个基类的时候,不论递归调用几次自身的构造函数,最终你都会去调用父类的构造函数,(不是显式调用的话,系统会调用默认无参数的父类构造函数);

    2)JAVA 中规定使用 this 和 super 时必须放在构造函数第一行,只有一个第一行;

    展开全文
  • class Sum {int n;float f() {float sum=0;for(int i=1;i<=n;i++)sum=sum+i;System.out.println(“()=”+n);return sum;}}class Average extends Sum {int n;...super.n=n;c=super.f();System.out....
  • 今天来谈一下super的用法以及使用时应该注意的事项。 下面先列举出容易出错的地方: 图一 图一中第十五行编译报错:There is no default constructor available in ‘AddClass’(这里缺少缺省函数),在处理这个...
  • Java中super关键字的用法及示例

    千次阅读 2016-02-14 11:29:13
    转自 ... 主要是由Hadoop中的函数想到,以前对super不太明白,写了几段代码搞懂了。 @Override protected void setup(Context context) throws IOException,  InterruptedException {
  • 主要介绍了Java编程this与super关键字的用法,包括从内存结构方面分析super的作用域,需要的朋友可以参考下
  • Java中在执行子类构造方法之前或者子类没有明确指定构造方法,会自动调用父类无参构造方法。(视频教程推荐:java课程)super的三种使用情况:访问父类方法中被覆盖方法。调用父类构造方法。访问父类中隐藏...
  • 通过用static来定义方法或成员,为我们编程提供了某种便利,从某种程度上可以说它类似于C语言中的全局函数和全局变量。...super这两个关键字的意义和用法。在Java中,this通常指当前对象,super则指父类的。当你想要...
  • super关键字的用法有三种: 1.在子类的成员方法,访问父类的成员变量。 2.在子类的成员方法,访问父类的成员方法。 3.在子类的构造方法,访问父类的构造方法。 public class Zi extends Fu { int num = 20; ...
  • 1. 子类构造函数如果要引用super的话,必须把super放在函数首位.classBase {Base() {System.out.println("Base");}}public classChecketextendsBase {Checket() {super();//调用父类构造方法,一定要放在方法...
  • Java编程中super关键字的用法

    千次阅读 2016-11-29 23:02:14
    详解Java编程中super关键字的用法 作者:孤傲苍狼 字体:[增加 减小] 类型:转载 时间:2015-10-19 我要评论 这篇文章主要介绍了Java编程中this与super关键字的用法,包括从内存结构方面分析super的作用域,需要的...
  • 主要介绍了Java编程this关键字与super关键字的用法示例,super是this的父辈,在继承过程两个关键字经常被用到,需要的朋友可以参考下
  • super关键字的用法有三种 : 1.在子类的成员方法,访问父类的成员变量 2.在子类的成员方法,访问父类成员方法 3.在子类的构造方法访问父类的构造方法 public class Fu { int num=50; public void ...
  • java中super关键字的三种用法
  • 1.使用super调用父类构造...由于子类不继承父类构造方法,因此,子类在其构造方法需要使用super来调用父类构造方法,而且super必须是子类构造方法中的头一条语句,即如果在子类构造方法,没有明显地写...
  • 1.this 关键字是类内部当中对自己一个引用,可以方便类方法访问自己属性; 2.可以返回对象自己这个类引用,同时还可以在一个构造函数当中调用另一个构造函数(这里面上面有个问题) 例: this(); 必须...
  • Java中super关键字的三种用法: 在子类的成员方法中,访问父类的成员变量。 在子类的成员方法中,访问父类的成员方法。 在子类的构造方法中,访问父类的构造方法。
  • this总要有个事物来代表类当前对象,就像C++中this指针一样,Java中的this关键字就是代表当前对象引用。它有三个主要作用:1、在构造方法中调用其他构造方法。比如有一个Student类,有三个构造函数,某一个...
  • Java中super关键字用法

    2019-08-02 16:35:30
    super关键字主要用在子类继承父类时,咱们程序员在子类方法里面想要调用父类方法,变量时。在子类main方法里面是不让用super、this,因为main是static修饰,static修饰方法里面不让用这两个关键字。 1...
  • Java中this关键字和super关键字的用法

    千次阅读 2016-11-03 20:21:20
    Java中,this通常指当前对象,super则指父类。当你想要引用当前对象某种东西,比如当前对象某个方法,或当前对象某个成员,你便可以利用this来实现这个目的,当然,this另一个用途是调用当前对象另一...
  • java继承中super关键字的用法

    千次阅读 2013-09-13 21:58:57
    今晚复习了下java继承类super关键字的用法,看了一个例题,看似简单其实特别容易错,笔试题经常出现这种类型的题,下面来分享下此类题: package study; class Base{ public String name; public Base(){ ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 679
精华内容 271
关键字:

java中super关键字的用法

java 订阅